How do I enforce test isolation in MSpec when static members/methods are required?

Question

Ok. I'm trying to wrap my head around why MSpec uses static methods / variables. (Well not exactly static methods, but with member variable delegates, it's practically the same).

This makes it impossible to reuse contexts. That or go through and make sure all static variables are reset manually. This has no enforcement on test isolation. If one test sets up some variables and the next one checks for it, it'd pass when it shouldn't.

This is starting to get very annoying. What I do in one "because" statement should just stay there, not get carried through to every other random test just because it's sharing the same context.

Edit-

The question is, how do I "ENFORCE" test isolation. For example, look at the specs below, sharing the FooContext. Let's take a wild guess if should_not_throw passes?

public class FooContext
{
    Establish context = () => Subject = new Foo();

    public static Foo Subject;
    public static int result;
    public static Exception ex;
}

public class When_getting_an_int_incorrectly : FooContext
{
    Because of = () => ex = Exception.Catch(() => result = Subject.GetInt(null)); 

    It should_throw = () => ex.ShouldNotBeNull();
}

public class When_getting_an_int_correctly : FooContext
{
    Because of = () => ex = Exception.Catch(() => result = Subject.GetInt(0));

    It should_not_throw = () => ex.ShouldBeNull();
}

Especially when compared with XUnit test library, MSpec seem like a mess. — Sleeper Smith, Aug 09 '13 at 01:56
Your question, as written, is kind of aggressive. But, I can see that you have valuable content in there. What's your main focus: A) Why does MSpec use custom delegates? B) How do I reuse contexts in MSpec. Or C) How do I isolate side-effects & global state in MSpec. You might be able to get several questions out of this. — Anthony Mastrean, Aug 09 '13 at 19:39
If you provide some code example that shows your problem, you might get a more helpful answer. — Simon Hohenadl, Aug 10 '13 at 04:49
@AnthonyMastrean C) How do I isolate side-effects etc is what I'm interested in. — Sleeper Smith, Aug 12 '13 at 00:48

score 2 · Answer 1 · answered Aug 10 '13 at 00:47

It's a technical and a historic limitation.

You need statics fields to share information between the delegates (Establish, Because, It, Cleanup).
MSpec tries to mimic rspec, so I think Aaron considered delegates to be a good fit and released the syntax you see today back in 2008 or 2009. This syntax is still in place today.

As for context sharing / context base classes: From what you state it seems like you're overusing the concept. You should always initialize static fields in the Establish, so it the global state will become a non-issue. Context sharing should be well considered, so, to quote you, it doesn't happen randomly. Try using helper methods for complex setup and be more verbose (I'd say explicit) in the Establishs. It will help make your specs more readable.

score 1 · Answer 2 · answered Sep 23 '13 at 01:35

Lo and behold. I would like to present my (partial) solution to the problem (Of enforcing fixture and setup isolation). That and resolving the problem of plumbing code all at the same time.

I basically put an automocking container in an instance of the fixture and make sure that fixture is recreated for every single spec. If some other setup is required, just inherit or add to the fixture.

(Note this uses structure map and structure map / moq / automocking container. I'm sure it's all the same for different container/mocking framework.)

/// <summary>
/// This is a base class for all the specs. Note this spec is NOT thread safe. (But then
/// I don't see MSpec running parallel tests anyway)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <remarks>
/// This class provides setup of a fixture which contains a) access to class under test
/// b) an auto mocking container and c) enforce a clean fixture for every spec.
/// </remarks>
public abstract class BaseSpec<T>
    where T : class
{
    public static TestFixture Fixture;
    private Establish a_new_context = () =>
        {
            Fixture = new TestFixture();
            MockedTypes = new Dictionary<Type, Action>();
        };

    /// <summary>
    /// This dictionary holds a list of mocks that need to be verified by the behavior.
    /// </summary>
    private static Dictionary<Type, Action> MockedTypes;
    /// <summary>
    /// Gets the mock of a requested type, and it creates a verify method that is used
    /// in the "AllMocksVerified" behavior.
    /// </summary>
    /// <typeparam name="TMock"></typeparam>
    /// <returns></returns>
    public static Mock<TMock> GetMock<TMock>()
        where TMock : class
    {
        var mock = Mock.Get(Fixture.Context.Get<TMock>());

        if (!MockedTypes.ContainsKey(typeof(TMock)))
            MockedTypes.Add(typeof(TMock), mock.VerifyAll);

        return mock;
    }

    [Behaviors]
    public class AllMocksVerified
    {
        private Machine.Specifications.It should_verify_all =
        () =>
        {
            foreach (var mockedType in MockedTypes)
            {
                mockedType.Value();
            }
        };
    }

    public class TestFixture
    {
        public MoqAutoMocker<T> Context { get; private set; }

        public T TestTarget
        {
            get { return Context.ClassUnderTest; }
        }

        public TestFixture()
        {
            Context = new MoqAutoMocker<T>();
        }
    }
}

And here is a sample usage.

    public class get_existing_goo : BaseSpec<ClassToTest>
    {
        private static readonly Goo Param = new Goo();

        private Establish goo_exist =
            () => GetMock<Foo>()
                      .Setup(a => a.MockMethod())
                      .Returns(Param);

        private static Goo result;

        private Because goo_is_retrieved =
            () => result = Fixture.Context.ClassUnderTest.MethodToTest();

        private It should_not_be_null =
            () => result.ShouldEqual(Param);
    }

Basically if something needs to be shared, put it in the instance of fixture itself. This "enforces" separation.... some what.

I still prefer Xunit in this regard.

How do I enforce test isolation in MSpec when static members/methods are required?

2 Answers2

Linked