Quel est le but des objets fictifs?

Question

Je suis nouveau dans le domaine des tests unitaires et j'entends continuellement les mots "objets fictifs" qui jaillissent beaucoup. En termes simples, quelqu'un peut-il expliquer ce que sont des objets fictifs et à quoi ils servent généralement lors de l'écriture de tests unitaires?

Answer 1

Puisque vous dites que vous êtes nouveau aux tests unitaires et a demandé pour les objets fantaisie dans les "termes du profane", je vais essayer un profane de l'exemple.

Les Tests Unitaires

Imaginez les tests unitaires pour ce système:

cook <- waiter <- customer

Il est en général aisé de concevoir des tests de bas niveau composant comme l' cook:

cook <- test driver

Le pilote d'essai simplement les commandes de plats différents et vérifie le cuisinier retourne le bon plat pour chaque commande.

Plus difficile de tester un composant intermédiaire, comme le garçon, qui utilise le comportement des autres composants. Un naïf testeur peut tester le serveur composant de la même façon, nous avons testé le cuisinier composant:

cook <- waiter <- test driver

Le pilote d'essai de l'ordre de différents plats et assurer le serveur renvoie le bon plat. Malheureusement, cela signifie que ce test du serveur de composant peut être dépendante sur le comportement correct de le faire cuire composant. Cette dépendance est encore pire si le cuisinier composant a toute épreuve-hostiles caractéristiques, comme un comportement non déterministe (le menu est composé du chef de surprise que d'un plat), de nombreuses dépendances (cook ne pas cuire sans l'ensemble de son personnel), ou beaucoup de ressources (certains plats nécessitent les ingrédients chers ou prendre une heure pour cuisiner).

Depuis ce serveur de test, idéalement, nous voulons tester le serveur, pas le cuire. Plus précisément, nous voulons nous assurer que le serveur transmet la commande du client afin de le faire cuire correctement et fournit les faire cuire de la nourriture pour le client correctement.

Les tests unitaires moyens d'essais unités de manière indépendante, donc une meilleure approche serait d'isoler le composant sous test (le garçon) à l'aide de ce Fowler appels de test en double (les nuls, les mégots, les faux, les simulacres).

    -----------------------
   |                       |
   v                       |
test cook <- waiter <- test driver

Ici, le test cook est "de mèche" avec le pilote d'essai. Idéalement, le système sous test est conçu de sorte que le test de cuisiner peut être facilement substitué (injecté) pour travailler avec le serveur sans changer le code de production (par exemple, sans changer le serveur de code).

Les Objets Fantaisie

Maintenant, le test cook (test double) pourrait être mis en place différentes façons:

• un faux cuire une à quelqu'un prétendant être un cuisinier en utilisant les repas et un four micro-ondes,
• un talon de cook - un vendeur de hot-dog qui vous donne toujours des hot-dogs, peu importe ce que vous commandez, ou
• une maquette à cuire, un flic infiltré à la suite d'un script faisant cuire dans une opération de piqûre.

Voir Fowler de l'article pour plus de détails au sujet des faux vs talons vs se moque de vs les nuls, mais pour l'instant, concentrons-nous sur un simulacre de cuire.

    -----------------------
   |                       |
   v                       |
mock cook <- waiter <- test driver

Une grande partie de l'unité de test, le serveur volet se concentre sur la façon dont le garçon interagit avec le cuisinier de la composante . Une maquette approche axée sur la spécification de ce que la bonne interaction et de détecter quand il va mal.

L'objet fantaisie sait à l'avance ce qui est censé se produire lors de l'essai (par exemple, les appels de méthodes à invoquer, etc.) et le simulacre de l'objet ne sait pas comment il est censé réagir (par exemple, ce retour de la valeur à fournir). La simulation indique que ce qui se passe vraiment diffère de ce qui est censé se produire. Une coutume de se moquer de l'objet peut être codé pour le comportement attendu de chaque cas de test, mais un moqueur cadre s'efforce de permettre un tel comportement de la spécification afin d'être clairement et facilement indiquées dans les cas de test.

La conversation autour d'une maquette de test basés pourrait ressembler à ceci:

pilote d'essai pour se moquer de cook: attendre un hot-dog de l'ordre et de lui donner ce mannequin hot-dog dans la réponse

pilote d'essai (posant en tant que client), pour garçon: je voudrais un hot-dog merci
garçon à se moquer de cook: 1 hot-dog merci
se moquer de cuisinier pour garçon: ordre: 1 hot-dog de prêt (ce qui donne le mannequin hot-dog de serveur)
serveur de test pilote: voici votre hot-dog (ce qui donne le mannequin hot-dog de pilote d'essai)

pilote d'essai: ESSAI RÉUSSI!

Mais depuis notre serveur est nouveau, c'est ce qui pourrait arriver:

pilote d'essai pour se moquer de cook: attendre un hot-dog de l'ordre et de lui donner ce mannequin hot-dog dans la réponse

pilote d'essai (posant en tant que client), pour garçon: je voudrais un hot-dog merci
garçon à se moquer de cook: 1 hamburger veuillez
maquette cuire arrête le test: on m'a dit d'attendre un hot-dog!

pilote d'essai de notes le problème: ÉCHEC du TEST! - le garçon a changé l'ordre

ou

pilote d'essai pour se moquer de cook: attendre un hot-dog de l'ordre et de lui donner ce mannequin hot-dog dans la réponse

pilote d'essai (posant en tant que client), pour garçon: je voudrais un hot-dog merci
garçon à se moquer de cook: 1 hot-dog merci
se moquer de cuisinier pour garçon: ordre: 1 hot-dog de prêt (ce qui donne le mannequin hot-dog de serveur)
serveur de test pilote: voici vos frites (donne frites de certains autres afin de pilote d'essai)

pilote d'essai de notes de l'inattendu frites: ÉCHEC du TEST! le garçon a donné dos plat tort

Il peut être difficile de voir clairement la différence entre les objets fantaisie et les talons sans un contraste de stub de base exemple pour aller avec cela, mais cette réponse est bien trop longtemps déjà :-)

Notez également que c'est un joli exemple simpliste et de moquer les cadres permettent pour certains assez sophistiqués spécifications de comportement attendu à partir de composants à l'appui de tests complets. Il y a beaucoup de matériel sur les objets fantaisie et se moquant de cadres pour plus d'informations.

Answer 2

Une Maquette de l'Objet est un objet qui se substitue à un objet réel. En programmation orientée objet, les objets fantaisie sont des objets simulés qui imitent le comportement des objets réels dans le contrôle des moyens.

Un programmeur informatique qui crée généralement une maquette de l'objet à tester le comportement d'un autre objet, de la même manière qu'un concepteur de voiture utilise un crash test dummy pour simuler le comportement dynamique d'un être humain dans un véhicule impacts.

http://en.wikipedia.org/wiki/Mock_object

Les objets fantaisie vous permettent de définir des scénarios de test, sans faire supporter de grands, lourde les ressources telles que des bases de données. Au lieu d'appeler une base de données pour les tests, vous pouvez simuler votre base de données à l'aide d'un objet fantaisie dans vos tests unitaires. Ceci vous libère du fardeau d'avoir à installer et à démonter une vraie base de données, il suffit de tester une méthode unique dans votre classe.

Le mot "Fantaisie" est parfois utilisé à tort de façon interchangeable avec "Stub." Les différences entre les deux mots sont décrites ici. Essentiellement, une maquette est un objet stub qui comprend également les attentes (c'est à dire "affirmations") pour le bon comportement de l'objet, de méthode, en cours de test.

Par exemple:

class OrderInteractionTester...
  public void testOrderSendsMailIfUnfilled() {
    Order order = new Order(TALISKER, 51);
    Mock warehouse = mock(Warehouse.class);
    Mock mailer = mock(MailService.class);
    order.setMailer((MailService) mailer.proxy());

    mailer.expects(once()).method("send");
    warehouse.expects(once()).method("hasInventory")
      .withAnyArguments()
      .will(returnValue(false));

    order.fill((Warehouse) warehouse.proxy());
  }
}

Notez que l' warehouse et mailer objets fantaisie sont programmés avec les résultats attendus.

Answer 3

Objets factices sont des objets simulés qui imitent le comportement des vrais. Généralement, vous écrivez un objet simulacre si :

• L’objet réel est trop complexe pour l’incorporer dans un test unitaire (par exemple une communication réseau, vous pouvez avoir un objet simulacre qui simulent été l’autre homologue)
• Le résultat de votre objet est non déterministe
• L’objet réel n’est pas encore disponible

Answer 4

Un objet Fantaisie est une sorte de Test de Double. Vous utilisez mockobjects de tester et de vérifier le protocole ou l'interaction de la classe sous test avec d'autres classes.

En général, vous sorte de "programme" ou "enregistrer" attentes : les appels de méthode que vous attendez de votre classe à faire à un objet sous-jacent.

Par exemple, disons que nous testons une méthode de service pour mettre à jour un champ dans un Widget. Et que, dans votre architecture il est un WidgetDAO qui traite avec la base de données. Parler avec la base de données est lente mise en place et le nettoyage par la suite est compliqué, on va donc se moquer de la WidgetDao.

pensons à ce que le service doit faire : il doit obtenir un Widget à partir de la base de données, faire quelque chose avec elle et l'enregistrer de nouveau.

Donc en pseudo-langage pseudo-maquette de la bibliothèque, nous aurions quelque chose comme :

Widget sampleWidget = new Widget();
WidgetDao mock = createMock(WidgetDao.class);
WidgetService svc = new WidgetService(mock);

// record expected calls on the dao
expect(mock.getById(id)).andReturn(sampleWidget);   
expect(mock.save(sampleWidget);

// turn the dao in replay mode
replay(mock);

svc.updateWidgetPrice(id,newPrice);

verify(mock);    // verify the expected calls were made
assertEquals(newPrice,sampleWidget.getPrice());

De cette façon, on peut facilement le test de développement de classes qui dépendent d'autres classes.

Answer 5

Je recommande fortement un grand article de Martin Fowler , expliquant ce qui exactement sont des simulacres et comment elles diffèrent des talons.