Rhino Mocks - en utilisant AssertWasCalled sur Common.Logging ILog.Debug

Question

Je ne parviens pas à utiliser Rhino Mocks pour affirmer qu'une méthode a été appelée (et idéalement avec un paramètre particulier). La méthode est ILog.Debug (FormatMessageHandler) dans commun. 2.0 la connexion en utilisant la nouvelle syntaxe lamba. Il fonctionne très bien en utilisant l'ancienne façon ILog.Debug plaine (chaîne).

    // Sample Code to Test
    public int TestFuncLambda(ILog log, int a, int b)
    {
        log.Debug(m => m("TestFunc START"));

        int c = a + b;

        log.Debug(m => m("TestFunc END"));

        return c;
    }

    public int TestFunc(ILog log, int a, int b)
    {
        log.Debug("TestFunc START");

        int c = a + b;

        log.Debug("TestFunc END");

        return c;
    }

    [TestMethod]
    public void Should_log_start_TestFuncLamba()
    {
        var logger = MockRepository.GenerateMock<ILog>();

        logger.Stub(x => x.IsDebugEnabled).Return(true);

        TestFuncLambda(logger, 1, 2);

        // Doesn't work, says zero calls plus I'm not sure how to check for the word "START" in the string either
        logger.AssertWasCalled(x => x.Debug(Arg<FormatMessageHandler>.Is.Anything), o => o.IgnoreArguments());
    }

    [TestMethod]
    public void Should_log_start_TestFunc()
    {
        var logger = MockRepository.GenerateMock<ILog>();
        logger.Stub(x => x.IsDebugEnabled).Return(true);

        TestFunc(logger, 1, 2);

        // Works fine
        logger.AssertWasCalled(x => x.Debug(Arg<string>.Matches(Text.Contains("START"))));
    }

Answer 1

Je compris. Je manquais la partie d'action pour le délégué. La syntaxe est:

logger.AssertWasCalled(x => x.Debug(Arg<Action<FormatMessageHandler>>.Is.Anything));

plutôt que

logger.AssertWasCalled(x => x.Debug(Arg<FormatMessageHandler>.Is.Anything), o => o.IgnoreArguments());

Comme mentionné o.IgnoreArguments () était redondant et non nécessaire.

Answer 2

Je vais supposer ici que vous êtes juste bricolez avec les RhinoMocks, et cela n'a rien à voir avec le cadre de l'exploitation forestière, est-ce exact? Je dis cela parce qu'il n'y a pas de mises en œuvre concrètes dans vos tests, ne se moque.

Sans tester votre code, cette ligne ressemble à ce sera toujours zéro:

logger.AssertWasCalled(x => x.Debug(Arg<FormatMessageHandler>.Is.Anything), o => o.IgnoreArguments());

parce que votre méthode actuelle TestFunc () passe à cordes log.debug, et non un FormatMessageHandler:

Il serait logique que le nombre d'appels est égal à zéro. Ajouter une ligne à TestFunc () comme ceci:

log.Debug(new FormatMessageHandler());

et voir si cela résout le problème.

Answer 3

Tout d'abord, créez une classe concrète pour voir si la bonne méthode de débogage () est appelée à TestFuncLambda. Cela fait en sorte que ça fait pas une sorte de conversion bizarre du lambda à chaîne.

Une fois que vous vérifiez qui devrait appeler la version correcte, vous avez isolé le problème avec RhinoMocks. Il pourrait être un bug avec des simulacres de rhinocéros. Donc, permet de réduire l'échec défini, mais enveloppant le lambda dans une nouvelle FormatMessageHandler () avant de passer dans Debug. Cela garantit que la fonction de droite moqué est appelé et non traduit par quelque chose d'autre.

Si vous ne trouvez pas un bug à ce point, et il ne fonctionne toujours pas, essayez de créer une instance de FormatMessageHandler () et l'enregistrer en tant que variable membre statique (juste pour tester ce qui est faux). Pass en qui a sauvé dans l'appel à TestFuncDebug Debug () et l'appel AssertWasCalled (). Si cela ne fonctionne pas, je suis d'idées.

BTW, je ne sais pas ce IgnoreArguments () est, mais je ne dois l'appeler dans mon RhinoMocks appelle à AssertWasCalled. En général, ayant Arg <>. Is.Anything fonctionne très bien.