private static Type GetFixtureType(MSTestFixtureTask fixture, IRemoteTaskServer server)
{
string assemblyLocation = fixture.AssemblyLocation;
if (!File.Exists(assemblyLocation))
{
server.TaskError(fixture,
string.Format("Cannot load assembly from {0}: file not exists", assemblyLocation));
return(null);
}
AssemblyName assemblyName = AssemblyName.GetAssemblyName(assemblyLocation);
if (assemblyName == null)
{
server.TaskError(fixture,
string.Format("Cannot load assembly from {0}: not an assembly", assemblyLocation));
return(null);
}
Assembly assembly = Assembly.Load(assemblyName);
if (assembly == null)
{
server.TaskError(fixture, string.Format("Cannot load assembly from {0}", assemblyLocation));
return(null);
}
return(assembly.GetType(fixture.TypeName));
}
public static ISetTempFolderPathStrategy Create(IRemoteTaskServer server)
{
var entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null && IsReSharper80(entryAssembly.GetName().Version))
return new BrokenSetTempFolderPathStrategy(server);
return new SetTempFolderPathStrategy(server);
}
public RemoteTaskWrapper(RemoteTask remoteTask, IRemoteTaskServer server)
{
RemoteTask = remoteTask;
this.server = server;
result = TaskResult.Inconclusive;
}
private TaskResult Finish(IRemoteTaskServer server, CSUnitTestFixtureTask fixture)
{
if (myFixtureTearDown != null)
{
server.TaskProgress(fixture, "Tearing down...");
try
{
TaskExecutor.Invoke(fixture.Instance, myFixtureTearDown);
}
catch (TargetInvocationException e)
{
Exception exception = e.InnerException ?? e;
string message;
Server.TaskException(fixture, TaskExecutor.ConvertExceptions(exception, out message));
Server.TaskFinished(fixture, message, TaskResult.Exception);
return TaskResult.Exception;
}
}
server.TaskProgress(fixture, "");
myTestTearDown = null;
myTestSetUp = null;
myFixtureSetUp = null;
myFixtureTearDown = null;
fixture.Instance = null;
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 RemoteTaskWrapper(RemoteTask remoteTask, IRemoteTaskServer server)
{
RemoteTask = remoteTask;
this.server = server;
result = TaskResult.Inconclusive;
}
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 SimpleTestingTaskRunner(IRemoteTaskServer server)
: base(server)
{
#if DEBUG
MessageBox.ShowInfo(string.Format("Started Task Runner - Attach Debugger to {0}", System.Diagnostics.Process.GetCurrentProcess().ProcessName));
#endif
}
public AdapterFacadeTaskServer(IRemoteTaskServer server)
{
if (server == null)
throw new ArgumentNullException("server");
this.server = server;
remoteTasks = new List<RemoteTask>();
}
private static bool BuildTypeInfo(IRemoteTaskServer server, RemoteTask fixture, Type type)
{
myTestTearDown = null;
myTestSetUp = null;
myFixtureSetUp = null;
myFixtureTearDown = null;
IList<MethodInfo> fixtureSetUp = new List<MethodInfo>();
IList<MethodInfo> fixtureTearDown = new List<MethodInfo>();
IList<MethodInfo> testSetUp = new List<MethodInfo>();
IList<MethodInfo> testTearDown = new List<MethodInfo>();
MethodInfo[] methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
foreach (MethodInfo method in methods)
{
if (IsFixtureSetup(method)) fixtureSetUp.Add(method);
else if (IsFixtureTeardown(method)) fixtureTearDown.Add(method);
else if (IsTestSetup(method)) testSetUp.Add(method);
else if (IsTestTeardown(method)) testTearDown.Add(method);
}
fixtureSetUp = FilterHiddenMethods(fixtureSetUp);
if (fixtureSetUp.Count == 1)
myFixtureSetUp = fixtureSetUp[0];
else if (fixtureSetUp.Count > 1)
{
server.TaskError(fixture, type.Name + " has multiple fixture setup methods");
return false;
}
fixtureTearDown = FilterHiddenMethods(fixtureTearDown);
if (fixtureTearDown.Count == 1)
myFixtureTearDown = fixtureTearDown[0];
else if (fixtureTearDown.Count > 1)
{
server.TaskError(fixture, type.Name + " has multiple fixture teardown methods");
return false;
}
testSetUp = FilterHiddenMethods(testSetUp);
if (testSetUp.Count == 1)
myTestSetUp = testSetUp[0];
else if (testSetUp.Count > 1)
{
server.TaskError(fixture, type.Name + " has multiple test setup methods");
return false;
}
testTearDown = FilterHiddenMethods(testTearDown);
if (testTearDown.Count == 1)
myTestTearDown = testTearDown[0];
else if (testTearDown.Count > 1)
{
server.TaskError(fixture, type.Name + " has multiple test teardown methods");
return false;
}
return true;
}
public RemoteTaskServer(IRemoteTaskServer server, TaskExecutorConfiguration configuration)
{
this.server = SimpleRemoteTaskServerFactory.Create(server);
Configuration = configuration;
clientController = SimpleClientControllerFactory.Create(server);
setTempFolderPathStrategy = SetTempFolderPathStrategyFactory.Create(server);
ShouldContinue = true;
}
public RemoteTaskServer(IRemoteTaskServer server, TaskExecutorConfiguration configuration)
{
this.server = SimpleRemoteTaskServerFactory.Create(server);
Configuration = configuration;
clientController = SimpleClientControllerFactory.Create(server);
setTempFolderPathStrategy = SetTempFolderPathStrategyFactory.Create(server);
ShouldContinue = true;
}
public StorEvilTaskRunner(IRemoteTaskServer server)
: base(server)
{
Logger.Log("StorEvilTaskRunner constructed");
server.ClientMessage("TaskRunner starting");
//_isDebug = server.GetConfiguration().IsInInternalDebug;
_result = TaskResult.Success;
}
public StorEvilTaskRunner(IRemoteTaskServer server)
: base(server)
{
Logger.Log("StorEvilTaskRunner constructed");
server.ClientMessage("TaskRunner starting");
//_isDebug = server.GetConfiguration().IsInInternalDebug;
_result = TaskResult.Success;
}
public AdapterFacadeTaskServer(IRemoteTaskServer server)
{
if (server == null)
{
throw new ArgumentNullException("server");
}
this.server = server;
remoteTasks = new List <RemoteTask>();
}
public TaskEnvironment(IRemoteTaskServer server,
IEnumerable<IAssemblyTaskProvider> assemblyTaskProviders,
IEnumerable<IClassTaskProvider> classTaskProviders,
IEnumerable<IMethodTaskProvider> methodTaskProviders)
{
Server = server;
AssemblyTaskProviders = assemblyTaskProviders;
ClassTaskProviders = classTaskProviders;
MethodTaskProviders = methodTaskProviders;
}
public static ISetTempFolderPathStrategy Create(IRemoteTaskServer server)
{
var entryAssembly = Assembly.GetEntryAssembly();
if (entryAssembly != null && IsReSharper80(entryAssembly.GetName().Version))
{
return(new BrokenSetTempFolderPathStrategy(server));
}
return(new SetTempFolderPathStrategy(server));
}
public TaskEnvironment(IRemoteTaskServer server,
IEnumerable <IAssemblyTaskProvider> assemblyTaskProviders,
IEnumerable <IClassTaskProvider> classTaskProviders,
IEnumerable <IMethodTaskProvider> methodTaskProviders)
{
Server = server;
AssemblyTaskProviders = assemblyTaskProviders;
ClassTaskProviders = classTaskProviders;
MethodTaskProviders = methodTaskProviders;
}
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);
}
public static ISetTempFolderPathStrategy Create(IRemoteTaskServer server)
{
var version = Assembly.GetEntryAssembly().GetName().Version;
// TODO: Handle this better for 8.0.1. Need to know what version 8.0.1 will be
// I'm betting on 8.0.1000-ish
if (version.Major == 8 && version.Minor == 0)
{
return(new BrokenSetTempFolderPathStrategy(server));
}
return(new SetTempFolderPathStrategy(server));
}
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 RemoteScenarioExecutor(IRemoteTaskServer server, AssemblyRegistry assemblyRegistry)
{
_server = server;
_assemblyRegistry = assemblyRegistry;
_sessionContext = new SessionContext(assemblyRegistry);
_eventBus = new EventBus();
_listener = new ResharperResultListener(_server);
_resolver = new MostRecentlyUsedContext();
_runner = BuildInPlaceRunner(_resolver);
_eventBus.Register(_resolver);
_eventBus.Register(_listener);
}
public void Report(IRemoteTaskServer server)
{
if (HasMessages)
{
string description;
if (TaskExecutor.Configuration.IsInInternalDebug)
{
description = "(This message displayed because ReSharper is in Internal mode)";
}
else
{
description = "(This message displayed due to xunit configuration. See app.config or xunit.runner.json)";
}
description += Environment.NewLine + Environment.NewLine + Messages;
server.ShowNotification("The xUnit.net ReSharper runner reported diagnostic messages:", description);
}
}
public void SetUp()
{
var codeGeneration = new CodeGenEventListener();
server = MockRepository.GenerateMock<IRemoteTaskServer>();
var featureFile = MockRepository.GenerateStub<IProjectFile>();
featureFile.Stub(_ => _.Location).Return(new FileSystemPath(Source));
scenarioTask = new NBehaveScenarioTask(featureFile, ScenarioTitle);
var scenarioTaskNode = new TaskExecutionNode(null, scenarioTask);
task = new NBehaveStepTask(featureFile, ScenarioTitle, "Given something");
var stepTaskNode = new TaskExecutionNode(scenarioTaskNode, task);
var nodes = new List<TaskExecutionNode> { scenarioTaskNode, stepTaskNode };
resultPublisher = new ResharperResultPublisher(nodes, server, codeGeneration);
feature = new Narrator.Framework.Feature("feature title");
Because_of();
}
public RemoteScenarioExecutor(IRemoteTaskServer server, AssemblyRegistry assemblyRegistry)
{
_server = server;
_assemblyRegistry = assemblyRegistry;
_sessionContext = new SessionContext(assemblyRegistry);
_eventBus = new EventBus();
new EventBusAutoRegistrar(_assemblyRegistry).InstallTo(_eventBus);
_listener = new ResharperResultListener(_server);
_resolver = new MostRecentlyUsedContext();
_runner = BuildInPlaceRunner(_resolver);
_eventBus.Register(_resolver);
_eventBus.Register(_listener);
ParameterConverter.AddCustomConverters(_assemblyRegistry);
}
public RemoteScenarioExecutor(IRemoteTaskServer server, AssemblyRegistry assemblyRegistry)
{
_server = server;
_assemblyRegistry = assemblyRegistry;
_sessionContext = new SessionContext(assemblyRegistry);
_eventBus = new EventBus();
new EventBusAutoRegistrar(_assemblyRegistry).InstallTo(_eventBus);
_listener = new ResharperResultListener(_server);
_resolver = new MostRecentlyUsedContext();
_runner = BuildInPlaceRunner(_resolver);
_eventBus.Register(_resolver);
_eventBus.Register(_listener);
ParameterConverter.AddCustomConverters(_assemblyRegistry);
}
private TaskResult Start(IRemoteTaskServer server, TaskExecutionNode node, CSUnitTestTask test)
{
var fixture = (CSUnitTestFixtureTask) 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;
}
string ignoreReason;
if (IsIgnored(testMI, out ignoreReason) && !test.Explicitly)
{
server.TaskFinished(test, ignoreReason, TaskResult.Skipped);
return TaskResult.Skipped;
}
if (myTestSetUp != null)
{
server.TaskProgress(test, "Setting up...");
try
{
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 void SetUp()
{
var codeGeneration = new CodeGenEventListener();
server = MockRepository.GenerateMock <IRemoteTaskServer>();
var featureFile = MockRepository.GenerateStub <IProjectFile>();
featureFile.Stub(_ => _.Location).Return(new FileSystemPath(Source));
scenarioTask = new NBehaveScenarioTask(featureFile, ScenarioTitle);
var scenarioTaskNode = new TaskExecutionNode(null, scenarioTask);
task = new NBehaveStepTask(featureFile, ScenarioTitle, "Given something");
var stepTaskNode = new TaskExecutionNode(scenarioTaskNode, task);
var nodes = new List <TaskExecutionNode> {
scenarioTaskNode, stepTaskNode
};
resultPublisher = new ResharperResultPublisher(nodes, server, codeGeneration);
feature = new Narrator.Framework.Feature("feature title");
Because_of();
}
private TaskResult Finish(IRemoteTaskServer server, TaskExecutionNode node, CSUnitTestTask test)
{
var fixture = (CSUnitTestFixtureTask) node.Parent.RemoteTask;
if (myTestTearDown != null)
{
server.TaskProgress(test, "Tearing down...");
try
{
TaskExecutor.Invoke(fixture.Instance, myTestTearDown);
}
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;
}
}
server.TaskProgress(test, "");
return TaskResult.Success;
}
public BrokenSetTempFolderPathStrategy(IRemoteTaskServer server)
{
this.server = server;
}
public BrokenSetTempFolderPathStrategy(IRemoteTaskServer server)
{
this.server = server;
}
public ScenarioExecutor(IRemoteTaskServer server, IStoryContextFactory factory)
{
_server = server;
_factory = factory;
}
public RunMethodRunner(IRemoteTaskServer server)
: base(server)
{
}
public static ISimpleRemoteTaskServer Create(IRemoteTaskServer server)
{
return new SimpleRemoteTaskServer(server);
}
public ResharperResultListener(IRemoteTaskServer server)
{
_server = server;
}
public PerAssemblyRunListener(IRemoteTaskServer server, RunAssemblyTask runAssemblyTask)
{
_server = server;
_runAssemblyTask = runAssemblyTask;
}
public SilverlightUnitTestTaskRunner(IRemoteTaskServer server)
: base(server)
{
}
public PerAssemblyRunListener(IRemoteTaskServer server, RunAssemblyTask runAssemblyTask)
{
_server = server;
_runAssemblyTask = runAssemblyTask;
}
public PerContextRunListener(IRemoteTaskServer server, RemoteTask contextNode)
{
_server = server;
_contextTask = contextNode;
}
public ReSharperRunListener(IRemoteTaskServer server, IDictionary <IIdentity, Task> taskDictionary)
{
_server = server;
_taskDictionary = taskDictionary;
}
public ReSharperRunnerLogger(IRemoteTaskServer server, XunitTestClassTask classTask)
{
this.server = server;
this.classTask = classTask;
}
public SilverlightUnitTestTaskRunner(IRemoteTaskServer server)
: base(server)
{
}
public KarmaTestRunner(IRemoteTaskServer server)
: base(server)
{
}
public FixieListener(IRemoteTaskServer server, NodeRunner nodeRunner, bool isParameterized)
{
this.server = server;
this.nodeRunner = nodeRunner;
this.isParameterized = isParameterized;
}
public TestRunner(IRemoteTaskServer server)
{
this.server = server;
RunContext = new RunContext(server);
}
public LegacySimpleRemoteTaskServer(IRemoteTaskServer server)
{
this.server = server;
}
public XunitTaskRunner(IRemoteTaskServer server)
: base(server)
{
taskServer = new RemoteTaskServer(server, TaskExecutor.Configuration);
testRunner = new TestRunner(taskServer);
}
public RecursiveMSpecTaskRunner(IRemoteTaskServer server)
: base(server)
{
}
public XunitTaskRunner(IRemoteTaskServer server)
: base(server)
{
testRunner = new TestRunner(server);
}
public FacadeTaskRunner(IRemoteTaskServer server)
: base(server)
{
executeResult = TaskResult.Error;
}
public static ISimpleClientController Create(IRemoteTaskServer server)
{
return new NullSimpleClientController();
}
public RunContext(IRemoteTaskServer server)
{
this.server = server;
ShouldContinue = true;
}
public static ISimpleClientController Create(IRemoteTaskServer server)
{
return new LegacySimpleClientController(server);
}
public MspecTaskRunner(IRemoteTaskServer server)
: base(server)
{
_testRunner = new TestRunner(server);
}
public static ISimpleRemoteTaskServer Create(IRemoteTaskServer server)
{
return(new SimpleRemoteTaskServer(server));
}
public RecursiveMSpecTaskRunner(IRemoteTaskServer server) : base(server)
{
}
public TaskRunner(IRemoteTaskServer server)
: base(server)
{
}
public TaskRunner(IRemoteTaskServer server)
: base(server)
{
}
public ReSharperListener(IRemoteTaskServer server)
{
_server = server;
}
