Quelle est la différence entre les falsifiant, en se moquant, et buter?

Vous pouvez obtenir des renseignements :

De Martin Fowler au sujet de Dérision et de Stub

Faux objets ont implémentations de travail, mais l'habitude de prendre des raccourcis qui les rend aptes à la production

Talons fournir des conserves de réponses à des appels effectués au cours de l'essai, habituellement, ne répond pas du tout à quoi que ce soit à l'extérieur de ce qui est programmée pour le test. Les talons peuvent également enregistrer des informations concernant les appels d'offres, comme une passerelle de messagerie stub qui se souvient des messages qu'il "envoyé", ou peut-être seulement le nombre de messages qu'il "envoyer".

Se moque de sont ce que nous en parlons ici: les objets pré-programmé avec des attentes, ce qui forme un cahier des charges des appels qu'ils devraient recevoir.

De xunitpattern:

Faux: Nous acquérir ou de construire une très légère mise en œuvre de la même fonctionnalité fournie par un composant qui le SUT dépend et d'instruire le SUT d'utiliser à la place du réel.

Stub : Cette application est configuré pour répondre à des appels de la CUS avec les valeurs (ou exceptions) qui exercera la fonction de Code non testé (voir la Production de Bugs sur la page X) au sein de la CUS. Une indication clé pour l'utilisation d'un Test de Stub est d'avoir le Code non testé causé par l'incapacité de contrôler les apports indirects de la SUT

Objet fantaisie qui implémente la même interface que l'objet sur lequel le SUT (Système Sous Test) dépend. On peut utiliser un Objet Fantaisie comme un point d'observation où nous avons besoin de faire le Comportement de Vérification pour éviter d'avoir un non testé Exigence (voir la Production de Bugs sur la page X) causée par une incapacité à observer les effets secondaires de l'appel de méthodes sur la CUS.

Personnellement

J'essaie de simplifier la vie en utilisant : Maquette et le Talon. J'utilise se Moquer quand c'est un objet qui renvoie une valeur qui est définie pour la classe testée. J'utilise Talon pour imiter une Interface ou une classe Abstraite pour être testé. En fait, il n'importe pas vraiment ce que vous l'appelez, ils sont de toutes les classes qui ne sont pas utilisés dans la production, et sont utilisés comme des classes utilitaires pour tester.

Je suis surpris que cette question a été autour depuis si longtemps et personne n'a encore fourni une réponse basée sur Roy Osherove de "L'Art de Tests Unitaires,.

Dans "3.1 Introduction stubs" définit un talon comme:

Un stub est une contrôlable de remplacement pour une dépendance
(ou collaborateur) dans le système. À l'aide d'un tampon, vous pouvez tester votre code sans
traitant de la dépendance directement.

Et définit la différence entre les talons et se moque comme:

La principale chose à retenir à propos de simulacres plutôt que de les stubs qui se moque sont comme les talons, mais vous valoir à l'encontre de la maquette de l'objet, alors que vous ne pas faire valoir contre une souche.

Faux, c'est juste le nom utilisé pour les deux talons et se moque. Par exemple, lorsque vous ne vous inquiétez pas à propos de la distinction entre les talons et se moque.

La façon Osherove la distinction entre les talons et se moque de, signifie que toute la classe utilisée comme un faux pour les tests peuvent être à la fois un tampon ou une maquette. Qui c'est pour un test spécifique qui dépend entièrement de la façon dont vous écrivez le vérifie dans votre test.

• Lors de votre test vérifie les valeurs dans la classe sous test, ou en fait n'importe où, mais le faux, le faux a été utilisé comme un tampon. Il vient de valeurs fournies pour la classe sous test, soit directement par les valeurs renvoyées par les appels ou indirectement par l'intermédiaire de causer des effets secondaires (dans certains états) suite à des appels sur elle.
• Lors de votre test vérifie les valeurs de la faux, il a été utilisé comme un simulacre.

Exemple de test de la classe FakeX est utilisé comme un stub:

const pleaseReturn5 = 5;
var fake = new FakeX(pleaseReturn5);
var cut = new ClassUnderTest(fake);

cut.SquareIt;

Assert.AreEqual(25, cut.SomeProperty);

La fake exemple, est utilisé comme un tampon parce que le Assert ne pas utiliser fake à tous.

Exemple d'un test où la classe de test X est utilisé comme un simulacre:

const pleaseReturn5 = 5;
var fake = new FakeX(pleaseReturn5);
var cut = new ClassUnderTest(fake);

cut.SquareIt;

Assert.AreEqual(25, fake.SomeProperty);

Dans ce cas, le Assert vérifie la valeur sur fake, ce qui le rend faux d'une fantaisie.

Maintenant, bien sûr, ces exemples sont très artificiel, mais je vois beaucoup de mérite dans cette distinction. Il vous fait prendre conscience de la façon dont vous testez vos trucs et où les dépendances de votre test sont.

Je suis d'accord avec Osherove qui

à partir d'un pur maintenabilité point de vue, dans mes tests, l'aide se moque crée plus de problèmes que de ne pas les utiliser. Cela a été mon expérience, mais je suis toujours en train d'apprendre quelque chose de nouveau.

Faire valoir contre le faux, c'est quelque chose que vous voulez vraiment éviter, car il rend vos tests fortement tributaire de la mise en œuvre d'une classe qui n'est pas l'objet de l'essai à tous. Ce qui signifie que les tests pour la classe ActualClassUnderTest peut commencer à briser parce que la mise en œuvre de ClassUsedAsMock changé. Et qui envoie une odeur désagréable pour moi. Tests pour ActualClassUnderTest doit, de préférence, break uniquement lorsque ActualClassUnderTest est changé.

Je me rends compte que l'écriture affirme contre le faux, c'est une pratique courante, surtout quand vous êtes un mockist type de TDD abonné. Je suppose que je suis fermement avec Martin Fowler dans le classicisme camp (Voir Martin Fowler "Simulacres ne sont pas des Talons") et comme Osherove éviter l'interaction des tests (qui ne peut être fait en s'affirmant contre le faux) autant que possible.

Pour le plaisir de la lecture sur pourquoi vous devriez éviter de se moque de tel que défini ici, google pour "fowler mockist classique". Vous trouverez une pléthore d'opinions.

Pour illustrer l'utilisation de talons et se moque, je voudrais également inclure un exemple basé sur Roy Osherove du "L'Art de Tests Unitaires".

L'imaginer, nous avons un LogAnalyzer application qui a pour seule fonction de l'impression de journaux. Il ne doit pas seulement parler à un service web, mais si le service web renvoie une erreur, LogAnalyzer a pour vous connecter l'erreur à une autre dépendance externe, de l'envoyer par e-mail pour le service web de l'administrateur.

Ici est la logique que nous aimerions tester à l'intérieur de LogAnalyzer:

if(fileName.Length<8)
{
 try
  {
    service.LogError("Filename too short:" + fileName);
  }
 catch (Exception e)
  {
    email.SendEmail("a","subject",e.Message);
  }
}

Comment faites-vous tester LogAnalyzer appelle le service de messagerie correctement lorsque le service web renvoie une exception?
Voici les questions auxquelles nous sommes confrontés:

• Comment pouvons-nous remplacer le service web?

• Comment peut-on simuler une exception dans le service web, de sorte que nous pouvons
  test de l'appel pour le service de messagerie?

• Comment saurons-nous que le service de messagerie a été appelée correctement ou à
  tous?

Nous pouvons traiter avec les deux premières questions par à l'aide d'un tampon pour le service web. Pour résoudre le troisième problème, nous pouvons utiliser un objet fantaisie pour le service de messagerie.

Un faux, c'est un terme générique qui peut être utilisé pour décrire un tampon ou une maquette.Dans notre test, nous allons avoir deux faux. L'un sera le service de messagerie maquette, que nous allons utiliser pour vérifier que les paramètres corrects ont été envoyés pour le service de messagerie. L'autre sera un stub que nous allons utiliser pour simuler une exception levée par le service web. C'est un stub parce que nous ne serons pas en utilisant le service web de faux pour vérifier le résultat du test, seulement assurez-vous que le test fonctionne correctement. Le service de messagerie est un simulacre, car nous allons faire valoir à son encontre qu'il a été appelé correctement.

[TestFixture]
public class LogAnalyzer2Tests
{
[Test]
 public void Analyze_WebServiceThrows_SendsEmail()
 {
   StubService stubService = new StubService();
   stubService.ToThrow= new Exception("fake exception");
   MockEmailService mockEmail = new MockEmailService();

   LogAnalyzer2 log = new LogAnalyzer2();
   log.Service = stubService
   log.Email=mockEmail;
   string tooShortFileName="abc.ext";
   log.Analyze(tooShortFileName);

   Assert.AreEqual("a",mockEmail.To); //MOCKING USED
   Assert.AreEqual("fake exception",mockEmail.Body); //MOCKING USED
   Assert.AreEqual("subject",mockEmail.Subject);
 }
}

Si vous êtes familier avec les Arrange-Loi-Valoir, alors un moyen d'expliquer la différence entre le talon et le simulacre qui pourrait être utile pour vous, c'est que les talons appartiennent à l'arrangement de la section, comme ils le sont pour l'organisation d'état d'entrée, et se moque appartiennent à l'assertion de la section qu'ils le sont pour faire valoir les résultats de la contre.

Les nuls de ne pas faire n'importe quoi. Ils sont juste pour remplir les listes de paramètres, de sorte que vous n'avez pas défini ou null erreurs. Ils existent aussi pour satisfaire le vérificateur de types strictement tapé langues, de sorte que vous pouvez être autorisé à compiler et exécuter.

stub et faux sont des objets qu'ils peuvent faire varier leur réponse en fonction des paramètres d'entrée. la principale différence entre eux est que d'un Faux est plus proche du monde réel de la mise en œuvre de la souche. Talons contiennent essentiellement codée en dur réponses à une demande attendue. Voyons un exemple:

public class MyUnitTest {

 @Test
 public void testConcatenate() {
  StubDependency stubDependency = new StubDependency();
  int result = stubDependency.toNumber("one", "two");
  assertEquals("onetwo", result);
 }
}

public class StubDependency() {
 public int toNumber(string param) {
  if (param == “one”) {
   return 1;
  }
  if (param == “two”) {
   return 2;
  }
 }
}

Un se moquer de est un faux et des talons. On se moque de fournir les mêmes fonctionnalités que les talons mais sont plus complexes. Ils peuvent avoir des règles définies pour eux qui dictent l'ordre de méthodes sur leur API doit être appelée. Les plus ils peuvent faire le suivi du nombre de fois qu'une méthode est appelée, et peut réagir en fonction de cette information. On se moque généralement connaître le contexte de chaque appel et peut réagir différemment à des situations différentes. De ce fait, se moque nécessitent une certaine connaissance de la classe, elles sont habitées. un stub est généralement impossible de savoir combien de fois une méthode a été appelée ou de l'ordre d'une séquence de méthodes a été appelé. Une maquette ressemble:

public class MockADependency {

 private int ShouldCallTwice;
 private boolean ShouldCallAtEnd;
 private boolean ShouldCallFirst;

 public int StringToInteger(String s) {
  if (s == "abc") {
   return 1;
  }
  if (s == "xyz") {
   return 2;
  }
  return 0;
 }

 public void ShouldCallFirst() {
  if ((ShouldCallTwice > 0) || ShouldCallAtEnd)
   throw new AssertionException("ShouldCallFirst not first thod called");
  ShouldCallFirst = true;
 }

 public int ShouldCallTwice(string s) {
  if (!ShouldCallFirst)
   throw new AssertionException("ShouldCallTwice called before ShouldCallFirst");
  if (ShouldCallAtEnd)
   throw new AssertionException("ShouldCallTwice called after ShouldCallAtEnd");
  if (ShouldCallTwice >= 2)
   throw new AssertionException("ShouldCallTwice called more than twice");
  ShouldCallTwice++;
  return StringToInteger(s);
 }

 public void ShouldCallAtEnd() {
  if (!ShouldCallFirst)
   throw new AssertionException("ShouldCallAtEnd called before ShouldCallFirst");
  if (ShouldCallTwice != 2) throw new AssertionException("ShouldCallTwice not called twice");
  ShouldCallAtEnd = true;
 }

}