Fermer

septembre 17, 2018

Fonctions C # encore plus prises en charge dans Telerik JustMock R3 2018


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.

Save My Seat

Le meilleur outil 2023 pour ta croissance Instagram !



Source link