Warten Sie auf einen Async Void Methodenaufruf für Unit-Tests

Sie sollten async void vermeiden. Verwenden Sie async void nur für Ereignishandler. DelegateCommand ist (logisch) ein Event-Handler, also können Sie dies folgendermaßen tun:

// Use [InternalsVisibleTo] to share internal methods with the unit test project.
internal async Task DoLookupCommandImpl(long idToLookUp)
{
  IOrder order = await orderService.LookUpIdAsync(idToLookUp);   

  // Close the search
  IsSearchShowing = false;
}

private async void DoStuff(long idToLookUp)
{
  await DoLookupCommandImpl(idToLookup);
}

und Gerätetest als:

[TestMethod]
public async Task TestDoStuff()
{
  //+ Arrange
  myViewModel.IsSearchShowing = true;

  // container is my Unity container and it setup in the init method.
  container.Resolve<IOrderService>().Returns(orderService);
  orderService = Substitute.For<IOrderService>();
  orderService.LookUpIdAsync(Arg.Any<long>())
              .Returns(new Task<IOrder>(() => null));

  //+ Act
  await myViewModel.DoLookupCommandImpl(0);

  //+ Assert
  myViewModel.IsSearchShowing.Should().BeFalse();
}

Meine empfohlene Antwort ist oben. Wenn Sie eine async void-Methode wirklich testen möchten, können Sie dies mit meiner AsyncEx-Bibliothek tun:

[TestMethod]
public void TestDoStuff()
{
  AsyncContext.Run(() =>
  {
    //+ Arrange
    myViewModel.IsSearchShowing = true;

    // container is my Unity container and it setup in the init method.
    container.Resolve<IOrderService>().Returns(orderService);
    orderService = Substitute.For<IOrderService>();
    orderService.LookUpIdAsync(Arg.Any<long>())
                .Returns(new Task<IOrder>(() => null));

    //+ Act
    myViewModel.DoLookupCommand.Execute(0);
  });

  //+ Assert
  myViewModel.IsSearchShowing.Should().BeFalse();
}

Diese Lösung ändert jedoch die SynchronizationContext für Ihr Ansichtsmodell während seiner Lebensdauer.

Eine async void-Methode ist im Wesentlichen eine "Feuer und Vergessen" -Methode. Es gibt keine Möglichkeit, ein Abschlussereignis zurück zu bekommen (ohne ein externes Ereignis usw.).

Wenn Sie einen Gerätetest durchführen müssen, würde ich empfehlen, stattdessen eine async Task-Methode zu erstellen. Sie können dann Wait() für die Ergebnisse aufrufen, um Sie darüber zu informieren, wenn die Methode abgeschlossen ist.

Diese Testmethode würde jedoch immer noch nicht funktionieren, da Sie DoStuff nicht direkt testen, sondern eine DelegateCommand testen, die sie umschließt. Sie müssen diese Methode direkt testen.

Sie können ein AutoResetEvent verwenden, um die Testmethode anzuhalten, bis der async-Aufruf abgeschlossen ist:

[TestMethod()]
public void Async_Test()
{
    TypeToTest target = new TypeToTest();
    AutoResetEvent AsyncCallComplete = new AutoResetEvent(false);
    SuccessResponse SuccessResult = null;
    Exception FailureResult = null;

    target.AsyncMethodToTest(
        (SuccessResponse response) =>
        {
            SuccessResult = response;
            AsyncCallComplete.Set();
        },
        (Exception ex) =>
        {
            FailureResult = ex;
            AsyncCallComplete.Set();
        }
    );

    // Wait until either async results signal completion.
    AsyncCallComplete.WaitOne();
    Assert.AreEqual(null, FailureResult);
}

Die angegebene Antwort testet den Befehl und nicht die Async-Methode. Wie oben erwähnt, benötigen Sie einen weiteren Test, um diese asynchrone Methode zu testen.

Nachdem ich einige Zeit mit einem ähnlichen Problem verbracht hatte, fiel es mir leicht, eine asynchrone Methode in einem Komponententest zu testen, indem ich einfach synchron aufrief:

    protected static void CallSync(Action target)
    {
        var task = new Task(target);
        task.RunSynchronously();
    }

und die Verwendung:

CallSync(() => myClass.MyAsyncMethod());

Der Test wartet auf dieser Zeile und wird fortgesetzt, nachdem das Ergebnis fertig ist, so dass wir sofort danach bestätigen können.

Die einzige Möglichkeit, die ich kenne, ist, Ihre async void-Methode auf async Task-Methode umzustellen

Ich hatte ein ähnliches Problem. In meinem Fall bestand die Lösung darin, Task.FromResult im moq-Setup für .Returns(...) wie folgt zu verwenden:

orderService.LookUpIdAsync(Arg.Any<long>())
    .Returns(Task.FromResult(null));

Alternativ hat Moq auch eine ReturnsAysnc(...) -Methode.

Ändern Sie Ihre Methode, um eine Task zurückzugeben, und Sie können Task.Result verwenden

bool res = configuration.InitializeAsync(appConfig).Result;
Assert.IsTrue(res);