public void ExecutorShouldNotDisplayWarningIfTestsAreExecuted()
{
var mockTestPlatform = new Mock <ITestPlatform>();
var mockTestRunRequest = new Mock <ITestRunRequest>();
var mockDiscoveryRequest = new Mock <IDiscoveryRequest>();
var testRunStats = new TestRunStatistics(1, new Dictionary <TestOutcome, long> {
{ TestOutcome.Passed, 1 }
});
List <TestCase> list = new List <TestCase>();
list.Add(new TestCase("Test1", new Uri("http://FooTestUri1"), "Source1"));
list.Add(new TestCase("Test2", new Uri("http://FooTestUri2"), "Source2"));
mockDiscoveryRequest.Setup(dr => dr.DiscoverAsync()).Raises(dr => dr.OnDiscoveredTests += null, new DiscoveredTestsEventArgs(list));
mockTestRunRequest.Setup(tr => tr.ExecuteAsync()).Returns(1).Raises(tr => tr.OnRunCompletion += null,
new TestRunCompleteEventArgs(testRunStats, false, false, null, null, new TimeSpan()));
mockTestPlatform.Setup(tp => tp.CreateTestRunRequest(It.IsAny <IRequestData>(), It.IsAny <TestRunCriteria>(), It.IsAny <TestPlatformOptions>())).Returns(mockTestRunRequest.Object);
mockTestPlatform.Setup(tp => tp.CreateDiscoveryRequest(It.IsAny <IRequestData>(), It.IsAny <DiscoveryCriteria>(), It.IsAny <TestPlatformOptions>())).Returns(mockDiscoveryRequest.Object);
this.ResetAndAddSourceToCommandLineOptions();
var testRequestManager = new TestRequestManager(CommandLineOptions.Instance, mockTestPlatform.Object, TestRunResultAggregator.Instance, this.mockTestPlatformEventSource.Object, this.inferHelper, this.mockMetricsPublisherTask);
var executor = GetExecutor(testRequestManager);
executor.Initialize("Test1");
executor.Execute();
this.mockOutput.Verify(op => op.WriteLine(It.Is <string>(st => st.Contains("Additionally, path to test adapters can be specified using /TestAdapterPath command.")), OutputLevel.Warning), Times.Never);
}
public ITestRunStatistics GetAggregatedRunStats()
{
var testOutcomeMap = new Dictionary <TestOutcome, long>();
long totalTests = 0;
if (testRunStatsList.Count > 0)
{
foreach (var runStats in testRunStatsList)
{
foreach (var outcome in runStats.Stats.Keys)
{
if (!testOutcomeMap.ContainsKey(outcome))
{
testOutcomeMap.Add(outcome, 0);
}
testOutcomeMap[outcome] += runStats.Stats[outcome];
}
totalTests += runStats.ExecutedTests;
}
}
var overallRunStats = new TestRunStatistics(testOutcomeMap);
overallRunStats.ExecutedTests = totalTests;
return(overallRunStats);
}
public void Run()
{
// TODO: run should eventually simulate both xunit, nunit adapters
// We should add a sequence of testclass/testmethod as input for replay
this.logger.Initialize(this.loggerEvents, TestResultsDirectory);
// Simulate test run start event
var sources = new List <string> {
"dummy source"
};
var testRunCriteria = new TestRunCriteria(sources: sources, frequencyOfRunStatsChangeEvent: 10);
this.loggerEvents.RaiseTestRunStart(testRunCriteria);
// Simulate a fake message event
this.loggerEvents.RaiseTestRunMessage(TestMessageLevel.Informational, "dummy message");
// Simulate a test result
var testCase = new TestCase();
var testResult = new TestResult(testCase);
this.loggerEvents.RaiseTestResult(testResult);
// Simulate test run completion
var stats = new TestRunStatistics(new Dictionary <TestOutcome, long> {
{ TestOutcome.Passed, 1 }
});
this.loggerEvents.RaiseTestRunComplete(stats);
}
private void OnCacheHit(TestRunStatistics testRunStats, ICollection <TestResult> results, ICollection <TestCase> inProgressTests)
{
if (this.testRunEventsHandler != null)
{
var testRunChangedEventArgs = new TestRunChangedEventArgs(testRunStats, results, inProgressTests);
this.testRunEventsHandler.HandleTestRunStatsChange(testRunChangedEventArgs);
}
else
{
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error("BaseRunTests.OnCacheHit: Unable to send TestRunStatsChange Event as TestRunEventsHandler is NULL");
}
}
}
public void CacheHitOnSize(TestRunStatistics stats, ICollection <Microsoft.VisualStudio.TestPlatform.ObjectModel.TestResult> results, ICollection <TestCase> tests)
{
Assert.AreEqual(this.ExpectedCacheSize, results.Count + tests.Count);
this.CacheHitCount++;
this.TotalInProgressTestsReceived += tests.Count;
}
public void RaiseTestRunComplete(TestRunStatistics stats)
{
var completeEvent = new TestRunCompleteEventArgs(stats: stats, isCanceled: false, isAborted: false, error: null, attachmentSets: null, elapsedTime: TimeSpan.FromSeconds(30));
this.TestRunComplete(this, completeEvent);
}
private async void StartMessageLoop(TaskCompletionSource <object> tcs)
{
while (isConnected)
{
var message = await ReceiveMessageAsync();
if (message != null)
{
if (message.MessageType == MessageType.SessionConnected)
{
// Version Check
comm.SendMessage(MessageType.VersionCheck, 1);
tcs.TrySetResult(null);
SendTestHostLaunched();
isConnected = true;
}
else if (!isConnected)
{
continue;
}
else if (message.MessageType == MessageType.StartDiscovery)
{
var req = comm.DeserializePayload <DiscoveryRequestPayload>(message);
comm.SendMessage(MessageType.DiscoveryInitialize);
var tests = ViewModels.TestRunnerVM.Instance.Tests;
comm.SendMessage(MessageType.DiscoveryComplete, new
DiscoveryCompletePayload()
{
LastDiscoveredTests = tests.Select(t => t.Test), TotalTests = tests.Count()
});
}
else if (message.MessageType == MessageType.TestRunSelectedTestCasesDefaultHost ||
message.MessageType == MessageType.TestRunAllSourcesWithDefaultHost)
{
var trr = comm.DeserializePayload <TestRunRequestPayload>(message);
if (trr.TestCases != null)
{
var testsToRun = ViewModels.TestRunnerVM.Instance.Tests.Select(t => t.Test).Where(t => trr.TestCases.Any(t2 => t2.Id == t.Id)).ToList();
DateTime start = DateTime.Now;
var _ = ViewModels.TestRunnerVM.Instance.Run(testsToRun, new SettingsXmlImpl(ViewModels.TestRunnerVM.Instance.Settings.AppendParameters(trr.RunSettings))).ContinueWith(task =>
{
TimeSpan elapsedTime = DateTime.Now - start;
if (task.IsCanceled)
{
SendMessage(MessageType.CancelTestRun);
}
else if (task.Exception != null)
{
SendMessage(MessageType.TestMessage, new TestMessagePayload {
MessageLevel = TestMessageLevel.Error, Message = task.Exception.ToString()
});
var runCompletePayload = new TestRunCompletePayload()
{
TestRunCompleteArgs = new TestRunCompleteEventArgs(null, false, true, task.Exception, null, TimeSpan.MinValue),
LastRunTests = null
};
SendMessage(MessageType.ExecutionComplete, runCompletePayload);
}
else
{
var results = task.Result;
var stats = new Dictionary <TestOutcome, long>()
{
{ TestOutcome.Passed, results.Where(t => t.Outcome == TestOutcome.Passed).Count() },
{ TestOutcome.Failed, results.Where(t => t.Outcome == TestOutcome.Failed).Count() },
{ TestOutcome.Skipped, results.Where(t => t.Outcome == TestOutcome.Skipped).Count() },
{ TestOutcome.NotFound, results.Where(t => t.Outcome == TestOutcome.NotFound).Count() },
{ TestOutcome.None, results.Where(t => t.Outcome == TestOutcome.None).Count() }
};
var testRunStats = new TestRunStatistics(results.Count(), stats);
var payload = new TestRunCompletePayload()
{
LastRunTests = new TestRunChangedEventArgs(testRunStats, results, testsToRun),
RunAttachments = new List <AttachmentSet>(),
TestRunCompleteArgs = new TestRunCompleteEventArgs(testRunStats, false, false, null, new System.Collections.ObjectModel.Collection <AttachmentSet>(), elapsedTime)
};
SendMessage(MessageType.ExecutionComplete, payload);
}
});
}
}
else
{
System.Diagnostics.Debug.WriteLine($"Got message: {message.MessageType}, Payload={message.Payload}");
}
}
}
comm.StopServer();
_ = StartAsync();
}
