public void Send(Message message)
{
lock (_writer)
{
try
{
TestHostTracing.Source.TraceEvent(
TraceEventType.Verbose,
0,
"[ReportingChannel]: Send({0})",
message);
_writer.Write(JsonConvert.SerializeObject(message));
}
catch (Exception ex)
{
TestHostTracing.Source.TraceEvent(
TraceEventType.Error,
0,
"[ReportingChannel]: Error sending {0}",
ex);
throw;
}
}
}
public GivenATestDiscoveryStartMessageHandler()
{
_dotnetTestMock = new Mock<IDotnetTest>();
_dotnetTestMock.Setup(d => d.State).Returns(DotnetTestState.VersionCheckCompleted);
_dotnetTestMock.Setup(d => d.PathToAssemblyUnderTest).Returns(AssemblyUnderTest);
_dotnetTestAtVersionCheckCompletedState = _dotnetTestMock.Object;
_testRunnerMock = new Mock<ITestRunner>();
_testRunnerFactoryMock = new Mock<ITestRunnerFactory>();
_testRunnerFactoryMock
.Setup(c => c.CreateTestRunner(It.IsAny<DiscoverTestsArgumentsBuilder>()))
.Callback<ITestRunnerArgumentsBuilder>(r => _argumentsBuilder = r as DiscoverTestsArgumentsBuilder)
.Returns(_testRunnerMock.Object);
_adapterChannelMock = new Mock<IReportingChannel>();
_testRunnerChannelMock = new Mock<IReportingChannel>();
_testRunnerChannelMock.Setup(t => t.Port).Returns(TestRunnerPort);
_reportingChannelFactoryMock = new Mock<IReportingChannelFactory>();
_reportingChannelFactoryMock.Setup(r =>
r.CreateTestRunnerChannel()).Returns(_testRunnerChannelMock.Object);
_testDiscoveryStartMessageHandler = new TestDiscoveryStartMessageHandler(
_testRunnerFactoryMock.Object,
_adapterChannelMock.Object,
_reportingChannelFactoryMock.Object);
_validMessage = new Message
{
MessageType = TestMessageTypes.TestDiscoveryStart
};
}
private void DoHandleMessage(IDotnetTest dotnetTest, Message message)
{
_adapterChannel.Send(new Message
{
MessageType = MessageType(dotnetTest)
});
}
private void HandleMessage(Message message)
{
_adapterChannel.Send(new Message
{
MessageType = _messageIfHandled,
Payload = message.Payload
});
}
public DotnetTestState HandleMessage(IDotnetTest dotnetTest, Message message)
{
var error = $"No handler for message '{message.MessageType}' when at state '{dotnetTest.State}'";
TestHostTracing.Source.TraceEvent(TraceEventType.Error, 0, error);
_adapterChannel.SendError(error);
throw new InvalidOperationException(error);
}
public DotnetTestState HandleMessage(IDotnetTest dotnetTest, Message message)
{
var nextState = DotnetTestState.NoOp;
if (CanHandleMessage(dotnetTest, message))
{
HandleMessage(message);
nextState = DotnetTestState.VersionCheckCompleted;
}
return nextState;
}
public DotnetTestState HandleMessage(IDotnetTest dotnetTest, Message message)
{
var nextState = DotnetTestState.NoOp;
if (CanHandleMessage(dotnetTest, message))
{
HandleMessage(message);
nextState = _nextStateIfHandled;
}
return nextState;
}
public DotnetTestState HandleMessage(IDotnetTest dotnetTest, Message message)
{
var nextState = DotnetTestState.NoOp;
if (CanHandleMessage(dotnetTest, message))
{
DoHandleMessage(dotnetTest, message);
nextState = NextState(dotnetTest);
}
return nextState;
}
public DotnetTestState HandleMessage(IDotnetTest dotnetTest, Message message)
{
var nextState = DotnetTestState.NoOp;
if (CanHandleMessage(dotnetTest, message))
{
HandleMessage(dotnetTest);
nextState = DotnetTestState.TestDiscoveryStarted;
}
return nextState;
}
public DotnetTestState HandleMessage(IDotnetTest dotnetTest, Message message)
{
var nextState = DotnetTestState.NoOp;
if (TestMessageTypes.TestSessionTerminate.Equals(message.MessageType))
{
nextState = DotnetTestState.Terminated;
_messages.Drain();
}
return nextState;
}
public DotnetTestState HandleMessage(IDotnetTest dotnetTest, Message message)
{
var nextState = DotnetTestState.NoOp;
if (CanHandleMessage(dotnetTest, message))
{
DoHandleMessage(dotnetTest, message);
nextState = DotnetTestState.TestExecutionSentTestRunnerProcessStartInfo;
}
return nextState;
}
public bool TryTake(out Message message)
{
message = null;
try
{
message = _readQueue.Take();
}
catch (InvalidOperationException)
{
return false;
}
return true;
}
public void It_executes_the_command_when_RunTestCommand_is_called()
{
var testResult = new Message
{
MessageType = "Irrelevant",
Payload = JToken.FromObject("Irrelevant")
};
var testRunner = new TestRunner(_runner, _commandFactoryMock.Object, _argumentsBuilderMock.Object);
testRunner.RunTestCommand();
_commandMock.Verify(c => c.Execute(), Times.Once);
}
public GivenATestRunnerTestResultMessageHandler()
{
_dotnetTestMock = new Mock<IDotnetTest>();
_dotnetTestMock.Setup(d => d.State).Returns(DotnetTestState.TestExecutionStarted);
_adapterChannelMock = new Mock<IReportingChannel>();
_validMessage = new Message
{
MessageType = TestMessageTypes.TestRunnerTestResult,
Payload = JToken.FromObject("testFound")
};
_testRunnerTestResultMessageHandler = new TestRunnerTestResultMessageHandler(_adapterChannelMock.Object);
}
private void HandleMessage(Message message)
{
foreach (var messageHandler in _messageHandlers)
{
var nextState = messageHandler.HandleMessage(this, message);
if (nextState != DotnetTestState.NoOp)
{
State = nextState;
return;
}
}
UnknownMessageHandler.HandleMessage(this, message);
}
private void HandleMessage(Message message)
{
var version = message.Payload?.ToObject<ProtocolVersionMessage>().Version;
TestHostTracing.Source.TraceInformation(
"[ReportingChannel]: Requested Version: {0} - Using Version: {1}",
version,
SupportedVersion);
_adapterChannel.Send(new Message
{
MessageType = TestMessageTypes.VersionCheck,
Payload = JToken.FromObject(new ProtocolVersionMessage
{
Version = SupportedVersion,
}),
});
}
public GivenATestRunnerWaitingCommandMessageHandler()
{
_testsToRun = new List<string> { "test1", "test2" };
_dotnetTestMock = new Mock<IDotnetTest>();
_dotnetTestMock.Setup(d => d.State).Returns(DotnetTestState.TestExecutionSentTestRunnerProcessStartInfo);
_dotnetTestMock.Setup(d => d.TestsToRun).Returns(_testsToRun);
_validMessage = new Message
{
MessageType = TestMessageTypes.TestRunnerWaitingCommand
};
_testRunnerChannelMock = new Mock<IReportingChannel>();
_reportingChannelFactory = new Mock<IReportingChannelFactory>();
_testRunnerWaitingCommandMessageHandler =
new TestRunnerWaitingCommandMessageHandler(_reportingChannelFactory.Object);
}
private void DoHandleMessage(IDotnetTest dotnetTest, Message message)
{
var testRunnerChannel = _reportingChannelFactory.CreateChannelWithAnyAvailablePort();
dotnetTest.StartListeningTo(testRunnerChannel);
testRunnerChannel.Accept();
var testRunner = _testRunnerFactory.CreateTestRunner(
new RunTestsArgumentsBuilder(dotnetTest.PathToAssemblyUnderTest, testRunnerChannel.Port, message));
var processStartInfo = testRunner.GetProcessStartInfo();
_adapterChannel.Send(new Message
{
MessageType = TestMessageTypes.TestExecutionTestRunnerProcessStartInfo,
Payload = JToken.FromObject(processStartInfo)
});
}
public GivenATestExecutionGetTestRunnerProcessStartInfoMessageHandler()
{
_testsToRun = new List<string> {"test1", "test2"};
_validMessage = new Message
{
MessageType = TestMessageTypes.TestExecutionGetTestRunnerProcessStartInfo,
Payload = JToken.FromObject(new RunTestsMessage { Tests = _testsToRun })
};
_dotnetTestMock = new Mock<IDotnetTest>();
_dotnetTestMock.Setup(d => d.State).Returns(DotnetTestState.VersionCheckCompleted);
_dotnetTestMock.Setup(d => d.PathToAssemblyUnderTest).Returns(AssemblyUnderTest);
_testStartInfo = new TestStartInfo
{
FileName = "runner",
Arguments = "arguments"
};
_testRunnerMock = new Mock<ITestRunner>();
_testRunnerMock.Setup(t => t.GetProcessStartInfo()).Returns(_testStartInfo);
_testRunnerFactoryMock = new Mock<ITestRunnerFactory>();
_testRunnerFactoryMock
.Setup(c => c.CreateTestRunner(It.IsAny<RunTestsArgumentsBuilder>()))
.Callback<ITestRunnerArgumentsBuilder>(r => _argumentsBuilder = r as RunTestsArgumentsBuilder)
.Returns(_testRunnerMock.Object);
_adapterChannelMock = new Mock<IReportingChannel>();
_testRunnerChannelMock = new Mock<IReportingChannel>();
_testRunnerChannelMock.Setup(t => t.Port).Returns(TestRunnerPort);
_reportingChannelFactoryMock = new Mock<IReportingChannelFactory>();
_reportingChannelFactoryMock.Setup(r =>
r.CreateTestRunnerChannel()).Returns(_testRunnerChannelMock.Object);
_testGetTestRunnerProcessStartInfoMessageHandler = new GetTestRunnerProcessStartInfoMessageHandler(
_testRunnerFactoryMock.Object,
_adapterChannelMock.Object,
_reportingChannelFactoryMock.Object);
}
public void It_generates_the_right_arguments_for_RunTests()
{
const int port = 1;
const string assembly = "assembly.dll";
var message = new Message
{
Payload = JToken.FromObject(new RunTestsMessage { Tests = new List<string> { "test1", "test2" } })
};
var runTestsArgumentsBuilder = new RunTestsArgumentsBuilder(assembly, port, message);
var arguments = runTestsArgumentsBuilder.BuildArguments();
arguments.Should().BeEquivalentTo(
assembly,
"--designtime",
"--port",
$"{port}",
"--wait-command");
}
private static bool CanHandleMessage(IDotnetTest dotnetTest, Message message)
{
return IsAtAnAcceptableState(dotnetTest) && message.MessageType == TestMessageTypes.TestDiscoveryStart;
}
protected abstract bool CanHandleMessage(IDotnetTest dotnetTest, Message message);
protected override bool CanHandleMessage(IDotnetTest dotnetTest, Message message)
{
return IsAtAnAcceptableState(dotnetTest) &&
message.MessageType == TestMessageTypes.TestRunnerTestStarted;
}
private static void HandleUnknownMessage(Message message, ReportingChannel channel)
{
var error = string.Format("Unexpected message type: '{0}'.", message.MessageType);
TestHostTracing.Source.TraceEvent(TraceEventType.Error, 0, error);
channel.SendError(error);
throw new InvalidOperationException(error);
}
protected override bool CanHandleMessage(IDotnetTest dotnetTest, Message message)
{
return dotnetTest.State == DotnetTestState.TestExecutionStarted &&
message.MessageType == TestMessageTypes.TestRunnerTestResult;
}
private void OnMessageReceived(object sender, Message message)
{
if (!TerminateTestSession(message))
{
_messages.Add(message);
}
}
private bool TerminateTestSession(Message message)
{
return TestSessionTerminateMessageHandler.HandleMessage(this, message) == DotnetTestState.Terminated;
}
private static void HandleProtocolVersionMessage(Message message, ReportingChannel channel)
{
var version = message.Payload?.ToObject<ProtocolVersionMessage>().Version;
var supportedVersion = 1;
TestHostTracing.Source.TraceInformation(
"[ReportingChannel]: Requested Version: {0} - Using Version: {1}",
version,
supportedVersion);
channel.Send(new Message()
{
MessageType = "ProtocolVersion",
Payload = JToken.FromObject(new ProtocolVersionMessage()
{
Version = supportedVersion,
}),
});
}
private static bool CanHandleMessage(IDotnetTest dotnetTest, Message message)
{
return IsAtAnAcceptableState(dotnetTest) &&
message.MessageType == TestMessageTypes.TestExecutionGetTestRunnerProcessStartInfo;
}
private static void HandleTestExecutionStartMessage(string testRunner, Message message, ReportingChannel channel, ProjectContext projectContext)
{
TestHostTracing.Source.TraceInformation("Starting Execution");
var commandArgs = new List<string> { projectContext.GetAssemblyPath(Constants.DefaultConfiguration) };
commandArgs.AddRange(new[]
{
"--designtime"
});
var tests = message.Payload?.ToObject<RunTestsMessage>().Tests;
if (tests != null)
{
foreach (var test in tests)
{
commandArgs.Add("--test");
commandArgs.Add(test);
}
}
ExecuteRunnerCommand(testRunner, channel, commandArgs);
channel.Send(new Message()
{
MessageType = "TestExecution.Response",
});
TestHostTracing.Source.TraceInformation("Completed Execution");
}
