Comment isoler d'autres méthodes dans la même classe en utilisant EasyMock

Question

J'ai une méthode qui invoque une autre méthode dans la même classe, tels que:

Class MyClass{ 
    public int methodA(){ 
     ... 
     methodB() 
     ... 
    } 

    public int methodB(){ 
     ... 
    } 
} 

Et je veux juste tester methodA(), alors comment puis-je isoler methodB() à l'aide EasyMock. Ma façon sacrément est de créer une instance faux de MyClass et l'injecter dans le methodA() comme ceci:

public int methodA(MyClass fake){ 
    ... 
    fake.methodB(); 
    ... 
} 

et attendre dans mon testcase:

MyClass fake = EasyMock.createMock(MyClass.class);  
EasyMock.expect(fake.methodB()).andReturn(...); 

Y at-il une meilleure solution pour cette situation ?

Answer 1

Oui: N'utilisez pas EasyMock mais une classe locale anonyme. Exemple:

public void testXyz throws Exception() { 
    MyClass fake = new MyClass() { 
     public int methodB(){ 
      return 12; 
     } 
    }; 

    fake.methodA(); 
} 

Answer 2

Je pense que vous devriez envisager de refactoriser MyClass.
Si les deux méthodes utilisent la même logique dans methodB(), l'extraction de la logique vers une méthode privée vous permettra de tester le scénario isolé d'appel de chacune de ces méthodes.

Answer 3

bien ... il est si simple :-)

YourClass instance = mock(YourClass.class); 

when(instance.methodB(args)).thenReturn(aFakeAnswer); 
when(instance.methodA(args)).thenCallRealMethod(); 

Je suis désolé de ne pas le code exact mais en général il ça marche comme ça et vous pouvez les classes abstraites de tests unitaires comme bien utiliser ce .

Answer 4

Voici une solution étonnamment simple utilisant EasyMock. Il semble décourageant mais est en fait un concept très simple.

L'astuce consiste à créer dans votre classe de test à la fois un objet MyClass régulier et un objet MyClass mocké. Ensuite, lorsque vous instanciez la classe My Class classique, remplacez la méthode que vous voulez simuler et appelez la même méthode dans la classe MyClass.

Compte tenu de cette classe:

Class MyClass{ 
    public int methodA(){ 
     ... 
     methodB() 
     ... 
    } 

    public int methodB(){ 
     ... 
    } 
} 

Dans votre écriture de test:

Class MyClassTest { 

    private MyClass myClass; 
    private MyClass mockMyClass; 
    ... 

    @Test 
    public void testMethodA() { 
     // Create mock of MyClass 
     mockMyClass = createMock(MyClass.class); 

     // Instantiate MyClass overriding desired methods with mocked methods 
     myClass = new MyClass() { 
      @Override 
      public int methodB() { 
       return mockMyClass.methodB(); 
      } 
     }; 

     // Set expectations 
     expect(mockMyClass.methodB()).andReturn(...); 
     replay(mockMyClass); 

     // Call test method - will in turn call overridden, mocked methodB() 
     myClass.methodA(); 

     verify(mockMyClass); 
    } 

} 

Vous pouvez avoir des méthodes d'aide qui instancient myClass différemment selon la méthode que vous testez.