java - prevent - ¿Cuál es el análogo de Mockito.spy/doReturn en EasyMock?

mockitoannotations initmocks

Question

Imagina, tengo la siguiente clase:

public class TestClass {
    public class Index<X> {

    }
    public class IndexData {
        private final Index<?> index;

        private final ReentrantReadWriteLock lock =
            new ReentrantReadWriteLock();

        public IndexData(final Index<?> index) {
            super();
            this.index = index;
        }

        public Index<?> getIndex() {
            return index;
        }

        public Lock getReadLock() {
            return lock.readLock();
        }

        public Lock getWriteLock() {
            return lock.writeLock();
        }   
    }

    public void add(final InputClass input)
    {
        final IndexData index = getIndex(input);

        final Lock lock = index.getWriteLock();
        lock.lock();
        try {
            // Do something here, which requires synchronization
        } finally {
            lock.unlock();
        }
    }

    protected IndexData getIndex(final InputClass input) {
        // Some logic of getting the index for input
        return null;
    }
}

Quiero escribir una prueba unitaria, que verifique que

1. en el método add , se index.getWriteLock() (no index.getReadLock() ),
2. la cerradura es tomada y
3. liberado.

Usando Mockito puedo escribir una prueba como esta:

@Test
public void testAddUsesWriteLock() {
    // Prepare
    final TestClass objectUnderTest = Mockito.spy(new TestClass());
    final InputClass input = Mockito.mock(InputClass.class);
    final IndexData indexData = Mockito.mock(IndexData.class);
    Mockito.doReturn(indexData).when(objectUnderTest).getIndex(input);
    final Lock lock = Mockito.mock(Lock.class);
    Mockito.doReturn(lock).when(indexData).getWriteLock();

    // Invoke method under test
    objectUnderTest.add(input);

    // Verify
    Mockito.verify(indexData).getWriteLock();
    Mockito.verify(indexData, Mockito.never()).getReadLock();
    Mockito.verify(lock).lock();
    Mockito.verify(lock).unlock();
}

¿Cómo puedo hacer lo mismo con EasyMock?

Concreto: ¿Cómo puedo el método getIndex devolver una simulación en EasyMock (línea Mockito.doReturn(indexData).when(objectUnderTest).getIndex(input) )?

Nota: Puede encontrar el código de este ejemplo aquí .

Answer 1

En el espíritu de proporcionar una posible solución (y contrariamente a mis comentarios anteriores) puedes probar uno de los siguientes

Opción 1

Si TestClass implementa una interfaz, puede lograr una prueba similar utilizando andDelegateTo () como se describe en esta publicación que habla de que Easymock no admite el espionaje.

opcion 2

Elimine su necesidad de espionaje extendiendo el TestClass específicamente para sus requisitos de prueba. Este es un enfoque común para tratar con las bases de código heredado donde no se puede alterar el código bajo prueba.

Usaré Mockito en este ejemplo para que esté alineado con su pregunta, sin embargo, el concepto funcionará igual con Easymock.

public class TestClassUsingMockito {
    /**
    We extend the original class under test so that we can override the creation of IndexData and
    thereby remove the responsibility of creating this object from the @Test method
    */
    private class ClassForTesting extends TestClass {

        private Lock lock;
        private IndexData indexData;

        public ClassForTesting(IndexData indexData, Lock lock) {
            this.indexData = indexData;
            this.lock = lock;
        }

        @Override
        protected IndexData getIndex(InputClass input) {
            return indexData;
        }
    }

    /**
    Look Ma'' no more Spys!
    */
    @Test
    public void testAddUsesWriteLock() {        
        // Prepare
        final Lock lock = Mockito.mock(Lock.class);
        final IndexData indexData = Mockito.mock(IndexData.class);
        Mockito.doReturn(lock).when(indexData).getWriteLock();
        // ... now use your new subclass for testing
        final TestClass objectUnderTest = new ClassForTesting(indexData, lock);
        final InputClass input = Mockito.mock(InputClass.class);

        // Invoke method under test
        objectUnderTest.add(input);

        // Verify
        Mockito.verify(indexData).getWriteLock();
        Mockito.verify(indexData, Mockito.never()).getReadLock();
        Mockito.verify(lock).lock();
        Mockito.verify(lock).unlock(); 
    }
}

¿Cuál es el análogo de Mockito.spy / doReturn en EasyMock?

Entonces, habiendo eliminado la necesidad de un Spy () en sus pruebas, la llamada de Mockito

Mockito.doReturn(lock).when(indexData).getWriteLock();

Se puede escribir en EasyMock como

expect(indexData.getWriteLock()).andStubReturn(lock);

Ejemplo de EasyMock de la misma prueba de Mockito anterior

public class TestClassUsingEasymock extends EasyMockSupport {

    private class ClassForTesting extends TestClass {

        private Lock lock;
        private IndexData indexData;

        public ClassForTesting(IndexData indexData, Lock lock) {
            this.indexData = indexData;
            this.lock = lock;
        }

        @Override
        protected IndexData getIndex(InputClass input) {
            return indexData;
        }
    }


    @Test
    public void testAddUsesWriteLock() {
        // Prepare
        final Lock lock = createNiceMock(Lock.class);       
        final IndexData indexData = createNiceMock(IndexData.class);
        EasyMock.expect(indexData.getWriteLock()).andStubReturn(lock);

        // ... now use your new subclass for testing
        final TestClass objectUnderTest = new ClassForTesting(indexData, lock);
        final InputClass input = createNiceMock(InputClass.class);

        lock.lock();
        EasyMock.expectLastCall();

        lock.unlock();
        EasyMock.expectLastCall();

        replayAll();

        // Invoke method under test
        objectUnderTest.add(input);

        // Verify
        verifyAll();
    }
}