La version de JustMock R3 est maintenant opérationnelle, apportant un support pour les fonctionnalités C # 7 "Valeurs de retour ref et locus ref", "Fonctions locales" ainsi que "Paramètres nommés" et moquage de propriétés non publiques.
vous avez eu du mal à tester une méthode qui renvoie une référence, ou la fonction locale définie dans une méthode, alors c'est l'article que vous devriez lire. Lisez la suite pour voir tout ce qui est nouveau dans la publication Telerik JustMock R3 2018.
Valeurs de retour de référence et locaux de référence
Si vous avez suivi le développement du langage C # "Ref retourne les valeurs et les locaux de ref." Tester cette fonctionnalité dans le code est souvent liée à la lutte de mot. La version R3 2018 rend les tests aussi simples que l'écriture de plusieurs lignes de code. Considérez les méthodes suivantes qui doivent être testées:
internal class Foo
{
private static int [] tableau = {1, 2, 3, 4, 5, 6};
] public ref int GetRefReturnInstanceWithArgs ( ref int p)
[
ref int local = ref array [0];
local + = p;
retour ref local;
} [19659002]
privé statique ref int GetRefReturnPrivateStaticWithArgs ( ref [19659006] int p)
[
ref int [19659007] local = ref array [0];
local + = p;
]
retour ref local;
[19659002] }
Une des parties intrigantes du test de ce code est la façon dont une valeur considérée comme un retour de référence peut être créée et renvoyée à la place de la valeur d'origine. JustMock introduit un délégué dédié à la gestion d'un tel scénario et une classe d'assistance LocalRef qui simplifie son utilisation. Vérifiez le code suivant pour voir un exemple de test de la manière dont la valeur de retour ref est créée et utilisée:
[TestMethod]
public void MockRefReturnInstanceMethodWithArgs ()
]
// Disposition
int Valeur attendue = 12;
var sut = Mock.Create ();
LocalRefHandle < int [19659084]> localRef = LocalRef.WithValue (expectValue);
Mock.Arrange (sut, s => s.GetRefReturnInstanceWithArgs ( ref Arg.Ref (Arg.AnyInt) .Value))
.Returns (localRef.Handle)
.OccursOnce ();
// Acte
int param = 10;
ref int resultat = ref sut.GetRefReturnInstanceWithArgs ( ref param) ;
// Assert
.Assert (sut);
Assert.Equal (Valeur attendue, résultat);
} [19659069] Et qu'en est-il lorsque la méthode est privée ou même privée statique? Il devrait être beaucoup plus difficile de le tester, non? Pas du tout.
Nous suivons l'approche déjà connue consistant à simuler des API non publiques avec l'attente Mock.NonPublic. Mais pour éviter toute confusion sur la méthode d'arrangement exacte dans l'attente non publique, nous avons extrait la logique requise dans une interface distincte nommée INonPublicRefReturnExpectation.
Consultez l'exemple de test suivant:
[TestMethod]
public void MockRefReturnPrivateStaticMethodWithArgs ()
]
// Disposition
int Valeur attendue = 12;
Mock.SetupStatic ();
LocalRefHandle < int > localRef = LocalRef.WithValue (expectedValue);
Mock.NonPublic.RefReturn.Arrange <Foo, int > ( " GetRefReturnPrivateStaticWithArgs "ArgExpr.Ref (1))
.Returns (localRef.Handle)
[19659032] .OccursOnce ();
// Acte
] var privateAccessor = Mock.NonPublic.MakeStaticPrivateAccessor ( typeof (Foo));
int param = 10 ;
ref int res = ref privateAccessor.RefReturn.CallMethod < int > ( "GetRefReturnPrivateStaticWithArgs" Arg.Ref (param) .Value);
// Assert
Mock.Assert ();
Assert.Equal ( expectedValue, res);
} [19659069] Comme je l'ai dit, plusieurs lignes de code pour un test suivant le schéma de test Arrange, Act, Assert (AAA) et la lutte sont terminées. Si vous avez besoin de plus d'informations, vous pouvez consulter notre article sur le sujet .
Fonctions locales
Fonctions locales est une autre fonctionnalité du langage C # que les développeurs sont impatients d'utiliser il. Mais alors ils font un pas en arrière après avoir trébuché sur la question de "comment tester une fonction locale?" La raison est simple. Jusqu'à présent, il n'existait aucun moyen efficace et maintenable de tester les fonctions locales.
Telerik JustMock est désormais le premier outil qui prend en charge le test et la simulation des fonctions locales de manière fiable. Maintenant à la partie plus pratique. Comment exactement je peux écrire mes tests? Considérez la classe suivante qui doit être testée:
interne classe Foo
[
public int GetResult ()
retour [19659007] 100 + GetLocal ();
int GetLocal ()
{
retour 42;
}
}
}
Pour simuler cette fonction locale simple, j'aurais besoin d'informations sur le nom de la classe, le nom o f la méthode du propriétaire et le nom de la fonction locale. Voici à quoi ressemblerait le test:
[TestMethod]
public néant TestBasicScenario ()
]
// Disposition
var sut = Mock.Create (Behavior.CallOriginal );
Mock.Local.Function.Arrange < int > (sut, "GetResult" [19659137] "GetLocal" ). DoNothing ();
// Act
var result = sut.GetResult ();
// Assert
Assert.AreEqual (100, résultat);
}
Vous pouvez voir que la maquette est créée avec le comportement d'origine de l'appel. Cela est nécessaire pour que la méthode propriétaire GetResult exécute le code d'origine.
C'était le cas le plus élémentaire, mais qu'en est-il si une surcharge qui prend des paramètres et possède également une fonction locale est ajoutée ultérieurement au code? Considérez la surcharge suivante:
public int GetResult ( int param)
{
retour param + 100 + GetLocal ();
int GetLocal () [19659002] [
retour 200;
}
}
Bien, dans ce cas, un autre test devrait être écrit pour la seconde surcharge avec des informations sur les types de ses paramètres. Voici à quoi ressemblerait le test:
[TestMethod]
public néant MockGetResultParams ()
]
// Disposition
var sut = Mock.Create (Behavior.CallOriginal );
Type [] containsMethodParamTypes = nouveau Type [] { typeof ( int )
Mock.Local.Function.Arrange < int > (sut, "GetResult" [19659084]containsMethodParamTypes, "GetLocal" ). Retourne (42);
// Loi
var resultParams = sut.GetResult (10);
// Assert
Assert.AreEqual (42, resultParams);
}
JustMock prend désormais en charge l'exécution directe d'une fonction locale. Utilisez simplement la méthode Call dans l'interface IFunctionExpectation. Considérez la classe suivante qui doit être testée:
interne classe Foo
{
privée bool IsEven ( valeur int )
[
bool isEven = (valeur% 2 == 0)? true : false ;
retourner isEven;
}
public void Méthode ()
{19459013]
bool resultat = LocalFunction (10);
] bool LocalFunction ( int ))
[
retourner IsEven (valeur);
[19659024]}
}
Et voici à quoi ressemblerait le test:
[TestMethod]
public néant CallLocal ()
[ ]
// Disposition
var sut = Mock.Create (Behavior.CallOriginal );
Mock.NonPublic.Arrange < bool > (sut, "IsEven" ). false )
// Acte
] var result = Mock.Local.Function.Call (sut, "Method" "LocalFunction" 14); [19659002]
// Assert
Assert.Equal ( false résultat);
}
Si vous vous posez la question, JustMock prend également en charge les fonctions locales utilisées dans méthodes et classes privées et statiques. Pour plus d'informations, consultez notre article de documentation .
Mocking non-Public Property Setters
Si vous avez utilisé une solution de contournement désagréable pour simuler un setter de propriété non-public . Vous pouvez le supprimer en toute sécurité. Nous avons introduit la méthode ArrangeSet dans l'interface INonPublicExpectation accessible via la classe Mock pour vous aider à tester ces paramètres privés. Jetez simplement un coup d'œil à l'exemple de test suivant pour mieux comprendre le concept.
Voici la propriété privée qui serait testée:
public class Foo
[
privé int Index { get ; set ; }
}
Et voici à quoi devrait ressembler le test:
[TestMethod]
public néant MockNonPublicPropArrangeSet ()
]
// Disposition
int AttenduValue = 20;
var sut = Mock.Create (Behavior.CallOriginal);
var privateAccessor = Mock .NonPublic.MakePrivateAccessor (sut);
Mock.NonPublic.ArrangeSet (sut, "Index" 12) .DoInstead (( ) => privateAccessor.SetProperty ( "Index" Valeur attendue));
// Loi
[19659024] privateAccessor.SetProperty ( "Index" 12);
int res = ( int ]) privateAccessor.GetProperty ( "Index" );
// Assert
Assert.Equal (expectedValue, res);
}
Paramètres nommés
Paramètres nommés a été une fonctionnalité de C # depuis longtemps maintenant et il est très populaire parmi les développeurs. Par conséquent, il y a quelque temps, nous avons introduit la prise en charge des méthodes d'instance moqueuses acceptant les paramètres nommés. Mais nous n'avions pas implémenté le support des méthodes statiques moqueuses acceptant des paramètres nommés. C'est maintenant chose faite, et c'est aussi simple que d'arranger une méthode statique normale. Vérifiez l'exemple de test suivant:
Voici la classe et la méthode à tester.
internal class Foo
{ [19659002] public static void StaticAction ( int param1 = 0, int param2 = 0, int param3 = 0)
lance new Exception non implémentée ();
}
Et voici ce que le le test devrait ressembler à:
[TestMethod]
public void TestStaticMethodAcceptingNamedParameters ()
]
// Disposition
Mock.SetupStatic ();
Mock.Arrange (() => Foo.StaticAction (param2: 2, param1: 3)). OccursOnce (); [19659002]
// Acte
Foo.StaticAction (3, 2);
// Assert
Mock. Assert ();
}
Découvrez la dernière ve
Assurez-vous d'essayer la dernière version de JustMock et de nous contacter avec vos commentaires . Il est déjà disponible pour téléchargement sur votre compte.
Pas un client JustMock? N'hésitez pas à télécharger une version d'évaluation gratuite de 30 jours .
Lancez ma version d'évaluation JustMock
Visionnez les webinaires de publication R3
notre nouveau communiqué en action, veuillez vous joindre à nous pour le webinaire Telerik UI R3 2018 le 2 octobre 2018 à 11 heures.
Source link