Simuler un retard dans l'exécution de l'Unité de Test à l'aide de Moq

Je suis en train de tester le suivant:

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;
}

avec l'appareil de 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() renvoie une chaîne de caractères et le "Délai de Livraison" la méthode est

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;
}

Je suis en utilisant Moq comme le moqueur cadre et MSTest que l'infrastructure de test. Chaque fois que je lance le test de l'unité, j'obtiens le résultat suivant:

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

Au-delà de l'évident "odeur de code" à l'aide du Fil.Dormir dans les méthodes ci-dessus, le résultat de l'unité de test n'est pas ce que je suis en train d'accomplir.

Quelqu'un peut-il suggérer une meilleure exactes façon d'utiliser le Moq cadre de simuler un délai de "livraison" du message. J'ai laissé de côté une partie de la "colle" de code et ne comprenaient que les parties pertinentes. Laissez-moi savoir si quelque chose que j'ai laissé de côté qui vous empêche d'être en mesure de comprendre la question.

Vous seriez mieux de créer un exemple de quelqu'un (autre que vous) peut s'exécuter qu'un aperçu de ce que vous essayez d'accomplir. Il n'y a rien ici, quelqu'un pourrait copier et exécuter sans faire un bouquet de travaux supplémentaires.

OriginalL'auteur Julian Easterling | 2013-04-04

c#moq mstest unit-testing

32

Si vous voulez une Moq se moquer de tout simplement s'asseoir et ne rien faire pendant un certain temps, vous pouvez utiliser un rappel:
```
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);
```
J'ai essayé que dans LinqPad et si vous ajustez la Thread.Sleep() le temps d'exécution varie en conséquence.

Le Callback() la méthode était ce que j'étais en manque... j'ai mis à jour l'unité de test à utiliser celui-ci et l'unité de test maintenant "se moque" le retard correctement... Merci!
cela ne semble pas fonctionner pour moi, je pense que le rappel est exécuté après le résultat est renvoyé par le Moq
Je suis d'accord avec @DanDinu - si vous exécutez deux appels simultanés à Bar() puis les deux Callbacks sont exécutées après les deux Bar()s complet.
Pour ceux qui ne sont pas en mesure d'obtenir que cela fonctionne: Le rappel ne sera exécuté avant la moqué de méthode, si vous vous moquez du rappel avant de vous moquer de retour d'appel (selon le Moq documentation "rappels peuvent être spécifiés avant et après l'invocation"). Si vous êtes en se moquant d'une méthode void, alors je crains que vous êtes hors de la chance, car le rappel sera toujours exécuté après la moqué de méthode s'exécute.
1000 est un temps long pour un test à exécuter. Ce doit être configuré pour s'exécuter jusqu'à ce qu'il est dit d'arrêter. Envisager de remplacer le Fil de discussion.Le sommeil de la Tâche.Retard

OriginalL'auteur Adam Rodger
7

Lorsque vous configurez votre fantaisie, vous pouvez dire le fil de dormir dans le retour func:
```
Mock<IMyService> myService = new Mock<IMyService>();

myService.Setup(x => x.GetResultDelayed()).Returns(() => {
    Thread.Sleep(100);
    return "result";
});
```
Exactement. Et cela a l'avantage sur le accepté la solution qu'il vous permet d'exécuter en tant que async si GetResultDelayed est e.g de type de Tâche<string>: myService.Setup(x => x.GetResultDelayed()).Retourne(async () => { attendent Tâche.Delay(100); return "";});

OriginalL'auteur Susanne Peng

Je ne pouvais pas obtenir Moq version de travail, j'ai donc fini par faire quelque chose comme ceci:

un petit exemple d'utilisation 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();

    }

}

Je l'aime serup! Je ne comprends pas pourquoi vous n'avez pas plus upvotes!

OriginalL'auteur serup

J'aime, et ont voté pour serup de la solution. Ma réponse est une version de son transformée en bibliothèque.

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;
    }
}

OriginalL'auteur Jacob Brewer

1

J'ai eu une situation similaire, mais avec une méthode Asynchrone. Ce qui a fonctionné pour moi a été de faire ce qui suit:
```
 mock_object.Setup(scheduler => scheduler.MakeJobAsync())
  .Returns(Task.Run(()=> { Thread.Sleep(50000); return Guid.NewGuid().ToString(); }));
```
OriginalL'auteur Louis Cribbins

Vous devez vous connecter pour publier un commentaire.