Langue
Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Shim types, l’une des deux technologies clés utilisées par le Microsoft Fakes Framework, jouent un rôle important dans l’isolation des composants de votre application pendant les tests. Ils fonctionnent en interceptant et en redirigeant les appels vers des méthodes spécifiques, que vous pouvez ensuite diriger vers du code personnalisé au sein de votre test. Cette fonctionnalité vous permet de gérer le résultat de ces méthodes afin de vous assurer que les résultats sont cohérents et prévisibles pendant chaque appel, quelles que soient les conditions externes. Ce niveau de contrôle simplifie le processus de test et aide à obtenir des résultats plus fiables et précis.
Utilisez shims lorsque vous devez créer une frontière entre votre code et les assemblies qui ne font pas partie de votre solution. Lorsque l’objectif est d’isoler les composants de votre solution les uns des autres, l’utilisation de stubs est recommandée. Pour obtenir une description détaillée des stubs, consultez Utiliser des stubs pour isoler les parties de votre application les unes des autres pour les tests unitaires.
Cet article fournit un guide pas à pas pour utiliser des types de shims afin de détourner les appels vers des méthodes spécifiques dans votre code de test unitaire.
Comprendre les limitations de type avec des shims
Il existe certaines limitations lors de l’utilisation de shims. Ils ne peuvent pas être utilisés sur tous les types de certaines bibliothèques dans la classe de base .NET, en particulier :
- mscorlib et System dans le framework .NET
- System.Runtime dans .NET Core ou .NET 5+
Lorsque vous concevez votre stratégie de test, planifiez cette contrainte pour garantir la réussite et l’efficacité des tests unitaires.
Créer un shim
Supposons que votre composant contient des appels à la System.IO.File.ReadAllLines méthode :
// Code under test:
this.Records = System.IO.File.ReadAllLines(path);
Pour préparer le composant pour les tests unitaires, effectuez les étapes décrites dans les procédures suivantes.
Créer une bibliothèque de classes
Créez une solution et un projet initial pour la bibliothèque de classes.
Dans la fenêtre Visual Studio Démarrage (File>Démarrage), créez un projet
Class Libraryen sélectionnant le modèle pour C# ou Visual Basic.
Configurez le nouveau projet :
- Définissez le nom de la bibliothèque de classes Project sur
HexFileReader. - Définissez le nom de la solution sur
ShimsTutorial. - Définissez l’infrastructure Target sur .NET Framework 4.8.
Cliquez sur Créer.
- Définissez le nom de la bibliothèque de classes Project sur
Une fois le projet ouvert, recherchez le fichier par défaut
Class1.csdans Explorateur de solutions et supprimez le fichier.Ajoutez un fichier nommé
HexFile.cset entrez la définition de classe suivante :
Ajouter un projet de test unitaire
Ajoutez un autre projet à votre solution pour les tests unitaires.
Dans Explorateur de solutions, cliquez avec le bouton droit sur la solution
ShimsTutorial, puis sélectionnez Add>New Project.Dans la fenêtre Démarrage, créez un
Unit Test Projectproject en sélectionnant le modèle.
Configurez le nouveau projet :
- Définissez le nom du test unitaire Project sur
TestProject. - Définissez l’infrastructure Target sur .NET Framework 4.8.
Cliquez sur Créer.
- Définissez le nom du test unitaire Project sur
Ajouter un assemblage Fakes
Ajoutez une référence au projet HexFileReader.
Dans Explorateur de solutions, développez le nœud
TestProject, cliquez avec le bouton droit sur le nœud References, puis sélectionnez Add Reference.
Dans le volet gauche de la fenêtre Gestionnaire de références , sélectionnez la section Projets .
Dans le volet central, cochez la case du
HexFileReaderprojet, puis sélectionnez OK.
Ajoutez l'assemblage Fakes.
Dans Explorateur de solutions, recherchez le nœud conteneur de l’assembly :
Pour un projet .NET Framework plus ancien (de style non-SDK), développez le nœud du projet de test unitaire, puis développez le nœud References.
Pour un projet au format SDK ciblant .NET Framework, .NET Core ou .NET 5+, développez le nœud Dependencies pour localiser l’assembly à simuler sous Assemblies, Projects ou Packages.
Pour Visual Basic, sélectionnez Show All Files dans la barre d’outils Explorateur de solutions pour afficher le nœud References.
Sélectionnez l’assembly
Systemqui contient la définition deSystem.IO.File.ReadAllLines.Cliquez avec le bouton droit sur le nœud
Systemet sélectionnez Ajouter l’assembly Fakes.
Le processus de génération génère des avertissements et des erreurs pour les types non pris en charge pour une utilisation avec des shims.
Une fois la build terminée, Explorateur de solutions s’actualise pour afficher un nœud Fakes pour le projet de test unitaire.
Sélectionnez le fichier et remplacez le
Fakes\mscorlib.fakescode XML pour exclure les types non pris en charge :<Fakes xmlns="http://schemas.microsoft.com/fakes/2011/" Diagnostic="true"> <Assembly Name="mscorlib" Version="4.0.0.0"/> <StubGeneration> <Clear/> </StubGeneration> <ShimGeneration> <Clear/> <Add FullName="System.IO.File"/> <Remove FullName="System.IO.FileStreamAsyncResult"/> <Remove FullName="System.IO.FileSystemEnumerableFactory"/> <Remove FullName="System.IO.FileInfoResultHandler"/> <Remove FullName="System.IO.FileSystemInfoResultHandler"/> <Remove FullName="System.IO.FileStream+FileStreamReadWriteTask"/> <Remove FullName="System.IO.FileSystemEnumerableIterator"/> </ShimGeneration> </Fakes>
Créer un test unitaire
Ajoutez un test unitaire pour votre projet.
Mettez à jour le fichier par défaut
TestProject\UnitTest1.csfourni par le modèle de projet.Recherchez la section de code suivante dans le fichier et remplacez-la par l’extrait de code fourni :
[TestMethod] public void TestMethod1() { }Fragment de remplacement :
[TestMethod] public void TestFileReadAllLine() { using (ShimsContext.Create()) { // Arrange System.IO.Fakes.ShimFile.ReadAllLinesString = (s) => new string[] { "Hello", "World", "Shims" }; // Act var target = new HexFile("this_file_doesnt_exist.txt"); Assert.AreEqual(3, target.Records.Length); } }Pour afficher tous les assemblies Fakes du test unitaire, sélectionnez Show All Files dans la barre de menus de Explorateur de solutions :
Ouvrez l’Explorateur de tests et exécutez le test.
Il est essentiel de supprimer correctement chaque contexte de shim. En règle générale, appelez la méthode ShimsContext.Create dans une instruction using pour garantir la suppression correcte des shims enregistrés. Par exemple, vous pouvez enregistrer un shim pour une méthode de test qui remplace la méthode DateTime.Now par un délégué qui renvoie toujours le 1er janvier 2000. Si vous oubliez de supprimer le shim enregistré dans la méthode de test, le reste de l’exécution des tests renvoie toujours la valeur DateTime.Now 1er janvier 2000. Ce résultat peut être surprenant et déroutant.
Passer en revue les conventions d’affectation de noms pour les classes shim
Les noms de classes Shim utilisent le Fakes.Shim préfixe suivi du nom de type d’origine. Les noms de paramètres sont ajoutés au nom de la méthode. (Vous n’avez pas besoin d’ajouter de référence d’assembly à System.Fakes.)
System.IO.File.ReadAllLines(path);
System.IO.Fakes.ShimFile.ReadAllLinesString = (path) => new string[] { "Hello", "World", "Shims" };
Comprendre le fonctionnement des shims
Les shims fonctionnent en introduisant des détours dans la base de code de l’application testée. Chaque fois qu’un appel à la méthode d’origine est effectué, le système Fakes intercepte et redirige l’appel, de sorte que votre code de shim personnalisé s’exécute à la place de la méthode d’origine.
Il est important de noter que ces détours sont créés et supprimés dynamiquement au moment de l’exécution. Les détours doivent toujours être créés pendant la durée de vie d’un ShimsContext. Lorsque shimsContext est supprimé, tous les shims actifs créés dans celui-ci sont également supprimés. Pour gérer cette conception efficacement, la recommandation consiste à encapsuler la création de détours dans une using instruction.
Découvrez les shims pour différents types de méthodes
Shims prennent en charge différents types de méthodes.
Méthodes statiques
Lorsque vous appliquez des shims à des méthodes statiques, les propriétés qui contiennent ces shims sont regroupées au sein d’un type de shim. Ces propriétés possèdent uniquement un setter, qui est utilisé pour attacher un délégué à la méthode ciblée.
Par exemple, pour une classe appelée MyClass avec une méthode MyMethodstatique :
//Code under test
public static class MyClass {
public static int MyMethod() {
...
}
}
Vous pouvez associer un shim à MyMethod de sorte qu’il renvoie toujours 5 :
// Unit test code
ShimMyClass.MyMethod = () => 5;
Méthodes d’instance (pour toutes les instances)
Tout comme les méthodes statiques, les méthodes d’instance peuvent également être redéfinies à l’aide d’un shim pour toutes les instances. Les propriétés qui contiennent ces shims sont placées dans un type imbriqué nommé AllInstances pour éviter toute confusion.
Pour la classe MyClass avec une méthode MyMethodd’instance :
// Code under test
public class MyClass {
public int MyMethod() {
...
}
}
Vous pouvez associer un shim à MyMethod afin qu’il renvoie systématiquement 5, quelle que soit l’instance :
// Unit test code
ShimMyClass.AllInstances.MyMethod = () => 5;
L’extrait de code suivant montre la structure de type générée de ShimMyClass:
// Fakes generated code
public class ShimMyClass : ShimBase<MyClass> {
public static class AllInstances {
public static Func<MyClass, int>MyMethod {
set {
...
}
}
}
}
Dans ce scénario, Fakes transmet l’instance d’exécution comme premier argument du délégué.
Méthodes d’instance (instance à runtime unique)
Les méthodes d’instance peuvent également être shimées à l’aide de différents délégués, en fonction du récepteur de l’appel. Cette approche permet à la même méthode d’instance d’exposer des comportements différents pour chaque instance du type. Les propriétés associées à ces shims sont des méthodes d’instance du type de shim lui-même. Chaque type de shim instancié est lié à une instance brute d’un type shimmed.
Par exemple, étant donné une classe MyClass avec une méthode MyMethodd’instance :
// Code under test
public class MyClass {
public int MyMethod() {
...
}
}
Vous pouvez créer deux types de shims pour MyMethod, de sorte que le premier renvoie systématiquement 5 et le second, systématiquement 10 :
// Unit test code
var myClass1 = new ShimMyClass()
{
MyMethod = () => 5
};
var myClass2 = new ShimMyClass { MyMethod = () => 10 };
L’extrait de code suivant montre la structure de type générée de ShimMyClass:
// Fakes generated code
public class ShimMyClass : ShimBase<MyClass> {
public Func<int> MyMethod {
set {
...
}
}
public MyClass Instance {
get {
...
}
}
}
L’instance de type shimmed réelle est accessible via la Instance propriété :
// Unit test code
var shim = new ShimMyClass();
var instance = shim.Instance;
Le type shim inclut également une conversion implicite vers le type shimmed, ce qui vous permet d’utiliser directement le type shim :
// Unit test code
var shim = new ShimMyClass();
MyClass instance = shim; // Implicit cast retrieves the runtime instance
Explorer les constructeurs de shim
Les constructeurs ne font pas exception au shimming. Ils peuvent être shimmés pour attacher des types de shim à des objets créés à l’avenir. Par exemple, chaque constructeur est représenté par une méthode statique nommée Constructor au sein du type shim.
Considérez une classe MyClass avec un constructeur qui accepte un entier :
public class MyClass {
public MyClass(int value) {
this.Value = value;
}
...
}
Un type shim pour ce constructeur peut être configuré de telle sorte que, quelle que soit la valeur passée au constructeur, chaque instance future retourne -5 lorsque le Value getter est appelé :
// Unit test code
ShimMyClass.ConstructorInt32 = (@this, value) => {
var shim = new ShimMyClass(@this) {
ValueGet = () => -5
};
};
Chaque type de shim expose deux types de constructeurs :
- Lorsque vous avez besoin d’une nouvelle instance, utilisez le constructeur par défaut.
- Lorsque vous disposez d’un shim de constructeur, utilisez le constructeur qui prend en argument une instance shimmée.
// Unit test code
public ShimMyClass() { }
public ShimMyClass(MyClass instance) : base(instance) { }
Le code suivant illustre le type généré pour :ShimMyClass
// Fakes generated code
public class ShimMyClass : ShimBase<MyClass>
{
public static Action<MyClass, int> ConstructorInt32 {
set {
...
}
}
public ShimMyClass() { }
public ShimMyClass(MyClass instance) : base(instance) { }
...
}
Accéder aux membres de base
Vous pouvez accéder aux propriétés de shim des membres de base en créant un shim pour le type de base. Ensuite, entrez l’instance enfant dans le constructeur de la classe shim de base.
Par exemple, considérez une classe MyBase avec une méthode MyMethod d’instance et un sous-type MyChild:
public abstract class MyBase {
public int MyMethod() {
...
}
}
public class MyChild : MyBase {
}
Un shim de MyBase peut être configuré en lançant un nouveau ShimMyBase shim :
// unit test code
var child = new ShimMyChild();
new ShimMyBase(child) { MyMethod = () => 5 };
Il est important de noter que lorsque vous passez le shim enfant en tant que paramètre au constructeur du shim de base, le type du shim enfant est implicitement converti en instance du shim enfant.
La structure du type généré pour ShimMyChild et ShimMyBase est similaire au code suivant :
// Fakes generated code
public class ShimMyChild : ShimBase<MyChild> {
public ShimMyChild() { }
public ShimMyChild(Child child)
: base(child) { }
}
public class ShimMyBase : ShimBase<MyBase> {
public ShimMyBase(Base target) { }
public Func<int> MyMethod
{ set { ... } }
}
Constructeurs statiques
Les types shim exposent une méthode StaticConstructor statique pour shimer le constructeur statique d’un type. Étant donné que les constructeurs statiques ne sont exécutés qu’une seule fois, vous devez vous assurer que le shim est configuré avant tout accès à un membre du type.
Finaliseurs
Les finaliseurs ne sont pas pris en charge dans Fakes.
Méthodes privées
Le générateur de code Fakes crée des propriétés shim pour les méthodes privées dont la signature ne contient que des types visibles, c’est-à-dire des types de paramètres et un type de retour visibles.
Interfaces de liaison
Lorsqu’un type shimmed implémente une interface, le générateur de code émet une méthode qui lui permet de lier tous les membres de cette interface à la fois.
Par exemple, en fonction d’une classe MyClass qui implémente IEnumerable<int>:
public class MyClass : IEnumerable<int> {
public IEnumerator<int> GetEnumerator() {
...
}
...
}
Vous pouvez substituer les implémentations de IEnumerable<int> dans MyClass en appelant la méthode Bind :
// Unit test code
var shimMyClass = new ShimMyClass();
shimMyClass.Bind(new List<int> { 1, 2, 3 });
La structure de type générée de ShimMyClass ressemble au code suivant :
// Fakes generated code
public class ShimMyClass : ShimBase<MyClass> {
public ShimMyClass Bind(IEnumerable<int> target) {
...
}
}
Modifier le comportement par défaut
Chaque type de shim généré inclut une instance de l’interface IShimBehavior , accessible via la ShimBase<T>.InstanceBehavior propriété. Ce comportement est appelé chaque fois qu’un client appelle un membre d’instance qui n’est pas explicitement shimmé.
Par défaut, si aucun comportement spécifique n’est défini, la conception utilise l’instance retournée par la propriété statique ShimBehaviors.Current , qui lève généralement une NotImplementedException exception.
Vous pouvez modifier ce comportement à tout moment en ajustant la InstanceBehavior propriété pour n’importe quelle instance de shim.
Par exemple, vous pouvez modifier le comportement pour ne rien faire ou renvoyer la valeur par défaut du type de retour : default(T)
// Unit test code
var shim = new ShimMyClass();
//Return default(T) or do nothing
shim.InstanceBehavior = ShimBehaviors.DefaultValue;
Vous pouvez également modifier globalement le comportement de toutes les instances shimmed, où la InstanceBehavior propriété n’est pas explicitement définie, en définissant la propriété statique ShimBehaviors.Current :
// Unit test code
// Change default shim for all shim instances where the behavior isn't set
ShimBehaviors.Current = ShimBehaviors.DefaultValue;
Identifier les interactions avec les dépendances externes
Pour vous aider à identifier quand votre code interagit avec des systèmes externes ou des dépendances (désignés par environment), vous pouvez utiliser des shims pour attribuer un comportement spécifique à tous les membres d’un type (y compris les méthodes statiques). En définissant le ShimBehaviors.NotImplemented comportement sur la propriété statique Behavior du type shim, tout accès à un membre de ce type qui n’est pas explicitement shimmé lève un NotImplementedException. Ce résultat peut servir de signal utile pendant le test, indiquant que votre code tente d’accéder à un système externe ou à une dépendance.
Voici un exemple de configuration de cette forme de shim dans votre code de test unitaire :
// Unit test code
// Assign the NotImplementedException behavior to ShimMyClass
ShimMyClass.Behavior = ShimBehaviors.NotImplemented;
Pour des raisons pratiques, une méthode abrégée est également fournie pour obtenir le même effet :
// Shorthand to assign the NotImplementedException behavior to ShimMyClass
ShimMyClass.BehaveAsNotImplemented();
Appeler des méthodes d’origine à partir des méthodes shim
Dans certains scénarios, vous devrez peut-être exécuter la méthode d’origine lors de l’exécution de la méthode shim. Par exemple, vous pouvez écrire du texte dans le système de fichiers après avoir validé le nom de fichier passé à la méthode.
Une approche pour gérer cette situation consiste à encapsuler un appel à la méthode d’origine à l’aide d’un délégué et de la ShimsContext.ExecuteWithoutShims() méthode :
// Unit test code
ShimFile.WriteAllTextStringString = (fileName, content) => {
ShimsContext.ExecuteWithoutShims(() => {
Console.WriteLine("enter");
File.WriteAllText(fileName, content);
Console.WriteLine("leave");
});
};
Vous pouvez également nullifier le shim, appeler la méthode d’origine, puis restaurer le shim :
// Unit test code
ShimsDelegates.Action<string, string> shim = null;
shim = (fileName, content) => {
try {
Console.WriteLine("enter");
// Remove shim in order to call original method
ShimFile.WriteAllTextStringString = null;
File.WriteAllText(fileName, content);
}
finally
{
// Restore shim
ShimFile.WriteAllTextStringString = shim;
Console.WriteLine("leave");
}
};
// Initialize the shim
ShimFile.WriteAllTextStringString = shim;
Gérer la concurrence avec des types de shim
Les types shim fonctionnent sur l’ensemble des threads au sein de l’AppDomain et ne possèdent pas d’affinité avec un thread. Il est essentiel de garder cette caractéristique à l’esprit si vous envisagez d’utiliser un lanceur de tests prenant en charge l’exécution concurrente. Il est important de noter que les tests qui impliquent des types shim ne peuvent pas s’exécuter simultanément, bien que le runtime Fakes n’applique pas cette restriction.
Utiliser des shims avec System.Environment
Pour shimer la System.Environment classe, vous devez modifier le mscorlib.fakes fichier.
Recherchez l’élément \<Assembly> et ajoutez le contenu suivant après la définition de l’élément :
<ShimGeneration>
<Add FullName="System.Environment"/>
</ShimGeneration>
Après avoir apporté des modifications et régénéré la solution, les méthodes et les propriétés de la System.Environment classe sont désormais disponibles pour le shimming.
Voici un exemple de la façon dont vous pouvez affecter un comportement à la GetCommandLineArgsGet méthode :
System.Fakes.ShimEnvironment.GetCommandLineArgsGet = ...
Lorsque vous apportez ces modifications, vous pouvez contrôler et tester la façon dont votre code interagit avec les variables d’environnement système, qui est un outil essentiel pour les tests unitaires complets.