public void DiscoveryManagerDiscoveryComplete_TestResultsIsNotEmptyAndDiscoveryCompleteHasBeenReceivedAndEIsAbortedIsFalse_RaisesTestResultsRemovedWithTestResults(string sourceAssemblyPath)
{
var fileSystem = Substitute.For <IFileSystem>();
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
var testCase = new TestCase()
{
Id = Guid.NewGuid(), Source = sourceAssemblyPath
};
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(Enumerable.Repeat(testCase, 1)));
discoveryManager.DiscoveryCompleted += Raise.EventWith(discoveryManager, new DiscoveryCompletedEventArgs(Enumerable.Empty <string>(), false));
var expected = uut.TestResults.ToArray();
var handler = Substitute.For <EventHandler <TestResultsEventArgs> >();
TestResultsEventArgs receivedArgs = null;
handler.When(x => x.Invoke(Arg.Any <object>(), Arg.Any <TestResultsEventArgs>())).Do(x => receivedArgs = (TestResultsEventArgs)x[1]);
uut.TestResultsRemoved += handler;
discoveryManager.DiscoveryCompleted += Raise.EventWith(discoveryManager, new DiscoveryCompletedEventArgs(Enumerable.Repeat(sourceAssemblyPath, 1), false));
handler.Received(1).Invoke(uut, Arg.Any <TestResultsEventArgs>());
CollectionAssert.AreEquivalent(expected, receivedArgs.TestResultsByTestCaseId.Values);
}
public HttpResponseMessage SubmitResult([FromBody] string testResJSON)
{
DirectoryManager dirman = new DirectoryManager();
TestManager testman = new TestManager(dirman);
TestResultManager testResMan = new TestResultManager(dirman);
try
{
ResultToSubmit resultToSubmit = JsonConvert.DeserializeObject <ResultToSubmit>(testResJSON);
testman.SubmitTestResults(resultToSubmit.authorName,
"otherResults", resultToSubmit.testTitle,
string.Concat(resultToSubmit.correctAnswerCount,
"/", resultToSubmit.questionCount), resultToSubmit.guessingUserName);
testman.SubmitTestResults(resultToSubmit.guessingUserName,
"personalResults", resultToSubmit.testTitle,
string.Concat(resultToSubmit.correctAnswerCount,
"/", resultToSubmit.questionCount), resultToSubmit.authorName);
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch (Exception)
{
return(Request.CreateResponse(HttpStatusCode.Forbidden));
}
}
//[Test]
public async Task Sandbox()
{
var fileSystem = new FileSystem();
var vstest = new VsTestConsoleWrapper(@"C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\Common7\IDE\Extensions\TestPlatform\vstest.console.exe");
vstest.InitializeExtensions(Enumerable.Repeat(@"C:\Users\Jake\Documents\Visual Studio 2017\Projects\nunit3-vs-adapter\src\NUnitTestAdapter\bin\Debug\net35\NUnit3.TestAdapter.dll", 1));
var testCaseDiscoveryManager = new TestCaseDiscoveryManager(vstest);
var testCaseManager = new TestResultManager(fileSystem, testCaseDiscoveryManager);
var testCasesDiscoveredHandler = Substitute.For <EventHandler <DiscoveredTestsEventArgs> >();
testCaseDiscoveryManager.TestCasesDiscovered += testCasesDiscoveredHandler;
var discoveryCompleteHandler = Substitute.For <EventHandler <DiscoveryCompletedEventArgs> >();
testCaseDiscoveryManager.DiscoveryCompleted += discoveryCompleteHandler;
var messageReceivedHandler = Substitute.For <EventHandler <TestRunMessageEventArgs> >();
testCaseDiscoveryManager.MessageReceived += messageReceivedHandler;
var testCasesAddedHandler = Substitute.For <EventHandler <TestResultsEventArgs> >();
testCaseManager.TestResultsAdded += testCasesAddedHandler;
var testCasesModifiedHandler = Substitute.For <EventHandler <TestResultsEventArgs> >();
testCaseManager.TestResultsModified += testCasesModifiedHandler;
var testCasesRemovedHandler = Substitute.For <EventHandler <TestResultsEventArgs> >();
testCaseManager.TestResultsRemoved += testCasesRemovedHandler;
await testCaseManager.AddSourceAssemblyPathAsync(@"C:\Users\Jake\Documents\Visual Studio 2017\Projects\FaultDictionaryDebugger\CommonUtilitiesTests\bin\Debug\CommonUtilitiesTests.dll");
CollectionAssert.IsNotEmpty(testCaseManager.TestResults);
}
public void RemoveSourceAssemblyPathAsync_DiscoveryManagerWaitForDiscoveryCompleteHasNotCompletedAndTestResultsContainsItemsWhereTestCaseSourceEqualsSourceAssemblyPath_DoesNotRaiseTestResultsRemoved(string sourceAssemblyPath)
{
var fileSystem = new MockFileSystem(null, "DummyDirectory");
fileSystem.AddFile(sourceAssemblyPath, sourceAssemblyPath);
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
uut.AddSourceAssemblyPathAsync(sourceAssemblyPath).Wait();
discoveryManager.IsDiscoveryInProgress.Returns(true);
var taskCompletionSource = new TaskCompletionSource <int>();
discoveryManager.WaitForDiscoveryCompleteAsync().Returns(taskCompletionSource.Task);
var testCase = new TestCase("DummyTestCase", new Uri("uri://dummy"), fileSystem.Path.GetFullPath(sourceAssemblyPath));
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(Enumerable.Repeat(testCase, 1)));
var handler = Substitute.For <EventHandler <TestResultsEventArgs> >();
uut.TestResultsRemoved += handler;
var task = uut.RemoveSourceAssemblyPathAsync(sourceAssemblyPath);
Task.Delay(100).Wait();
handler.DidNotReceive().Invoke(Arg.Any <object>(), Arg.Any <TestResultsEventArgs>());
discoveryManager.IsDiscoveryInProgress.Returns(false);
taskCompletionSource.SetResult(0);
}
public void DiscoveryManagerTestCasesDiscovered_TestResultsIsEmpty_RaisesTestCasesAddedWithEachTestObjectFactoryCreateTestResult(int testCaseCount)
{
var fileSystem = Substitute.For <IFileSystem>();
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = Substitute.ForPartsOf <FakeTestObjectFactory>();
var createdTestResults = new List <ITestResult>();
testObjectFactory.CreateTestResult(Arg.Any <TestCase>()).Returns(x =>
{
var testResult = FakeTestObjectFactory.Default.CreateTestResult((TestCase)x[0]);
createdTestResults.Add(testResult);
return(testResult);
});
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
var handler = Substitute.For <EventHandler <TestResultsEventArgs> >();
TestResultsEventArgs receivedArgs = null;
handler.When(x => x.Invoke(Arg.Any <object>(), Arg.Any <TestResultsEventArgs>())).Do(x => receivedArgs = (TestResultsEventArgs)x[1]);
uut.TestResultsAdded += handler;
var testCases = Enumerable.Range(1, testCaseCount).Select(x => new TestCase()
{
Id = Guid.NewGuid()
}).ToArray();
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(testCases));
handler.Received(1).Invoke(uut, Arg.Any <TestResultsEventArgs>());
CollectionAssert.AreEquivalent(createdTestResults, receivedArgs.TestResultsByTestCaseId.Values);
}
public void RemoveSourceAssemblyPathAsync_DiscoveryManagerWaitForDiscoveryCompleteHasNotCompleted_DoesNotComplete(string sourceAssemblyPath)
{
var fileSystem = new MockFileSystem(null, "DummyDirectory");
fileSystem.AddFile(sourceAssemblyPath, sourceAssemblyPath);
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
uut.AddSourceAssemblyPathAsync(sourceAssemblyPath).Wait();
discoveryManager.IsDiscoveryInProgress.Returns(true);
var taskCompletionSource = new TaskCompletionSource <int>();
discoveryManager.WaitForDiscoveryCompleteAsync().Returns(taskCompletionSource.Task);
var testCase = new TestCase("DummyTestCase", new Uri("uri://dummy"), fileSystem.Path.GetFullPath(sourceAssemblyPath));
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(Enumerable.Repeat(testCase, 1)));
var task = uut.RemoveSourceAssemblyPathAsync(sourceAssemblyPath);
Task.Delay(100).Wait();
Assert.IsFalse(task.IsCompleted);
discoveryManager.IsDiscoveryInProgress.Returns(false);
taskCompletionSource.SetResult(0);
}
public async Task RemoveSourceAssemblyPathAsync_TestResultsEachTestCaseSourceEqualsFileSystemPathGetFullPath_RaisesTestResultsRemovedWithTestResults(string sourceAssemblyPath, int testResultCount)
{
var fileSystem = new MockFileSystem(null, "DummyDirectory");
fileSystem.AddFile(sourceAssemblyPath, sourceAssemblyPath);
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
await uut.AddSourceAssemblyPathAsync(sourceAssemblyPath);
var testCases = Enumerable.Repeat(1, testResultCount).Select(x => new TestCase()
{
Id = Guid.NewGuid(), Source = fileSystem.Path.GetFullPath(sourceAssemblyPath)
}).ToArray();
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(testCases));
var expected = uut.TestResults.ToArray();
var handler = Substitute.For <EventHandler <TestResultsEventArgs> >();
TestResultsEventArgs receivedArgs = null;
handler.When(x => x.Invoke(Arg.Any <object>(), Arg.Any <TestResultsEventArgs>())).Do(x => receivedArgs = (TestResultsEventArgs)x[1]);
uut.TestResultsRemoved += handler;
await uut.RemoveSourceAssemblyPathAsync(sourceAssemblyPath);
handler.Received(1).Invoke(uut, Arg.Any <TestResultsEventArgs>());
CollectionAssert.AreEquivalent(expected, receivedArgs.TestResultsByTestCaseId.Values);
}
public void DiscoveryManagerTestCasesDiscovered_EDiscoveredTestCasesIdsContainsEachTestResultsTestCaseId_TestResultsIsEquivalentToEachTestObjectFactoryCloneTestResult(int testCaseCount)
{
var fileSystem = Substitute.For <IFileSystem>();
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = Substitute.ForPartsOf <FakeTestObjectFactory>();
var clonedTestResults = new List <ITestResult>();
testObjectFactory.CloneTestResult(Arg.Any <ITestResult>(), Arg.Any <TestCase>()).Returns(x =>
{
var testResult = FakeTestObjectFactory.Default.CloneTestResult((ITestResult)x[0], (TestCase)x[1]);
clonedTestResults.Add(testResult);
return(testResult);
});
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
var testCases1 = Enumerable.Range(1, testCaseCount).Select(x => new TestCase()
{
Id = Guid.NewGuid()
}).ToArray();
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(testCases1));
var testCases2 = testCases1.Select(x => new TestCase()
{
Id = x.Id
}).ToArray();
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(testCases2));
var result = uut.TestResults;
CollectionAssert.AreEquivalent(clonedTestResults, result);
}
public void DiscoveryManagerTestCasesDiscovered_EDiscoveredTestCasesIdsContainsEachTestResultsTestCaseId_InvokesTestObjectFactoryCloneTestResultWithEachTestResult(int testCaseCount)
{
var fileSystem = Substitute.For <IFileSystem>();
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = Substitute.ForPartsOf <FakeTestObjectFactory>();
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
var testCases1 = Enumerable.Range(1, testCaseCount).Select(x => new TestCase()
{
Id = Guid.NewGuid()
}).ToArray();
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(testCases1));
var testResults = uut.TestResults.ToArray();
var testCases2 = testCases1.Select(x => new TestCase()
{
Id = x.Id
}).ToArray();
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(testCases2));
foreach (var testResult in testResults)
{
testObjectFactory.Received(1).CloneTestResult(testResult, Arg.Any <TestCase>());
}
}
public void RemoveSourceAssemblyPathAsync_DiscoveryManagerWaitForDiscoveryCompleteHasNotCompletedAndTestResultsContainsItemsWhereTestCaseSourceEqualsSourceAssemblyPath_TestResultsIsEquivalentToInitial(string sourceAssemblyPath)
{
var fileSystem = new MockFileSystem(null, "DummyDirectory");
fileSystem.AddFile(sourceAssemblyPath, sourceAssemblyPath);
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
uut.AddSourceAssemblyPathAsync(sourceAssemblyPath).Wait();
discoveryManager.IsDiscoveryInProgress.Returns(true);
var taskCompletionSource = new TaskCompletionSource <int>();
discoveryManager.WaitForDiscoveryCompleteAsync().Returns(taskCompletionSource.Task);
var testCase = new TestCase("DummyTestCase", new Uri("uri://dummy"), fileSystem.Path.GetFullPath(sourceAssemblyPath));
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(Enumerable.Repeat(testCase, 1)));
var expected = uut.TestResults.ToArray();
var task = uut.RemoveSourceAssemblyPathAsync(sourceAssemblyPath);
Task.Delay(100).Wait();
var result = uut.TestResults;
CollectionAssert.AreEquivalent(expected, result);
// Cleanup
discoveryManager.IsDiscoveryInProgress.Returns(false);
taskCompletionSource.SetResult(0);
}
public void RemoveSourceAssemblyPathAsync_DiscoveryManagerWaitForDiscoveryCompleteHasNotCompleted_SourceAssemblyPathsContainsSourceAssemblyPath(string sourceAssemblyPath)
{
var fileSystem = new MockFileSystem(null, "DummyDirectory");
fileSystem.AddFile(sourceAssemblyPath, sourceAssemblyPath);
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
uut.AddSourceAssemblyPathAsync(sourceAssemblyPath).Wait();
discoveryManager.IsDiscoveryInProgress.Returns(true);
var taskCompletionSource = new TaskCompletionSource <int>();
discoveryManager.WaitForDiscoveryCompleteAsync().Returns(taskCompletionSource.Task);
var task = uut.RemoveSourceAssemblyPathAsync(sourceAssemblyPath);
Task.Delay(100).Wait();
CollectionAssert.Contains(uut.SourceAssemblyPaths, fileSystem.Path.GetFullPath(sourceAssemblyPath));
discoveryManager.IsDiscoveryInProgress.Returns(false);
taskCompletionSource.SetResult(0);
}
public void Constructor_Otherwise_SetsTestResultsToEmpty()
{
var fileSystem = Substitute.For <IFileSystem>();
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
CollectionAssert.IsEmpty(uut.TestResults);
}
public void Constructor_Otherwise_SubscribesToDiscoveryManagerTestCasesDiscovered()
{
var fileSystem = Substitute.For <IFileSystem>();
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
discoveryManager.Received(1).TestCasesDiscovered += Arg.Any <EventHandler <DiscoveredTestsEventArgs> >();
}
public void GetResults()
{
PatientDto patient = new PatientDto()
{
ContactNo = "0770881084"
};
TestResultManager resu = new TestResultManager();
var res = resu.Getresults(patient);
}
public void RemoveSourceAssemblyPathAsync_SourceAssemblyPathIsNull_ThrowsException()
{
var fileSystem = Substitute.For <IFileSystem>();
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
var result = Assert.ThrowsAsync <ArgumentNullException>(async() => await uut.RemoveSourceAssemblyPathAsync(null));
Assert.AreEqual("sourceAssemblyPath", result.ParamName);
}
public void DeleteResultRow()
{
TestResultDto Attribute = new TestResultDto()
{
ID = 334,
VisitID = 73,
};
TestResultManager Attrib = new TestResultManager();
var res = Attrib.DeleteAttribute(Attribute);
}
static void Main(string[] args)
{
IStudentManager studentManager = new StudentManager();
studentManager.AddStudent("Adam", 15);
studentManager.AddStudent("Bertil", 17);
studentManager.AddStudent("Ceasar", 21);
studentManager.AddStudent("David", 65);
ITeacherManager teacherManager = new TeacherManager();
teacherManager.AddTeacher("Kalle");
ICourseManager courseManager = new CourseManager();
courseManager.AddCourse("C#", "Kalle");
courseManager.AddCourse("Datalagring med .Net", "Kalle");
IExamManager examManager = new ExamManager();
var exam1 = examManager.AddExam("C#", 0.4m);
var exam2 = examManager.AddExam("C#", 0.6m);
var question1 = examManager.AddQuestion(exam1, "Vad är ett interface?");
var option1 = examManager.AddAnswerOption(question1, "En grej i C#", true);
var option2 = examManager.AddAnswerOption(question1, "En sorts fisk", false);
var question2 = examManager.AddQuestion(exam1, "Vad är en klass?");
var option3 = examManager.AddAnswerOption(question2, "En annan grej i C#", true);
var option4 = examManager.AddAnswerOption(question2, "En sorts insekt", false);
var question3 = examManager.AddQuestion(exam2, "Vad är Entity Framework?");
var option5 = examManager.AddAnswerOption(question3, "En ORM i C#", true);
var option6 = examManager.AddAnswerOption(question3, "En sorts däggdjur", false);
IExamAnswerManager examAnswerManager = new ExamAnswerManager();
var examAnswer1 = examAnswerManager.AddExamAnswer("Adam", exam1);
examAnswerManager.AddExamQuestionAnswer(examAnswer1, question1, option1);
examAnswerManager.AddExamQuestionAnswer(examAnswer1, question2, option4);
var examAnswer2 = examAnswerManager.AddExamAnswer("Adam", exam2);
examAnswerManager.AddExamQuestionAnswer(examAnswer2, question2, option5);
ITestResultManager testResultManager = new TestResultManager();
var examGrader = new ExamGrader(testResultManager, examAnswerManager);
examGrader.GradeExam("Adam", "C#", 0);
Console.WriteLine("Klart.");
Console.ReadLine();
}
private void InitObjects()
{
Users = new UserManager(context);
Rulos = new RuloManager(context);
DefinationProcesses = new DefinationProcessManager(context);
Machines = new MachineManager(context);
TestResults = new TestResultManager(context);
Floors = new FloorManager(context);
OriginCategories = new OriginCategoryManager(context);
TestCategories = new TestCategoryManager(context);
Samples = new SampleManager(context);
}
public void RemoveSourceAssemblyPathAsync_SourceAssemblyPathsDoesNotContainFileSystemPathGetFullPath_ThrowsException(string sourceAssemblyPath)
{
var fileSystem = new MockFileSystem(null, "DummyDirectory");
fileSystem.AddFile(sourceAssemblyPath, sourceAssemblyPath);
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
var result = Assert.ThrowsAsync <ArgumentException>(async() => await uut.RemoveSourceAssemblyPathAsync(sourceAssemblyPath));
Assert.AreEqual("sourceAssemblyPath", result.ParamName);
StringAssert.Contains(nameof(uut.SourceAssemblyPaths), result.Message);
}
public async Task AddSourceAssemblyPathAsync_Otherwise_SourceAssemblyPathsContainsSourceAssemblyPath(string sourceAssemblyPath)
{
var fileSystem = new MockFileSystem(null, "DummyDirectory");
fileSystem.AddFile(sourceAssemblyPath, sourceAssemblyPath);
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
await uut.AddSourceAssemblyPathAsync(sourceAssemblyPath);
var expected = fileSystem.Path.GetFullPath(sourceAssemblyPath);
CollectionAssert.Contains(uut.SourceAssemblyPaths, expected);
}
public async Task AddSourceAssemblyPathAsync_SourceAssemblyPathIsNotNull_InvokesFileSystemPathGetFullPathWithSourceAssemblyPath(string sourceAssemblyPath)
{
var fileSystem = Substitute.For <IFileSystem>();
var path = Substitute.For <PathBase>();
path.GetFullPath(Arg.Any <string>()).Returns(sourceAssemblyPath);
fileSystem.Path.Returns(path);
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
await uut.AddSourceAssemblyPathAsync(sourceAssemblyPath);
path.Received(1).GetFullPath(sourceAssemblyPath);
}
public void ApproveTestByMLT()
{
PatientTest patientTest = new PatientTest()
{
VisitID = 69,
};
User user = new User()
{
UserId = 76,
Username = "******"
};
TestResultManager testManager = new TestResultManager();
var approve = testManager.ApproveTest(patientTest, user);
}
public async Task AddSourceAssemblyPathAsync_DiscoveryManagerIsDiscoveryInProgressIsTrue_InvokesDiscoveryManagerWaitForDiscoveryCompleteUntilDiscoveryManagerIsDiscoveryInProgressIsFalse(string sourceAssemblyPath)
{
var fileSystem = new MockFileSystem(null, "DummyDirectory");
fileSystem.AddFile(sourceAssemblyPath, sourceAssemblyPath);
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
discoveryManager.IsDiscoveryInProgress.Returns(true, true, true, false, true);
discoveryManager.WaitForDiscoveryCompleteAsync().Returns(Task.CompletedTask);
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
await uut.AddSourceAssemblyPathAsync(sourceAssemblyPath);
await discoveryManager.Received(3).WaitForDiscoveryCompleteAsync();
}
public void RemoveSourceAssemblyPathAsync_FileSystemPathGetFullPathThrowsArgumentException_WrapsException(string sourceAssemblyPath)
{
var fileSystem = Substitute.For <IFileSystem>();
var path = Substitute.For <PathBase>();
var exception = new ArgumentException();
path.GetFullPath(Arg.Any <string>()).Returns(x => throw exception);
fileSystem.Path.Returns(path);
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
var result = Assert.ThrowsAsync <ArgumentException>(async() => await uut.RemoveSourceAssemblyPathAsync(sourceAssemblyPath));
Assert.AreEqual("sourceAssemblyPath", result.ParamName);
Assert.AreSame(exception, result.InnerException);
}
public void DiscoveryManagerTestCasesDiscovered_TestResultsIsEmpty_InvokesTestObjectFactoryCreateTestResultWithEachEDiscoveredTestCase(int testCaseCount)
{
var fileSystem = Substitute.For <IFileSystem>();
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = Substitute.ForPartsOf <FakeTestObjectFactory>();
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
var testCases = Enumerable.Range(1, testCaseCount).Select(x => new TestCase()
{
Id = Guid.NewGuid()
}).ToArray();
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(testCases));
foreach (var testCase in testCases)
{
testObjectFactory.Received(1).CreateTestResult(testCase);
}
}
public void DiscoveryManagerDiscoveryComplete_TestResultsIsNotEmptyAndDiscoveryCompleteHasBeenReceivedAndEIsAbortedIsFalse_TestResultsIsEmpty(string sourceAssemblyPath)
{
var fileSystem = Substitute.For <IFileSystem>();
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
var testCase = new TestCase()
{
Id = Guid.NewGuid(), Source = sourceAssemblyPath
};
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(Enumerable.Repeat(testCase, 1)));
discoveryManager.DiscoveryCompleted += Raise.EventWith(discoveryManager, new DiscoveryCompletedEventArgs(Enumerable.Empty <string>(), false));
discoveryManager.DiscoveryCompleted += Raise.EventWith(discoveryManager, new DiscoveryCompletedEventArgs(Enumerable.Repeat(sourceAssemblyPath, 1), false));
var result = uut.TestResults;
CollectionAssert.IsEmpty(result);
}
public void DiscoveryManagerDiscoveryComplete_TestResultsIsNotEmptyAndDiscoveryCompleteHasNotBeenReceived_TestResultsIsEquivalentToInitial(int testCaseCount)
{
var fileSystem = Substitute.For <IFileSystem>();
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
var testCases = Enumerable.Repeat(1, testCaseCount).Select(x => new TestCase()
{
Id = Guid.NewGuid()
}).ToArray();
discoveryManager.TestCasesDiscovered += Raise.EventWith(discoveryManager, new DiscoveredTestsEventArgs(testCases));
var expected = uut.TestResults.ToArray();
discoveryManager.DiscoveryCompleted += Raise.EventWith(discoveryManager, new DiscoveryCompletedEventArgs(Enumerable.Empty <string>(), false));
var result = uut.TestResults;
CollectionAssert.AreEquivalent(expected, result);
}
public void UpdateAttribute()
{
TestResultDto updateResult = new TestResultDto()
{
//Result ID
ID = 358,
Value = "1.5%",
Status = " Normal",
};
UserDto user = new UserDto()
{
UserId = 42,
Username = "******"
};
TestResultManager Attrib = new TestResultManager();
var res = Attrib.UpdateAttribute(updateResult, user);
}
public async Task AddSourceAssemblyPathAsync_Otherwise_InvokesDiscoveryManagerDiscoverTestsAsyncWithSourceAssemblyPath(string sourceAssemblyPath)
{
var fileSystem = new MockFileSystem(null, "DummyDirectory");
fileSystem.AddFile(sourceAssemblyPath, sourceAssemblyPath);
var discoveryManager = Substitute.For <ITestCaseDiscoveryManager>();
IEnumerable <string> receivedSources = null;
discoveryManager.When(x => x.DiscoverTestCasesAsync(Arg.Any <IEnumerable <string> >())).Do(x => receivedSources = (IEnumerable <string>)x[0]);
var testObjectFactory = FakeTestObjectFactory.Default;
var uut = new TestResultManager(fileSystem, discoveryManager, testObjectFactory);
await uut.AddSourceAssemblyPathAsync(sourceAssemblyPath);
var expected = fileSystem.Path.GetFullPath(sourceAssemblyPath);
await discoveryManager.Received(1).DiscoverTestCasesAsync(Arg.Any <IEnumerable <string> >());
CollectionAssert.AreEquivalent(receivedSources, Enumerable.Repeat(expected, 1));
}
public void GradeExam(ExamAnswer examAnswer)
{
ITestResultManager testResultManager = new TestResultManager();
var testResult = testResultManager.AddTestResult(examAnswer);
int correct = 0;
int total = 0;
foreach (var question in examAnswer.Exam.Questions)
{
var studentAnswer = examAnswer.ExamQuestionAnswers.FirstOrDefault(eqa =>
eqa.QuestionID == question.QuestionID);
var isCorrect = studentAnswer.AnswerAlternativeID ==
question.AnswerAlternatives.FirstOrDefault(a => a.IsCorrect)?.AnswerAlternativeID;
testResultManager.AddAnswer(testResult, studentAnswer.AnswerAlternative, isCorrect);
if (isCorrect)
{
correct++;
}
total++;
}
testResultManager.SetTotalScore(testResult, (decimal)correct / (decimal)total);
}
