public override void AssemblyStart(TestAssembly testAssembly)
{
Console.WriteLine(
"##teamcity[testSuiteStarted name='{0}']",
Escape(Path.GetFileName(testAssembly.AssemblyFilename))
);
}
public IList<RunData> Create(TestAssembly assembly)
{
IList<RunData> items = new List<RunData>();
assembly.Fixtures = assembly.Fixtures.OrderBy((m) => m.Name).ToList();
string lastFixtureName = "#";
RunData item = null;
foreach (TestFixture fixture in assembly.Fixtures)
{
if (fixture.Name.StartsWith(lastFixtureName))
{
item.Groups.Add(fixture.Group);
item.Fixtures.Add(fixture);
if (fixture.Exclusive == true)
{
item.Exclusive = true;
}
continue;
}
item = CreateNewFromFixture(assembly, fixture);
lastFixtureName = fixture.Name;
items.Add(item);
}
return items;
}
public virtual void AssemblyFinished(TestAssembly testAssembly, int total, int failed, int skipped, double time)
{
TotalTests = total;
TotalFailures = failed;
TotalSkips = skipped;
TotalTime = time;
}
public override void AssemblyFinished(TestAssembly testAssembly, int total, int failed, int skipped, double time)
{
base.AssemblyFinished(testAssembly, total, failed, skipped, time);
if (!silent)
Console.Write("\r");
Console.WriteLine("{0} total, {1} failed, {2} skipped, took {3} seconds", total, failed, skipped, time.ToString("0.000", CultureInfo.InvariantCulture));
}
public override void AssemblyFinished(TestAssembly testAssembly, int total, int failed, int skipped, double time)
{
base.AssemblyFinished(testAssembly, total, failed, skipped, time);
Console.WriteLine(
"##teamcity[testSuiteFinished name='{0}']",
Escape(Path.GetFileName(testAssembly.AssemblyFilename))
);
}
public void SetsTestAssemblyOnTestClasses()
{
StubExecutorWrapper wrapper = new StubExecutorWrapper();
TestClass testClass = new TestClass("typeName", new TestMethod[0]);
var assembly = new TestAssembly(wrapper, new[] { testClass });
Assert.Same(assembly, testClass.TestAssembly);
}
public void DisposingAssemblyDisposesExecutorWrapper()
{
StubExecutorWrapper wrapper = new StubExecutorWrapper();
var assembly = new TestAssembly(wrapper, new TestClass[0]);
assembly.Dispose();
Assert.True(wrapper.Dispose__Called);
}
public virtual void ExceptionThrown(TestAssembly testAssembly, Exception exception)
{
Console.WriteLine();
Console.WriteLine("CATASTROPHIC ERROR OCCURRED:");
Console.WriteLine(exception.ToString());
Console.WriteLine("WHILE RUNNING:");
Console.WriteLine(testAssembly.AssemblyFilename);
Console.WriteLine();
}
public SpecThisTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink, IXunitTestCollectionFactory collectionFactory = null)
: base(assemblyInfo, sourceProvider, diagnosticMessageSink)
{
IAttributeInfo collectionBehaviorAttribute = assemblyInfo.GetCustomAttributes(typeof(CollectionBehaviorAttribute)).SingleOrDefault<IAttributeInfo>();
bool flag = collectionBehaviorAttribute != null && collectionBehaviorAttribute.GetNamedArgument<bool>("DisableTestParallelization");
string configurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
TestAssembly testAssembly = new TestAssembly(assemblyInfo, configurationFile);
this.TestCollectionFactory = collectionFactory ?? ExtensibilityPointFactory.GetXunitTestCollectionFactory(diagnosticMessageSink, collectionBehaviorAttribute, (ITestAssembly)testAssembly);
this.TestFrameworkDisplayName = string.Format("{0} [{1}, {2}]", XunitTestFrameworkDiscoverer.DisplayName, this.TestCollectionFactory.DisplayName, flag ? "non-parallel" : "parallel");
}
public void FilterWithFalsePredicate()
{
var wrapper = new StubExecutorWrapper();
var class1Method1 = new TestMethod("method1", null, null);
var class1Method2 = new TestMethod("method2", null, null);
var class2Method3 = new TestMethod("method3", null, null);
var class1 = new TestClass("foo", new[] { class1Method1, class1Method2 });
var class2 = new TestClass("bar", new[] { class2Method3 });
var assembly = new TestAssembly(wrapper, new[] { class1, class2 });
var tests = assembly.EnumerateTestMethods(testMethod => false);
Assert.Equal(0, tests.Count());
}
public void GetFileInfo_EscapingFromTheRootFolder_ReturnsNotFound()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js"),
TestEntry.File("jquery.min.js"),
TestEntry.File("site.css"))));
// Act
var provider = new ManifestEmbeddedFileProvider(assembly);
// Assert
var jqueryValidate = provider.GetFileInfo(Path.Combine("..", "wwwroot", "jquery.validate.js"));
Assert.IsType <NotFoundFileInfo>(jqueryValidate);
}
void AddTestAssembly(TestAssembly testAssembly)
{
ListViewItem lviAssembly = new ListViewItem
{
Text = Path.GetFileNameWithoutExtension(testAssembly.AssemblyFilename),
ToolTipText = testAssembly.AssemblyFilename + Environment.NewLine +
"xunit.dll verison " + testAssembly.XunitVersion,
Tag = testAssembly
};
AddFileWatcher(testAssembly);
listAssemblies.Items.Add(lviAssembly);
UpdateAssemblyFilter();
UpdateTraitsList();
UpdateTestList();
UpdateAssemblyDynamicMenus();
}
public void GetFileInfo_ResolveNonExistingFile_ReturnsNotFoundFileInfo()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js"),
TestEntry.File("jquery.min.js"),
TestEntry.File("site.css"))));
var provider = new ManifestEmbeddedFileProvider(assembly);
// Act
var file = provider.GetFileInfo("some/non/existing/file.txt");
// Assert
Assert.IsType <NotFoundFileInfo>(file);
}
public void ScopedFileProvider_DoesNotReturnFilesOutOfScope(string path)
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js")),
TestEntry.File("site.css")));
var provider = new ManifestEmbeddedFileProvider(assembly);
var scopedProvider = new ManifestEmbeddedFileProvider(assembly, provider.Manifest.Scope("wwwroot"), DateTimeOffset.UtcNow);
// Act
var jqueryValidate = scopedProvider.GetFileInfo(path);
// Assert
Assert.IsType <NotFoundFileInfo>(jqueryValidate);
}
public void ResolveAssemblies_ThrowsIfRelatedAssemblyDefinesAdditionalRelatedAssemblies()
{
// Arrange
var expected = $"Assembly 'TestRelatedAssembly' declared as a related assembly by assembly '{ThisAssembly}' cannot define additional related assemblies.";
var assembly1 = typeof(ApplicationAssembliesProvider).Assembly;
var assembly2 = new TestAssembly();
var relatedAssemblies = new[] { assembly1, assembly2 };
var provider = new TestApplicationAssembliesProvider
{
GetRelatedAssembliesDelegate = (assembly) => relatedAssemblies,
};
// Act & Assert
var ex = Assert.Throws <InvalidOperationException>(() => provider.ResolveAssemblies(ThisAssembly).ToArray());
Assert.Equal(expected, ex.Message);
}
public void GetDirectoryContents_ReturnsNotFoundDirectoryContents_ForPathsWithInvalidCharacters(string path)
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js"),
TestEntry.File("jquery.min.js"),
TestEntry.File("site.css"))));
// Act
var provider = new ManifestEmbeddedFileProvider(assembly);
// Assert
var directory = provider.GetDirectoryContents(path);
Assert.IsType <NotFoundDirectoryContents>(directory);
}
public void GetRelatedAssemblies_LoadsRelatedAssembly()
{
// Arrange
var destination = Path.Combine(AssemblyDirectory, "RelatedAssembly.dll");
var assembly = new TestAssembly
{
AttributeAssembly = "RelatedAssembly",
};
var relatedAssembly = typeof(RelatedAssemblyPartTest).Assembly;
var result = RelatedAssemblyAttribute.GetRelatedAssemblies(assembly, throwOnError: true, file => true, file =>
{
Assert.Equal(file, destination);
return(relatedAssembly);
});
Assert.Equal(new[] { relatedAssembly }, result);
}
public void CallsTestRunnerWithTestList()
{
var wrapper = new Mock <IExecutorWrapper>();
var callback = new Mock <ITestMethodRunnerCallback>();
var testMethod1 = new TestMethod("testMethod1", null, null);
var testMethod2 = new TestMethod("testMethod2", null, null);
var testMethod3 = new TestMethod("testMethod3", null, null);
var testClass = new TestableTestClass("typeName", new[] { testMethod1, testMethod2, testMethod3 });
var testAssembly = new TestAssembly(wrapper.Object, new[] { testClass });
var result = testClass.Run(new[] { testMethod1, testMethod2, testMethod3 }, callback.Object);
Assert.Single(testClass.RunTests_Methods, "testMethod1");
Assert.Single(testClass.RunTests_Methods, "testMethod2");
Assert.Single(testClass.RunTests_Methods, "testMethod3");
Assert.Same(callback.Object, testClass.RunTests_Callback);
Assert.Equal(testClass.RunTests_ReturnValue, result);
}
public void MultiAssemblySimpleFilterAcceptanceTest()
{
string code =
@"
using System;
using Xunit;
public class MockTestClass
{
[Fact]
public void SuccessTest()
{
Assert.Equal(2, 2);
}
}
";
using (MockAssembly mockAssembly1 = new MockAssembly())
using (MockAssembly mockAssembly2 = new MockAssembly())
{
mockAssembly1.Compile(code);
mockAssembly2.Compile(code);
Mock <ITestMethodRunnerCallback> callback = new Mock <ITestMethodRunnerCallback>();
callback.Setup(c => c.TestStart(It.IsAny <TestMethod>())).Returns(true);
callback.Setup(c => c.TestFinished(It.IsAny <TestMethod>())).Returns(true);
MultiAssemblyTestEnvironment mate = new MultiAssemblyTestEnvironment();
mate.Load(mockAssembly1.FileName);
mate.Load(mockAssembly2.FileName);
TestAssembly testAssembly1 = mate.EnumerateTestAssemblies().Where(a => a.AssemblyFilename == mockAssembly1.FileName).Single();
TestAssembly testAssembly2 = mate.EnumerateTestAssemblies().Where(a => a.AssemblyFilename == mockAssembly2.FileName).Single();
TestMethod assembly1Method = testAssembly1.EnumerateTestMethods().Single();
TestMethod assembly2Method = testAssembly1.EnumerateTestMethods().Single();
mate.Run(mate.EnumerateTestMethods(m => m.TestClass.TestAssembly == testAssembly1), callback.Object);
callback.Verify(c => c.AssemblyStart(testAssembly1));
callback.Verify(c => c.TestStart(assembly1Method));
callback.Verify(c => c.TestFinished(assembly1Method));
callback.Verify(c => c.AssemblyFinished(testAssembly1, 1, 0, 0, It.IsAny <double>()));
callback.Verify(c => c.AssemblyStart(testAssembly2), Times.Never());
var runResult = Assert.IsType <TestPassedResult>(assembly1Method.RunResults[0]);
Assert.Null(runResult.Output);
}
}
public void GetFileInfo_ReturnsNotFoundfileInfo_ForPathsWithInvalidCharacters(string path)
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js"),
TestEntry.File("jquery.min.js"),
TestEntry.File("site.css"))));
// Act
var provider = new ManifestEmbeddedFileProvider(assembly);
// Assert
var file = provider.GetFileInfo(path);
Assert.IsType <NotFoundFileInfo>(file);
Assert.Equal(path, file.Name);
}
/// <summary>
/// Build a suite of tests given the name or the location of an assembly
/// </summary>
/// <param name="assemblyNameOrPath">The name or the location of the assembly.</param>
/// <param name="options">A dictionary of options to use in building the suite</param>
/// <returns>
/// A TestSuite containing the tests found in the assembly
/// </returns>
public ITest Build(string assemblyNameOrPath, IDictionary <string, object> options)
{
log.Debug("Loading {0} in AppDomain {1}", assemblyNameOrPath, AppDomain.CurrentDomain.FriendlyName);
TestSuite testAssembly = null;
try
{
var assembly = AssemblyHelper.Load(assemblyNameOrPath);
testAssembly = Build(assembly, assemblyNameOrPath, options);
}
catch (Exception ex)
{
testAssembly = new TestAssembly(assemblyNameOrPath);
testAssembly.MakeInvalid(ExceptionHelper.BuildMessage(ex, true));
}
return(testAssembly);
}
public void Validate(TestAssembly testAssembly)
{
foreach (var fixture in testAssembly.Fixtures)
{
foreach (var method in fixture.TestMethods)
{
TestViolation violation = AssertTestOrNull(
method,
testAssembly.AssemblyCategories,
fixture.TestFixtureCategories
);
if (violation != null)
{
fixture.AddViolation(violation);
}
}
}
}
public void ExecuteSimple()
{
var types = new[] { typeof(TestBullet1) };
var strategy = new Mock <ISysDatabaseStrategy>();
strategy.Setup(x => x.GetLastVersion(It.IsAny <string>())).Returns(0);
ObjectFactory.Initialize(x =>
{
x.ForSingletonOf <ISysDatabaseStrategy>().Use(strategy.Object);
x.ForSingletonOf <IDatabaseStrategy>().Use(new Mock <IDatabaseStrategy>().Object);
});
var assembly = new TestAssembly(types);
Executor.Execute(assembly);
Assert.IsTrue(TestBullet1.IsUpdateInvoked);
}
private RunData CreateNewFromFixture(TestAssembly testAssembly, TestFixture fixture)
{
RunData item = new RunData()
{
Fixtures = new List<TestFixture>() { fixture },
Root = Args.Root,
Output = new StringBuilder(),
Groups = new HashSet<string>(),
Exclusive = fixture.Exclusive ?? false,
Executable = Args.GetExecutablePath(),
RunId = Guid.NewGuid(),
AssemblyName = testAssembly.Name
};
if (!string.IsNullOrEmpty(fixture.Group))
{
item.Groups.Add(fixture.Group);
}
return item;
}
private TestSuite Build(Assembly assembly, string assemblyPath, IDictionary options)
{
TestSuite testAssembly = null;
try
{
IList fixtureNames = options[PackageSettings.LOAD] as IList;
IList fixtures = GetFixtures(assembly, fixtureNames);
testAssembly = BuildTestAssembly(assembly, assemblyPath, fixtures);
}
catch (Exception ex)
{
testAssembly = new TestAssembly(assemblyPath);
testAssembly.RunState = RunState.NotRunnable;
testAssembly.Properties.Set(PropertyNames.SkipReason, ex.Message);
}
return(testAssembly);
}
public void SetUpThrowsException()
{
var consoleOutput = new StringWriter();
AssemblyFactory.Type = typeof(ATestAssembly);
ATestAssembly.AssemblyFixtureType = typeof(AssemblyFixtureThrowsInSetUp);
var ta = new TestAssembly(new AssemblyName("ATestAssembly"));
Console.SetOut(consoleOutput);
ta.RunTests(new TestRun(new AllTestsCriterion()), new SimpleTestListener());
var expected =
"Error: Exception thrown in SetUp method of TestAssemblyFixture:"
+ LineFeed +
" Tests depending on it might fail. Error details follow."
+ LineFeed +
"Exception thrown in " + ATestAssembly.AssemblyFixtureType.FullName
+ @".SetUp()";
Assert.Contains(expected, consoleOutput.ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="MettleTestFrameworkDiscoverer"/> class.
/// </summary>
/// <param name="assemblyInfo">The test assembly.</param>
/// <param name="sourceProvider">The source information provider.</param>
/// <param name="diagnosticMessageSink">The message sink used to send diagnostic messages</param>
/// <param name="collectionFactory">The test collection factory used to look up test collections.</param>
public MettleTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo,
ISourceInformationProvider sourceProvider,
IMessageSink diagnosticMessageSink,
IXunitTestCollectionFactory collectionFactory = null)
: base(assemblyInfo, sourceProvider, diagnosticMessageSink)
{
var collectionBehaviorAttribute = assemblyInfo.GetCustomAttributes(typeof(CollectionBehaviorAttribute)).SingleOrDefault();
var disableParallelization = collectionBehaviorAttribute != null && collectionBehaviorAttribute.GetNamedArgument <bool>("DisableTestParallelization");
string config = null;
#if NETFRAMEWORK
config = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
#endif
var testAssembly = new TestAssembly(assemblyInfo, config);
TestCollectionFactory = collectionFactory ?? ExtensibilityPointFactory.GetXunitTestCollectionFactory(diagnosticMessageSink, collectionBehaviorAttribute, testAssembly);
TestFrameworkDisplayName = $"{DisplayName} [{TestCollectionFactory.DisplayName}, {(disableParallelization ? "non-parallel" : "parallel")}]";
this.AssemblyInfo = assemblyInfo;
}
public void Parse_TestClass()
{
args.Stub(m => m.PLevel).Return(PLevel.TestClass);
Assembly assembly = Assembly.GetExecutingAssembly();
TestAssembly testAssembly = target.Parse(assembly);
Assert.AreEqual(assembly.Location, testAssembly.Name);
TestFixture testClass1 = testAssembly.Fixtures.FirstOrDefault(x => x.Name == "ParallelTestRunner.Tests.VSTest.TestClass1");
Assert.IsNotNull(testClass1);
Assert.AreEqual("Group2", testClass1.Group);
Assert.IsFalse(testClass1.Exclusive.Value);
TestFixture testClass2 = testAssembly.Fixtures.FirstOrDefault(x => x.Name == "ParallelTestRunner.Tests.VSTest.TestClass2");
Assert.IsNotNull(testClass2);
Assert.AreEqual("Group1", testClass2.Group);
Assert.AreEqual(true, testClass2.Exclusive);
}
public void GivenIHaveATestAssemblyWithAValidConfigurationFile()
{
_executorMock = new Mock <ITestExecutor>();
_executorMock.Setup(m => m.RunTests(It.IsAny <IEnumerable <TestDetails> >(), It.IsAny <TestAssembly>(), It.IsAny <string>(), null));
_configMock = new Mock <IConfigurationManager>();
string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\FieldTest.Runner.exe.config";
_configMock.Setup(m => m.CopyApplicationConfiguration(It.IsAny <string>(), It.IsAny <string>()));
_remoteTestRunner = new Core.RemoteTestRunner(null, _configMock.Object, _executorMock.Object);
var testAssembly = new TestAssembly("", "ValidAssembly", "This is a string to a valid location");
var testClass = new TestClass(testAssembly, "ValidClass", "Valid.Namespace");
var test = new TestDetails(testClass, "TestMethod", "", 0);
_tests = new List <TestDetails>()
{
test
};
}
static public bool RunAssemblyInitializeMethod(TestAssembly testAssembly)
{
Guard.NotNull(testAssembly, nameof(testAssembly));
var method = testAssembly.AssemblyInitializeMethod;
if (method == null)
{
return(true);
}
EventHandlerPipeline.Raise(
new AssemblyInitializeMethodBeginEvent()
{
MethodName = method.Name,
FirstTestClassFullName = testAssembly.TestClasses.First().FullName,
FirstTestMethodName = testAssembly.TestClasses.First().TestMethods.First().Name,
});
var success = Run(method, null, true, null, false);
EventHandlerPipeline.Raise(new AssemblyInitializeMethodEndEvent());
return(success);
}
public void CallsExecutorWrapperToRunTests()
{
var xmlDocument = new XmlDocument();
xmlDocument.LoadXml("<foo/>");
var xmlNode = xmlDocument.ChildNodes[0];
var wrapper = new Mock <IExecutorWrapper>(MockBehavior.Strict);
var callback = new Mock <ITestMethodRunnerCallback>();
var testMethod = new TestMethod("testMethod", null, null);
var testClass = new TestClass("typeName", new[] { testMethod });
var testAssembly = new TestAssembly(wrapper.Object, new[] { testClass });
wrapper.Setup(w => w.RunTests(testClass.TypeName, new List <string> {
"testMethod"
}, It.IsAny <Predicate <XmlNode> >()))
.Returns(xmlNode);
var result = testClass.Run(new[] { testMethod }, callback.Object);
Assert.Equal("<foo />", result);
}
void ReloadAssemblies(IEnumerable assemblyListViewItems)
{
foreach (ListViewItem assemblyListViewItem in assemblyListViewItems)
{
TestAssembly testAssembly = (TestAssembly)assemblyListViewItem.Tag;
string assemblyFilename = testAssembly.AssemblyFilename;
string configFilename = testAssembly.ConfigFilename;
RemoveFileWatcher(testAssembly);
mate.Unload(testAssembly);
testAssembly = mate.Load(assemblyFilename, configFilename);
assemblyListViewItem.Tag = testAssembly;
AddFileWatcher(testAssembly);
}
UpdateAssemblyFilter();
UpdateTestList();
UpdateTraitsList();
progress.Status = ProgressControl.ProgressStatus.Unknown;
}
public void Contructor_CanScopeManifestToAFolder()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js")),
TestEntry.File("site.css")));
var provider = new ManifestEmbeddedFileProvider(assembly);
var scopedProvider = new ManifestEmbeddedFileProvider(assembly, provider.Manifest.Scope("wwwroot"), DateTimeOffset.UtcNow);
// Act
var jqueryValidate = scopedProvider.GetFileInfo("jquery.validate.js");
// Assert
Assert.True(jqueryValidate.Exists);
Assert.False(jqueryValidate.IsDirectory);
Assert.Equal("jquery.validate.js", jqueryValidate.Name);
Assert.Null(jqueryValidate.PhysicalPath);
Assert.Equal(0, jqueryValidate.Length);
}
public void TestStarted(ITest test)
{
#if PORTABLE
if (test is TestAssembly)
{
TestAssembly testAssembly = test as TestAssembly;
Console.WriteLine(testAssembly.Name);
}
else if (test is TestFixture)
{
TestFixture testFixture = test as TestFixture;
Console.WriteLine("\t{0}", testFixture.Name);
}
else if (test is TestMethod)
{
TestMethod testMethod = test as TestMethod;
Console.Write("\t\t{0} => ", testMethod.Name);
}
#else
Events += string.Format("<{0}:", test.Name);
#endif
}
private static void ProcessAssemblyInput(string[] inputLines, Dictionary <string, TestAssembly> assemblies)
{
// ASSEMBLY=>{AssemblyID}
// {Path}
// {HintPath}
// {HintPath}
// {HintPath}
// ;
string assemblyId = ExtractValue("ASSEMBLY=>{", inputLines[0]);
string assemblyPath = inputLines[1];
var hintPaths = inputLines.Skip(2).ToList();
TestAssembly newAssembly = new TestAssembly(assemblyId, string.Empty, assemblyPath);
if (hintPaths != null && hintPaths.Count > 0)
{
newAssembly.HintPaths.AddRange(hintPaths);
}
assemblies.Add(assemblyId, newAssembly);
}
public void GetDirectoryContents_EnumeratesFilesAndDirectoriesOnAGivenPath()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot"),
TestEntry.File("site.css")));
var provider = new ManifestEmbeddedFileProvider(assembly);
var expectedContents = new[]
{
CreateTestFileInfo("wwwroot", isDirectory: true),
CreateTestFileInfo("site.css")
};
// Act
var contents = provider.GetDirectoryContents(".").ToArray();
// Assert
Assert.Equal(expectedContents, contents, FileInfoComparer.Instance);
}
public void GetFileInfo_AllowsLeadingDots_OnThePath()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js"),
TestEntry.File("jquery.min.js"),
TestEntry.File("site.css"))));
// Act
var provider = new ManifestEmbeddedFileProvider(assembly);
// Assert
var jqueryValidate = provider.GetFileInfo(Path.Combine(".", "wwwroot", "jquery.validate.js"));
Assert.True(jqueryValidate.Exists);
Assert.False(jqueryValidate.IsDirectory);
Assert.Equal("jquery.validate.js", jqueryValidate.Name);
Assert.Null(jqueryValidate.PhysicalPath);
Assert.Equal(0, jqueryValidate.Length);
}
public void GetFileInfo_ResolvesFiles_WithDifferentCasing(string folder, string file)
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js"),
TestEntry.File("jquery.min.js"),
TestEntry.File("site.css"))));
// Act
var provider = new ManifestEmbeddedFileProvider(assembly);
// Assert
var jqueryValidate = provider.GetFileInfo(Path.Combine(folder, file));
Assert.True(jqueryValidate.Exists);
Assert.False(jqueryValidate.IsDirectory);
Assert.Equal("jquery.validate.js", jqueryValidate.Name);
Assert.Null(jqueryValidate.PhysicalPath);
Assert.Equal(0, jqueryValidate.Length);
}
private TestSuite BuildTestAssembly(Assembly assembly, string assemblyName, IList fixtures, bool autoSuites)
{
TestSuite testAssembly = new TestAssembly(assembly, assemblyName);
if (autoSuites)
{
NamespaceTreeBuilder treeBuilder =
new NamespaceTreeBuilder(testAssembly);
treeBuilder.Add(fixtures);
testAssembly = treeBuilder.RootSuite;
}
else
{
foreach (TestSuite fixture in fixtures)
{
if (fixture != null)
{
if (fixture is SetUpFixture)
{
fixture.RunState = RunState.NotRunnable;
fixture.IgnoreReason = "SetUpFixture cannot be used when loading tests as a flat list of fixtures";
}
testAssembly.Add(fixture);
}
}
}
NUnitFramework.ApplyCommonAttributes(assembly, testAssembly);
testAssembly.Properties["_PID"] = System.Diagnostics.Process.GetCurrentProcess().Id;
testAssembly.Properties["_APPDOMAIN"] = AppDomain.CurrentDomain.FriendlyName;
// TODO: Make this an option? Add Option to sort assemblies as well?
testAssembly.Sort();
return(testAssembly);
}
private void TestProjectTreeView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
TestCaseInfo caseInfo = this.TestProjectTreeView.SelectedItem as TestCaseInfo;
if (caseInfo != null)
{
DependencyObject parent = VisualTreeHelper.GetParent(current as TreeViewItem);
while (!(parent is TreeViewItem))
{
parent = VisualTreeHelper.GetParent(parent);
}
parent = VisualTreeHelper.GetParent(parent);
while (!(parent is TreeViewItem))
{
parent = VisualTreeHelper.GetParent(parent);
}
TestProjectShip testProjectShip = (parent as TreeViewItem).Header as TestProjectShip;
this.testProjectsViewModel.SelectedItemChanged(testProjectShip);
}
TestAssembly assembly = this.TestProjectTreeView.SelectedItem as TestAssembly;
if (assembly != null)
{
DependencyObject parent = VisualTreeHelper.GetParent(current as TreeViewItem);
while (!(parent is TreeViewItem))
{
parent = VisualTreeHelper.GetParent(parent);
}
TestProjectShip testProjectShip = (parent as TreeViewItem).Header as TestProjectShip;
this.testProjectsViewModel.SelectedItemChanged(testProjectShip);
}
this.testProjectsViewModel.SelectedItemChanged(this.TestProjectTreeView.SelectedItem);
}
private static int Run(Arguments args)
{
string path = args.AssembliesPath.FullName;
SetupAssemblyResolver(path);
Console.WriteLine("Loading assemblies from '{0}'", path);
var sw = new DebugStopwatch("1.LoadAssemblies");
IEnumerable <Assembly> assemblies = args.AssembliesPath
.EnumerateFiles("*.dll", SearchOption.TopDirectoryOnly)
.Where(file => !args.ExcludedAssemblies.Contains(file.Name))
.Select(GetAssemblyOrNull)
.Where(ass => ass != null)
.Where(NUnitFrameworkReferenceChecker.ReferencesNUnitFramework);
sw.Dispose();
int violations = 0;
TestAssemblyScanner scanner = new TestAssemblyScanner(
new IAssemblyValidator[] {
new ProhibitedAssemblyCategoryValidator(args.ProhibitedAssemblyCategories),
new RequaredCategoryValidator(args.RequiredCategories)
});
using (IndentedTextWriter writer = new IndentedTextWriter(Console.Error, "\t")) {
foreach (Assembly assembly in assemblies)
{
TestAssembly testAssembly = scanner.Scan(assembly);
violations += Report(testAssembly, writer);
}
DebugStopwatch.Report(writer);
}
return(violations);
}
public void ExceptionThrown(TestAssembly testAssembly, Exception exception)
{
if (InvokeRequired)
{
Delegate del = new ExceptionThrownDelegate(ExceptionThrown);
BeginInvoke(del, testAssembly, exception);
return;
}
textResults.Text += exception.ToString() + Environment.NewLine + Environment.NewLine;
}
void AddFileWatcher(TestAssembly testAssembly)
{
FileWatcher fileWatcher = new FileWatcher(testAssembly.AssemblyFilename);
fileWatcher.Changed += (s, e) => ReloadAssembly(testAssembly);
fileWatchers[testAssembly] = fileWatcher;
}
public void AssemblyFinished(TestAssembly testAssembly, int total, int failed, int skipped, double time)
{
if (InvokeRequired)
{
BeginInvoke(new AssemblyFinishedDelegate(AssemblyFinished), testAssembly, total, failed, skipped, time);
return;
}
testsTotal += total;
testsFailed += failed;
testsSkipped += skipped;
testsDuration += time;
}
public void AssemblyStart(TestAssembly testAssembly)
{
}
public void AssemblyFinished(TestAssembly testAssembly, int total, int failed, int skipped, double time)
{
throw new NotImplementedException();
}
private TestSuite BuildTestAssembly( string assemblyName, IList fixtures, bool autoSuites )
{
TestSuite testAssembly = new TestAssembly( assemblyName );
if ( autoSuites )
{
NamespaceTreeBuilder treeBuilder =
new NamespaceTreeBuilder( testAssembly );
treeBuilder.Add( fixtures );
testAssembly = treeBuilder.RootSuite;
}
else
foreach( TestSuite fixture in fixtures )
{
if (fixture != null)
{
if (fixture is SetUpFixture)
{
fixture.RunState = RunState.NotRunnable;
fixture.IgnoreReason = "SetUpFixture cannot be used when loading tests as a flat list of fixtures";
}
testAssembly.Add(fixture);
}
}
if ( fixtures.Count == 0 )
{
testAssembly.RunState = RunState.NotRunnable;
testAssembly.IgnoreReason = "Has no TestFixtures";
}
NUnitFramework.ApplyCommonAttributes( assembly, testAssembly );
testAssembly.Properties["_PID"] = System.Diagnostics.Process.GetCurrentProcess().Id;
testAssembly.Properties["_APPDOMAIN"] = AppDomain.CurrentDomain.FriendlyName;
// TODO: Make this an option? Add Option to sort assemblies as well?
testAssembly.Sort();
return testAssembly;
}
/// <summary>
/// Unloads the specified assembly.
/// </summary>
/// <param name="assembly">The assembly to unload.</param>
public void Unload(TestAssembly assembly)
{
Guard.ArgumentNotNull("assembly", assembly);
Guard.ArgumentValid("assembly", "Assembly not loaded in this environment", testAssemblies.Contains(assembly));
testAssemblies.Remove(assembly);
assembly.Dispose();
}
void ReloadAssembly(TestAssembly testAssembly)
{
if (InvokeRequired)
{
BeginInvoke(new ReloadAssemblyDelegate(ReloadAssembly), testAssembly);
return;
}
ListViewItem lvi = FindTestAssemblyItem(testAssembly);
if (lvi != null)
{
if (isRunning)
{
isCancelRequested = true;
reloadRequested.Add(testAssembly);
}
else
{
ReloadAssemblies(new[] { lvi });
statusLabel.Text = "Reloaded " + testAssembly.AssemblyFilename + " at " + DateTime.Now.ToShortTimeString();
}
}
}
public void TestFixtureNestedInIgnoredTestFixture() {
AssemblyFactory.Type = typeof(ASpecialAssembly);
var assembly = new TestAssembly(new AssemblyName("bla"));
assembly.RunTests(new TestRun(new AllTestsCriterion()), new SimpleTestListener());
Assert.DoesNotContain("Bar", SimpleTestListener.Messages);
}
public void IgnoreAppliedOnlyAfterTestSpec() {
AssemblyFactory.Type = typeof(ASpecialAssembly);
var assembly = new TestAssembly(new AssemblyName("bla"));
// The fixture is actually in category "Blue"!
assembly.RunTests(new TestRun(new CategoryCriterion("Green")), new SimpleTestListener());
Assert.Equals(0, SimpleTestListener.IgnoredItems.Length,
"Ignored tests that were not specified.");
}
public void IgnoredTestFixtureIsReported() {
AssemblyFactory.Type = typeof(ASpecialAssembly);
var assembly = new TestAssembly(new AssemblyName("bla"));
assembly.RunTests(new TestRun(new AllTestsCriterion()), new SimpleTestListener());
Assert.Contains(GetType().Assembly.FullName +
"#csUnit.Core.Tests.TestAssemblyTests+IgnoredFixture##Ignored for testing reasons.#",
SimpleTestListener.IgnoredItems);
}
public void ExceptionThrown(TestAssembly testAssembly, Exception exception)
{
innerCallback.ExceptionThrown(testAssembly, exception);
}
public void AssemblyStart(TestAssembly testAssembly)
{
throw new NotImplementedException();
}
void AddTestAssembly(TestAssembly testAssembly)
{
ListViewItem lviAssembly = new ListViewItem
{
Text = Path.GetFileNameWithoutExtension(testAssembly.AssemblyFilename),
ToolTipText = testAssembly.AssemblyFilename + Environment.NewLine +
"xunit.dll verison " + testAssembly.XunitVersion,
Tag = testAssembly
};
AddFileWatcher(testAssembly);
listAssemblies.Items.Add(lviAssembly);
UpdateAssemblyFilter();
UpdateTraitsList();
UpdateTestList();
UpdateAssemblyDynamicMenus();
}
public void TestMethodNotForThisEnvironmentThrows()
{
var wrapper = new Mock<IExecutorWrapper>();
var mate = TestableMultiAssemblyTestEnvironment.Create();
var testMethod = new TestMethod(null, null, null);
var testClass = new TestClass(null, new[] { testMethod });
var testAssembly = new TestAssembly(wrapper.Object, new[] { testClass });
var callback = new Mock<ITestMethodRunnerCallback>();
Assert.Throws<ArgumentException>(() => mate.Run(new[] { testMethod }, callback.Object));
}
ListViewItem FindTestAssemblyItem(TestAssembly testAssembly)
{
foreach (ListViewItem lvi in listAssemblies.Items)
if (lvi.Tag == testAssembly)
return lvi;
return null;
}
public void TearDownThrowsException() {
var consoleOutput = new StringWriter();
AssemblyFactory.Type = typeof(ATestAssembly);
ATestAssembly.AssemblyFixtureType = typeof(AssemblyFixtureThrowsInTearDown);
var ta = new TestAssembly(new AssemblyName("ATestAssembly"));
Console.SetOut(consoleOutput);
ta.RunTests(new TestRun(new AllTestsCriterion()), new SimpleTestListener());
var expected =
"Executing " + GetType().FullName + @"+ATestAssembly+ATestClass.TheOnlyTestInThisAssembly()" + LineFeed +
"Error: Exception thrown in TearDown method of TestAssemblyFixture:" + LineFeed +
" Assembly might not properly tear down used resources. Error details follow." + LineFeed +
"Exception thrown in " + ATestAssembly.AssemblyFixtureType.FullName + @".TearDown()" + LineFeed;
Assert.Contains(expected, consoleOutput.ToString());
}
private void RemoveFileWatcher(TestAssembly testAssembly)
{
FileWatcher fileWatcher = fileWatchers[testAssembly];
fileWatcher.Dispose();
fileWatchers.Remove(testAssembly);
}
public void AssemblyNotInAssemblyList()
{
var wrapper = CreateStubExecutor();
var assembly = new TestAssembly(wrapper, new TestClass[0]);
Assert.Throws<ArgumentException>(
() => new TestableMultiAssemblyTestEnvironment().Unload(assembly));
}
