Comment effacer les précédentes attentes sur un objet?

Je tiens à mettre en place une valeur de retour

_stubRepository.Stub(Contains(null)).IgnoreArguments().Return(true);

mais alors à un test spécifique, remplacer ce qui est attendu de fausse déclaration.

Quelque chose comme:

_stubRepository.ClearExpectations();  //<- this does not exist, I'm just making something up
_stubRepository.Stub(Contains(null)).IgnoreArguments().Return(false);

Avis, je ne veux pas l'attente de fausse déclaration sur le second appel, je veux remplacer la première attente.

Cela permettrait de simplifier mes tests scénario considérablement.

InformationsquelleAutor George Mauer | 2009-04-20

.net rhino-mocks

75

Il y a trois façons:

Vous pouvez réinitialiser les attentes en utilisant BackToRecord

Je dois avouer que je n'ai jamais vraiment utilisé parce qu'il est maladroit.
```
//clear expectations, an enum defines which
_stubRepository.BackToRecord(BackToRecordOptions.All);
//go to replay again.
_stubRepository.Replay();
```
Edit: Maintenant je l'utilise parfois, c'est en fait la façon la plus propre. Il devrait y avoir une méthode d'extension (comme Stub), qui n'est elle - je pense qu'il a juste obtenu oublié. Je vous propose de rédiger votre propre.

Vous pouvez utiliser la Répétition.Tout()

Il des "pauses" de l'ordre de l'écrasé de définition et de "remplacement" des définitions précédentes. Mais c'est en quelque sorte implicite. Je l'utilise parfois, parce que c'est facile à écrire.
```
_stubRepository.Stub(x => x.Contains(null))
  .IgnoreArguments()
  .Return(false)
  .Repeat.Any();
```
Vous pouvez créer une nouvelle maquette

Trivial, mais explicite et facile à comprendre. C'est seulement un problème si vous voulez garder beaucoup de définitions et de ne modifier que d'un seul appel.
```
_stubRepository = MockRepository.GenerateMock<IRepository>();
_stubRepository.Stub(x => x.Contains(null))
  .IgnoreArguments()
  .Return(false);
```
- En interne Rhino Mock parler, à l'aide de Répéter. Tout crée un reproductibles attente, ce qui trump attentes normales au cours de la lecture. Je recommande d'utiliser BackToRecord, cependant.
- Ah, soit tout compris, sauf pour la Relecture() de l'appel.
- C'est une chose vraiment connu par les gens à l'aide de RhinoMocks depuis 3.4 ou plus. RhinoMocks travaillé à la tenue de la Relecture, cela signifie qu'une maquette a dû être mis en mode de reprise explicitement. Avec 3.5, heureusement, cela a disparu, on se moque toujours en mode de lecture (au moins pour le code personnalisé). Jusqu'à ce que vous remettez sur le mode d'enregistrement - à l'exception de la compensation attentes, je ne vois aucune raison de le faire. J'ai déjà voulu écrire un correctif pour ce deux lignes confortablement réinitialiser les attentes.
- public static void ResetExpectations<T>(ce T fictif) où T : classe { maquette.BackToRecord(BackToRecordOptions.Les attentes); se moquer.Replay(); } j'ai un tas de pratique rhino se moque des extensions que je devrais mettre sur google code en fait..
- Que faire si vous avez défini plusieurs attentes sur la maquette de l'objet et que vous souhaitez réinitialiser un seul d'entre eux? Est la Répétition.Toute option le seul?
- Vous pouvez également éviter la réinitialisation des attentes à l'aide de AssertWasCalled au lieu de Expect et WhenCalled au lieu de Return. Il y a aussi un TentativeReturn, qui, je l'ai utilisée jusqu'à maintenant. Je devrais écrire un paragraphe sur la façon d'éviter le problème ...
InformationsquelleAutor Stefan Steinegger
22

Pour ces situations, j'ai créé un simple RinoMocks de l'extension de la méthode afin de mieux montrer l'intention de talon et d'accroître la lisibilité.
```
public static void OverridePrevious<T>(this IMethodOptions<T> options)
{
    options.Repeat.Any();
}
```
Ainsi, au lieu d'un mystérieux appel comme celui-ci qui peut exiger un commentaire:
```
[SetUp]
public void Setup()
{
    carStub.Stub(x => x.Model).Return("Model1");
    carStub.Stub(x => x.Model).Return("Model2");
}

[Test]
public void SomeTest()
{
    //Arrange
    //overrides previous stubs that were setup for the Model property
    carStub.Stub(x => x.Model).Return(null).Repeat.Any();

    //Act
    //Assert
}
```
Vous pouvez obtenir un plus lisible test qui montre mieux l'intention de l' .Répétez.Tout() appelle:
```
carStub.Stub(x => x.Model).Return(null).OverridePrevious();
```
- Afin de garder l'option ouverte pour la chaîne de la stub de la configuration, ne devrait pas l'extension de la méthode de retour d'un IMethodOptions<T>? public static IMethodOptions<T> OverridePrevious<T>(this IMethodOptions<T> options) { return options.Repeat.Any(); }.
- Je n'ai pas essayé ou eu le besoin de garder la "chaîne ouverte" mais oui, je suppose que vous avez raison. Bon point.
- J'aime OverridePrevious comme nulle - il des forces pour la fin.
InformationsquelleAutor MoMo
7

Pour le bien de la communauté, je vais ajouter cette ajouter à Stefan de la liste des options ci-dessus:

Si la valeur de retour doit être changé fréquemment, je trouve ça propre et efficace à utiliser une fermeture comme suit.
```
bool returnValue = true;
_stubRepository.Stub(x => x.Contains(null)).IgnoreArguments().Do(new Func<bool>(() => {
    return returnValue;
}));

returnValue = false;
//Calls to Contains now return false;

returnValue = true;
//Calls to Contains now return true;
```
L'expression lambda sera exécutée à chaque fois Contains est appelé et parce que nous avons créé une fermeture de référencement returnValue, il va toujours chercher le actuel valeur de returnValue.
- C'est la solution la plus propre à mon avis
InformationsquelleAutor Micah Hahn

Vous devez vous connecter pour publier un commentaire.