Comment puis-je l'unité de tester cette inputStream a été fermé?

J'ai un Runnable le long des lignes de:

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

Comment puis-je tester inputStream.close() a été invoquée? Je suis actuellement en utilisant Mockito et JUnit. Je sais que l'injection de la inputStream est une idée, mais je ne veux pas les ressources nécessaires pour être utilisé jusqu'à ce que run?() est appelé, par conséquent, il être une variable locale. Alors, comment puis-je la refonte de mon code qui me permet de tester si la clôture a été appelé?

OriginalL'auteur mogronalol | 2012-12-10

Si j'ai bien compris la tâche correctement, il pouvait être comme ça

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

+1 pour le faire proprement.
isClose = true devrait probablement être en dessous de la super.close() dans le cas où la fermeture déclenche une exception.
À droite, c'était juste pour montrer l'idée, il pourrait aussi être nommé / non-classe anonyme, isClosed champ à l'intérieur et isClosed méthode

OriginalL'auteur Evgeniy Dorofeev

6

Comme il n'y a aucune raison pour exposer l'InputStream en dehors du champ d'application de cette méthode, vous avez un test de problème.

Mais je suppose que vous n'avez pas directement des soins sur le InputStream en cours de fermeture. Vous voulez tester tout ça parce que vous avez été dit que c'est une bonne pratique (et il l'est). Mais je pense que ce que vous avez réellement se soucient que de l'impact négatif des flux d'ouverture à gauche. Quel est l'effet?

Essayer de modifier cette méthode afin de ne pas fermer le flux de données, puis de l'exécuter plusieurs fois. Avez-vous une fuite de mémoire, ou de descripteurs de fichiers ou de certains autres tomfoolery? Si oui, vous avez un délai raisonnable test.

Sinon, juste aller de l'avant et d'exposer un décorée InputStream qui peut vous dire si elle a été fermée ou non. Rendre colis protégé. C'est le "impur", mais une approche pragmatique.

+1, il a obtenu le point, il est important de tester l'impact d'un échec de ne pas l'intérieur behaiviour d'une classe.

OriginalL'auteur Synesso

De vérifier si la méthode close() est appelée, vous pouvez utiliser Mockito.espion() pour créer un objet proxy qui permet de mémoriser les appels. Spy délégués de tous les appels à la sous-jacentes InputStream, juste mémorise ce qui s'est passé:

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

Cela ne résout pas vos problèmes avec injection d'instance de InputStream, en fait. Il semble que vous besoin d'une sorte de l'usine, qui peut ouvrir un flux pour vous, et vous pouvez vous moquer de cette usine dans les tests unitaires. Appelons cette usine d'un système de fichiers:

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

Maintenant, vous pouvez injecter une instance du système de fichiers, et de ne pas utiliser les ressources avant de lancer la méthode est exécutée:

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 peut faire plus que juste de l'écoute, vous pouvez apprendre à modifier son comportement à l'aide de Mockito.lors de la(), tout comme vous le feriez avec une maquette.

OriginalL'auteur Piotr

Vous pouvez le faire comme ceci...

    try
    {
         inputStream.readLine();        
    }
    catch (IOException e)
    {
        Assert.assertEquals(e.getLocalizedMessage(), "Stream closed");
    }

OriginalL'auteur Jason

0

Vous pouvez écrire dans le test quelque chose comme:
```
try {
    run();
} catch (IOException e) {
    Assert.fail();
}
```
Lors de votre méthode proche strem et si une exception se produit, le test échouera.

1. Ce test ne sera pas échouer si le close invocation est supprimé. 2. Un jeté IOException ferait échouer le test de toute façon.
Synesso, merci pour votre commentaire 1. Nous parlons de cas avec close(); 2. Pouvez-vous m'expliquer s'il vous plaît?
1. oui, mais le test n'est pas bon si il n'a pas d' fail lorsque le code de production est cassé. Vous obtenez un "faux positif". 2. Si vous n'attrapez pas la IOException, mais au lieu de le laisser être jetés, c'adéquatement échoue le test, pas besoin de try, catch et assert
Ne vous dire que IOException sera en mesure jeté ailleurs que lorsque le volet est fermé?
Ce n'est pas ce que je veux dire. Si run() jette un IOException le test échoue, même sans le bloc try/catch. Ainsi, le try/catch n'est pas nécessaire.

OriginalL'auteur Dedyshka

Vous devez vous connecter pour publier un commentaire.