È possibile creare un oggetto fittizio che implementa più interfacce con EasyMock?

Question

È possibile creare un oggetto fittizio che implementa diverse interfacce con EasyMock?

Ad esempio, interfaccia Foo e interfaccia Closeable?

In Rhino Mocks è possibile fornire più interfacce durante la creazione di un oggetto fittizio, ma il metodo createMock() di EasyMock richiede solo un tipo.

È possibile raggiungere questo obiettivo con EasyMock, senza ricorrere al fallback della creazione di un'interfaccia temporanea che estenda sia Foo e Closeable, sia che si deridi?

Answer 1

EasyMock non supporta questo modo si è bloccato con fallback dell'interfaccia temporanea.

Per inciso, sento un po 'di codice wiff - un metodo dovrebbe trattare davvero un oggetto come 2 cose diverse, l'interfaccia Foo e in questo caso?

Questo implica che il metodo sta eseguendo più operazioni e mentre sospetto che una di queste operazioni sia quella di "chiudere" lo Closeable, non avrebbe più senso se il codice chiamante decidesse se chiudere o meno ' è obbligatorio?

Strutturando il codice in questo modo mantiene "aperto" e "chiuso" nello stesso blocco try ... finally e IMHO rende il codice più leggibile senza menzionare il metodo più generale e consente di passare oggetti che implementano solo Foo.

Answer 2

Avete preso in considerazione qualcosa di simile:

interface Bar extends Foo, Closeable { 
} 

e quindi finto interfaccia Bar?

Answer 3

In base alle mie conoscenze, l'unico strumento di simulazione per Java con supporto esplicito per la simulazione di più interfacce è JMockit. (La mia ispirazione per l'aggiunta di questa funzionalità è venuto da Moq e Rhino Mocks, che sono strumenti .NET.)

Un esempio (dal mockit.ExpectationsUsingMockedTest JUnit classe 4 test):

@Test 
public <M extends Dependency & Runnable> void mockParameterWithTwoInterfaces(final M mock) 
{ 
    new Expectations() 
    { 
     { 
     mock.doSomething(true); returns(""); 
     mock.run(); 
     } 
    }; 

    assertEquals("", mock.doSomething(true)); 
    mock.run(); 
} 

Dependency e Runnable sono interfacce. Il metodo doSomething appartiene al primo e run al secondo.

Answer 4

Anche se fondamentalmente d'accordo con la risposta di Nick Holt, ho pensato di sottolineare che mockito permette di fare ciò che si chiede con il seguente invito:

Foo mock = Mockito.mock(Foo.class, withSettings().extraInterfaces(Bar.class)); 

Ovviamente dovrete usare il cast: (Bar)mock quando è necessario utilizzare il mock come Bar ma che cast non sarà gettare ClassCastException

Ecco un esempio che è un po 'più completo, anche se del tutto assurda:

import static org.junit.Assert.fail; 
import org.junit.Test; 
import static org.mockito.Mockito.*; 
import org.mockito.Mockito; 
import static org.hamcrest.MatcherAssert.assertThat; 
import static org.hamcrest.Matchers.*; 
import org.hamcrest.Matchers; 

import java.util.Iterator; 


public class NonsensicalTest { 


    @Test 
    public void testRunnableIterator() { 
     // This test passes. 

     final Runnable runnable = 
        mock(Runnable.class, withSettings().extraInterfaces(Iterator.class)); 
     final Iterator iterator = (Iterator) runnable; 
     when(iterator.next()).thenReturn("a", 2); 
     doThrow(new IllegalStateException()).when(runnable).run(); 

     assertThat(iterator.next(), is(Matchers.<Object>equalTo("a"))); 

     try { 
      runnable.run(); 
      fail(); 
     } 
     catch (IllegalStateException e) { 
     } 
    } 

Answer 5

Un altro modo per risolvere questo problema è quello di utilizzare un CGLib mixin:

final Interface1 interface1 = mockery.mock(Interface1.class); 
final Interface2 interface2 = mockery.mock(Interface2.class); 

service.setDependence(Mixin.create(new Object[]{ interface1, interface2 })); 

mockery.checking(new Expectations(){{ 
    oneOf(interface1).doSomething(); 
    oneOf(interface2).doNothing(); 
}}); 

service.execute(); 

o meno questa è una buona idea, è qualcosa fino alla discussione ...