nunit-console/src/NUnitEngine/nunit.engine.tests/Runners/MasterTestRunnerTests.cs at 166798cf118b2604b28db65e570fd74dcb96f337 · nunit/nunit-console · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
// Copyright (c) Charlie Poole, Rob Prouse and Contributors. MIT License - see LICENSE.txt

using NUnit.Framework;
using NSubstitute;
using NUnit.Engine.Services;
using NUnit.Framework.Internal;
using NSubstitute.Core.Arguments;

namespace NUnit.Engine.Runners
{
    [TestFixtureSource(nameof(TestData))]
    public class MasterTestRunnerTests
    {
        private FakeServiceContext _services;
        private TestPackage _package;

        private ITestEngineRunner _engineRunner;
        private MasterTestRunner _masterTestRunner;

        private static TestFixtureData[] TestData =
        {
            new TestFixtureData(new[] { "test.dll" }),
            new TestFixtureData(new[] { "test1.dll", "test2.dll" })
        };

        public MasterTestRunnerTests(params string[] testFiles)
        {
            _package = new TestPackage(testFiles);
        }

        [SetUp]
        public void Initialize()
        {
            // Fake Context provides  substitutes for all services
            _services = new FakeServiceContext();
            _services.Initialize();

            _engineRunner = Substitute.For<ITestEngineRunner>();
            _services.TestRunnerFactory.MakeTestRunner(_package).ReturnsForAnyArgs(_engineRunner);

            _masterTestRunner = new MasterTestRunner(_services, _package);
        }

        [TearDown]
        public void Cleanup()
        {
            _engineRunner.Dispose();
            _masterTestRunner.Dispose();
        }

        //[Test]
        //public void Load()
        //{
        //    _engineRunner.Load().Returns(new TestEngineResult());
        //    _masterTestRunner.Load();
        //    _engineRunner.Received().Load();
        //}

#if NETFRAMEWORK
        //[Test]
        //public void Reload()
        //{
        //    _engineRunner.Reload().Returns(new TestEngineResult());
        //    _masterTestRunner.Reload();
        //    _engineRunner.Received().Reload();
        //}

        [Test]
        public void Explore()
        {
            var filter = TestFilter.Empty;
            _engineRunner.Explore(filter).Returns(new TestEngineResult());
            _masterTestRunner.Explore(filter);
            _engineRunner.Received().Explore(filter);
        }

        [Test]
        public void Run()
        {
            var listener = Substitute.For<ITestEventListener>();
            var filter = TestFilter.Empty;
            _engineRunner.Run(Arg.Any<TestEventDispatcher>(), filter).Returns(new TestEngineResult());
            _masterTestRunner.Run(listener, filter);
            _engineRunner.Received().Run(Arg.Any<TestEventDispatcher>(), filter);
        }

        [Test]
        public void RunAsync()
        {
            var listener = Substitute.For<ITestEventListener>();
            var filter = TestFilter.Empty;
            _engineRunner.Run(Arg.Any<TestEventDispatcher>(), filter).Returns(new TestEngineResult());
            _masterTestRunner.Run(listener, filter);
            _engineRunner.Received().Run(Arg.Any<TestEventDispatcher>(), filter);
        }

        [Test]
        public void RequestStop()
        {
            _masterTestRunner.GetEngineRunner();
            _masterTestRunner.RequestStop();

            _engineRunner.Received().RequestStop();
        }
#endif
    }
}