TestModel PopulateTestTree(Assembly assembly)
{
TestModel testModel = new TestModel();
var testFrameworkManager = RuntimeAccessor.ServiceLocator.Resolve<ITestFrameworkManager>();
var logger = new MarkupStreamLogger(TestLog.Default);
var testFrameworkSelector = new TestFrameworkSelector()
{
Filter = testFrameworkHandle => testFrameworkHandle.Id == TestFrameworkHandle.Id,
FallbackMode = TestFrameworkFallbackMode.Strict
};
ITestDriver testDriver = testFrameworkManager.GetTestDriver(testFrameworkSelector, logger);
var testIsolationProvider = (ITestIsolationProvider)RuntimeAccessor.ServiceLocator.ResolveByComponentId("Gallio.LocalTestIsolationProvider");
var testIsolationOptions = new TestIsolationOptions();
using (ITestIsolationContext testIsolationContext = testIsolationProvider.CreateContext(testIsolationOptions, logger))
{
var testPackage = new TestPackage();
testPackage.AddFile(new FileInfo(AssemblyUtils.GetFriendlyAssemblyCodeBase(assembly)));
var testExplorationOptions = new TestExplorationOptions();
var messageSink = TestModelSerializer.CreateMessageSinkToPopulateTestModel(testModel);
new LogProgressMonitorProvider(logger).Run(progressMonitor =>
{
testDriver.Explore(testIsolationContext, testPackage, testExplorationOptions,
messageSink, progressMonitor);
});
}
return testModel;
}
/// <summary>
/// Creates a copy of the options.
/// </summary>
/// <returns>The copy.</returns>
public TestIsolationOptions Copy()
{
TestIsolationOptions copy = new TestIsolationOptions();
copy.properties.AddAll(properties);
return(copy);
}
/// <inheritdoc />
public ITestIsolationContext CreateContext(TestIsolationOptions testIsolationOptions, ILogger logger)
{
if (testIsolationOptions == null)
throw new ArgumentNullException("testIsolationOptions");
if (logger == null)
throw new ArgumentNullException("logger");
return CreateContextImpl(testIsolationOptions, logger);
}
public void CreateProcess_WhenAttachPropertyProvided_ReturnsExistingProcess()
{
processFinder.Processes = new[] { MockRepository.GenerateStub<IProcess>() };
var options = new TestIsolationOptions();
options.AddProperty("AcadAttachToExisting", "true");
var process = factory.CreateProcess(options);
Assert.IsInstanceOfType<ExistingAcadProcess>(process);
}
/// <inheritdoc />
public ITestIsolationContext CreateContext(TestIsolationOptions testIsolationOptions, ILogger logger)
{
if (testIsolationOptions == null)
{
throw new ArgumentNullException("testIsolationOptions");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
return(CreateContextImpl(testIsolationOptions, logger));
}
public void CreateContext_ReturnsAnAcadTestIsolationContext()
{
var options = new TestIsolationOptions();
var process = MockRepository.GenerateStub<IAcadProcess>();
var processFactory = MockRepository.GenerateStub<IAcadProcessFactory>();
processFactory.Stub(x => x.CreateProcess(Arg.Is(options))).Return(process);
var provider = new AcadTestIsolationProvider(processFactory);
var context = provider.CreateContext(options, logger);
Assert.IsInstanceOfType<AcadTestIsolationContext>(context);
}
private static bool UseRemoting(TestIsolationOptions testIsolationOptions)
{
if (testIsolationOptions.Properties.ContainsKey("MessageSink"))
{
var messageSinkToUse = testIsolationOptions.Properties["MessageSink"];
if (messageSinkToUse == "Remoting")
return true;
throw new ArgumentException(string.Format("{0} is not a valid value for MessageSink", messageSinkToUse));
}
// HACK: this code gets executed both in and out of proc :(
// it won't be necessary once all communication is via messaging
return Process.GetCurrentProcess().ProcessName == "Gallio.Host";
}
/// <summary>
/// Creates a hosted test isolation context.
/// </summary>
/// <param name="hostFactory">The host factory.</param>
/// <param name="testIsolationOptions">The test isolation options.</param>
/// <param name="logger">The logger.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="hostFactory"/>,
/// <paramref name="testIsolationOptions"/> or <paramref name="logger"/> is null.</exception>
public HostedTestIsolationContext(IHostFactory hostFactory,
TestIsolationOptions testIsolationOptions, ILogger logger)
{
if (hostFactory == null)
{
throw new ArgumentNullException("hostFactory");
}
if (testIsolationOptions == null)
{
throw new ArgumentNullException("testIsolationOptions");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.hostFactory = hostFactory;
TestIsolationOptions = testIsolationOptions;
this.logger = logger;
}
/// <summary>
/// Gets the right message sink for the runner, based on the test isolation options.
/// </summary>
/// <param name="testIsolationOptions">The test isolation options.</param>
/// <param name="messageSink">The message sink to wrap.</param>
/// <returns>An appropriate message sink for the runner.</returns>
public static IMessageSink GetRunnerMessageSink(TestIsolationOptions testIsolationOptions, IMessageSink messageSink)
{
return UseRemoting(testIsolationOptions)
? messageSink
: new AsyncTcpListenerMessageSink(messageSink, GetMessageFormatter(testIsolationOptions), GetPort(testIsolationOptions));
}
public void CreateProcess_WhenWorkingDirectoryPreferenceIsInvalid_ThrowsArgumentException()
{
preferenceManager.WorkingDirectory = new string(Path.GetInvalidPathChars());
var options = new TestIsolationOptions();
Assert.Throws<ArgumentException>(() => factory.CreateProcess(options));
}
public void CreateProcess_WhenUserSpecifiedExecutablePreferenceRefersToMissingFile_ThrowsFileNotFoundException()
{
preferenceManager.StartupAction = StartupAction.StartUserSpecified;
preferenceManager.UserSpecifiedExecutable = @"c:\missing\path\to\acad.exe";
var options = new TestIsolationOptions();
Assert.Throws<FileNotFoundException>(() => factory.CreateProcess(options));
}
public void CreateProcess_WhenUserSpecifiedExecutablePreferenceIsNull_ThrowsArgumentException()
{
preferenceManager.StartupAction = StartupAction.StartUserSpecified;
preferenceManager.UserSpecifiedExecutable = null;
var options = new TestIsolationOptions();
Assert.Throws<ArgumentException>(() => factory.CreateProcess(options));
}
public void CreateProcess_WhenStartupActionPreferenceIsStartMru_SetsFileName()
{
preferenceManager.StartupAction = StartupAction.StartMostRecentlyUsed;
var options = new TestIsolationOptions();
var process = factory.CreateProcess(options);
Assert.IsInstanceOfType<CreatedAcadProcess>(process);
Assert.AreEqual(@"c:\most\recently\used\acad.exe", ((CreatedAcadProcess)process).FileName);
}
public void CreateProcess_WhenCommandLineArgumentsPreferenceProvided_SetsProcessArguments()
{
preferenceManager.CommandLineArguments = "arguments";
var options = new TestIsolationOptions();
var process = factory.CreateProcess(options);
Assert.IsInstanceOfType<CreatedAcadProcess>(process);
Assert.AreEqual("arguments", ((CreatedAcadProcess)process).Arguments);
}
/// <inheritdoc />
protected override ITestIsolationContext CreateContextImpl(TestIsolationOptions testIsolationOptions, ILogger logger)
{
return new PartCoverTestIsolationContext(testIsolationOptions, logger, runtime);
}
private List<Test> getTests(string assembly)
{
var testIsolationProvider = (ITestIsolationProvider)RuntimeAccessor.ServiceLocator.ResolveByComponentId("Gallio.LocalTestIsolationProvider");
var testIsolationOptions = new TestIsolationOptions();
ITestIsolationContext testIsolationContext = testIsolationProvider.CreateContext(testIsolationOptions, _logger);
// Create a test package.
// You can set a whole bunch of options here.
var testPackage = new TestPackage();
testPackage.AddFile(new FileInfo(assembly));
testPackage.TestFrameworkFallbackMode = TestFrameworkFallbackMode.Strict;
var testExplorationOptions = new TestExplorationOptions();
// This query you can answer by exploring tests and looking at their metadata for "TestsOn".
// You can explore tests using the Explore method of TestDriver. It sends a bunch of
// messages to an IMessageSink just like Run. Just scan these messages for tests that
// match the pattern you like.
// Alternately, you can build a TestModel once up front and traverse the resulting test tree
// to find what you need. The Explore method of testDriver is just like Run, except that
// it does not run the tests.
// TestModelSerializer is a little helper we can use to build up a TestModel from test messages on the fly.
// The TestModel is just a tree of test metadata. Pretty straightforward.
TestModel testModel = new TestModel();
IMessageSink messageSink = TestModelSerializer.CreateMessageSinkToPopulateTestModel(testModel);
var logProgressMonitorProvider = new LogProgressMonitorProvider(_logger);
logProgressMonitorProvider.Run((progressMonitor) =>
{
_testDriver.Explore(testIsolationContext, testPackage, testExplorationOptions, messageSink, progressMonitor);
});
return testModel.AllTests.Where(x => x.IsTestCase).ToList();
}
public IEnumerable<AutoTest.TestRunners.Shared.Results.TestResult> Run(RunSettings settings)
{
if (!_isInitialized)
return new AutoTest.TestRunners.Shared.Results.TestResult[] { getNotInitializedResult(settings) };
var tests = settings.Assembly.Tests.ToList();
var members = settings.Assembly.Members.ToList();
var namespaces = settings.Assembly.Namespaces.ToList();
var runAll = namespaces.Count == 0 && members.Count == 0 && tests.Count == 0;
var steps = new List<TestStepData>();
var testResults = new List<AutoTest.TestRunners.Shared.Results.TestResult>();
// Get a test isolation context. Here we want to run tests in the same AppDomain.
var testIsolationProvider = (ITestIsolationProvider)RuntimeAccessor.ServiceLocator.ResolveByComponentId("Gallio.LocalTestIsolationProvider");
var testIsolationOptions = new TestIsolationOptions();
ITestIsolationContext testIsolationContext = testIsolationProvider.CreateContext(testIsolationOptions, _logger);
var testPackage = new TestPackage();
testPackage.AddFile(new FileInfo(settings.Assembly.Assembly));
testPackage.TestFrameworkFallbackMode = TestFrameworkFallbackMode.Strict;
// Create some test exploration options. Nothing interesting for you here, probably.
var testExplorationOptions = new TestExplorationOptions();
var messageSink = new MessageConsumer()
.Handle<TestStepStartedMessage>((message) =>
{
steps.Add(message.Step);
})
.Handle<TestStepFinishedMessage>(message =>
{
var test = steps.FirstOrDefault(x => x.Id.Equals(message.StepId) && x.IsTestCase);
if (test == null)
return;
var fixture = string.Format("{0}.{1}", test.CodeReference.NamespaceName, steps.First(x => x.Id.Equals(test.ParentId)).Name);
testResults.Add(new AutoTest.TestRunners.Shared.Results.TestResult(
"MbUnit",
settings.Assembly.Assembly,
fixture,
message.Result.Duration.TotalMilliseconds,
string.Format("{0}.{1}", fixture, test.Name),
convertState(message.Result.Outcome.Status),
message.Result.Outcome.DisplayName));
});
// Provide a progress monitor.
var logProgressMonitorProvider = new LogProgressMonitorProvider(_logger);
var options = new TestExecutionOptions();
options.FilterSet = new Gallio.Model.Filters.FilterSet<ITestDescriptor>(new OrFilter<ITestDescriptor>(getTestFilter(namespaces, members, tests)));
// Run the tests.
logProgressMonitorProvider.Run((progressMonitor) =>
{
_testDriver.Run(testIsolationContext, testPackage, testExplorationOptions, options, messageSink, progressMonitor);
});
return testResults;
}
private static int? GetPort(TestIsolationOptions testIsolationOptions)
{
return null;
}
private static IMessageFormatter GetMessageFormatter(TestIsolationOptions testIsolationOptions)
{
return new BinaryMessageFormatter();
}
public void CreateProcess_WhenExePropertyRefersToMissingFile_ThrowsFileNotFoundException()
{
var options = new TestIsolationOptions();
options.AddProperty("AcadExePath", @"c:\path\to\missing\acad.exe");
Assert.Throws<FileNotFoundException>(() => factory.CreateProcess(options));
}
/// <summary> /// Creates a test isolation context. /// </summary> /// <param name="testIsolationOptions">The test isolation options, not null.</param> /// <param name="logger">The logger, not null.</param> /// <returns>The test isolation context.</returns> protected abstract ITestIsolationContext CreateContextImpl(TestIsolationOptions testIsolationOptions, ILogger logger);
public void CreateProcess_WhenMoreThanOneExistingProcess_AttachExisting_ThrowsNotSupportedException()
{
processFinder.Processes = new[]
{
MockRepository.GenerateStub<IProcess>(),
MockRepository.GenerateStub<IProcess>()
};
var options = new TestIsolationOptions();
options.AddProperty("AcadAttachToExisting", @"true");
Assert.Throws<NotSupportedException>(() => factory.CreateProcess(options));
}
/// <summary> /// Creates a test isolation context. /// </summary> /// <param name="testIsolationOptions">The test isolation options, not null.</param> /// <param name="logger">The logger, not null.</param> /// <returns>The test isolation context.</returns> protected abstract ITestIsolationContext CreateContextImpl(TestIsolationOptions testIsolationOptions, ILogger logger);
public void CreateProcess_WhenStartupActionPreferenceIsAttachToExisting_ReturnsExistingProcess()
{
processFinder.Processes = new[] { MockRepository.GenerateStub<IProcess>() };
preferenceManager.StartupAction = StartupAction.AttachToExisting;
var options = new TestIsolationOptions();
var process = factory.CreateProcess(options);
Assert.IsInstanceOfType<ExistingAcadProcess>(process);
}
/// <summary>
/// Creates a copy of the options.
/// </summary>
/// <returns>The copy.</returns>
public TestIsolationOptions Copy()
{
TestIsolationOptions copy = new TestIsolationOptions();
copy.properties.AddAll(properties);
return copy;
}
public void CreateProcess_WhenStartupActionPreferenceIsStartUserSpecified_SetsFileName()
{
preferenceManager.StartupAction = StartupAction.StartUserSpecified;
preferenceManager.UserSpecifiedExecutable = @"c:\path\to\acad.exe";
var options = new TestIsolationOptions();
var process = factory.CreateProcess(options);
Assert.IsInstanceOfType<CreatedAcadProcess>(process);
Assert.AreEqual(@"c:\path\to\acad.exe", ((CreatedAcadProcess)process).FileName);
}
/// <inheritdoc />
protected override ITestIsolationContext CreateContextImpl(TestIsolationOptions testIsolationOptions, ILogger logger)
{
return(new HostedTestIsolationContext(hostFactory, testIsolationOptions, logger));
}
public void CreateProcess_WhenUserSpecifiedExecutablePreferenceIsInvalid_ThrowsArgumentException()
{
preferenceManager.StartupAction = StartupAction.StartUserSpecified;
preferenceManager.UserSpecifiedExecutable = new string(Path.GetInvalidPathChars());
var options = new TestIsolationOptions();
Assert.Throws<ArgumentException>(() => factory.CreateProcess(options));
}
public void CreateProcess_WhenExePropertyProvided_SetsProcessFileName()
{
var options = new TestIsolationOptions();
options.AddProperty("AcadExePath", @"c:\path\to\acad.exe");
var process = factory.CreateProcess(options);
Assert.IsInstanceOfType<CreatedAcadProcess>(process);
Assert.AreEqual(@"c:\path\to\acad.exe", ((CreatedAcadProcess)process).FileName);
}
public void CreateProcess_WhenWorkingDirectoryPreferenceProvided_SetsWorkingDirectory()
{
preferenceManager.WorkingDirectory = @"c:\working\dir\";
var options = new TestIsolationOptions();
var process = factory.CreateProcess(options);
Assert.IsInstanceOfType<CreatedAcadProcess>(process);
Assert.AreEqual(@"c:\working\dir\", ((CreatedAcadProcess)process).WorkingDirectory);
}
public void CreateProcess_WhenExePropertyProvided_OverridesPreferenceManager()
{
preferenceManager.StartupAction = StartupAction.AttachToExisting;
var options = new TestIsolationOptions();
options.AddProperty("AcadExePath", @"c:\path\to\acad.exe");
var process = factory.CreateProcess(options);
Assert.IsInstanceOfType<CreatedAcadProcess>(process);
Assert.AreEqual(@"c:\path\to\acad.exe", ((CreatedAcadProcess)process).FileName);
}
public void CreateProcess_WhenWorkingDirectoryPreferenceRefersToMissingDirectory_ThrowsDirectoryNotFoundException()
{
preferenceManager.WorkingDirectory = @"c:\missing\dir\";
var options = new TestIsolationOptions();
Assert.Throws<DirectoryNotFoundException>(() => factory.CreateProcess(options));
}
public void CreateProcess_WhenExePropertyIsInvalid_ThrowsArgumentException()
{
var options = new TestIsolationOptions();
options.AddProperty("AcadExePath", new string(Path.GetInvalidPathChars()));
Assert.Throws<ArgumentException>(() => factory.CreateProcess(options));
}
public void CreateProcess_WhenAttachPropertyProvided_OverridesPreferenceManager()
{
processFinder.Processes = new[] { MockRepository.GenerateStub<IProcess>() };
preferenceManager.StartupAction = StartupAction.StartMostRecentlyUsed;
var options = new TestIsolationOptions();
options.AddProperty("AcadAttachToExisting", @"true");
var process = factory.CreateProcess(options);
Assert.IsInstanceOfType<ExistingAcadProcess>(process);
}
/// <inheritdoc />
public void Initialize(TestRunnerOptions testRunnerOptions, ILogger logger, IProgressMonitor progressMonitor)
{
if (testRunnerOptions == null)
throw new ArgumentNullException("testRunnerOptions");
if (logger == null)
throw new ArgumentNullException("logger");
if (progressMonitor == null)
throw new ArgumentNullException("progressMonitor");
ThrowIfDisposed();
if (state != State.Created)
throw new InvalidOperationException("The test runner has already been initialized.");
testRunnerOptions = testRunnerOptions.Copy();
this.testRunnerOptions = testRunnerOptions;
tappedLogger = new TappedLogger(this, logger);
int extensionCount = extensions.Count;
using (progressMonitor.BeginTask("Initializing the test runner.", 1 + extensionCount))
{
foreach (ITestRunnerExtension extension in extensions)
{
string extensionName = extension.GetType().Name; // TODO: improve me
progressMonitor.SetStatus(String.Format("Installing extension '{0}'.", extensionName));
try
{
// Note: We don't pass the tapped logger to the extensions because the
// extensions frequently write to the console a bunch of information we
// already have represented in the report. We are more interested in what
// the test driver has to tell us.
extension.Install(eventDispatcher, logger);
progressMonitor.Worked(1);
}
catch (Exception ex)
{
throw new RunnerException(String.Format("Failed to install extension '{0}'.", extensionName), ex);
}
progressMonitor.SetStatus("");
}
try
{
UnhandledExceptionPolicy.ReportUnhandledException += OnUnhandledException;
eventDispatcher.NotifyInitializeStarted(new InitializeStartedEventArgs(testRunnerOptions));
progressMonitor.SetStatus("Initializing the test isolation context.");
TestIsolationOptions testIsolationOptions = new TestIsolationOptions();
GenericCollectionUtils.ForEach(testRunnerOptions.Properties, x => testIsolationOptions.AddProperty(x.Key, x.Value));
testIsolationContext = testIsolationProvider.CreateContext(testIsolationOptions, tappedLogger);
progressMonitor.Worked(1);
}
catch (Exception ex)
{
eventDispatcher.NotifyInitializeFinished(new InitializeFinishedEventArgs(false));
UnhandledExceptionPolicy.ReportUnhandledException -= OnUnhandledException;
throw new RunnerException("A fatal exception occurred while initializing the test isolation context.", ex);
}
state = State.Initialized;
eventDispatcher.NotifyInitializeFinished(new InitializeFinishedEventArgs(true));
}
}
