Test unitario Sito Web ASP.net Codice progetto memorizzato in App_Code

Question

Ho un progetto sito Web ASP.net (.net 3.5). Attualmente tutti i file di codice non code dietro (inclusi roba Linq2Sql, contesti dati, logica aziendale, metodi di estensione, ecc.) Si trovano nella cartella App_Code.

Sono interessato all'introduzione del test di unità (utilizzando nunit) in almeno alcune sezioni del progetto che vanno avanti. Qualsiasi unità di test che vorrei fare avrebbe bisogno di avere pieno accesso a tutto il codice che si trova attualmente nella cartella App_Code. Ho fatto qualche lettura iniziale fino ad ora, e il consenso sembra essere:

• Questo non sarà possibile data la mia messa a punto corrente
• Unit testing richiede riferimento a classi che fanno parte di una DLL compilata e un Web Il progetto del sito per definizione viene compilato solo in fase di esecuzione.
• Per procedere, dovrò convertire il mio intero progetto in un'applicazione Web, o spostare tutto il codice che vorrei testare (cioè: l'intero contenuto di App_Code) in un progetto di libreria di classi e riferimento il progetto della biblioteca di classi nel progetto del sito web. Ognuno di questi fornirà l'accesso alle classi di cui ho bisogno in formato dll compilato, che mi consentirà di testare le unità.

È corretto? O c'è un altro modo in cui posso Unit Test senza ristrutturare/refactoring il mio intero progetto?

Answer 1

Le tue conclusioni sembrano corrette. Voterò per spostare le funzionalità in uno o più progetti di librerie di classi, poiché ciò potrebbe aprire la porta per riutilizzare la stessa funzionalità anche in altri progetti.

Answer 2

E come indicato dall'OP è anche possibile passare a un progetto di app Web, che direi più pulito, le pagine possono rimanere nel progetto dell'app wep, le avrete in 1 DLL (verificabile). Tutta la tua logica aziendale ecc. Va in una libreria di classi/librerie separate.

Answer 3

Sembra che questo sia possibile mentre si utilizza ancora App_code, ma sposterei questa logica nel proprio progetto di libreria di classi o cambiare il tipo di progetto in Applicazione Web, come suggeriscono Fredrik e Colin.

Creo sempre i miei progetti ASP.NET come progetti di applicazioni Web e non come siti Web.

Answer 4

Abbiamo questo problema alla mia azienda (Il mio capo non ama le DLL, un po 'di spazzatura su versioni ...)

Abbiamo due modi per aggirare è che usiamo spesso:

1) Get lo strumento CI per testare le unità: usiamo TeamCity che ha un'integrazione NUnit piuttosto stretta e la nostra soluzione si basa abbastanza rapidamente (e ha pochi test sufficienti) affinché questa sia un'opzione valida.

2) Precompilare manualmente e unit test i binari risultanti: È perfettamente possibile eseguire il compilatore ASP.net/MSBuild dalla riga di comando (come se si stesse facendo una build 'Pubblica') e basta testare i binari risultanti .

Tuttavia, se si ha la possibilità di segregare il codice in binari (librerie di classi) o semplicemente utilizzando un'applicazione Web, suggerirei che sia un'alternativa migliore.

Answer 5

Il mio negozio ha finalmente elaborato una risposta a questo per il nostro progetto MVC. E voglio condividerlo come ho inseguito un sacco di vicoli ciechi su StackOverflow sentendo molte persone dire che non si poteva fare.Noi lo facciamo in questo modo:

• Aprire la cartella MVC "come un sito web, da IIS locale", che ottiene intellisense e il debug di funzionare correttamente
• Aggiungere un progetto di test di unità che vive nella nostra directory di origine controllata
• Aggiungere una fase di pre-build al progetto TEST, poiché non è possibile aggiungerne uno a un progetto aperto come sito Web. Il sito Web Imagine è \ FooSite e il nostro progetto di prova è \ FooSite.Tests. Il codice dell'app compilato finirà nello in FooSite.Tests \ FooSite_Precompiled \ bin.
*

<Target Name="BeforeBuild"> 
    <AspNetCompiler VirtualPath="FooSite" TargetPath="$(ProjectDir)\FooSite_Precompiled" Force="true" 
Debug="true" /> </Target> 

• Aggiungere un riferimento alla FooSite_Precompiled/bin/App_Code.dll nel progetto di test.
• Boom è tutto. Puoi avere la tua torta e mangiarla anche tu. Ogni volta che fai clic su Costruisci nella tua soluzione chiami lo strumento aspnet_compiler.ext sul tuo sito web csproj (che esiste ancora) che è in grado, a differenza di MSBuild, di compilare app_code, e il Debug = "true" ti permette di inserire in il codice app_code.dll durante il debug del test dell'unità. E tu devi compilare solo quando esegui test unitari aggiornati. Quando stai guardando gli effetti della tua modifica sulla pagina, ti basta Cambia codice/Salva/Aggiorna pagina poiché la cartella app_code dinamicamente compila quando chiamata dal tuo server web.

Answer 6

Se una persona si ritrovano implementare la soluzione di Brian, ecco una Website.targets file che è possibile includere nella soluzione di test di unità. Ricompila (re) il sito Web solo quando App_Code cambia. Basta aggiungere qualcosa come

<PropertyGroup> 
    <WebsiteName>MyWebsite</WebsiteName> 
    <WebsitePath>..</WebsitePath> 
    </PropertyGroup> 
    <Import Project="$(ProjectDir)\Website.targets" /> 
    <Target Name="BeforeBuild" DependsOnTargets="CompileWebsite"> 
    </Target> 

al vostro Csproj, personalizzando WebsiteName e WebsitePath e si dovrebbe essere pronti ad andare. Website.targets:

<?xml version="1.0" encoding="utf-8"?> 
<!-- 
    Target that compiles Website's App_Code to be used for testing 
    --> 
<Project DefaultTargets="CompileWebsite" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> 
    <ItemGroup> 
    <AppCodeFiles Include="$(WebsitePath)\$(WebsiteName)\App_Code\**\*.*" /> 
    </ItemGroup> 
    <Target Name="CompileWebsite" Inputs="@(AppCodeFiles)" Outputs="$(ProjectDir)\PrecompiledWeb\bin\App_Code.dll"> 
    <AspNetCompiler VirtualPath="$(WebsiteName)" PhysicalPath="$(WebsitePath)\$(WebsiteName)" TargetPath="$(ProjectDir)\PrecompiledWeb" Force="true" Debug="true" /> 
    </Target> 
    <Target Name="CleanWebsite"> 
    <RemoveDir Directories="$(WebsitePath)\$(WebsiteName)\PrecompiledWeb" /> 
    </Target> 
</Project> 

Answer 7

E 'possibile classi di unit test memorizzati nella cartella App_Code senza convertire il progetto a una Web App o in movimento le vostre classi a un progetto Libreria di classi.

Tutto ciò che è necessario è l'impostazione dei file di codice "Build Actions to Compile". Ciò causerà il debug e il test dell'unità sul sito Web per l'output di un file .dll.

Ora quando si fa riferimento al progetto del sito Web dal progetto di test dell'unità, le classi nella cartella app_code saranno visibili.

NOTA:

Impostazione dei file Cs Build Action-Compile causerà il vostro sito web per generare un file dll sul debug e unit test. Il file .dll causerà problemi quando esegui il debug del tuo sito Web perché IIS troverà il tuo codice in due punti, il cestino e la cartella App_Code e non saprà quale usare. Al momento, elimini solo il file .dll quando voglio eseguire il debug.

Answer 8

Ho dovuto modificare la soluzione di Brian White aggiungendo l'attributo PhysicalPath.Inoltre, non utilizzo lo Default Web Site e ho dovuto modificare la proprietà VirtualPath con il nome del mio sito web.

<Target Name="BeforeBuild"> 
    <AspNetCompiler VirtualPath="myIISsitename.com" PhysicalPath="$(SolutionDir)MySiteFolder" TargetPath="$(ProjectDir)\MySite_Precompiled" Force="true" Debug="true" /> 
</Target> 

La dll risultante sarà a MySite_Precompiled\App_Code.dll