Пример #1
0
        public void TestCoordinatorEnabledMessageSink_should_receive_TestRunTree_when_EndTestRun_is_received()
        {
            var consoleMessageSink = Sys.ActorOf(Props.Create(() => new ConsoleMessageSinkActor(true)));
            var nodeIndexes        = Enumerable.Range(1, 4).ToArray();
            var nodeTests          = NodeMessageHelpers.BuildNodeTests(nodeIndexes);

            var beginSpec = new BeginNewSpec(nodeTests.First().TypeName, nodeTests.First().MethodName, nodeTests);

            consoleMessageSink.Tell(beginSpec);

            // create some messages for each node, the test runner, and some result messages
            // just like a real MultiNodeSpec
            var allMessages    = NodeMessageHelpers.GenerateMessageSequence(nodeIndexes, 300);
            var runnerMessages = NodeMessageHelpers.GenerateTestRunnerMessageSequence(20);
            var passMessages   = NodeMessageHelpers.GenerateResultMessage(nodeIndexes, true);

            allMessages.UnionWith(runnerMessages);
            allMessages.UnionWith(passMessages);

            foreach (var message in allMessages)
            {
                consoleMessageSink.Tell(message);
            }

            //end the spec
            consoleMessageSink.Tell(new EndSpec());

            //end the test run...
            var sinkReadyToTerminate =
                consoleMessageSink.AskAndWait <MessageSinkActor.SinkCanBeTerminated>(new EndTestRun(),
                                                                                     TimeSpan.FromSeconds(3));

            Assert.NotNull(sinkReadyToTerminate);
        }
        public void TestRunCoordinator_should_start_and_route_messages_to_SpecRunCoordinator()
        {
            var testRunCoordinator = Sys.ActorOf(Props.Create <TestRunCoordinator>());
            var nodeIndexes        = Enumerable.Range(1, 4).ToArray();
            var nodeTests          = NodeMessageHelpers.BuildNodeTests(nodeIndexes);

            var beginSpec = new BeginNewSpec(nodeTests.First().TypeName, nodeTests.First().MethodName, nodeTests);

            //begin a new spec
            testRunCoordinator.Tell(beginSpec);

            // create some messages for each node, the test runner, and some result messages
            // just like a real MultiNodeSpec
            var allMessages    = NodeMessageHelpers.GenerateMessageSequence(nodeIndexes, 300);
            var runnerMessages = NodeMessageHelpers.GenerateTestRunnerMessageSequence(20);

            allMessages.UnionWith(runnerMessages);

            foreach (var message in allMessages)
            {
                testRunCoordinator.Tell(message);
            }

            //end the spec
            testRunCoordinator.Tell(new EndTestRun(), TestActor);
            var testRunData = ExpectMsg <TestRunTree>();

            Assert.Equal(1, testRunData.Specs.Count());

            var specMessages = new SortedSet <MultiNodeMessage>();

            foreach (var spec in testRunData.Specs)
            {
                specMessages.UnionWith(spec.RunnerMessages);
                foreach (var fact in spec.NodeFacts)
                {
                    specMessages.UnionWith(fact.Value.EventStream);
                }
            }

            Assert.True(allMessages.SetEquals(specMessages));
        }
Пример #3
0
        public void SpecRunCoordinator_should_log_TestRunner_messages()
        {
            var nodeIndexes = Enumerable.Range(1, 3).ToArray();
            var nodeTests   = NodeMessageHelpers.BuildNodeTests(nodeIndexes);

            var specRunCoordinator = Sys.ActorOf(Props.Create(() => new SpecRunCoordinator(nodeTests.First()
                                                                                           .TypeName, nodeTests.First().MethodName, nodeTests)));

            var runnerMessages = NodeMessageHelpers.GenerateTestRunnerMessageSequence(100);

            foreach (var multiNodeMessage in runnerMessages)
            {
                specRunCoordinator.Tell(multiNodeMessage);
            }

            //End the test
            specRunCoordinator.Tell(new EndSpec(), TestActor);
            var factData = ExpectMsg <FactData>();

            Assert.True(factData.RunnerMessages.Any());
            Assert.True(runnerMessages.SetEquals(factData.RunnerMessages));
        }
        public void TestRunCoordinator_should_publish_FactData_to_Subscribers_when_Specs_complete()
        {
            var testRunCoordinator = Sys.ActorOf(Props.Create <TestRunCoordinator>());
            var nodeIndexes        = Enumerable.Range(1, 4).ToArray();
            var nodeTests          = NodeMessageHelpers.BuildNodeTests(nodeIndexes);

            var beginSpec = new BeginNewSpec(nodeTests.First().TypeName, nodeTests.First().MethodName, nodeTests);

            //register the TestActor as a subscriber for FactData announcements
            testRunCoordinator.Tell(new TestRunCoordinator.SubscribeFactCompletionMessages(TestActor));

            //begin a new spec
            testRunCoordinator.Tell(beginSpec);

            // create some messages for each node, the test runner, and some result messages
            // just like a real MultiNodeSpec
            var allMessages    = NodeMessageHelpers.GenerateMessageSequence(nodeIndexes, 300);
            var runnerMessages = NodeMessageHelpers.GenerateTestRunnerMessageSequence(20);
            var passMessages   = NodeMessageHelpers.GenerateResultMessage(nodeIndexes, true);

            allMessages.UnionWith(runnerMessages);
            allMessages.UnionWith(passMessages);

            foreach (var message in allMessages)
            {
                testRunCoordinator.Tell(message);
            }

            //end the spec
            testRunCoordinator.Tell(new EndSpec());

            var factData = ExpectMsg <FactData>();

            Assert.True(factData.Passed.Value, "Spec should have passed");
            Assert.True(factData.NodeFacts.All(x => x.Value.Passed.Value), "All individual nodes should have reported test pass");
        }