C＃-nunit / mstest等效于junit的@RunWith（HierarchicalContextRunner.class）

Question

I've been following a unit test tutorial and the code is written in java, the tests are hierachical and I can't translate them to c# without knowing whats the equivalent of @RunWith(HierarchicalContextRunner.class) in nunit and/or mstest.

I've been thinking about inheritance, but I'm not sure thats the right answer.

Answer 1

I don't think there is a way to replace runners in either NUnit or MSTest, but here is the way I am doing it with NUnit.

First, you need NUnit >= 2.5 so that SetUp methods are run from the top of the inheritance hierarchy to the current test class. Then:

public abstract class Given_An_Engine {
    protected Engine _engine;

    [SetUp]
    public void GivenAnEngine() {
        _engine = new Engine();
    }

    public abstract class That_Is_Stopped : Given_An_Engine {
        [SetUp]
        public void ThatIsStopped() {
            _engine.State = STOPPED;
        }

        public class When_I_Open_The_Status_UI : That_Is_Stopped {
            public StatusUI _ui; // You'll learn better ways than making _ui public. This is just for shortness.

            [SetUp]
            public void WhenIOpenTheStatusUI() {
              _ui = _engine.OpenUI();
            }

            [TestFixture]
            public class Behaves_Like_Display_Of_Stopped_Engine
                : Behaves_Like_Display_Of_Stopped_Engine<When_I_Open_The_Status_UI> {}
        }
    }
}

public class Behaves_Like_Display_Of_Stopped_Engine<TContext> 
    where TContext: Given_An_Engine.That_Is_Stopped.When_I_Open_The_Status_UI, new() {

    TContext ctx = new TContext();

    [SetUp]
    public void SetUp() {
        ctx.RunSetUp();
    }

    [TearDown]
    public void TearDown() {
        ctx.RunTearDown();
    }

    [Test]
    public void Displays_Stopped() {
       Assert.AreEqual("Stopped", ctx._ui.lblStatus.Text);
    }

    [Test]
    public void Displays_A_Red_Lamp() {
       Assert.AreEqual(Color.Red, ctx._ui.LampColor);
    }
}

The RunSetUp and RunTearDown methods are extension methods on object that you should try to write yourself, they're only 30-ish lines long. RunSetUp should run all SetUp methods from the top of the hierarchy down to the objects's class, and RunTearDown should do just the reverse. I leave it as an exercice to you.

RunSetUp and RunTearDown also allow you to compose your test classes.

public abstract Given_Two_Engines {
    protected Given_An_Engine engine1 = new Given_An_Engine.That_Is_Stopped();
    protected Given_An_Engine engine2 = new Given_An_Engine.That_Is_Stopped();

    [SetUp]
    public void GivenTwoEngines() {
        engine1.RunSetUp();
        engine2.RunSetUp();
    }

    [TearDown]
    public void UnGivenTwoEngines() {
        engine2.RunTearDown();
        engine1.RunTearDown();
    }

Try it, and let me know what you think of the resulting names of the fixtures in the NUnit GUI.