Cómo probar objetos miembro privadas sin hacer un nuevo objeto

Alex:

Estoy tratando de escribir pruebas unitarias contra una clase. No puedo cambiar la clase, pero creo que es posible poner a prueba utilizando la reflexión. Sólo que no sé cómo hacerlo. Aquí está la clase:

public class MyClass extends AnotherClass implements TheInterface
{
    private enum SomeTypes
    {
        SAMPLE01, SAMPLE02, SAMPLE03
    }

    private CircularList<SomeTypes> someTypesList; 
    Date date= new Date();
    private SomeOtherClassProcessor01 someOtherClassProcessor01;
    private SomeOtherClassProcessor02 someOtherClassProcessor02;
    private SomeOtherClassProcessor03 someOtherClassProcessor03;

    public Properties initialize (Properties properties) throws Exception
    {
        Properties propertiesToReturn = super.initialize(properties);
        someTypesList = new CircularList<SomeTypes>    (Arrays.asList(SomeTypes.values())); 
        someOtherClassProcessor01 = new SomeOtherClassProcessor01(); 
        someOtherClassProcessor02 = new SomeOtherClassProcessor02(); 
        someOtherClassProcessor03 = new SomeOtherClassProcessor03(); 

        return propertiesToReturn;
    }

    @Override
    public void get(ImportedClass someParams) throws Exception
    {
        SomeTypes types = someTypesList.getFirstAndRotate();

        switch(types)
        {
            case SAMPLE01:
            someOtherClassProcessor01.doSomething(someParams,     date);
            break;
            case SAMPLE02:
            someOtherClassProcessor02.doSomething(someParams,     date);
            break;
            case SAMPLE03:
            someOtherClassProcessor03.doSomething(someParams,     date);
            break;
            default:
            throw new IllegalArgumentException("This " + types + "     was not implemented.");
        }
    }   
}

Para mi prueba de esto es lo que tengo hasta ahora ... no sé realmente cómo hacerlo.

@RunWith(PowerMockRunner.class)
@PrepareForTest(MyClass.class)
public class TestingMyClass
{
    MyClass mockMyClass;
    SomeOtherClassProcessor01 someOtherClassProcessor01;
    SomeOtherClassProcessor02 someOtherClassProcessor02;
    SomeOtherClassProcessor03 someOtherClassProcessor03;
    Date date;


    @Before
    public void initialize () throws Exception
    {
        mockMyClass = spy(new MyClass()); 
        mockSomeOtherClassProcessor01 =     mock(SomeOtherClassProcessor01.class);
        mockSomeOtherClassProcessor02 =     mock(SomeOtherClassProcessor02.class);
        mockSomeOtherClassProcessor03 =     mock(SomeOtherClassProcessor03.class);
    }

    @Test
    public void testingGet() throws Exception
    {
        date = new Date(); 
        //this is where I'm stuck
        Whitebox.setInternalState(mockMyClass,     "someOtherClassProcessor01", mockSomeOtherClassProcessor01);

    }
}

¿Sería posible utilizar whitebox para esto? Necesito para asegurarse de que hay una llamada en el interior del captador para esos objetos. Debería intentar algo así como cuando (someOtherClassProcessor01.doSomething (cualquier (), fecha)). ThenReturn (verdadero)? Por favor, hágamelo saber si usted necesita más detalles.

edit: es posible incluso para burlarse SomeTypes enumeración privadas?

iluxa:

Una opción es sustituir sus propias implementaciones (burlaron) de SomeOtherClassProcessoren MyClassel uso de la reflexión:

MyClass myClass = new MyClass();
SomeOtherProcessor01 mockProcessor01 = mock(SomeOtherProcessor01.class);

// reflection bit: find the field by its name
// handle NoSuchFieldException
Field someProcessorField = MyClass.getDeclaredField("someOtherProcessor01");
// the field is declared as private, so make it accessible in order to work with it
someProcessorField.setAccessible(true);
// now set your mocked processor into the field. 
// First argument is the object to change; second argument - new value for the field
someProcessorField.set(myClass, mockProcessor01);

PD. Usando PowerMock y / o reflexión es la entrega a un mal diseño (según Timoteo :). Usted no debe ser en función de código que que no está ya bien probado, y si lo es, no se debe intentar probar de nuevo. Suponga que su prueba en realidad revela un error - ¿cómo solucionarlo si usted no controla el código? Supongamos Java 11 se convierte en una cosa y prohíbe el uso de la reflexión. Supongamos que el código que está cambios de prueba y los campos se renombran - con la reflexión, que no tiene la seguridad de tiempo de compilación ... Lista de los problemas potenciales que sucede