Testen einer async-Methode aufrufen

Unten ist eine vereinfachte setup der Anwendung. Es hat eine Klasse Foobar, welche Anrufe auf der Fassade, die Methode für das abrufen von Daten. Die Fassade ruft einen web-service, um tatsächlich die Daten zu und manipuliert die Daten ein bisschen und dann gibt es für Foobar.

Nun, da der web service kann eine gute Weile ausgeführt, die den Aufruf der Methode an der Fassade werden muss asynchron. Damit die Fassade-Methode nicht über einen Wert zurück, sondern verwendet die Methode ein callback-Objekt. Schau dir das Beispiel an und Lesen Sie weiter unten.

public class Foobar {
    private List<DTO> dtos;

    @Autowired
    private Facade facade;

    public void refresh() {
        facade.refreshFoobar(new CallBack() {
            public void dataFetched(List<DTO> dtos) {
                setDtos(dtos);
            }

        });
    }    

    public void setDtos(List<DTO> dtos) {
        this.dtos = dtos;
    }
}


public class Facade {

    ...

    public void refreshFoorbar(CallBack cb) {
        //Fetch data from a web service
        List<DTO> dtos = webService.getData();  
        //Manipulate DTOs
        ....
        //call on the callback method
        cb.dataFecthed(dtos);
    }

}

Habe ich zwei Möglichkeiten der Herstellung der Fassade-Methode asynchron, entweder durch erstellen eines Threads manuell oder mit Hilfe von Federn @Async annotation.

public class Facade {

    public void refreshFoorbar(CallBack cb) {
        new Thread() {

            @Override
            public void run() {
                ....
            }

        }.start();

    }
}

//... OR ...

public class Facade {

    @Async
    public void refreshFoorbar(CallBack cb) {
        ....    
    }
}

Mein problem ist, dass ich jetzt noch schreiben, ein integration-test für diese Kette von Methodenaufrufen. Ich glaube, ich muss mich zu zwingen, die async-Fassade-Aufruf synchron, wenn die integration-test ist ran, sonst kann ich nicht wissen, für sicher, wenn ich den entsprechenden behauptet. Die einzige Idee, die für die Herstellung der Methodenaufruf synchron ist die Verwendung von manuell behandelt threads UND machen das einfädeln bedingte (so, für Testzwecke habe ich eine if-Klausel, die bestimmt, ob die Fassade Verfahren werden sollte, lief in einem separaten thread oder nicht).

Allerdings habe ich das Gefühl, dass es sein könnte eine bessere Lösung für mein problem, ob es einen besseren Weg, zwingt die Methode, die mir synchron, z.B. mit Feder, oder durch testen von multithreading auf irgendeine Weise.

Dies ist, wo ich brauche Eure Vorschläge, wie würden Sie mein problem lösen? Beachten Sie, ich bin mit junit-für beide Einheiten-und Integrationstests.

Ich weiß nicht, ob es der richtige Weg. In der Regel Tests für asynchrone Bedingungen ist nur dem Start der asynchronen Aufgabe, für eine Weile warten, und dann testen, ob die Aufgabe abgeschlossen wurde.

InformationsquelleAutor Kim L | 2011-09-29

  1. 12

    Einfache Lösung wäre die Rückgabe eines Future-Objekts, wie diese,

    @Async
public Future<String> refreshFoorbar(CallBack cb) {
    yourHeavyLifting(); //asynchronous call
    return new AsyncResult<String>("yourJobNameMaybe");   
}

    Und in Ihrem test, der Zukunft eine Referenz, und rufen Sie die get() Methode.

    future.get(); //if its not already complete, waits for it to complete
assertTrue(yourTestCondition)

    Diese blog-post zeigt ein Beispiel.

    sehen, wenn es hilft, www-01.ibm.com/support/knowledgecenter/SSCKBL_8.5.5/...

    InformationsquelleAutor stratwine

  2. 6

    Wenn JUnit Tests Sachen wie diese, benutze ich eine Test-callback mit einem CountDownLatch, die gezählt wird nach unten durch die callback-und await()ed durch die test-Methode.

    private static class TestingCallback implements Callback {
    private final CountDownLatch latch;
    public TestingCallback(CountDownLatch latch) {
        this.latch = latch;
    }
    @Override public void onEvent() {
        this.latch.countDown();
    }
}

@Test
public void testCallback() {
    final CountDownLatch latch = new CountDownLatch(1);

    classUnderTest.execute( new TestCallback(latch) );

    assertTrue(latch.await(30, TimeUnit.SECONDS));
}

    Wenn das callback aufgerufen wird (asynchron) durch den code unter test, den Riegel zurück true und der test bestanden. Wenn der callback nicht aufgerufen, den test mal nach dreißig Sekunden und die assertion fehlschlägt.

    InformationsquelleAutor Barend

Schreibe einen Kommentar