se moquer d'une classe singleton

La meilleure façon de se moquer d'un singleton est de ne pas les utiliser du tout, ou au moins pas dans le sens traditionnel. Quelques pratiques que vous voudrez peut-être Rechercher sont:

• programmation aux interfaces
• injection de dépendance
• inversion du contrôle

Donc, plutôt que d'en avoir un seul, vous accédez comme ceci:

Singleton.getInstance().doSometing();

... définissez votre "singleton" en tant qu'interface et demandez à autre chose de gérer son cycle de vie et de l'injecter là où vous en avez besoin, par exemple en tant que privé variable d'instance:

@Inject private Singleton mySingleton;

Ensuite, lorsque vous testez la classe / components / etc qui dépend du singleton, vous pouvez facilement en injecter une version fictive.

La plupart des conteneurs d'injection de dépendance vous permettront de marquer un composant comme 'singleton', mais c'est au conteneur de le gérer.

En utilisant les pratiques ci-dessus, il est beaucoup plus facile de tester l'Unité de votre code et vous permet de vous concentrer sur votre logique fonctionnelle au lieu de la logique de câblage. Cela signifie également que votre code est vraiment commence à devenir vraiment orienté objet, car toute utilisation de méthodes statiques (y compris les constructeurs) est discutable. Ainsi, vos composants commencent à devenir vraiment réutilisables.

Consultez Google Guice comme entrée pour 10:

Http://code.google.com/p/google-guice/

Vous pouvez également regarder Spring et / ou OSGi qui peuvent faire ce genre de chose. Il y a beaucoup de choses IOC / DI là-bas. :)

Un Singleton, par définition, a exactement une instance. D'où sa création est strictement contrôlée par la classe elle-même. Typiquement, c'est une classe concrète, pas une interface, et en raison de son constructeur privé, elle n'est pas sous-classable. De plus, il est trouvé activement par ses clients (en appelant Singleton.getInstance() ou un équivalent), de sorte que vous ne pouvez pas facilement utiliser par exemple Dependency Injection pour remplacer son instance "réelle" par une instance fictive:

class Singleton {
    private static final myInstance = new Singleton();
    public static Singleton getInstance () { return myInstance; }
    private Singleton() { ... }
    // public methods
}

class Client {
    public doSomething() {
        Singleton singleton = Singleton.getInstance();
        // use the singleton
    }
}

Pour les mocks, vous auriez idéalement besoin d'une interface qui peut être librement sous-classé, et dont la mise en œuvre concrète est fournie à son(ses) client (s) par injection de dépendance.

Vous pouvez détendre L'implémentation Singleton pour la rendre testable par

• fournir une interface qui peut être implémentée par une sous-classe fictive ainsi que la "vraie"
• ajout d'une méthode setInstance pour permettre de remplacer l'instance dans les tests unitaires

Exemple:

interface Singleton {
    private static final myInstance;
    public static Singleton getInstance() { return myInstance; }
    public static void setInstance(Singleton newInstance) { myInstance = newInstance; }
    // public method declarations
}

// Used in production
class RealSingleton implements Singleton {
    // public methods
}

// Used in unit tests
class FakeSingleton implements Singleton {
    // public methods
}

class ClientTest {
    private Singleton testSingleton = new FakeSingleton();
    @Test
    public void test() {
        Singleton.setSingleton(testSingleton);
        client.doSomething();
        // ...
    }
}

Comme vous le voyez, vous ne pouvez créer que votre unité de code Singleton testable en compromettant la "propreté" du Singleton. En fin de compte, il est préférable de ne pas utiliser si vous pouvez l'éviter.

Update: et voici la référence obligatoire à travailler efficacement avec le code hérité par Michael Feathers.

Cela dépend beaucoup de l'implémentation singleton. Mais surtout parce qu'il a un constructeur privé et donc vous ne pouvez pas l'étendre. Mais vous avez l'option suivante

• créer une interface - SingletonInterface
• faites en sorte que votre classe singleton implémente cette interface
• let Singleton.getInstance() return SingletonInterface
• fournissez une implémentation fictive de SingletonInterface dans vos tests
• définissez - le dans le champ private static sur Singleton en utilisant la réflexion.

Mais vous feriez mieux d'éviter les singletons (qui représentent un état global). cette conférence explique certains concepts de conception importants du point de vue de la testabilité.

Ce n'est pas que le modèle Singleton soit lui-même un mal pur, mais cela est massivement surutilisé même dans des situations où il est inapprorié. Beaucoup de développeurs pensent "Oh, je n'aurai probablement besoin que d'un seul d'entre eux, alors faisons-en un singleton". En fait, vous devriez penser "je n'aurai probablement besoin que d'un de ceux-ci, alors construisons-en un au début de mon programme et transmettons des références là où c'est nécessaire."

Le premier problème avec singleton et testing n'est pas tant à cause de la singleton mais à cause de la paresse. En raison de la commodité d'obtenir un singleton, la dépendance sur l'objet singleton est souvent intégrée directement dans les méthodes, ce qui rend très difficile de changer le singleton en un autre objet avec la même interface mais avec une implémentation différente (par exemple, un objet fictif).

Au Lieu de:

void foo() {
   Bar bar = Bar.getInstance();
   // etc...
}

Préférer:

void foo(IBar bar) {
   // etc...
}

Maintenant, vous pouvez tester la fonction foo avec un moqué bar objet que vous pouvez contrôler. Vous avez retiré la dépendance afin que vous puissiez tester foo sans tester bar.

L'autre problème avec singletons et testing est lors du test du singleton lui-même. Un singleton est (par conception) très difficile à reconstruire, donc par exemple vous ne pouvez tester le constructeur singleton qu'une seule fois. Il est également possible que l'instance unique de Bar conserve l'état entre les tests, provoquant le succès ou l'échec en fonction de l'ordre dans lequel les tests sont exécutés.

Il y a un moyen de se moquer de Singleton. Utilisez powermock pour simuler la méthode statique et utilisez Whitebox pour appeler le constructeur YourClass mockHelper = Whitebox .invokeConstructor(YourClass.class); Whitebox.setInternalState(mockHelper, "yourdata",mockedData); PowerMockito.mockStatic(YourClass.class); Mockito.when(YourClass.getInstance()).thenReturn(mockHelper);

Ce qui se passe, c'est que le code D'octet Singleton change en cours d'exécution .

Profitez