public void RunAllTestsInAssembly(string pathToAssembly, ISpecificationRunListener specificationRunListener)
{
Assembly assemblyToRun = Assembly.LoadFrom(pathToAssembly);
DefaultRunner mspecRunner = new DefaultRunner(specificationRunListener, RunOptions.Default);
mspecRunner.RunAssembly(assemblyToRun);
}
protected override void Run()
{
IdeApp.Workbench.SaveAll();
var doc = IdeApp.Workbench.ActiveDocument;
var textEditorData = doc.GetContent<ITextEditorDataProvider> ().GetTextEditorData ();
var project = IdeApp.Workspace.GetProjectContainingFile (doc.FileName);
var targetFile = project.GetOutputFileName (project.DefaultConfiguration.Selector).FullPath;
var sourceFile = doc.FileName;
var lineNumber = textEditorData.Caret.Line;
var manager = new ProgressMonitorManager();
var build = manager.GetBuildProgressMonitor ();
IdeApp.ProjectOperations.CurrentSelectedProject.Build(build, project.DefaultConfiguration.Selector);
IdeApp.Workbench.StatusBar.ShowMessage("Executing specifications");
using (var context = IdeApp.Workbench.StatusBar.CreateContext())
{
var kernel = new ConventionKernel ();
var listener = new Listener ();
var runner = new DefaultRunner (listener, new RunOptions (new string[] { }, new string[] { }, new string[] {}));
kernel.Bind<ISpecificationRunner> ().ToConstant (runner);
var executor = kernel.Get<ISpecificationsExecutor> ();
executor.Execute (targetFile, sourceFile, lineNumber);
}
IdeApp.Workbench.StatusBar.ShowMessage ("Specifications executed");
}
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 void RunTestsInAssembly(string pathToAssembly, IEnumerable<string> specsToRun, ISpecificationRunListener specificationRunListener)
{
try
{
Assembly assemblyToRun = Assembly.LoadFrom(pathToAssembly);
DefaultRunner mspecRunner = new DefaultRunner(specificationRunListener, RunOptions.Default);
foreach (string spec in specsToRun)
{
// get the spec type
string[] splits = spec.Split(new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries);
string specClassName = splits[0];
string specFieldName = splits[1];
Type specType = assemblyToRun.GetType(specClassName);
// get the method info from the type
MemberInfo specField = specType.GetMembers(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Public).Where(x => x.Name == specFieldName).SingleOrDefault();
mspecRunner.RunMember(assemblyToRun, specField);
}
}
catch (Exception)
{
throw;
}
}
public AssemblyRunner(ISpecificationRunListener listener, Assembly assembly, RunOptions options)
{
try
{
var runner = new DefaultRunner(listener, options);
runner.RunAssembly(assembly);
}
catch (Exception err)
{
listener.OnFatalError(new ExceptionResult(err));
}
}
public NamespaceRunner(ISpecificationRunListener listener, Assembly assembly, RunOptions options, string targetNamespace)
{
try
{
var runner = new DefaultRunner(listener, options);
runner.RunNamespace(assembly, targetNamespace);
}
catch (Exception err)
{
listener.OnFatalError(new ExceptionResult(err));
}
}
public MemberRunner(ISpecificationRunListener listener, Assembly assembly, RunOptions options, MemberInfo memberInfo)
{
try
{
var runner = new DefaultRunner(listener, options);
runner.RunMember(assembly, memberInfo);
}
catch (Exception err)
{
listener.OnFatalError(new ExceptionResult(err));
}
}
private void Run(string[] args)
{
var commandLine = new CommandLine(args);
var scanner = new VisualStudioAssemblyScanner(services);
var assemblyNames =
libraryManager.GetReferencingLibraries("machine.specifications").SelectMany(l => l.Assemblies);
foreach (var assemblyName in assemblyNames)
{
var assembly = loadContext.Load(assemblyName);
if (commandLine.DesignTime)
{
scanner.SendToVisualStudio(assembly);
var listener = new AggregateRunListener(new ISpecificationRunListener[]
{
new VisualStudioRunListener(services)
});
var runner = new DefaultRunner(listener, RunOptions.Default);
if (commandLine.Tests.Any())
{
var converter = new VisualStudioTestConverter();
var contexts = scanner.GetContexts(assembly);
foreach (var context in contexts)
{
foreach (var specification in context.Specifications)
{
var test = converter.GetVisualStudioTest(context, specification);
if (commandLine.Tests.Any(t => t == test.FullyQualifiedName))
{
runner.RunMember(assembly, specification.FieldInfo);
}
}
}
}
else
{
runner.RunAssembly(assembly);
}
}
else
{
var listener = new AggregateRunListener(new ISpecificationRunListener[]
{
new OutputRunListener(new ColorOutput(new VerboseOutput(new DefaultConsole()))),
});
var runner = new DefaultRunner(listener, RunOptions.Default);
runner.RunAssembly(assembly);
}
}
}
public void RunTestsInAssembly(string pathToAssembly, IEnumerable<VisualStudioTestIdentifier> specsToRun, ISpecificationRunListener specificationRunListener)
{
DefaultRunner mspecRunner = null;
Assembly assemblyToRun = null;
try
{
assemblyToRun = Assembly.LoadFrom(pathToAssembly);
mspecRunner = new DefaultRunner(specificationRunListener, RunOptions.Default);
IEnumerable<Context> specificationContexts = new AssemblyExplorer().FindContextsIn(assemblyToRun) ?? Enumerable.Empty<Context>();
Dictionary<string, Context> contextMap = specificationContexts.ToDictionary(c => c.Type.FullName, StringComparer.Ordinal);
// We use explicit assembly start and end to wrap the RunMember loop
mspecRunner.StartRun(assemblyToRun);
foreach (VisualStudioTestIdentifier test in specsToRun)
{
Context context = contextMap[test.ContainerTypeFullName];
if (context == null)
continue;
Specification specification = context.Specifications.SingleOrDefault(spec => spec.FieldInfo.Name.Equals(test.FieldName, StringComparison.Ordinal));
if (specification is BehaviorSpecification)
{
// MSpec doesn't expose any way to run an an "It" coming from a "[Behavior]", so we have to do some trickery
VisualStudioTestIdentifier listenFor = specification.ToVisualStudioTestIdentifier(context);
DefaultRunner behaviorRunner = new DefaultRunner(new SingleBehaviorTestRunListenerWrapper(specificationRunListener, listenFor), RunOptions.Default);
behaviorRunner.RunMember(assemblyToRun, context.Type);
}
else
{
mspecRunner.RunMember(assemblyToRun, specification.FieldInfo);
}
}
} catch (Exception e) {
specificationRunListener.OnFatalError(new ExceptionResult(e));
}
finally
{
if (mspecRunner != null && assemblyToRun != null)
mspecRunner.EndRun(assemblyToRun);
}
}
static RunScope GetRunScope(DefaultRunner runner)
{
var scope = new RunScope();
var runnerType = runner.GetType();
var startRun = runnerType.GetMethod("StartRun", new[]{typeof(Assembly)});
if (startRun != null)
{
scope.StartRun = asm => startRun.Invoke(runner, new object[] { asm });
}
var endRun = runnerType.GetMethod("EndRun", new[] {typeof(Assembly)});
if (endRun != null)
{
scope.EndRun = asm => endRun.Invoke(runner, new object[] { asm });
}
return scope;
}
private Controller(Action<string> listenCallback, RunOptions runOptions)
{
_listener = new ControllerRunListener(listenCallback);
_explorer = new AssemblyExplorer();
_runner = new DefaultRunner(_listener, runOptions, signalRunStartAndEnd: false);
}
public MemberRunner(ISpecificationRunListener listener, Assembly assembly, RunOptions options, MemberInfo memberInfo)
{
try
{
var runner = new DefaultRunner(listener, options);
runner.RunMember(assembly, memberInfo);
}
catch (Exception err)
{
listener.OnFatalError(new ExceptionResult(err));
}
}
public NamespaceRunner(ISpecificationRunListener listener, Assembly assembly, RunOptions options, string targetNamespace)
{
try
{
var runner = new DefaultRunner(listener, options);
runner.RunNamespace(assembly, targetNamespace);
}
catch (Exception err)
{
listener.OnFatalError(new ExceptionResult(err));
}
}
public AssemblyRunner(ISpecificationRunListener listener, Assembly assembly, RunOptions options)
{
try
{
var runner = new DefaultRunner(listener, options);
runner.RunAssembly(assembly);
}
catch (Exception err)
{
listener.OnFatalError(new ExceptionResult(err));
}
}
public AssemblyRunner(ISpecificationRunListener listener, Assembly assembly, RunOptions options)
{
var runner = new DefaultRunner(listener, options);
runner.RunAssembly(assembly);
}
public MemberRunner(ISpecificationRunListener listener, Assembly assembly, RunOptions options, MemberInfo memberInfo)
{
var runner = new DefaultRunner(listener, options);
runner.RunMember(assembly, memberInfo);
}
public NamespaceRunner(ISpecificationRunListener listener, Assembly assembly, RunOptions options, string targetNamespace)
{
var runner = new DefaultRunner(listener, options);
runner.RunNamespace(assembly, targetNamespace);
}
public void RunTestsInAssembly(string pathToAssembly, IEnumerable<string> specsToRun, ISpecificationRunListener specificationRunListener)
{
DefaultRunner mspecRunner = null;
dynamic dynMSpeccRunner = null;
Assembly assemblyToRun = null;
bool canIndicateStartAndEnd = false;
// determine the mspec version, if its greater or equal to 0.5.12 we can call the start and endrun methods in mspec
string pathToMSpec = Path.Combine(Path.GetDirectoryName(pathToAssembly), "Machine.Specifications.dll");
if (File.Exists(pathToMSpec))
{
FileVersionInfo fileInfo = FileVersionInfo.GetVersionInfo(pathToMSpec);
if (fileInfo.FileMinorPart > 5)
{
canIndicateStartAndEnd = true;
}
else
if (fileInfo.FileMinorPart == 5 && fileInfo.FileBuildPart >= 12)
{
canIndicateStartAndEnd = true;
}
}
try
{
assemblyToRun = Assembly.LoadFrom(pathToAssembly);
mspecRunner = new DefaultRunner(specificationRunListener, RunOptions.Default);
dynMSpeccRunner = mspecRunner;
if (canIndicateStartAndEnd)
{
dynMSpeccRunner.StartRun(assemblyToRun);
}
foreach (string spec in specsToRun)
{
// get the spec type
string[] splits = spec.Split(new string[] { "::" }, StringSplitOptions.RemoveEmptyEntries);
string specClassName = splits[0];
string specFieldName = splits[1];
Type specType = assemblyToRun.GetType(specClassName);
// get the method info from the type
MemberInfo specField = specType.GetMembers(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Public).Where(x => x.Name == specFieldName).SingleOrDefault();
mspecRunner.RunMember(assemblyToRun, specField);
}
}
catch (Exception)
{
throw;
}
finally
{
if (mspecRunner != null && assemblyToRun != null)
{
if (canIndicateStartAndEnd)
{
dynMSpeccRunner.EndRun(assemblyToRun);
}
mspecRunner = null;
dynMSpeccRunner = null;
assemblyToRun = null;
}
}
}
