We use test-driven development on my team, and the kind of code we
write can't really be unit-tested unless you use mock objects to
isolate dependencies. We've been using C# with NUnit and
NMock. I've run into some problems using NMock with F#, and I
thought I'd share my experiences. If any of you have some
suggestions on how to work around these problems, or better approaches
to mock objects with F#, I'd like to hear from you.

1. Problems with cycle of compile / test with NUnit.
The typical cycle of work with C# and NUnit is this:
a. Write a unit test.

b. Get it to compile.

c. Click "Run" on the NUnit GUI to run the test.

d. See the test fail.

e. Fix the code being tested, to make it pass the test.

f. Recompile

g. Click "Run" on the NUnit GUI and see the test pass.

If I use "Build Solution" in Visual Studio, then the test DLL
(which references the production DLL) also gets updated and NUnit
reloads it.

The problem is that no such update occurs when I do "Build Solution"
with an F# project. The code to test gets recompiled, but unless
I make a spurious change to the test code (add/remove a space), the
test DLL remains unchanged, so NUnit doesn't reload anything, and I
don't see the results of the fix.

2. Problems with initialization.

The typical way of using NMock and NUnit is as follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

[TestFixture]
public class MyTestClass
{
    Mockery mock;

    ISomethingToMock something;
    [SetUp]

    public void Setup()
    {
        mock = new Mockery();
        something = mock.NewMock<ISomethingToMock>();
        ...
    }
    ...
    [Test]
    public void SomeTest()
    {
        Expect.Once.On(something).Method("TheMethodName").With(arg1, arg2);
        ...
    }   
}

Some problems occur when you try to translate this into F#.

First, there is the problem of an initial value for the instance

variable something:

1
2
3
4
5
6
7
8

[<TestFixture>]
type MyTestClass() =
    let mutable mock = null
    let mutable something = ???

    [<SetUp>]
    member x.Setup() =
        ....

You can't initialize something to null, because the compiler won't let you -- null is not a valid value for interface types. You want to reinitialize mock and something in Setup(), which gets called just before every call to a test function, but you need some initial value for them.

3. Problems with expectations.

In C#, a test can have a line like this:

1

    Expect.Once.On(something).Method("TheMethodName").With(arg1, arg2);

This programs the behavior of the mock object something: it will expect to see exactly one call to method TheMethodName, with arguments equal to arg1 and arg2. The corresponding line in F# is quite ugly:

1

    Expect.Once.On(something).Method("TheMethodName").With([|(arg1 :> obj), (arg2 :> obj)|]) |> ignore;

The ignore is needed because there is a non-void return value. The C# signature of the With method is

1

    IMatchSyntax IArgumentSyntax.With(params object[] equalArgVals)

that is, With() takes a variable-length list of arguments.
My tentative conclusion is that it's not really practical to use NMock
with F#. If anyone knows of a way around these difficulties, I'd
like to hear about it. Better yet, is there a mock object
framework specifically for use with F#?