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

Question

Je voudrais mettre en place une valeur de retour

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

mais dans un test spécifique, passer outre cette attente de retourner faux.

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 revenir faux sur le deuxième appel, je veux remplacer la première attente.

Ceci aiderait grandement à simplifier mon scénario de test.

Answer 1

Il existe trois façons:

Vous pouvez réinitialiser les attentes en utilisant BackToRecord

Je dois admettre que je 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, il est en fait la manière la plus propre. Il devrait y avoir une méthode d'extension (comme Stub) qui le fait - je pense que c'est juste oublié. Je suggérerais d'écrire le vôtre.

Vous pouvez utiliser Repeat.Any()

Il brise l'ordre de la définition et bouchonné « préséances » 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 ne changer qu'un appel.

_stubRepository = MockRepository.GenerateMock<IRepository>(); 
_stubRepository.Stub(x => x.Contains(null)) 
    .IgnoreArguments() 
    .Return(false); 

Answer 2

Pour ces situations, je créé une méthode simple extention RinoMocks pour mieux montrer l'intention de la souche et promouvoir la lisibilité.

public static void OverridePrevious<T>(this IMethodOptions<T> options) 
{ 
    options.Repeat.Any(); 
} 

Ainsi, au lieu d'un appel cryptique comme suit qui peut nécessiter 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 test plus lisible que montre mieux l'intention des appels .Repeat.Any() :

carStub.Stub(x => x.Model).Return(null).OverridePrevious(); 

Answer 3

au nom de la communauté, je vais ajouter ceci à ajouter à la liste des options de Stefan ci-dessus:

Si la valeur de retour doit être changée fréquemment, je trouve qu'il est propre et efficace d'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 que Contains est appelé et parce que nous avons créé une référence à la fermeture returnValue, il regardera toujours la valeur actuelle de returnValue.