Foq Mock.Expect with Times> 1总是失败

Question

None of the Mock.Expect examples I've found use Times other than 0 or 1 (never, once). I modifed one of the existing tests from Foq.Usage.fsx to attempt something that's not 0 or 1, but I can't make it work.

Does anyone see anything wrong?

let [<Test>] ``expect method is called the specified number of times`` () =
    // Arrange
    let xs = Mock.Of<System.Collections.Generic.IList<int>>()
    // Assert (setup)
    Mock.Expect(<@ xs.Contains(0) @>, never)
    Mock.Expect(<@ xs.Contains(1) @>, once)
    Mock.Expect(<@ xs.Contains(2) @>, exactly 2)
    // Act
    xs.Contains(1) |> ignore
    xs.Contains(2) |> ignore
    xs.Contains(2) |> ignore
    // Assert
    verifyAll xs

Answer 1

This is a bug in Foq , when you use Mock.Expect it checks the expectations are met at the time of invocation on the mock. If the given expectation is not met an exception is thrown. This may in theory be useful as it gives a stack trace at the exact point that an expectation is not met.

The issue with exactly 2 is that the expectation is checked first after one invocation and it is not exactly two. In effect at invocation time we want to interpret exactly 2 as at most two, and at verifyAll as exactly two.

You can get closer to the behaviour I believe you want with the existing implementation using Mock.Expect with atmost 2 and/or a plain old verify after the effect:

let [<Test>] ``expect method is called the specified number of times`` () =
    // Arrange
    let xs = Mock.Of<System.Collections.Generic.IList<int>>()
    // Assert (setup)
    Mock.Expect(<@ xs.Contains(0) @>, never)
    Mock.Expect(<@ xs.Contains(1) @>, once)
    Mock.Expect(<@ xs.Contains(2) @>, atmost 2)
    // Act
    xs.Contains(1) |> ignore
    xs.Contains(2) |> ignore
    xs.Contains(2) |> ignore
    // Assert
    Mock.Verify(<@ xs.Contains(2) @>, exactly 2)
    verifyAll xs

Thanks for reporting the issue. The issue is now fixed in the source and will be available in the next release.

Answer 2

As discussed in the comments, this doesn't answer your question but ... I'd write this (which works):

let xs = Mock.Of<System.Collections.Generic.IList<_>>()
// Act
xs.Contains(1) |> ignore
xs.Contains(2) |> ignore
xs.Contains(2) |> ignore
// Assert
verify <@ xs.Contains(0) @> never
verify <@ xs.Contains(1) @> once
verify <@ xs.Contains(2) @> <| exactly 2

Answer 3

Thank you, Ruben. I agree, the explicit verify s are best, but (also on your suggestion) the code below works in case anyone would want to use Expect / verifyAll .

let [<Test>] ``expect method is called the specified number of times`` () =
    // Arrange
    let xs = Mock.Of<System.Collections.Generic.IList<int>>()
    // Act
    xs.Contains(1) |> ignore
    xs.Contains(2) |> ignore
    xs.Contains(2) |> ignore
    // Assert
    Mock.Expect(<@ xs.Contains(0) @>, never)
    Mock.Expect(<@ xs.Contains(1) @>, once)
    Mock.Expect(<@ xs.Contains(2) @>, exactly 2)
    verifyAll xs