Mockito schlägt auf NoSuchMethodError fehl, da die Methode in der abstrakten Klasse ist, die generische Methode verwendet

Question

Ich führe einige Diensttests durch und ich teste eine konkrete Klasse, die sich von einem erstreckt, der Generics verwendet.

Ein Beispiel Aufbau der Service-Schicht ist unten:

public abstract class AbstractService <E extends AbstractEntity, IT extends AbstractItem> { 

    public void deleteAllItems(E entity) { 
     List<IT> items = new ArrayList<IT>(entity.getItems()); 
     for(IT item : items) { 
      //Yada, yada 
     } 
    } 
} 

public class Service extends AbstractService<Entity, Item> { 

} 

public class OtherService() { 
    @Inject 
    private ServiceManager serviceManager; 

    public void deleteItems(Entity e) { 
     serviceManager.getService().deleteAllItems(e); 
    } 
} 

Dann ist es zu testen ich folgendes haben:

public class Test { 
    private Service service; 
    private OtherService otherService; 
    private ServiceManager serviceManager; 

    @BeforeMethod 
    public void setup() { 
     serviceManager= mock(serviceManager.class); 
     service= mock(Service.class); 
     when(serviceManager.getService()).thenReturn(service); 
     otherService=injector.getInstance(OtherService.class); 
    } 

    @Test 
    public void test() { 
     Entity e = new Entity(); 
     //Attach some items 
     otherService.deleteItems(e); 
     verify(service).deleteAllItems(e); 
    } 
} 

Dies sollte die OtherService nennen, die (Wir existiert verwenden Injektion, um das Objekt zu erhalten), und rufen Sie dann die Methode deleteItems(), die wiederum deleteAllItems() auf der Service aufrufen sollte. Bevor ich das Java-Generika umgesetzt hatte, das hat gut funktioniert, aber da ich das Java-Generika umgesetzt habe, schlägt der Mockito Test mit der folgenden Ausnahme:

java.lang.NoSuchMethodError: Service.deleteAllItems(Entity;)V at Test.test(Test.java:XXX) org.mockito.exceptions.misusing.UnfinishedVerificationException: Missing method call for verify(mock) here: -> at Test.test(Test.java:XXX)

Example of correct verification: verify(mock).doSomething()

Also, this error might show up because you verify either of: final/private/equals()/hashCode() methods. Those methods cannot be stubbed/verified.

Welche klingt es nicht die Methode finden kann. Sollte ich stattdessen die abstrakte Klasse von AbstractService verspotten oder gibt es noch etwas, das mir fehlt?

EDIT

Von dem, was ich habe die Mockito Innenleben zu sehen ist, erzeugt es ein Beispiel dafür:

public void AbstractService.deleteAllItems(Entity) 

Für das MockitoMethod Objekt, so dass Sinn, dass Service.deleteAllItems() machen würde " wird nicht aufgerufen ", es scheint, Mockito nimmt an, dass nur die Basisklasse jemals aufgerufen wurde. So scheint es, dass ich stattdessen die Basisklasse verspotten muss. Ich werde weiter untersuchen, aber wenn jemand noch andere Ideen hat, ich bin offen für Vorschläge

Answer 1

Nach weiteren Untersuchungen fand ich einen Weg, um Mockito zu zwingen, die richtige Klasse zu nennen. Wie ich kurz erwähnt habe, verwenden wir Injektion, um das Objekt zu erhalten. Während des Setups durchlaufen wir einen Setup des Injektors, von dem ich nicht das Gefühl hatte, dass er das Problem verursacht. Aber es hat eine Lösung präsentiert.Das war, wie wir es nannten:

Injector injector = Guice.createInjector(new Module() { 
      @Override 
      public void configure(Binder binder) { 
       service = mock(Service.class); 
       binder.bind(Service.class). 
        toInstance(service); 
} 

Um das Problem zu lösen, wir gebunden nur die AbstractService Klasse zur verspotteten Instanz der Service Klasse, etwa so:

Injector injector = Guice.createInjector(new Module() { 
      @Override 
      public void configure(Binder binder) { 
       service = mock(Service.class); 
       binder.bind(Service.class). 
        toInstance(service); 
       binder.bind(AbstractService.class). 
        toInstance(service);      
} 

So, jetzt, wenn Mockito versucht, eine Instanz des AbstractService zu bekommen, ruft es das gespottete Service auf und löst unser Problem.

Wenn jemand Feedback hat, dann gibt es eine alternative Lösung, dann zögern Sie nicht zu posten und ich kann es testen und prüfen, ob es bessere Methoden gibt, was wir tun.

Answer 2

ich vorschlagen kann, um das Problem zu lokalisieren - entweder ist es in spöttisch:

@Test 
public void test() { 
    Entity e = new Entity(); 
    service.deleteItems(e); // Note! 'service' itself, not an 'otherService' 
    verify(service).deleteAllItems(e); 
} 

oder in Injektion (Vererbung und Generics entfernen):

public class Service /*extends AbstractService<Entity, Item>*/ { 
    public void deleteAllItems(Entity entity) { 
     //... 
    } 
} 

Teilen Sie das Problem iterativly und Sie werden die Ursache finden.

Answer 3

Wenn Sie eine nicht generische Unterklasse einer generischen Klasse erstellen, erstellt Java "bridge methods" für alle Methoden, die den generischen Typ verwenden. Die Bridge-Methoden sehen aus wie die geerbten Methoden, verwenden aber die spezifische Klasse, die für generische Parameter anstelle von Generika angegeben ist.

Java erstellt diese Methoden, weil die Methoden der Unterklasse nicht generisch sind, also müssen sie wie "nicht-generische" Methoden aussehen (d. H. Nicht löschbar, Reflektion wird wie erwartet funktionieren, usw.). Einzelheiten finden Sie unter this answer.

Die Lösung ist, dass Mockito den von serviceManager.getService() zurückgegebenen Typ vortäuscht.