void SetStartUpParameters(ITestRun testRun) { if (TestRunStartTypes.Immediately == testRun.StartType) testRun.Status = TestRunQueue.TestRuns.Any(tr => tr.TestLabId == testRun.TestLabId && tr.IsQueued()) ? TestRunStatuses.Pending : TestRunStatuses.Running; if (testRun.IsActive()) testRun.SetStartTime(); }
public void SetUp() { TestSettings.PrepareModuleTests(); TestFactory.GetTestRunWithStatus(TestRunStatuses.Running); _workflow = WorkflowCollection.Workflows.First(); _testRun = TestRunQueue.TestRuns.First(); }
void SetCommonData(ITestRun testRun, IDictionary<string, object> formData) { if (null == formData || 0 >= formData.Count) return; foreach (var pair in formData) AddOrUpdateDataItem(testRun, formData, pair.Key); }
void AddOrUpdateDataItem(ITestRun testRun, IDictionary<string, object> formData, string key) { testRun.Data.AddOrUpdateDataItem( new CommonDataItem { Key = key, Value = (formData[key] ?? string.Empty).ToString() }); }
public void CancelTestRun(ITestRun testRun) { TaskPool.TasksForClients.Where(task => task.TestRunId == testRun.Id && !task.IsFinished() && !task.IsActive()).ToList().ForEach(task => task.TaskStatus = TestTaskStatuses.Canceled); testRun.Status = TestRunStatuses.Cancelled; if (TaskPool.TasksForClients.Any(task => task.TestRunId == testRun.Id && task.IsActive())) { TaskPool.TasksForClients.Where(task => task.TestRunId == testRun.Id && task.IsActive()).ToList().ForEach(task => task.TaskStatus = TestTaskStatuses.Interrupted); testRun.Status = TestRunStatuses.Cancelling; } // disconnecting clients ClientsCollection.Clients.RemoveAll(client => client.TestRunId == testRun.Id); testRun.SetTimeTaken(); RunNextInRowTestRun(); }
public static TestResult Map(ITestRun testRun, double? coverage, string serverName) { return new TestResult() { ServerName = serverName, CompletedTime = testRun.DateCompleted, PassedTestCount = testRun.Statistics.PassedTests, FailedTestCount = testRun.Statistics.FailedTests, NotRunTestCount = testRun.Statistics.InconclusiveTests, TotalTestCount = testRun.Statistics.TotalTests, CodeCoverage = coverage != null ? new CodeCoverageResult() { CompletedTime = testRun.DateCompleted, Coverage = coverage.Value } : null }; }
public virtual void CancelTestRun(ITestRun testRun) { TaskPool.TasksForClients.Where(task => task.TestRunId == testRun.Id && !task.IsFinished() && !task.IsActive() && !task.IsCancel).ToList().ForEach(task => task.TaskStatus = TestTaskStatuses.Canceled); var activeTasks = TaskPool.TasksForClients.Where(task => task.TestRunId == testRun.Id && task.IsActive()).ToList(); if (activeTasks.Any()) { // 20150918 // temporarily // until there'll be async execution of task here // linked lines of code 20150918-001 // activeTasks.ForEach(task => { if (!task.IsCancel) task.TaskStatus = TestTaskStatuses.InterruptedByUser; }); // TODO: provide all clients that ran active tasks with newly available tasks // however clients can't interrupt their tasks // testRun.Status = TestRunStatuses.Canceling; } else { testRun.Status = TestRunStatuses.Canceled; } // TODO: set test run status Canceled after all isCancel tasks have finished // disconnecting clients // 20150807 // ClientsCollection.Clients.RemoveAll(client => client.TestRunId == testRun.Id); // 20150909 // no more unregistration of clients // testRun.UnregisterClients(); // set time only for completely cancelled test runs // testRun.SetTimeTaken(); if (TestRunStatuses.Canceled == testRun.Status) testRun.SetTimeTaken(); // 20150909 // RunNextInRowTestRun(); if (TestRunStatuses.Canceled == testRun.Status) RunNextInRowTestRun(); }
void ThenTestRunIsRunning(ITestRun testRun) { Assert.Equal(true, testRun.IsActive()); }
void ThenTestRunIsCompleted(ITestRun testRun) { Assert.Equal(true, testRun.IsCompleted()); }
public static string GetFileName(this ITestRun testRun) { return(testRun.TestInfo.Finish.GetTestName()); }
public static bool IsActive(this ITestRun testRun) { // 20150918 // return TestRunStatuses.Running == testRun.Status; return(TestRunStatuses.Running == testRun.Status || TestRunStatuses.Canceling == testRun.Status); }
public static string GetTestLabName(this ITestRun testRun) { return(TestLabCollection.TestLabs.FirstOrDefault(testLab => testLab.Id == testRun.TestLabId).Name); }
public static void SetStartTime(this ITestRun testRun) { testRun.StartTime = DateTime.Now; }
public static void SetTimeTaken(this ITestRun testRun) { (testRun as TestRun).SetFinishTime(); }
public static bool IsScheduled(this ITestRun testRun) { return(TestRunStatuses.Scheduled == testRun.Status); }
public static bool IsQueued(this ITestRun testRun) { return(TestRunStatuses.Running == testRun.Status || TestRunStatuses.Pending == testRun.Status); }
public static bool IsPending(this ITestRun testRun) { return(TestRunStatuses.Pending == testRun.Status); }
public static bool IsNotQuiet(this ITestRun testRun) { return(TestRunStatuses.Running == testRun.Status || TestRunStatuses.Canceling == testRun.Status); }
public static bool IsAcceptingNewClients(this ITestRun testRun) { return(TestRunStatuses.Running == testRun.Status); }
/// <summary> /// Executes a test run. The ITestRun object specifies which tests to run /// and how. If the tests write to the console (either Error or Out) this /// output will be redirected to 'twConsole'. /// </summary> /// <param name="testRun">ITestRun object describing what tests to run and how.</param> /// <param name="twConsole">TextWriter to where Out and Error are redirected.</param> public void RunTests(ITestRun testRun, TextWriter twConsole) { SetUpConsoleAndWorkingDirectory(twConsole); if( _listener != null ) { _listener.OnAssemblyStarted(null, new AssemblyEventArgs(_testAssembly.FullName, _testAssembly.CodeBase)); } try { _testAssembly.RunTests(testRun, _listener); } catch( Exception ex ) { if( _listener != null ) { _listener.OnTestsAborted(null, new AssemblyEventArgs(_testAssembly.FullName, _testAssembly.CodeBase)); } CheckAndHandleCsUnitCrash(ex); } finally { if( _listener != null ) { _listener.OnAssemblyFinished(null, new AssemblyEventArgs(_testAssembly.FullName, _testAssembly.CodeBase)); } RestoreConsoleAndWorkingDirectory(); } }
public void RunTests(ITestRun testSelection) { RaiseAbortedEvent(); }
void WhenCancelingTestRun(ITestRun testRun) { _response = _browser.Put(UrlList.TestRuns_Root + "/" + testRun.Id + "/cancelTestRun", with => { with.Accept("application/json"); }); }
void THEN_testRun_is_completed(ITestRun testRun) { Assert.Equal(true, testRun.IsCompleted()); }
/// <summary> /// Executes tests specified as a test run. The TestRun object contains /// information about what tests to execute and how. /// </summary> /// <param name="testRun">Information about the test run.</param> public void RunTests(ITestRun testRun) { if (_testAssemblies.Count > 0) { _testRun = testRun; PrepareTestRun(); RunTests(_queuedAssemblies.Dequeue(), _testRun); } }
void ThenTestRunIsPending(ITestRun testRun) { Assert.Equal(true, testRun.IsPending()); }
private void RunTests(ITestAssembly testAssembly, ITestRun testRun) { if( testAssembly != null ) { try { //testAssembly.Refresh(); testAssembly.RunTests(testRun); } catch( Exception ex ) { // Invoke the abort event b/c an exception that goes unhandled // here is the equivalent of an aborted recipe. var recipeEventArgs = new RecipeEventArgs(ex.Message); TestsRunning = false; if( Aborted != null ) { Aborted(this, recipeEventArgs); } } } }
void ThenTestRunStatusIsCanceled(ITestRun testRun) { Assert.Equal(TestRunStatuses.Canceled, testRun.Status); }
public void RunTests(ITestRun testRun) { throw new Exception("The method or operation is not implemented."); }
/// <summary> /// This method is used to initiate execution in test manager, create test run and results and set required parameters /// </summary> /// <returns></returns> public bool InitExecution() { //Create a connection to tfs project ITestManagementTeamProject tfsProject = null; tfsProject = GetProject(ProjectUrl, ProjectName); if (tfsProject == null) { throw new Exception("Unabled to connect to test project: " + ProjectName); } //Retrieve test plan details ITestPlanCollection testPlans = tfsProject.TestPlans.Query("select * from TestPlan where PlanName ='" + TestPlanName + "'"); if (testPlans.Count == 0) { throw new Exception("Unabled to locate test plan: " + TestPlanName + " in Test Manager."); } ITestPlan tfsTestPlan = testPlans.First(); //Retrieve test suite details ITestSuiteCollection testSuites = null; //Optionally, test suite id of test manager can be passed as an command line arguments //This helps when same test case has been added to multiple test suites if (TestSuiteId.ToLower().Equals(string.Empty) || TestSuiteId.ToLower().Equals(string.Empty) || TestSuiteId.ToLower().Equals("testsuiteid", StringComparison.OrdinalIgnoreCase)) { testSuites = tfsProject.TestSuites.Query("Select * from TestSuite where Title='" + TestSuiteName + "' and PlanID='" + tfsTestPlan.Id + "'"); } else { testSuites = tfsProject.TestSuites.Query("Select * from TestSuite where Id='" + TestSuiteId + "' and PlanID='" + tfsTestPlan.Id + "'"); } IStaticTestSuite tfsTestSuite = testSuites.Cast <IStaticTestSuite>().FirstOrDefault(testSuite => testSuite.Title.ToLower().Equals(TestSuiteName.ToLower()) || testSuite.Id.ToString().Equals(TestSuiteId)); if (tfsTestSuite == null) { throw new Exception("Unabled to locate test suite: " + TestSuiteName + " in Test Manager Test Plan: " + TestPlanName); } //Get handle to a specific test case in the test suite ITestCase tfsTestCase = tfsTestSuite.AllTestCases.FirstOrDefault(testcase => testcase.Id.Equals(TestCaseId)); if (tfsTestCase == null) { throw new Exception("Unabled to locate test case id: " + TestCaseId + " in Test Manager"); } //Create a test run ITestPoint tfsTestPoint = CreateTestPoints(tfsTestPlan, tfsTestSuite, tfsTestCase); ITestRun tfsTestRun = CreateTestRun(tfsProject, tfsTestPlan, tfsTestPoint); tfsTestRun.Refresh(); //Suprisingly, most recently created test results should be available in last, but test manager returns it at first position //Find test results that were create by the test run ITestCaseResultCollection tfsTestCaseResults = tfsProject.TestResults.ByTestId(tfsTestCase.Id); ITestCaseResult tfsTestResult = tfsTestCaseResults.Last(); //Default assignment foreach (ITestCaseResult testResult in tfsTestCaseResults) { if (testResult.DateCreated.CompareTo(tfsTestRun.DateCreated) == 1) { tfsTestResult = testResult; break; } } //Set test run and result id to property variable for usage while uploading results Property.RcTestRunId = tfsTestRun.Id; Property.RcTestResultId = tfsTestResult.TestResultId; //Set status of test case execution //Set other details on test execution tfsTestResult.ComputerName = Property.RcMachineId; tfsTestResult.DateStarted = DateTime.Now; tfsTestResult.State = TestResultState.InProgress; tfsTestResult.Save(); return(true); }
private void AddTestResultByTestoutcome(ITestRun testRun, IList<TestOutcome> outcomeList, ref IList<TestResult> list) { foreach (var outcome in outcomeList) { foreach (var tr in testRun.QueryResultsByOutcome(outcome)) { TestResult instance = new TestResult { TestCaseId = tr.TestCaseId, TestCaseTitle = tr.TestCaseTitle, State = tr.State, Outcome = tr.Outcome, DateStarted = tr.DateStarted, DateCompleted = tr.DateCompleted, ErrorMsg = tr.ErrorMessage, LogUri = tr.Attachments.FirstOrDefault().Uri.AbsoluteUri, }; list.Add(instance); } } }
string GIVEN_url_to_testRun_data() { _testRun = new TestRun(); ClientSettings.Instance.CurrentClient = new TestClient { TestRunId = _testRun.Id }; return UrlList.TestData_Root + "/" + _testRun.Id + UrlList.TestData_CommonData_forClient_relPath; }
public void RunTests(ITestRun selection) { if( Started != null ) { Started(this, new RecipeEventArgs()); } }
public static void UnregisterClients(this ITestRun testRun) { // TODO: send command to unregister to clients ClientsCollection.Clients.RemoveAll(client => client.TestRunId == testRun.Id); }
// [MbUnit.Framework.Test][NUnit.Framework.Test][Fact] // public void Should_add_one_task_to_the_common_pool_on_imporing_one_task() // { // Xunit.Assert.Equal(0, 1); // } // // [MbUnit.Framework.Test][NUnit.Framework.Test][Fact] // public void Should_add_all_tasks_to_the_common_pool_on_importing_several_tasks() // { // Xunit.Assert.Equal(0, 1); // } // // // ========================================================================================== // [MbUnit.Framework.Test][NUnit.Framework.Test][Fact] // public void Should_add_one_task_to_one_client_pool() // { // Xunit.Assert.Equal(0, 1); // } // // [MbUnit.Framework.Test][NUnit.Framework.Test][Fact] // public void Should_add_all_tasks_to_one_client_pool() // { // Xunit.Assert.Equal(0, 1); // } // // // ========================================================================================== // [MbUnit.Framework.Test][NUnit.Framework.Test][Fact] // public void Should_add_one_task_to_all_client_pools() // { // Xunit.Assert.Equal(0, 1); // } // // [MbUnit.Framework.Test][NUnit.Framework.Test][Fact] // public void Should_add_all_tasks_to_all_client_pools() // { // Xunit.Assert.Equal(0, 1); // } // // // ========================================================================================== // [MbUnit.Framework.Test][NUnit.Framework.Test][Fact] // public void Should_add_no_tasks_to_not_matching_client_pools() // { // Xunit.Assert.Equal(0, 1); // } // // [MbUnit.Framework.Test][NUnit.Framework.Test][Fact] // public void Should_add_one_task_to_matching_client_pools() // { // Xunit.Assert.Equal(0, 1); // } // // [MbUnit.Framework.Test][NUnit.Framework.Test][Fact] // public void Should_add_all_tasks_to_matching_client_pools() // { // Xunit.Assert.Equal(0, 1); // } void GivenTasksForRule(ITestRun testRun, string rule) { TaskPool.TasksForClients.AddRange( new[] { new TestTask { Id = 1, TaskStatus = TestTaskStatuses.Running, Rule = rule, TestRunId = testRun.Id, WorkflowId = testRun.WorkflowId }, new TestTask { Id = 2, TaskStatus = TestTaskStatuses.New, IsCancel = true, Rule = rule, TestRunId = testRun.Id, WorkflowId = testRun.WorkflowId }, new TestTask { Id = 2, TaskStatus = TestTaskStatuses.New, Rule = rule, TestRunId = testRun.Id, WorkflowId = testRun.WorkflowId } } ); }
void THEN_testRun_is_running(ITestRun testRun) { Assert.Equal(true, testRun.IsActive()); }
public void RunTests(ITestRun selection) { FireFinishedEvent(); }
public Task SaveResults(string runId, int suiteId) { return(Task.Factory.StartNew(() => { // tell the spinner this task is starting ViewModelLocator.MainWindowViewModel.TaskManager.AddTask(); // retrieve the info for the specified run RunInfo rfRunInfo = Services.Rainforest.Runs.GetSingle(runId); // check to see if the run is finished if (rfRunInfo.state != "complete" && rfRunInfo.state != "aborted") { ViewModelLocator.MainWindowViewModel.TaskManager.RemoveTask(); throw new Core.ServiceException(Core.Error.RunNotComplete, runId); } // run has completed or has been aborted and is being processed, tag can be removed this.TFS.RemoveTag(suiteId, $"RUNID{runId}"); // if run was aborted then drop results if (rfRunInfo.state == "aborted") { ViewModelLocator.MainWindowViewModel.TaskManager.RemoveTask(); throw new Core.ServiceException(Core.Error.RunAborted, runId); } // Run was completed successfully // deserialize the RF tests info that were in the run, ids here are all rfIds, these are NOT JsonObjects.Test objects var anon = new[] { new { id = 0, result = "" } }; var rfTestResults = JsonConvert.DeserializeAnonymousType(rfRunInfo.extras["tests"].ToString(), anon); // Get all the testpoints from the suite var testPointDict = TFS.Session.workingPlan .QueryTestPoints(String.Format("SELECT * FROM TestPoint WHERE SuiteId = {0}", suiteId)) .ToDictionary(tp => tp.TestCaseId, tp => tp); // create a run in tfs to create results against ITestRun tfsTestRun = Session.workingPlan.CreateTestRun(false); // map the RF test results to a new enumerable with stored TFS id var refinedRFTestResults = rfTestResults.Select(r => { // retrieve the test from RF, need to search tag for matching TFS id // each should have a tag already as it was ensured before the run was created // TOEXPAND -> could possible add redundant check for no tags found in case manually removed Test rfTest = Services.Rainforest.Tests.GetSingle(r.id.ToString()); string tfsId = Parse.ExtractIdFromTags("TFSID", rfTest.tags); return new { rfid = r.id, verdict = r.result, tfsId = Int32.Parse(tfsId) }; }) .ToList(); // go through RF results once to find the needed testpoints and add to run foreach (var result in refinedRFTestResults) { // find test point for the matching TFS tc and add to run ITestPoint testPoint = testPointDict[result.tfsId]; tfsTestRun.AddTestPoint(testPoint, testPoint.TestCaseWorkItem.Owner); } tfsTestRun.Save(); // retrieve all the TFS results from the run Dictionary <int, ITestCaseResult> tfsTestResults = tfsTestRun.QueryResults().ToDictionary(r => r.TestCaseId, r => r); // go through RF results again to save the outcomes to the tfs results foreach (var result in refinedRFTestResults) { ITestCaseResult tfsResult = tfsTestResults[result.tfsId]; switch (result.verdict) { case "passed": tfsResult.Outcome = TestOutcome.Passed; tfsResult.State = TestResultState.Completed; break; case "failed": tfsResult.Outcome = TestOutcome.Failed; tfsResult.State = TestResultState.Completed; break; default: // TOEXPAND -> should never get here, verdict will always have a value break; } tfsResult.State = TestResultState.Completed; tfsResult.RunBy = Session.userTFId; tfsResult.Save(); } tfsTestRun.Save(); tfsTestRun.Refresh(); // tell the spinner this task is done ViewModelLocator.MainWindowViewModel.TaskManager.RemoveTask(); })); }
private MyTestListener ExecuteLoaderAndListen(ITestRun testRun) { var loader = new Loader(_assemblyPathName); var listener = new MyTestListener(loader); loader.RunTests(testRun); do { Thread.Sleep(200); } while (listener.TestsRunning); loader.Dispose(); Thread.SpinWait(20); return listener; }
// TODO: remove duplication // void SetCommonData(ITestRun testRun, ICommonData commonData) // { // if (null == commonData || 0 >= commonData.Data.Count) // return; // foreach (var pair in commonData.Data) // AddOrUpdateDataItem(testRun, commonData.Data, pair.Key); // } void SetCreatedTime(ITestRun testRun) { testRun.CreatedTime = DateTime.Now; }
public void RunTests(ITestRun testRun) { _testRun = testRun; StartWorkerThread(); }
void THEN_testRun_is_pending(ITestRun testRun) { Assert.Equal(true, testRun.IsPending()); }
public void Execute(ITestRun testRun, ITestListener listener) { Use(listener); try { SafeCurrentDirectory(); if( CreateObject() && FixtureSetUp() ) { foreach( var testMethod in _testMethods ) { if( !testMethod.Ignore ) { if( testRun.Contains(testMethod) && SetUp(testMethod) ) { testMethod.Execute(_testListener); TearDown(testMethod); } } else { _testListener.OnTestSkipped(new TestFixtureInfo(this), new TestResultEventArgs( AssemblyName, FullName, testMethod.Name, testMethod.IgnoreReason, 0){TestResult = TestResultCategory.Skipped}); } } FixtureTearDown(); } } finally { RestoreCurrentDirectory(); } }
public void RunTests(ITestRun testSelection, ITestListener listener) { SetUp(); foreach( var tc in TestFixtures ) { if( testSelection.Contains(tc) ) { if(!tc.IsIgnored) { tc.Execute(testSelection, listener); } else { listener.OnTestSkipped(this, new TestResultEventArgs( FullName, tc.FullName, string.Empty, tc.IgnoreReason, 0)); } } } TearDown(); }