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); }