public TestService(IExecutionQueue queue, ITestConverter converter, IEventAggregator events,
FixtureLibrary library)
{
_queue = queue;
_converter = converter;
_events = events;
_library = library;
}
public NUnitEventListener(ITestExecutionRecorder recorder, ITestConverter testConverter, INUnit3TestExecutor executor)
{
this.executor = executor;
dumpXml = executor.Dump;
_settings = executor.Settings;
_recorder = recorder;
_testConverter = testConverter;
}
public void Setup()
{
recorder = Substitute.For <ITestExecutionRecorder>();
converter = Substitute.For <ITestConverter>();
dumpxml = Substitute.For <IDumpXml>();
settings = Substitute.For <IAdapterSettings>();
executor = Substitute.For <INUnit3TestExecutor>();
executor.Settings.Returns(settings);
}
public TestStateManager(ITestConverter converter, Test test)
{
_converter = converter;
_test = test;
_history = new VersionHistory();
_undoCommand = new ActionCommand(undo);
_redoCommand = new ActionCommand(redo);
Version(null);
RecordSnapshot();
}
public TestStateManager(ITestConverter converter, Test test)
{
_converter = converter;
_test = test;
_history = new VersionHistory();
_undoCommand = new ActionCommand(undo);
_redoCommand = new ActionCommand(redo);
Version(null);
RecordSnapshot();
}
public void SetUp()
{
test = new Test("my test");
service = new TestConverter();
listener1 = MockRepository.GenerateMock<ITestStateListener>();
listener2 = MockRepository.GenerateMock<ITestStateListener>();
listener3 = MockRepository.GenerateMock<ITestStateListener>();
manager = new TestStateManager(service, test);
manager.RegisterListener(listener1);
manager.RegisterListener(listener2);
manager.RegisterListener(listener3);
}
//-------------------------------------------------------------------------
public virtual async Task ConvertAsync(Stream input, TextWriter output)
{
XElement testXml = await XElement.LoadAsync(input, LoadOptions.None, CancellationToken.None);
ITestResultXmlParser <TIn> parser = this.ParserFactory(testXml);
parser.Parse();
TIn sourceTest = parser.Result;
ITestConverter <TIn, TOut> testConverter = this.ConverterFactory(sourceTest);
testConverter.Convert();
TOut targetTest = testConverter.Result;
ITestResultXmlBuilder <TOut> builder = this.BuilderFactory(targetTest);
builder.Build();
await builder.Result.SaveAsync(output, SaveOptions.None, CancellationToken.None);
}
public IList <TestCase> Convert(NUnitResults discoveryResults, string assemblyPath)
{
if (discoveryResults == null)
{
return(new List <TestCase>());
}
AssemblyPath = assemblyPath;
var timing = new TimingLogger(Settings, TestLog);
if (Settings.DiscoveryMethod != DiscoveryMethod.Legacy)
{
TestRun = ConvertXml(discoveryResults);
}
var nunitTestCases = discoveryResults.TestCases();
// As a side effect of calling TestConverter.ConvertTestCase,
// the converter's cache of all test cases is populated as well.
// All future calls to convert a test case may now use the cache.
if (Settings.DiscoveryMethod == DiscoveryMethod.Legacy)
{
converterForXml = new TestConverterForXml(TestLog, AssemblyPath, Settings);
foreach (XmlNode testNode in nunitTestCases)
{
loadedTestCases.Add(converterForXml.ConvertTestCase(new NUnitEventTestCase(testNode)));
}
TestLog.Info(
$" NUnit3TestExecutor discovered {loadedTestCases.Count} of {nunitTestCases.Count} NUnit test cases using Legacy discovery mode");
}
else
{
converter = new TestConverter(TestLog, AssemblyPath, Settings, this);
var isExplicit = TestRun.IsExplicit;
var testCases = RunnableTestCases(isExplicit);
foreach (var testNode in testCases)
{
loadedTestCases.Add(converter.ConvertTestCase(testNode));
}
var msg = isExplicit ? "Explicit run" : "Non-Explicit run";
TestLog.Info(
$" NUnit3TestExecutor discovered {loadedTestCases.Count} of {nunitTestCases.Count} NUnit test cases using Current Discovery mode, {msg}");
}
timing.LogTime("Converting test cases ");
return(loadedTestCases);
IEnumerable <NUnitDiscoveryTestCase> RunnableTestCases(bool isExplicit)
{
IEnumerable <NUnitDiscoveryTestCase> result;
if (isExplicit || !Settings.DesignMode)
{
result = TestRun.TestAssembly.AllTestCases;
}
else
{
result = TestRun.TestAssembly.RunnableTestCases;
}
return(result);
}
}
public void SetUp()
{
test = new Test("my test");
service = MockRepository.GenerateMock<ITestConverter>();
listener1 = MockRepository.GenerateMock<ITestStateListener>();
source = MockRepository.GenerateMock<ITestStateListener>();
listener3 = MockRepository.GenerateMock<ITestStateListener>();
manager = new TestStateManager(service, test);
manager.RegisterListener(listener1);
manager.RegisterListener(source);
manager.RegisterListener(listener3);
theNewJson = "{new: 'json'}";
service.Expect(x => x.ToJson(test)).Return(theNewJson);
manager.Version(source);
manager.RecordSnapshot();
}
public void SetUp()
{
test = new Test("my test");
service = MockRepository.GenerateMock<ITestConverter>();
listener1 = MockRepository.GenerateMock<ITestStateListener>();
source = MockRepository.GenerateMock<ITestStateListener>();
listener3 = MockRepository.GenerateMock<ITestStateListener>();
manager = new TestStateManager(service, test);
manager.RegisterListener(listener1);
manager.RegisterListener(source);
manager.RegisterListener(listener3);
theNewJson = "{new: 'json'}";
manager.StoreJson(theNewJson, source);
}
public void SetUp()
{
test = new Test("my test");
service = MockRepository.GenerateMock<ITestConverter>();
listener1 = MockRepository.GenerateMock<ITestStateListener>();
listener2 = MockRepository.GenerateMock<ITestStateListener>();
listener3 = MockRepository.GenerateMock<ITestStateListener>();
manager = new TestStateManager(service, test);
manager.RegisterListener(listener1);
manager.RegisterListener(listener2);
manager.RegisterListener(listener3);
theOriginalJson = "{old: 'json'}";
theNewJson = "{new: 'json'}";
service.Expect(x => x.ToJson(test)).Return(theOriginalJson);
service.Expect(x => x.ToJson(test)).Return(theNewJson);
manager = new TestStateManager(service, test);
// setting the pre-condition here
manager.CurrentJson.ShouldEqual(theOriginalJson);
manager.Version(null);
// second version of the JSON
manager.CurrentJson.ShouldEqual(theNewJson);
manager.RecordSnapshot();
manager.IsDirty().ShouldBeFalse();
manager.RegisterListener(listener1);
manager.RegisterListener(listener2);
manager.RegisterListener(listener3);
// After all that, undo
manager.Undo.Execute(null);
}
public void Setup()
{
recorder = Substitute.For <ITestExecutionRecorder>();
converter = Substitute.For <ITestConverter>();
dumpxml = Substitute.For <IDumpXml>();
}
public NUnitEventListener(ITestExecutionRecorder recorder, ITestConverter testConverter, IDumpXml dumpXml)
{
this.dumpXml = dumpXml;
_recorder = recorder;
_testConverter = testConverter;
}
public AddTestCommandHandler(EfDbContext context, ITestConverter converter) : base(context)
{
_converter = converter;
}
