/// <inheritdoc/>
public void Run(
_IMessageSink messageSink,
FrontControllerRunSettings settings)
{
Guard.ArgumentNotNull(nameof(messageSink), messageSink);
Guard.ArgumentNotNull(nameof(settings), settings);
Run(settings.SerializedTestCases.Select(tc => Deserialize(tc)).WhereNotNull(), messageSink);
}
/// <inheritdoc/>
public void Run(
_IMessageSink messageSink,
FrontControllerRunSettings settings)
{
Guard.NotNull($"This instance of {typeof(Xunit2).FullName} was created for discovery only; execution-related operations cannot be performed.", remoteExecutor);
Guard.ArgumentNotNull(messageSink);
Guard.ArgumentNotNull(settings);
remoteExecutor.RunTests(
BulkDeserialize(settings.SerializedTestCases.ToList()).Select(kvp => kvp.Value).ToList(),
CreateOptimizedRemoteMessageSink(messageSink),
Xunit2OptionsAdapter.Adapt(settings.Options)
);
}
public async ValueTask NoTestMethods()
{
using var assembly = await CSharpAcceptanceTestV2Assembly.Create(code : "");
var controller = TestableXunit2.Create(assembly.FileName, null, true);
var settings = new FrontControllerRunSettings(_TestFrameworkOptions.ForExecution(), new string[0]);
using var sink = SpyMessageSink <_TestAssemblyFinished> .Create();
controller.Run(sink, settings);
sink.Finished.WaitOne();
Assert.Empty(sink.Messages.OfType <_TestPassed>());
Assert.Empty(sink.Messages.OfType <_TestFailed>());
Assert.Empty(sink.Messages.OfType <_TestSkipped>());
}
public async ValueTask TheoryAcceptanceTest()
{
var code = @"
module FSharpTests
open Xunit
[<Theory>]
[<InlineData(42)>]
[<InlineData(2112)>]
let TestMethod(x : int) =
Assert.Equal(2112, x)
";
using var assembly = await FSharpAcceptanceTestV2Assembly.Create(code.Replace("\t", " "));
var controller = TestableXunit2.Create(assembly.FileName, null, true);
var findSettings = new FrontControllerFindSettings(_TestFrameworkOptions.ForDiscovery());
using var discoverySink = SpyMessageSink <_DiscoveryComplete> .Create();
controller.Find(discoverySink, findSettings);
discoverySink.Finished.WaitOne();
using var executionSink = SpyMessageSink <_TestAssemblyFinished> .Create();
var serializedTestCases = discoverySink.Messages.OfType <_TestCaseDiscovered>().Select(tcdm => tcdm.Serialization !).ToArray();
Assert.All(serializedTestCases, serializedTestCase => Assert.NotNull(serializedTestCase));
var runSettings = new FrontControllerRunSettings(_TestFrameworkOptions.ForExecution(), serializedTestCases);
controller.Run(executionSink, runSettings);
executionSink.Finished.WaitOne();
Assert.Empty(executionSink.Messages.OfType <_TestSkipped>());
var passedTest = Assert.Single(executionSink.Messages.OfType <_TestPassed>());
var passedMetadata = executionSink.Messages.OfType <_TestStarting>().Single(ts => ts.TestUniqueID == passedTest.TestUniqueID);
Assert.Equal("FSharpTests.TestMethod(x: 2112)", passedMetadata.TestDisplayName);
var failedTest = Assert.Single(executionSink.Messages.OfType <_TestFailed>());
var failedMetadata = executionSink.Messages.OfType <_TestStarting>().Single(ts => ts.TestUniqueID == failedTest.TestUniqueID);
Assert.Equal("FSharpTests.TestMethod(x: 42)", failedMetadata.TestDisplayName);
}
public async ValueTask FactAcceptanceTest()
{
var code = @"
using System;
using Xunit;
public class TestClass
{
[Fact]
public void TestMethod() { Assert.True(false); }
}";
using var assembly = await CSharpAcceptanceTestV2Assembly.Create(code);
var controller = TestableXunit2.Create(assembly.FileName, null, true);
var findSettings = new FrontControllerFindSettings(_TestFrameworkOptions.ForDiscovery());
using var discoverySink = SpyMessageSink <_DiscoveryComplete> .Create();
controller.Find(discoverySink, findSettings);
discoverySink.Finished.WaitOne();
using var executionSink = SpyMessageSink <_TestAssemblyFinished> .Create();
var serializedTestCases = discoverySink.Messages.OfType <_TestCaseDiscovered>().Select(tcdm => tcdm.Serialization !).ToArray();
Assert.All(serializedTestCases, serializedTestCase => Assert.NotNull(serializedTestCase));
var runSettings = new FrontControllerRunSettings(_TestFrameworkOptions.ForExecution(), serializedTestCases);
controller.Run(executionSink, runSettings);
executionSink.Finished.WaitOne();
Assert.Empty(executionSink.Messages.OfType <_TestPassed>());
Assert.Empty(executionSink.Messages.OfType <_TestSkipped>());
var failedTest = Assert.Single(executionSink.Messages.OfType <_TestFailed>());
var failedMetadata = executionSink.Messages.OfType <_TestStarting>().Single(ts => ts.TestUniqueID == failedTest.TestUniqueID);
Assert.Equal("TestClass.TestMethod", failedMetadata.TestDisplayName);
}
public virtual TestRunState Run(
IReadOnlyList <_TestCaseDiscovered>?testCases = null,
TestRunState initialRunState = TestRunState.NoTests)
{
Guard.NotNull($"Attempted to use an uninitialized {GetType().FullName}", testListener);
Guard.NotNull($"Attempted to use an uninitialized {GetType().FullName}", frontController);
try
{
// TODO: This should be able to be converted to FindAndRun, but we need test case
// count for the results sink...?
if (testCases == null)
{
testCases = Discover();
}
var resultSink = new ResultSink(testListener, testCases.Count)
{
TestRunState = initialRunState
};
disposalTracker.Add(resultSink);
var executionOptions = _TestFrameworkOptions.ForExecution(projectAssembly.Configuration);
var settings = new FrontControllerRunSettings(executionOptions, testCases.Select(tc => tc.Serialization));
frontController.Run(resultSink, settings);
resultSink.Finished.WaitOne();
return(resultSink.TestRunState);
}
catch (Exception ex)
{
testListener.WriteLine("Error during test execution:\r\n" + ex, Category.Error);
return(TestRunState.Error);
}
}
