Testavior
1.4.0
Testavior est une solution légère pour vous aider à développer des tests de comportement pour ASP.NET Core .
Les tests de comportement sont un moyen de tester les fonctionnalités de votre application en appliquant différents types de comportements pour couvrir un scénario fonctionnel .
Il fournit une approche simple et efficace pour rédiger des tests automatisés pour votre application ASP.NET Core.
Pour plus d'informations sur les tests de comportement avec Asp.net Core, veuillez jeter un coup d'œil ici http://geeklearning.io/a-different-approach-toest-your-asp-net-core-application
Testavior fournit 2 bibliothèques:
Sur votre projet de base ASP.NET
> dotnet add package GeekLearning.Testavior.Configuration
Sur votre projet de test d'unité .NET Core
> dotnet add package GeekLearning.Testavior
L'environnement de test fourni par Testavior est basé sur un service de configuration de démarrage qui vous permet de séparer la configuration de l'environnement de production de la configuration de l'environnement de test . Ce service de configuration est représenté par un contrat IStartupConfigurationService qui définit 3 méthodes: Configure - ConfigureEnvironment - ConfigureService qui doivent être appelées dans la routine de démarrage pour injecter la configuration dépendante de l'environnement.
1 - Dans votre projet de base ASP.NET :
StartupConfigurationService (modifiez le nom si vous le souhaitez) à votre projet Web.IStartupConfigurationService (éventuellement, hériter de DefaultStartupConfigurationService pour utiliser l'implémentation vide par défaut)ConfigureServices : implémentez les options de configuration spécifiques à l'environnement de productionConfigure : implémentez la configuration du middleware spécifique à l'environnement de productionConfigureEnvironment : implémentez ce qui doit être exécuté avant quoi que ce soitÉchantillon:
public class StartupConfigurationService : DefaultStartupConfigurationService
{
public override void ConfigureServices ( IServiceCollection services , IConfigurationRoot configuration )
{
base . ConfigureServices ( services , configuration ) ;
var connection = "CONNECTION_STRING" ;
services . AddDbContext < [ EF_DB_CONTEXT ] > ( options =>
options . UseSqlServer ( connection ) ) ;
}
} 2 - Dans votre classe de programme :
Injectez votre StartupConfigurationService en appelant la méthode ConfigureStartup sur votre WebHostBuilder :
new WebHostBuilder ( )
.. .
. UseStartup < Startup > ( )
. ConfigureStartup < StartupConfigurationService > ( ) 3 - Dans votre classe Startup :
IStartupConfigurationService dans la classe StartupConfigureEnvironment à la fin du constructeur StartupConfigureServices à la fin de la méthode Startup.ConfigureServices d'origineConfigure au début de la méthode Startup.Configure d'origineÉchantillon:
public class Startup
{
private IStartupConfigurationService externalStartupConfiguration ;
public Startup ( IHostingEnvironment env , IStartupConfigurationService externalStartupConfiguration = null )
{
this . externalStartupConfiguration = externalStartupConfiguration ;
this . externalStartupConfiguration . ConfigureEnvironment ( env ) ;
}
public void ConfigureServices ( IServiceCollection services )
{
services . AddMvc ( )
// Pass configuration (IConfigurationRoot) to the configuration service if needed
this . externalStartupConfiguration . ConfigureServices ( services , null ) ;
}
public void Configure ( IApplicationBuilder app , IHostingEnvironment env , ILoggerFactory loggerFactory )
{
this . externalStartupConfiguration . Configure ( app , env , loggerFactory ) ;
app . UseMvc ( ) ;
}
} 4 - Dans votre fichier de projet de test:
Le moteur de rasoir utilise des fichiers de dépendance (.deps.json) pour résoudre certaines références au moment de l'exécution. Ainsi, pour tester la partie MVC d'une application, il est nécessaire d'importer ces fichiers. Pour le faire, ajoutez la section suivante à votre .csproj :
< Target Name = " CopyDepsFiles " AfterTargets = " Build " Condition = " '$(TargetFramework)'!='' " >
< ItemGroup >
< DepsFilePaths Include = " $([System.IO.Path]::ChangeExtension('%(_ResolvedProjectReferencePaths.FullPath)', '.deps.json')) " />
</ ItemGroup >
< Copy SourceFiles = " %(DepsFilePaths.FullPath) " DestinationFolder = " $(OutputPath) " Condition = " Exists('%(DepsFilePaths.FullPath)') " />
</ Target > 5 - Pour les utilisateurs Xunit
Si vous avez l'intention d'utiliser Xunit, suivez d'abord la documentation officielle, ajoutez un fichier xunit.runner.json à votre projet de test:
{
"shadowCopy" : false
} et ajoutez la section suivante à votre .csproj :
< ItemGroup >
< None Include = " xunit.runner.json " CopyToOutputDirectory = " PreserveNewest " />
</ ItemGroup > Un service de IStartupConfigurationService spécifique est requis pour l'environnement de test si vous souhaitez implémenter la configuration spécifique du test .
Testavior est livré avec une mise en œuvre de IStartupConfigurationService de test spécifique à un test: TestStartupConfigurationService qui fournit un environnement de test plein de fonctionnalités utiles (voir la section des fonctionnalités ).
Bien sûr, vous pouvez implémenter votre propre service de configuration de démarrage (en utilisant ou non le TestStartupConfigurationService Service).
Pour créer un environnement de test , inscanciez simplement la classe TestEnvironment en le faisant passer votre Startup ASP.NET Core Application, votre implémentation IStartupConfigurationService , le type de votre objet CoreContex EF et le chemin relatif vers votre projet ASP.NET Core (requis pour résoudre les vues MVC).
var testEnvironment = new TestEnvironment < Startup , TestStartupConfigurationService < [ EF_DB_CONTEXT ] > > (
Path . Combine ( System . AppContext . BaseDirectory , @"[PATH_TO_WEB_APP]" ) ) ; Écrivez votre test API en envoyant simplement des demandes Web en utilisant l' environnement de test :
[ TestMethod ]
public void ScenarioShouldBeOk ( )
{
var testEnvironment = new TestEnvironment < Startup , TestStartupConfigurationService < [ EF_DB_CONTEXT ] > > (
Path . Combine ( System . AppContext . BaseDirectory , @"[PATH_TO_WEB_APP]" ) ) ;
var response = testEnvironment . Client . GetAsync ( "/api/data" ) . Result ;
response . EnsureSuccessStatusCode ( ) ;
// Test result content
var result = JsonConvert . DeserializeObject < Data [ ] > ( response . Content . ReadAsStringAsync ( ) . Result ) ;
Assert . AreEqual ( "data" , result . Data ) ;
} Écrire un test MVC est presque aussi simple que de tester une API, sauf que vous voudrez peut-être tester le modèle renvoyé par le serveur et non la vue .
Pour ce faire, Testavior fournit un référentiel ViewModel qui interceptera et stockera les modèles de la vue renvoyés par le serveur.
Vous pouvez accéder à ce référentiel à l'aide du mécanisme d'injection de dépendance au cœur ASP.NET:
[ TestMethod ]
public void ScenarioShouldBeOk ( )
{
var testEnvironment = new TestEnvironment < Startup , TestStartupConfigurationService < [ EF_DB_CONTEXT ] > > (
Path . Combine ( System . AppContext . BaseDirectory , @"[PATH_TO_WEB_APP]" ) ) ;
testEnvironment . Client . GetAsync ( "/" ) . Result . EnsureSuccessStatusCode ( ) ;
var viewModel = testEnvironment
. ServiceProvider
. GetRequiredService < ViewModelRepository > ( )
. Get < [ VIEWMODEL_TYPE ] > ( ) ;
Assert . AreEqual ( "data" , viewModel . Data ) ;
}Et n'hésitez pas à jeter un œil à la section des échantillons;)
Bonnes tests! :)
