560

How do I verify that method was NOT called in Moq?

Does it have something like AssertWasNotCalled?

UPDATE: Starting from Version 3.0, a new syntax can be used:

mock.Verify(foo => foo.Execute("ping"), Times.Never());
Improve this question
1
  • As of v4.8, there's an alternative approach that's also worth considering. Commented Feb 7, 2022 at 3:00

8 Answers 8

Reset to default
665

Run a verify after the test with the Times.Never() option.

_mock.Object.DoSomething() _mock.Verify(service => service.ShouldntBeCalled(), Times.Never());
Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

What's critical here is that the Verify(action, Never) call is after the invocation to the mock. I thought it was setting up the verification for calling VerifyAll() later (which does not work)
Not sure if it's because a newer version, but if you setup the mock with ´MockBehavior.Strict´ and don't add a Setup then it'll fail if the method is called. No need for a Verify.
171

UPDATE: Since version 3, check the update to the question above or Dann's answer below.

Either, make your mock strict so it will fail if you call a method for which you don't have an expect

new Mock<IMoq>(MockBehavior.Strict)

Or, if you want your mock to be loose, use the .Throws( Exception )

var m = new Mock<IMoq>(MockBehavior.Loose); m.Expect(a => a.moo()).Throws(new Exception("Shouldn't be called."));
Improve this answer

7 Comments

... or Callback() to set some flag that can be asserted.
Also with option#2, you can't have a VerifyAll in a general Teardown method - it will fail saying that the expectation was not met ; when the test should ideally pass.
This isn't really a "verify not called" as it could be caught within the method and would still work - providing a false positive!
Expect is now deprecated
This might have been the best possible way in 2009, but certainly not now. sorry
|
57

Stolen from: John Foster's answer to the question, "Need help to understand Moq better"

One of the things that you might want to test is that the pay method does not get called when a person aged over 65 is passed into the method

[Test] public void Someone_over_65_does_not_pay_a_pension_contribution() { var mockPensionService = new Mock<IPensionService>(); var person = new Person("test", 66); var calc = new PensionCalculator(mockPensionService.Object); calc.PayPensionContribution(person); mockPensionService.Verify(ps => ps.Pay(It.IsAny<decimal>()), Times.Never); }
Improve this answer

Comments

12

This does not work in recent versions of Moq (since at least 3.1), it should be specified in the Verify method as mentioned in the answer.

Actually, it's better to specify .AtMost(0) after the Returns statement.

var m = new Mock<ISomething>(); m.Expect(x => x.Forbidden()).Returns("foo").AtMost(0);

Although the "throws" also works, AtMost(0) is more expressive IMHO.

Improve this answer

Comments

8

Using VerifyNoOtherCalls (requires Moq 4.8 or later)

This answer is an indirect approach. Instead of checking that a particular method wasn't called, you check that no unexpected calls were made in general.

Consider that a thorough test of a mock does 2 things:

  1. Verify that all expected calls were made
  2. Verify that no unexpected calls were made

If you're already doing step 1, adding step 2 is trivial:

// Step 1 (if relevant - see note below) mock.Verify(..., Times.Exactly(2)); mock.Verify(..., Times.Once()); // ... // Step 2 mock.VerifyNoOtherCalls();

Notes

  • If you omit step 1, step 2 will simply ensure no calls were made to the mock at all.
  • This does not require a strict mock.
  • Source: Moq Quickstart
Improve this answer

Comments

2

I realise this is a very old question, but it just appeared in my sidebar, and I'd like to add my solution.

Many unit tests appear to mock several functions, as part of the setup, but then aren't used during the test.

Surely it's better to enable strict mocking (which means anything not explicitly setup will throw an exception), and then don't set up any functions you don't expect to be called. Or to put it another way, only set up the functions that one test expects to be called, and anything else will thrown an exception.

var thingBeingTested = new Mock<IThink>(MockBehaviour.Strict); thingBeingTested.ThisWillThrowAnExceptionBecauseItHasNotBeenMocked();
Improve this answer

1 Comment

See Chris's answer below, but one reason for an explicit negative test, it to make the design more explicit wrt to refactoring e.g. it might have consequences if a call is made
0

Suppose you have this method and you want to test that it's not being called

//Setup var databaseSessionMock = new Mock<IDatabaseSession>(); databaseSessionMock.Setup(m => m.Commit()).Returns(true).Verifiable(); RepositoryFactory.Configure<IDatabaseSession>(databaseSessionMock.Object);

you can test like this

databaseSessionMock.Verify(m => m.Commit(It.IsAny()), Times.Never(), "Database Session mock object was not used");
Improve this answer

Comments

-6

Use .AtMostOnce();

After the real test, call the method again. If it throws an exception, it was called.

Improve this answer

3 Comments

Isn't a little bit too obscure, to assert that exception was thrown by mocking framework?
Why? Just check the type of the exception. If it's one thrown my Moq, you're safe.
Using Verify with Times.Never is a better choice ... I agree with alex that this solution works, but is definitely obscure.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.