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