¿Cómo puedo realizar una prueba unitaria de que este inputStream se ha cerrado?

Solución:

Si entendiera la tarea correctamente, podría ser así.

static boolean isClosed;

public void run() {
    InputStream inputStream = null;
    try {
        inputStream = new FileInputStream(file) {
            @Override
            public void close() throws IOException {
                isClosed = true;
                super.close();
            }
        };
        // more stuff here

Como no hay razón para exponer InputStream fuera del alcance de este método, tiene un problema de prueba.

Pero supongo que no te preocupas directamente por el InputStream estar cerrado. Quiere probar eso porque le han dicho que es una buena práctica (y lo es). Pero creo que lo que realmente te importa es el impacto negativo de dejar abierta la corriente. Cual es el efecto?

Intente modificar este método para que no cierre la transmisión, luego ejecútelo varias veces. ¿Tiene una pérdida de memoria, se queda sin identificadores de archivos o alguna otra tontería? Si es así, tiene una prueba razonable.

Alternativamente, simplemente continúe y exponga un InputStream decorado que pueda decirle si se ha cerrado o no. Hágalo empaquetar protegido. Ese es el enfoque “impuro”, pero pragmático.

Para comprobar si se llama al método close (), puede utilizar Mockito.spy () para crear un objeto proxy que pueda memorizar llamadas. Spy delega todas las llamadas al InputStream subyacente, simplemente memoriza lo que sucedió:

InputStream inputStreamSpy = Mockito.spy(inputStream);
// a code that is expected to close your stream goes here ...
Mockito.verify(inputStreamSpy).close();

En realidad, esto no resolverá sus problemas con la inyección de una instancia de InputStream. Parece que necesita algún tipo de fábrica, que pueda abrir un flujo para usted, y puede burlarse de esa fábrica en pruebas unitarias. Llamemos a esta fábrica un sistema de archivos:

public class FileSystem {
    public FileInputStream newFileInputStream(File file) {
        return new FileInputStream(file);
    }
}

Ahora, puede inyectar una instancia del FileSystem, y no usará recursos antes de que se ejecute el método de ejecución:

public void run() {
    InputStream inputStream = null;
    try {
        inputStream = fileSystem.newFileInputStream(file);
        //more stuff here
    } 
    catch (Exception e) {
        //simplified for reading
    }
    finally {
        if(inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {}
        }
    }
}

@Test
public void runShouldCloseInputStream() {
    InputStream inputStream = ...
    InputStream inputStreamSpy = Mockito.spy(inputStream);
    FileSystem fileSystemMock = Mockito.mock(FileSystem.class);
    when(mockFileSystem.newFileInputStream(Mockito.any(File.class)))
        .thenReturn(inputStreamSpy);

    MyRunnable instance = new MyRunnable(mockFileSystem);
    instance.run();

    verify(inputStreamSpy).close();
}

Spy puede hacer más que solo escuchar, puedes enseñarle a alterar el comportamiento usando Mockito.when (), tal como lo harías con un simulacro normal.

---

---

Utiliza Nuestro Buscador