Testing asynchronous API, with Given-When-Then style, multiple When-Then?

Question

I know it is recommended to have "single assert" in tests or single group of "When" and "Then" in BDD paradigm.

I was thinking whether it would be okay to relax this assumption, when testing an asynchronous API. Where request has to be first made, and then later it completes.

Something like this:

@Rule
public final Java6JUnitSoftAssertions softly = new Java6JUnitSoftAssertions();

@Test
public void setLessStrictCriterionGivenAllFetchesCompleted() {
    givenRepoWithCriterion(new MockCriterion(2));
    givenAllFetchesCompleted();

    // When I set a less strict criterion of ">= 1"
    final MockCriterion criterionMinValue1 = new MockCriterion(1);
    itemRepo.setCriteriaAndFetch(criterionMinValue1);

    // Then there is a fetch request in the queue, to fetch ">= 1"
    assertQueue(criterionMinValue1);
    // And there are loading items
    assertRepoItems(null, null, null);
    assertAll();

    // -------- Notice second group of When-Then starts here --------

    // When the fetch finishes
    fetcher.yieldFetch();

    // Then item list is 1 2 3
    assertRepoItems(1, 2, 3);
}

Note that there are two groups of When-Then.

The assertAll() is there to force asserting the first group of AssertJ soft assertions.

The fetches are normally done via HTTP in the real implementation, but, for the tests, there is a mocked fetcher and the finish of a fetch is emulated via fetcher.yieldFetch();

Would you consider that overall structure to be a good way to write such tests?

What other/better ways might be there?