Simulieren eine Verzögerung in der Ausführung in Unit-Test mit Moq

Ich versuche zum test das folgende:

protected IHealthStatus VerifyMessage(ISubscriber destination)
{
    var status = new HeartBeatStatus();

    var task = new Task<CheckResult>(() =>
    {
        Console.WriteLine("VerifyMessage(Start): {0} - {1}", DateTime.Now, WarningTimeout);
        Thread.Sleep(WarningTimeout - 500);
        Console.WriteLine("VerifyMessage(Success): {0}", DateTime.Now);
        if (CheckMessages(destination))
        {
            return CheckResult.Success;
        }

        Console.WriteLine("VerifyMessage(Pre-Warning): {0} - {1}", DateTime.Now, ErrorTimeout);
        Thread.Sleep(ErrorTimeout - 500);
        Console.WriteLine("VerifyMessage(Warning): {0}", DateTime.Now);
        if (CheckMessages(destination))
        {
            return CheckResult.Warning;
        }

        return CheckResult.Error;
    });

    task.Start();

    task.Wait();
    status.Status = task.Result;

    return status;
}

mit der folgenden unit-test:

public void HeartBeat_Should_ReturnWarning_When_MockReturnsWarning()
{
    //Arrange
    var heartbeat = new SocketToSocketHeartbeat(_sourceSubscriber.Object, _destinationSubscriber.Object);
    heartbeat.SetTaskConfiguration(this.ConfigurationHB1ToHB2_ValidConfiguration());

    //Simulate the message being delayed to destination subscriber.
    _destinationSubscriber.Setup(foo => foo.ReceivedMessages).Returns(DelayDelivery(3000, Message_HB1ToHB2()));

    //Act
    var healthStatus = heartbeat.Execute();

    //Assert
    Assert.AreEqual(CheckResult.Warning, healthStatus.Status);
}

Message_HB1ToHB2() nur einen string zurückgibt der Charaktere und die "Verzögerung Delivery" - Methode ist

private List<NcsMessage> DelayDelivery(int delay, string message)
{
    var sent = DateTime.Now;
    var msg = new NcsMessage()
    {
        SourceSubscriber = "HB1",
        DestinationSubscriber = "HB2",
        SentOrReceived = sent,
        Message = message
    };

    var messages = new List<NcsMessage>();
    messages.Add(msg);

    Console.WriteLine("DelayDelivery: {0}", DateTime.Now);
    Thread.Sleep(delay);
    Console.WriteLine("DelayDelivery: {0}", DateTime.Now);

    return messages;
}

Ich bin mit Moq wie das mocking framework und MSTest als Test-framework. Wenn ich das Gerät testen, ich bekomme die folgende Ausgabe:

DelayDelivery: 04/04/2013 15:50:33
DelayDelivery: 04/04/2013 15:50:36
VerifyMessage(Start): 04/04/2013 15:50:36 - 3000
VerifyMessage(Success): 04/04/2013 15:50:38

Jenseits des offensichtlichen "code smell" mit dem Thread.Schlaf in den obigen Methoden, ist das Ergebnis der unit-test ist nicht das, was ich versuche zu erreichen.

Kann jeder jeden schlagen eine bessere/genaue Weg, um das Moq-framework zum simulieren einer Verzögerung bei der "Lieferung" von der Nachricht. Ich habe einige der "glue-code" und nur die relevanten Teile. Lassen Sie mich wissen, wenn etwas habe ich ausgelassen, die verhindert, dass Sie in der Lage, die Frage zu verstehen.

Sie wären besser dran, erstellen einer Beispiel jemand (außer Ihnen) überhaupt ausführen kann, die zeigt, was Sie versuchen zu erreichen. Es gibt hier nichts, jemand könnte kopieren und ausführen, ohne dabei einen Haufen extra-Arbeit.

InformationsquelleAutor Julian Easterling | 2013-04-04

c#moq mstest unit-testing

32

Wenn Sie möchten, eine Moq mock, einfach nur sitzen und nichts tun für eine Weile, können Sie einen Rückruf:
```
Mock<IFoo> mockFoo = new Mock<IFoo>();
mockFoo.Setup(f => f.Bar())
       .Callback(() => Thread.Sleep(1000))
       .Returns("test");

string result = mockFoo.Object.Bar(); //will take 1 second to return

Assert.AreEqual("test", result);
```
Ich habe versucht, dass in LinqPad und wenn Sie passen Sie die Thread.Sleep() die Ausführungszeit variiert entsprechend.
- Die Callback () - Methode war es, was mir fehlte... ich aktualisierte den unit-test zu verwenden, und das Gerät jetzt testen "mocks" die Verzögerung richtig... vielen Dank!
- dies scheint nicht für mich arbeiten, ich denke, der callback wird ausgeführt, wenn das Ergebnis zurückgegeben wird, indem die Moq
- Ich Stimme mit @DanDinu - wenn Sie zwei gleichzeitige Anrufe zu Bar() dann die beiden Callbacks ausgeführt werden nachdem beide Bar()s abgeschlossen.
- Für diejenigen, die nicht in der Lage zu bekommen dies funktioniert: Der Rückruf wird nur dann ausgeführt werden, bevor das verspottet-Methode, wenn Sie verhöhnen die callback-bevor Sie spotten der Rückruf (wie in der Moq Dokumentation "callbacks angegeben werden können, vor und nach dem Aufruf"). Wenn Sie mocking eine void-Methode, dann fürchte ich, hast du Pech, als der Rückruf wird immer ausgeführt, nachdem der verspottet Methode ausführt.
- 1000 ist eine lange Zeit für eine Prüfung zu laufen. Dies sollte sein setup zu laufen, bis Sie sagte zu stoppen. Erwägen Sie einen Wechsel-Thread.Schlafen mit Aufgabe.Verzögerung
InformationsquelleAutor Adam Rodger
7

Wenn Sie Ihre setup mock kann man sagen der thread in der return func:
```
Mock<IMyService> myService = new Mock<IMyService>();

myService.Setup(x => x.GetResultDelayed()).Returns(() => {
    Thread.Sleep(100);
    return "result";
});
```
- Genau. Und dies hat den Vorteil, über die akzeptierte Lösung, die es ermöglicht es Ihnen, führen Sie es als asynchron, wenn GetResultDelayed ist e.g-Typ Task<string>: myService.Setup(x => x.GetResultDelayed()).Gibt(async () => { await Task.Delay(100); return Ergebnis; });
InformationsquelleAutor Susanne Peng

Konnte ich nicht Moq-version zu arbeiten, so dass ich endete, dass so etwas wie dieses:

einem kleinen Beispiel mit WaitHandle:

[TestFixture]
public class EventWaitHandleTests
{
    class Worker {
        private volatile bool _shouldStop;
        public EventWaitHandle WaitHandleExternal;

        public void DoWork ()
        {
            while (!_shouldStop)
            {
                Console.WriteLine("worker thread: working...");
                Thread.Sleep(1000);
                WaitHandleExternal.Set();
            }
        }

        public void RequestStop()
        {
            _shouldStop = true;
        }

    }

    [Test]
    public void WaitForHandleEventTest()
    {
        EventWaitHandle _waitHandle = new AutoResetEvent (false); //is signaled value change to true

        //start a thread which will after a small time set an event
        Worker workerObject = new Worker ();
        workerObject.WaitHandleExternal = _waitHandle;
        Thread workerThread = new Thread(workerObject.DoWork);

        //Start the worker thread.
        workerThread.Start();

        Console.WriteLine ("Waiting...");
        _waitHandle.WaitOne();                //Wait for notification
        Console.WriteLine ("Notified");

        //Stop the worker thread.
        workerObject.RequestStop();

    }

}

Ich mag es serup! Ich verstehe nicht, warum Sie nicht mehr upvotes!

InformationsquelleAutor serup

Ich mag und habe für serup-Lösung. Meine Antwort ist eine version der seine umgebaut für die Nutzung als Bibliothek.

using System;
using System.Threading.Tasks;
using Microsoft.VisualStudio.TestTools.UnitTesting;

///<summary>
///support halting a workflow and waiting for a finish request
///</summary>
public class MockWorker
{
    private readonly DateTime? _end;
    private volatile bool _shouldStop;

    ///<summary>
    ///Create a worker object
    ///</summary>
    ///<param name="timeoutInMilliseconds">How long before DoWork will timeout.  default - Null will not timeout.</param>
    public MockWorker(int? timeoutInMilliseconds = null)
    {
        if (timeoutInMilliseconds.HasValue)
            _end = DateTime.Now.AddMilliseconds(timeoutInMilliseconds.Value);
    }

    ///<summary>
    ///Instruct DoWork to complete
    ///</summary>
    public void RequestStop()
    {
        _shouldStop = true;
    }

    ///<summary>
    ///Do work async will run until either timeoutInMilliseconds is exceeded or RequestStop is called.
    ///</summary>
    public async Task DoWorkAsync()
    {
        while (!_shouldStop)
        {
            await Task.Delay(100);
            if (_end.HasValue && _end.Value < DateTime.Now)
                throw new AssertFailedException("Timeout");
        }
    }

    ///<summary>
    ///Do work async will run until either timeoutInMilliseconds is exceeded or RequestStop is called.
    ///</summary>
    ///<typeparam name="T">Type of value to return</typeparam>
    ///<param name="valueToReturn">The value to be returned</param>
    ///<returns>valueToReturn</returns>
    public async Task<T> DoWorkAsync<T>(T valueToReturn)
    {
        await DoWorkAsync();
        return valueToReturn;
    }
}

InformationsquelleAutor Jacob Brewer

Ich hatte eine ähnliche situation, aber mit einer Async-Methode. Was für mich gearbeitet wurde, Folgendes zu tun:

 mock_object.Setup(scheduler => scheduler.MakeJobAsync())
  .Returns(Task.Run(()=> { Thread.Sleep(50000); return Guid.NewGuid().ToString(); }));

InformationsquelleAutor Louis Cribbins

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.