public RemoteTaskNotification CreateTaskNotification(TaskExecutionNode node) { var remoteTask = node.RemoteTask; if (remoteTask is RunAssemblyTask) { return(new AssemblyRemoteTaskNotification(node)); } if (remoteTask is ContextTask) { return(new ContextRemoteTaskNotification(node)); } if (remoteTask is ContextSpecificationTask) { return(new ContextSpecificationRemoteTaskNotification(node)); } if (remoteTask is BehaviorSpecificationTask) { return(new BehaviorSpecificationRemoteTaskNotification(node)); } return(new SilentRemoteTaskNotification()); }
public override void ExecuteRecursive(TaskExecutionNode node) { //Debugger.Break(); var assemblyProviders = new IAssemblyTaskProvider[] { new MsTestAssemblyTaskProvider(), new NUnitAssemblyTaskProvider(), new XUnitAssemblyTaskProvider() }; var classProviders = new IClassTaskProvider[] { new MsTestClassTaskProvider(), new NUnitClassTaskProvider(), new XUnitClassTaskProvider() }; var methodProviders = new IMethodTaskProvider[] { new MsTestMethodTaskProvider(), new NUnitMethodTaskProvider(), new XUnitMethodTaskProvider() }; var taskEnvironment = new TaskEnvironment(Server, assemblyProviders, classProviders, methodProviders); var taskNode = new TaskNode(node, taskEnvironment); foreach (var silverlightTaskNode in taskNode.GetSilverlightTasks()) { silverlightTaskNode.Execute(Execute); } }
public override TaskResult Start(TaskExecutionNode node) { var task = (RunAssemblyTask) node.RemoteTask; _contextAssembly = LoadContextAssembly(task); if (_contextAssembly == null) { return TaskResult.Error; } var result = VersionCompatibilityChecker.Check(_contextAssembly); if (!result.Success) { Server.TaskExplain(task, result.Explanation); Server.TaskError(task, result.ErrorMessage); return TaskResult.Error; } _listener = new PerAssemblyRunListener(Server, task); _runner = new DefaultRunner(_listener, RunOptions.Default, false); return TaskResult.Success; }
public RemoteTaskNotification CreateTaskNotification(TaskExecutionNode node, ICollection <string> contexts) { var remoteTask = node.RemoteTask; if (remoteTask is RunAssemblyTask) { return(new AssemblyRemoteTaskNotification(node)); } if (remoteTask is ContextTask) { contexts.Add(((ContextTask)remoteTask).ContextTypeName); return(new ContextRemoteTaskNotification(node)); } if (remoteTask is ContextSpecificationTask) { return(new ContextSpecificationRemoteTaskNotification(node)); } if (remoteTask is BehaviorSpecificationTask) { return(new BehaviorSpecificationRemoteTaskNotification(node)); } return(new SilentRemoteTaskNotification()); }
private ExecutionResult ExecuteRecursiveInternal(TaskExecutionNode node) { Server.TaskStarting(node.RemoteTask); ExecutionResult result; try { if (node.RemoteTask is RunProjectTask) SetUpScenarioExecutorForCurrentProject(node); if (node.RemoteTask is RunScenarioTask) result = ExecuteScenario(node); else result = ExecuteChildTasks(node); } catch (Exception ex) { Logger.Log(ex.ToString()); Server.TaskOutput(node.RemoteTask, ex + "\r\n", TaskOutputType.STDOUT); result = new ExecutionResult(TaskResult.Error, ex.ToString()); } if (!(node.RemoteTask is RunProjectTask)) Server.TaskFinished(node.RemoteTask, result.Message, result.Status); return result; }
void TryRegisterSpecifications(TaskExecutionNode node) { if (node.RemoteTask is ContextSpecificationTask) { _listener.RegisterSpecification(new ExecutableSpecificationInfo(node)); } }
/// <summary> /// Recursively maps a tree of task execution nodes to facade tasks. /// </summary> /// <remarks> /// <para> /// The server will retain references to the nodes and the tasks for the /// duration of its lifetime so that it can perform an inverse mapping as /// required. /// </para> /// </remarks> /// <param name="node">The execution node to map.</param> /// <returns>The facade task tree.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="node"/> is null.</exception> public FacadeTask MapTasks(TaskExecutionNode node) { if (node == null) { throw new ArgumentNullException("node"); } var remoteTask = node.RemoteTask as FacadeTaskWrapper; #if RESHARPER_60_OR_NEWER var facadeTask = remoteTask == null ? new NullFacadeTask() : remoteTask.FacadeTask; #else var facadeTask = remoteTask.FacadeTask; #endif facadeTask.RemoteTaskHandle = remoteTasks.Count; remoteTasks.Add(remoteTask); foreach (TaskExecutionNode child in node.Children) { facadeTask.AddChild(MapTasks(child)); } return(facadeTask); }
public RemoteTaskNotification CreateTaskNotification(TaskExecutionNode node, ICollection<string> contexts) { var remoteTask = node.RemoteTask; if (remoteTask is RunAssemblyTask) { return new AssemblyRemoteTaskNotification(node); } if (remoteTask is ContextTask) { contexts.Add(((ContextTask)remoteTask).ContextTypeName); return new ContextRemoteTaskNotification(node); } if (remoteTask is ContextSpecificationTask) { return new ContextSpecificationRemoteTaskNotification(node); } if (remoteTask is BehaviorSpecificationTask) { return new BehaviorSpecificationRemoteTaskNotification(node); } return new SilentRemoteTaskNotification(); }
private static string GetName(TaskExecutionNode node) { var test = node.RemoteTask as TestTask; if (test != null) return test.Name; return null; }
private TaskExecutionNode CreateMethodNode(TaskExecutionNode classNode, Method method) { var methodNode = new TaskExecutionNode(classNode, method.Task); foreach (var theoryTask in method.TheoryTasks) methodNode.Children.Add(new TaskExecutionNode(methodNode, theoryTask)); return methodNode; }
public override TaskResult Start(TaskExecutionNode node) { ContextTask task = (ContextTask) node.RemoteTask; _contextAssembly = LoadContextAssembly(task); if (_contextAssembly == null) { return TaskResult.Error; } _contextClass = _contextAssembly.GetType(task.ContextTypeName); if (_contextClass == null) { Server.TaskExplain(node.RemoteTask, String.Format("Could not load type '{0}' from assembly {1}.", task.ContextTypeName, task.AssemblyLocation)); Server.TaskError(node.RemoteTask, "Could not load context"); return TaskResult.Error; } _listener = new PerContextRunListener(Server, node.RemoteTask); _runner = new DefaultRunner(_listener, RunOptions.Default); return TaskResult.Success; }
public override TaskResult Start(TaskExecutionNode node) { var task = (RunAssemblyTask)node.RemoteTask; _contextAssembly = LoadContextAssembly(task); if (_contextAssembly == null) { return(TaskResult.Error); } var result = VersionCompatibilityChecker.Check(_contextAssembly); if (!result.Success) { Server.TaskExplain(task, result.Explanation); Server.TaskError(task, result.ErrorMessage); return(TaskResult.Error); } _listener = new PerAssemblyRunListener(Server, task); _runner = new DefaultRunner(_listener, RunOptions.Default); _runScope = GetRunScope(_runner); return(TaskResult.Success); }
public static void Report(XDocument doc, IRemoteTaskServer server, TaskExecutionNode node) { var testCases = Parse(doc); if (testCases == null) { return; } var testNodes = from n in node.Flatten(x => x.Children) where n.RemoteTask is TestTask select n; foreach (var testNode in testNodes) { var key = GetFullName(testNode); if (!testCases.ContainsKey(key)) { continue; } var testCase = testCases[key]; var task = testNode.RemoteTask; #if RESHARPER_8 if (testCase.Duration != null) { server.TaskDuration(task, testCase.Duration.Value); } #endif server.TaskFinished(task, testCase.Error, testCase.TaskResult); } }
public RemoteTaskNotification CreateTaskNotification(TaskExecutionNode node) { var remoteTask = node.RemoteTask; if (remoteTask is RunAssemblyTask) { return new AssemblyRemoteTaskNotification(node); } if (remoteTask is ContextTask) { return new ContextRemoteTaskNotification(node); } if (remoteTask is ContextSpecificationTask) { return new ContextSpecificationRemoteTaskNotification(node); } if (remoteTask is BehaviorSpecificationTask) { return new BehaviorSpecificationRemoteTaskNotification(node); } return new SilentRemoteTaskNotification(); }
public override void ExecuteRecursive(TaskExecutionNode node) { var task = node.RemoteTask as TestTask; if (task == null) { return; } var projectFolder = task.ProjectFolder; Action job = () => { // TODO split tasks by project and e2e var confFile = KarmaConfig.Build(projectFolder, Enumerable.Empty <string>(), false); if (!StartKarma(projectFolder, confFile)) { return; } // notify task server var doc = LoadResults(projectFolder, false); JUnitReporter.Report(doc, Server, node); }; job.BeginInvoke(null, null); }
public override void ExecuteRecursive(TaskExecutionNode node) { var task = (RunAssemblyTask)node.RemoteTask; var priorCurrentDirectory = Environment.CurrentDirectory; try { // Use the assembly in the folder that the user has specified, or, if not, use the assembly location var assemblyFolder = GetAssemblyFolder(TaskExecutor.Configuration, task); var assemblyPath = new AssemblyPath(Path.Combine(assemblyFolder, GetFileName(task.AssemblyLocation))); Environment.CurrentDirectory = assemblyFolder; var listener = new PerAssemblyRunListener(Server, task); var contextList = new List<string>(); node.Flatten(x => x.Children).Each(children => RegisterRemoteTaskNotifications(listener, children, contextList)); var runOptions = RunOptions.Custom.FilterBy(contextList); var appDomainRunner = new AppDomainRunner(listener, runOptions); if (TaskExecutor.Configuration.ShadowCopy) { string cachePath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); runOptions.ShadowCopyTo(cachePath); this.Server.SetTempFolderPath(cachePath); } appDomainRunner.RunAssembly(assemblyPath); } finally { Environment.CurrentDirectory = priorCurrentDirectory; } }
private TaskExecutionNode CreateTaskNodes() { var assemblyNode = new TaskExecutionNode(null, null); foreach (var @class in Classes) assemblyNode.Children.Add(CreateClassNode(assemblyNode, @class)); return assemblyNode; }
public static void Report(XDocument doc, IRemoteTaskServer server, TaskExecutionNode node) { var testCases = Parse(doc); if (testCases == null) return; var testNodes = from n in node.Flatten(x => x.Children) where n.RemoteTask is TestTask select n; foreach (var testNode in testNodes) { var key = GetFullName(testNode); if (!testCases.ContainsKey(key)) continue; var testCase = testCases[key]; var task = testNode.RemoteTask; #if RESHARPER_8 if (testCase.Duration != null) { server.TaskDuration(task, testCase.Duration.Value); } #endif server.TaskFinished(task, testCase.Error, testCase.TaskResult); } }
private void SetUpScenarioExecutorForCurrentProject(TaskExecutionNode node) { var projectTask = node.RemoteTask as RunProjectTask; var assemblyRegistry = new AssemblyRegistry(projectTask.Assemblies.Union(new[] { typeof(Scenario).Assembly.Location })); _executor = new RemoteScenarioExecutor(Server, assemblyRegistry); }
private IIntent CreateIntent (TaskExecutionNode node) { var task = (Task) node.RemoteTask; var intent = Intent.Create(task.Identity); node.Children.Select(CreateIntent).ForEach(intent.AddIntent); return intent; }
public override TaskResult Execute(TaskExecutionNode node) { RemoteTask task = node.RemoteTask; if (task is CSUnitTestFixtureTask) return TaskResult.Success; if (task is CSUnitTestTask) return Execute(Server, node, (CSUnitTestTask) task); return TaskResult.Error; }
private IIntent CreateIntent(TaskExecutionNode node) { var task = (Task)node.RemoteTask; var intent = Intent.Create(task.Identity); node.Children.Select(CreateIntent).ForEach(intent.AddIntent); return(intent); }
public TaskNode(TaskExecutionNode node, TaskEnvironment environment, TaskNode parent = null) { Task = node.RemoteTask; Environment = environment; Parent = parent; Status = TaskStatus.NotStarted; Result = TaskResult.Skipped; Children = node.Children.Select(child => new TaskNode(child, environment, this)).ToArray(); }
private TaskExecutionNode CreateMethodNode(TaskExecutionNode classNode, Method method) { var methodNode = new TaskExecutionNode(classNode, method.Task); foreach (var theoryTask in method.TheoryTasks) { methodNode.Children.Add(new TaskExecutionNode(methodNode, theoryTask)); } return(methodNode); }
private TaskExecutionNode CreateTaskNodes() { var assemblyNode = new TaskExecutionNode(null, null); foreach (var @class in Classes) { assemblyNode.Children.Add(CreateClassNode(assemblyNode, @class)); } return(assemblyNode); }
private static TaskResult Execute(IRemoteTaskServer server, TaskExecutionNode node, MSTestTask test) { var fixture = (MSTestFixtureTask)node.Parent.RemoteTask; object instance = fixture.Instance; Type type = instance.GetType(); MethodInfo testMI = type.GetMethod(test.TestMethod, new Type[0]); if (testMI == null) { server.TaskError(test, string.Format("Cannot find test method '{0}'", test.TestMethod)); return(TaskResult.Error); } server.TaskProgress(test, ""); string expectedExceptionType; GetExpectedException(testMI, out expectedExceptionType); Exception exception = null; try { TaskExecutor.Invoke(instance, testMI); } catch (TargetInvocationException e) { exception = e.InnerException ?? e; } // if (exception != null && exception.GetType().FullName == "csUnit.IgnoreException") // { // server.TaskFinished(test, exception.Message, TaskResult.Skipped); // return TaskResult.Skipped; // } if (expectedExceptionType != null && exception == null) { // failed, exception expected but not thrown server.TaskError(test, string.Format("Expected exception '{0}' was not thrown", expectedExceptionType)); return(TaskResult.Error); } if (expectedExceptionType != null && expectedExceptionType == exception.GetType().FullName) { return(TaskResult.Success); } if (exception != null) { if (exception.GetType().FullName == "Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException") { exception = new MSTestExceptionAdapter(exception); } throw new TargetInvocationException(exception); } return(TaskResult.Success); }
private IRunIntent CreateRunIntent(TaskExecutionNode node) { var configuration = TaskExecutor.Configuration; var runTask = (RunTask)node.RemoteTask; var runIntent = RunIntent.Create(configuration.SeparateAppDomain, configuration.ShadowCopy, runTask.VisualStudioProcessId); node.Children.Select(CreateIntent).ForEach(runIntent.AddIntent); return(runIntent); }
private static string GetName(TaskExecutionNode node) { var test = node.RemoteTask as TestTask; if (test != null) { return(test.Name); } return(null); }
private TaskExecutionNode CreateClassNode(TaskExecutionNode assemblyNode, Class @class) { var classNode = new TaskExecutionNode(assemblyNode, @class.ClassTask); if (ShouldAddMethods(@class)) { foreach (var method in @class.Methods) classNode.Children.Add(CreateMethodNode(classNode, method)); } return classNode; }
public override void ExecuteRecursive(TaskExecutionNode node) { var bootstrapTask = (XunitBootstrapTask)node.RemoteTask; var assemblyTaskNode = node.Children[0]; var assemblyTask = (XunitTestAssemblyTask)assemblyTaskNode.RemoteTask; PopulateRunContext(testRunner.RunContext, assemblyTaskNode); testRunner.Run(assemblyTask, bootstrapTask.DisableAllConcurrency); }
public override void ExecuteRecursive(TaskExecutionNode node) { try { _result = ExecuteRecursiveInternal(node).Status; } catch (Exception ex) { Logger.Log(ex.ToString()); } }
private ExecutionResult ExecuteScenario(TaskExecutionNode scenarioNode) { var remoteTask = scenarioNode.RemoteTask; var scenarioOrOutline = ((RunScenarioTask)remoteTask).GetScenario(); var scenario = scenarioOrOutline as Scenario; if (null != scenario) { return(new ExecutionResult(_executor.Execute(scenarioNode.RemoteTask), "")); } return(new ExecutionResult(TaskResult.Success, "")); }
static IEnumerable <TaskExecutionNode> FlattenChildren(TaskExecutionNode node) { foreach (var child in node.Children) { yield return(child); foreach (var descendant in child.Children) { yield return(descendant); } } }
public override void ExecuteRecursive(TaskExecutionNode node) { var asm = node.RemoteTask as NBehaveAssemblyTask; if (asm == null) return; Initialize(node); var featureTasks = GetFeatureTasks(node); NotifyTasksStarting(featureTasks.ToList()); var runner = new TextRunner(config); runner.Run(); }
private void ExecuteLoadContextAssemblyTask(TaskExecutionNode node) { var lcat = node.RemoteTask as LoadContextAssemblyTask; var path = lcat.AssemblyPath; if (!_loadedAssemblies.Contains(path)) { _loadedAssemblies.Add(path); _loader.RegisterAssembly(Assembly.LoadFrom(path)); } }
private void CanExecuteRecursive() { var remoteTaskServer = Substitute.For<IRemoteTaskServer>(); var taskRunner = new TaskRunner(remoteTaskServer); var remoteTask = Substitute.For<RemoteTask>("RemoteTask"); var node = new TaskExecutionNode(null, remoteTask); taskRunner.ExecuteRecursive(node); remoteTaskServer.Received().TaskStarting(Arg.Any<RemoteTask>()); remoteTaskServer.Received().TaskFinished(Arg.Any<RemoteTask>(), Arg.Any<string>(), TaskResult.Success); }
static IEnumerable<TaskExecutionNode> FlattenChildren(TaskExecutionNode node) { foreach (var child in node.Children) { yield return child; foreach (var descendant in child.Children) { yield return descendant; } } }
private IRunIntent CreateRunIntent (TaskExecutionNode node) { var configuration = TaskExecutor.Configuration; var runTask = (RunTask) node.RemoteTask; var runIntent = RunIntent.Create(configuration.SeparateAppDomain, configuration.ShadowCopy, runTask.VisualStudioProcessId); _cancellationTokenSource = runIntent.CancellationTokenSource; node.Children.Select(CreateIntent).ForEach(runIntent.AddIntent); return runIntent; }
public override TaskResult Execute(TaskExecutionNode node) { if (node.RemoteTask is RunScenarioTask) { var result = ExecuteScenario(node); if (result.Status != TaskResult.Success) _result = result.Status; return result.Status; } return TaskResult.Success; }
private TaskExecutionNode CreateClassNode(TaskExecutionNode assemblyNode, Class @class) { var classNode = new TaskExecutionNode(assemblyNode, @class.ClassTask); if (ShouldAddMethods(@class)) { foreach (var method in @class.Methods) { classNode.Children.Add(CreateMethodNode(classNode, method)); } } return(classNode); }
public override TaskResult Finish(TaskExecutionNode node) { RemoteTask task = node.RemoteTask; if (task is CSUnitTestFixtureTask) { return Finish(Server, (CSUnitTestFixtureTask)task); } if (task is CSUnitTestTask) { return Finish(Server, node, (CSUnitTestTask)task); } return TaskResult.Error; }
public override void ExecuteRecursive(TaskExecutionNode node) { try { Logger.Log("ExecuteRecursive"); Logger.Log(node.RemoteTask.RunnerID); _result = ExecuteRecursiveInternal(node).Status; } catch (Exception ex) { Logger.Log(ex.ToString()); } }
private void CanExecuteRecursive() { var remoteTaskServer = Substitute.For <IRemoteTaskServer>(); var taskRunner = new TaskRunner(remoteTaskServer); var remoteTask = Substitute.For <RemoteTask>("RemoteTask"); var node = new TaskExecutionNode(null, remoteTask); taskRunner.ExecuteRecursive(node); remoteTaskServer.Received().TaskStarting(Arg.Any <RemoteTask>()); remoteTaskServer.Received().TaskFinished(Arg.Any <RemoteTask>(), Arg.Any <string>(), TaskResult.Success); }
public override void ExecuteRecursive(TaskExecutionNode node) { var runMethodTask = node.RemoteTask as RunMethodTask; if (runMethodTask == null) return; var result = TaskResult.Skipped; var message = string.Empty; string output = null; try { var assembly = Assembly.LoadFrom(runMethodTask.AssemblyLocation); var type = assembly.GetType(runMethodTask.ClassName); if (runMethodTask.IsClassStatic) { var res = type.InvokeMember(runMethodTask.MethodName, BindingFlags.InvokeMethod, null, null, null); if (res != null) output = res.ToString(); } else { var obj = Activator.CreateInstance(type); var flags = BindingFlags.InvokeMethod | BindingFlags.Public; if (runMethodTask.IsMethodStatic) flags |= BindingFlags.Static; else flags |= BindingFlags.Instance; var res = type.InvokeMember(runMethodTask.MethodName, flags, null, obj, null); if (res != null) output = res.ToString(); } result = TaskResult.Success; } catch (Exception e) { var exceptions = TaskExecutor.ConvertExceptions(e, out message); Server.TaskException(runMethodTask, exceptions); result = TaskResult.Exception; } finally { if (!string.IsNullOrEmpty(output)) { Server.TaskOutput(runMethodTask, output, TaskOutputType.STDOUT); Trace.WriteLine(output.FirstOrDefault().ToString()); } Server.TaskFinished(runMethodTask, message, result); } }
public override TaskResult Finish(TaskExecutionNode node) { RemoteTask task = node.RemoteTask; if (task is MSTestFixtureTask) { return(Finish(Server, (MSTestFixtureTask)task)); } if (task is MSTestTask) { return(Finish(Server, node, (MSTestTask)task)); } return(TaskResult.Error); }
private void ExecuteSilverlightTasks(TaskExecutionNode node) { var assemblyTaskProviders = UnitTestTaskProviderFactory.GetAssemblyTaskProviders(); var classTaskProviders = UnitTestTaskProviderFactory.GetClassTaskProviders(); var methodTaskProviders = UnitTestTaskProviderFactory.GetMethodTaskProviders(); var taskEnvironment = new TaskEnvironment(Server, assemblyTaskProviders, classTaskProviders, methodTaskProviders); var taskNode = new TaskNode(node, taskEnvironment); foreach (var silverlightTaskNode in taskNode.GetSilverlightTasks()) { silverlightTaskNode.Execute(Execute); } }
private TaskResult Start(IRemoteTaskServer server, TaskExecutionNode node, MSTestTask test) { var fixture = (MSTestFixtureTask)node.Parent.RemoteTask; object instance = fixture.Instance; Type type = instance.GetType(); MethodInfo testMI = type.GetMethod(test.TestMethod, new Type[0]); if (testMI == null) { server.TaskError(test, string.Format("Cannot find test method '{0}'", test.TestMethod)); return(TaskResult.Error); } if (IsIgnored(testMI) && !test.Explicitly) { server.TaskFinished(test, null, TaskResult.Skipped); return(TaskResult.Skipped); } if (myTestSetUp != null) { server.TaskProgress(test, "Setting up..."); try { if (myTestSetUp.GetParameters().Length == 1) { var testContext = new object[] { null }; TaskExecutor.Invoke(fixture.Instance, myTestSetUp, testContext); } else { TaskExecutor.Invoke(fixture.Instance, myTestSetUp); } } catch (TargetInvocationException e) { Exception exception = e.InnerException ?? e; string message; Server.TaskException(test, TaskExecutor.ConvertExceptions(exception, out message)); Server.TaskFinished(test, message, TaskResult.Exception); return(TaskResult.Exception); } } return(TaskResult.Success); }
public override void ExecuteRecursive(TaskExecutionNode node) { //Debugger.Break(); try { ExecuteSilverlightTasks(node); } catch (Exception e) { MessageBox.ShowError(e.ToString(), "AgUnit: Exception during test run"); throw; } }
sealed public override void ExecuteRecursive(TaskExecutionNode node) { AdapterFacadeTaskServer facadeTaskServer = new AdapterFacadeTaskServer(Server); AdapterFacadeLogger facadeLogger = new AdapterFacadeLogger(); FacadeTaskExecutorConfiguration facadeTaskExecutorConfiguration = new FacadeTaskExecutorConfiguration() { ShadowCopy = TaskExecutor.Configuration.ShadowCopy, AssemblyFolder = TaskExecutor.Configuration.AssemblyFolder }; FacadeTask facadeTask = facadeTaskServer.MapTasks(node); executeResult = FacadeUtils.ToTaskResult(Execute(facadeTaskServer, facadeLogger, facadeTask, facadeTaskExecutorConfiguration)); }
private void Initialize(TaskExecutionNode node) { config = NBehaveConfiguration.New; var codeGenListener = new CodeGenEventListener(); var resharperResultNotifier = new ResharperResultPublisher(node.Children, Server, codeGenListener); var listener = new NBehaveTaskRunnerListener(resharperResultNotifier); var files = node.Children.Select(_ => ((NBehaveFeatureTask)_.RemoteTask).FeatureFile).Distinct().ToList(); var asm = (NBehaveAssemblyTask)node.RemoteTask; var assemblies = new[] { asm.AssemblyFile }; var eventListener = new MultiOutputEventListener(codeGenListener, listener); ModifyConfig(files, assemblies, eventListener); }
public override void ExecuteRecursive(TaskExecutionNode node) { //System.Diagnostics.Debugger.Launch(); try { ExecuteSilverlightTasks(node); } catch (Exception e) { MessageBox.ShowError(e.ToString(), "AgUnit: Exception during test run"); throw; } }
private static void PopulateRunContext(RunContext runContext, TaskExecutionNode assemblyTaskNode) { foreach (var classNode in assemblyTaskNode.Children) { runContext.Add((XunitTestClassTask)classNode.RemoteTask); foreach (var methodNode in classNode.Children) { runContext.Add((XunitTestMethodTask)methodNode.RemoteTask); foreach (var theoryNode in methodNode.Children) { runContext.Add((XunitTestTheoryTask)theoryNode.RemoteTask); } } } }
public override void ExecuteRecursive(TaskExecutionNode node) { var assemblyTask = node.RemoteTask as MspecTestAssemblyTask; if (assemblyTask == null) { return; } var context = new TestContext(assemblyTask); PopulateContext(context, node); _testRunner.Run(context); }
private static string GetFullName(TaskExecutionNode node) { // using karma-junit-reporter convention var fullname = ""; while (node != null) { var name = GetName(node); if (string.IsNullOrEmpty(name)) break; fullname = string.IsNullOrEmpty(fullname) ? name : name + " " + fullname; node = node.Parent; } return fullname.Replace('.', '_'); }
public override TaskResult Start(TaskExecutionNode node) { var task = (ContextSpecificationTask)node.RemoteTask; _contextAssembly = LoadContextAssembly(task); if (_contextAssembly == null) { return TaskResult.Error; } // var result = VersionCompatibilityChecker.Check(_contextAssembly); // if (!result.Success) // { // Server.TaskExplain(task, result.Explanation); // Server.TaskError(task, result.ErrorMessage); // // return TaskResult.Error; // } _contextClass = _contextAssembly.GetType(task.ContextTypeName); if (_contextClass == null) { Server.TaskExplain(task, String.Format("Could not load type '{0}' from assembly {1}.", task.ContextTypeName, task.AssemblyLocation)); Server.TaskError(node.RemoteTask, "Could not load context"); return TaskResult.Error; } _member = _contextClass.GetField(task.SpecificationFieldName, BindingFlags.Instance | BindingFlags.Public); if(_member == null) { Server.TaskExplain(task, String.Format("Could not find specification '{0}' in type {1} from assembly {2}.", task.SpecificationFieldName, task.ContextTypeName, task.AssemblyLocation)); Server.TaskError(node.RemoteTask, "Could not find specification"); return TaskResult.Error; } Server.TaskStarting(task); return TaskResult.Success; }
public override void ExecuteRecursive(TaskExecutionNode node) { var remoteTask = node.RemoteTask; Server.TaskProgress(remoteTask, null); var runResult = SimpleRunner.RunMember(_member); Server.TaskOutput(remoteTask, runResult.Message, TaskOutputType.STDOUT); var taskResult = TaskResult.Success; var message = string.Empty; if (!runResult.Passed) { if (runResult.Thrown != null) { message += runResult.Message + Environment.NewLine; Server.TaskExplain(remoteTask, runResult.Message); Server.TaskException(remoteTask, new[] { new TaskException(runResult.Thrown) }); } foreach (var expectation in runResult.Expectations.Where(e => !e.Passed)) { message += expectation.Text + Environment.NewLine; Server.TaskExplain(remoteTask, expectation.Text); Server.TaskException(remoteTask, new[] { new TaskException(expectation.Exception) }); } taskResult = TaskResult.Exception; } else { foreach (var expectation in runResult.Expectations) { message += expectation.Text + Environment.NewLine; Server.TaskExplain(remoteTask, expectation.Text); } } Server.TaskFinished(remoteTask, message, taskResult); _taskResult = taskResult; }
public override void ExecuteRecursive(TaskExecutionNode node) { //Debugger.Break(); var assemblyTaskProviders = UnitTestTaskProviderFactory.GetAssemblyTaskProviders(); var classTaskProviders = UnitTestTaskProviderFactory.GetClassTaskProviders(); var methodTaskProviders = UnitTestTaskProviderFactory.GetMethodTaskProviders(); var taskEnvironment = new TaskEnvironment(Server, assemblyTaskProviders, classTaskProviders, methodTaskProviders); var taskNode = new TaskNode(node, taskEnvironment); foreach (var silverlightTaskNode in taskNode.GetSilverlightTasks()) { silverlightTaskNode.Execute(Execute); } }
void RunContext(TaskExecutionNode node) { var task = (ContextTask) node.RemoteTask; _contextClass = _contextAssembly.GetType(task.ContextTypeName); if (_contextClass == null) { Server.TaskExplain(task, String.Format("Could not load type '{0}' from assembly {1}.", task.ContextTypeName, task.AssemblyLocation)); Server.TaskError(node.RemoteTask, "Could not load context"); return; } _runner.RunMember(_contextAssembly, _contextClass); }