Vérification des résultats d'une usine dans un test unitaire

J'ai développé quelques classes de comportement similaire, qu'ils implémentent la même interface. J'ai mis en place une usine qui crée l'objet et renvoie l'interface. Je suis en train d'écrire un test unitaire pour l'usine. Tout ce que vous obtenez en retour est une interface de l'objet.
Quelle est la meilleure façon de tester que l'usine a fonctionné correctement?

Je voudrais savoir la réponse en Java, mais si il y a une solution qui traverse les langues, je voudrais savoir s'il.

Numéro 2. dans la réponse, serait fait comme l'autre réponse? Si je vais donc marquer l'autre de répondre aussi bien acceptées et reformuler ma question est la suivante adresse à la fois une usine où l'interface est retourné et vous n'avez pas la moindre idée de ce type de classe de béton mis en œuvre l'interface, et le cas où vous ne savez ce que la classe de béton a été utilisé.

source d'informationauteur javelinBCD

  1. 17

    Car je ne sais pas comment votre méthode de fabrique ressemble, tout ce que je peux conseiller le droit maintenant de

    1. Vérifier que l'objet est à la bonne mise en œuvre concrète que vous recherchez:

      IMyInterface fromFactory = factory.create(...);  
Assert.assertTrue(fromFactory instanceof MyInterfaceImpl1);

    2. Vous pouvez vérifier si le réglage d'usine de la des cas concrets en cours de validité avec les variables d'instance.

  2. 22

    Ce que vous essayez de faire est de ne pas les Tests Unitaires

    Si vous de tester si oui ou non retournés, les objets sont des instances de certaines classes de béton, vous n'êtes pas de tests unitaires. Vous êtes des tests d'intégration. Alors que les tests d'intégration est important, ce n'est pas la même chose.

    Dans les tests unitaires, vous avez seulement besoin de tester l'objet lui-même. Si vous affirmez sur le type concret de l'abstrait des objets retournés, à vous de tester au cours de la mise en œuvre de l'objet retourné.

    Tests unitaires sur des Objets en général

    Lorsque les tests unitaires, il y a quatre choses, vous souhaitez faire valoir:

    1. Les valeurs de retour de requêtes (non-méthodes void) sont ce à quoi vous vous attendez à être.
    2. Effets secondaires de commandes (méthodes void) modifier l'objet lui-même comme vous le souhaitez.
    3. Commandes envoyer à d'autres objets sont reçus (Ce qui est généralement fait à l'aide de simulacres).

    En outre, vous ne voulez tester ce qui pourrait être observé à partir d'une instance de l'objet, c'est à dire l'interface publique. Sinon, vous attachez-vous à un ensemble de détails de mise en œuvre. Ce serait vous obliger à modifier vos tests lorsque ces détails changent.

    Tests Unitaires Usines

    Tests unitaires sur des Usines est vraiment inintéressant, parce que vous n'êtes pas intéressé par le comportement des objets retournés de requêtes. Ce comportement est (je l'espère) testé ailleurs, supposer alors que les tests unitaires que l'objet lui-même. Vous n'êtes réellement intéressé à savoir si ou non l'objet retourné a la bonne typequi est garanti si votre programme compile.

    Que les Usines ne changent pas au fil du temps (car alors ils seraient des "Constructeurs", qui est un autre motif), il n'y a pas de commandes pour tester.

    Usines sont responsables de l'instanciation de l'objet, de sorte qu'ils ne doivent pas dépendre des autres usines pour le faire pour eux. Ils pourrait dépendent d'un Constructeur, mais tout de même, nous ne sommes pas censés tester le Générateur de l'exactitude, de savoir si ou non le Constructeur reçoit le message.

    Cela signifie que tout ce que vous avez à les tester sur des Usines est de savoir si ou de ne pas envoyer les messages vers les objets sur lesquels ils reposent. Si vous utiliser l'Injection de Dépendance, c'est presque banal. Juste se moquer de l'dépendances dans vos tests unitaires, et de vérifier qu'ils reçoivent les messages.

    Résumé des Tests Unitaires Usines

    1. Ne pas tester le comportement ni les détails d'implémentation des objets retournés! Votre Usine n'est pas responsable de la mise en œuvre des instances de l'objet!
    2. Tester si oui ou non les commandes envoyées à des dépendances sont reçus.

    Que c'est. Si il n'y a pas de dépendances, il n'y a rien à l'épreuve. Sauf peut-être pour affirmer que l'objet retourné n'est pas un null de référence.

    Des Tests D'Intégration Usines

    Si vous avez une exigence que le retour de l'abstrait type d'objet est une instance spécifique d'un type de béton, alors cela relève de tests d'intégration.

    D'autres ici ont déjà répondu à comment faire cela en utilisant la instanceof opérateur.

  3. 0

    @cem-catikkas je pense qu'il serait plus juste de comparer le getClass().getName() les valeurs. Dans le cas qui MyInterfaceImpl1 classe est sous-classé votre test pourrait être rompu, comme le sous-classe est instanceof MyInterfaceImpl1. Je voudrais réécrire comme suit:

    IMyInterface fromFactory = factory.create(...);  
Assert.assertEquals(fromFactory.getClass().getName(), MyInterfaceImpl1.class.getName());

    Si vous pensez que cela risque d'échouer, d'une certaine façon (je ne peux pas imaginer), de rendre les deux vérifications.

  4. 0
    if (myNewObject instanceof CorrectClass)
{
    /* pass test */
}

    mise à jour:

    Ne sais pas pourquoi c'est marqué vers le bas, donc je vais développer un peu...

    public void doTest()
{
    MyInterface inst = MyFactory.createAppropriateObject();
    if (! inst instanceof ExpectedConcreteClass)
    {
        /* FAIL */
    }
}