public void GetTestsShouldNotReturnHiddenTestMethodsFromAnyLevel()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummySecondHidingTestClass), Assembly.GetExecutingAssembly().FullName);
var tests = typeEnumerator.Enumerate(out this.warnings);
Assert.IsNotNull(tests);
Assert.AreEqual(
1,
tests.Count(t => t.TestMethod.Name == "BaseTestMethod"),
"DummySecondHidingTestClass hides BaseTestMethod so it should be discovered.");
Assert.AreEqual(
1,
tests.Count(t => t.TestMethod.Name == "DerivedTestMethod"),
"DummySecondHidingTestClass hides DerivedTestMethod so it should be discovered.");
Assert.IsFalse(
tests.Any(t => t.TestMethod.DeclaringClassFullName == typeof(DummyBaseTestClass).FullName),
"DummySecondHidingTestClass hides all base test methods so declaring class should not be any base class");
Assert.IsFalse(
tests.Any(t => t.TestMethod.DeclaringClassFullName == typeof(DummyHidingTestClass).FullName),
"DummySecondHidingTestClass hides all base test methods so declaring class should not be any base class");
Assert.IsFalse(
tests.Any(t => t.TestMethod.DeclaringClassFullName == typeof(DummyOverridingTestClass).FullName),
"DummySecondHidingTestClass hides all base test methods so declaring class should not be any base class");
}
public void GetTestsShouldNotReturnBaseTestMethodsFromAnotherAssemblyByConfiguration()
{
string runSettingxml =
@"<RunSettings>
<MSTestV2>
<CaptureTraceOutput>true</CaptureTraceOutput>
<MapInconclusiveToFailed>false</MapInconclusiveToFailed>
<EnableBaseClassTestMethodsFromOtherAssemblies>false</EnableBaseClassTestMethodsFromOtherAssemblies>
</MSTestV2>
</RunSettings>";
var mockRunContext = new Mock <IRunContext>();
var mockRunSettings = new Mock <IRunSettings>();
mockRunContext.Setup(dc => dc.RunSettings).Returns(mockRunSettings.Object);
mockRunSettings.Setup(rs => rs.SettingsXml).Returns(runSettingxml);
MSTestSettings.PopulateSettings(mockRunContext.Object);
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: false);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyDerivedTestClass), Assembly.GetExecutingAssembly().FullName);
var tests = typeEnumerator.Enumerate(out this.warnings);
Assert.IsNotNull(tests);
Assert.IsTrue(
tests.All(t => t.TestMethod.Name != "BaseTestMethod"),
"DummyDerivedFromRemoteTestClass inherits DummyRemoteBaseTestClass from different assembly. BestTestMethod from DummyRemoteBaseTestClass should not be discovered when RunSettings MSTestV2 specifies EnableBaseClassTestMethodsFromOtherAssemblies = false.");
}
public int GetCount(Type t)
{
int result = 0;
TypeEnumerator typeEnumerator = GetEnumerator(t);
while (typeEnumerator.MoveNext())
result++;
return result;
}
public void EnumerateShouldReturnEmptyCollectionWhenNoValidTestMethodsExist()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: false, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), string.Empty);
var tests = typeEnumerator.Enumerate(out this.warnings);
Assert.IsNotNull(tests);
Assert.AreEqual(0, tests.Count);
}
public void IsIgnoreAttributeOnTestClassReturnsFalseIfIgnoreIsNotSetOnTestClass()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameType: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
// Setup mocks
this.mockReflectHelper.Setup(rh => rh.IsAttributeDefined(typeof(DummyTestClass), typeof(UTF.IgnoreAttribute), It.IsAny <bool>())).Returns(false);
Assert.IsFalse(typeEnumerator.IsIgnoreAttributeOnTestClass);
}
public void GetTestsShouldReturnBaseTestMethodsInSameAssembly()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyDerivedTestClass), Assembly.GetExecutingAssembly().FullName);
var tests = typeEnumerator.Enumerate(out this.warnings);
var methodCount = typeof(DummyDerivedTestClass).GetMethods(BindingFlags.Instance | BindingFlags.Public).Count(m => m.DeclaringType.Assembly == typeof(DummyDerivedTestClass).Assembly);
Assert.IsNotNull(tests);
Assert.AreEqual(methodCount, tests.Count);
}
public void GetTestFromMethodShouldSetWorkItemIds()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod("MethodWithVoidReturnType");
this.mockReflectHelper.Setup(rh => rh.GetCustomAttributes(methodInfo, typeof(UTF.WorkItemAttribute))).Returns(new Attribute[] { new UTF.WorkItemAttribute(123), new UTF.WorkItemAttribute(345) });
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, true, this.warnings);
CollectionAssert.AreEqual(new string[] { "123", "345" }, testElement.WorkItemIds);
}
public void GetTestFromMethodShouldSetWorkItemIdsToNullIfNotAny()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod("MethodWithVoidReturnType");
this.mockReflectHelper.Setup(rh => rh.GetCustomAttributes(methodInfo, typeof(UTF.WorkItemAttribute))).Returns(new Attribute[0]);
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, true, this.warnings);
Assert.IsNull(testElement.WorkItemIds);
}
public void GetTestFromMethodShouldSetCssProjectStructure()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod("MethodWithVoidReturnType");
this.mockReflectHelper.Setup(rh => rh.GetCustomAttribute(methodInfo, typeof(UTF.CssProjectStructureAttribute))).Returns(new UTF.CssProjectStructureAttribute("ProjectStructure123"));
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, true, this.warnings);
Assert.AreEqual("ProjectStructure123", testElement.CssProjectStructure);
}
public void GetTestsShouldReturnBaseTestMethodsInSameAssembly()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyDerivedTestClass), Assembly.GetExecutingAssembly().FullName);
var tests = typeEnumerator.Enumerate(out this.warnings);
Assert.IsNotNull(tests);
Assert.IsTrue(
tests.Any(t => t.TestMethod.Name == "BaseTestMethod"),
"DummyDerivedTestClass inherits DummyBaseTestClass from same assembly. BestTestMethod from DummyBaseTestClass should be discovered.");
}
public void GetTestsShouldReturnDeclaredTestMethods()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyBaseTestClass), Assembly.GetExecutingAssembly().FullName);
var tests = typeEnumerator.Enumerate(out this.warnings);
Assert.IsNotNull(tests);
Assert.IsTrue(
tests.Any(t => t.TestMethod.Name == "BaseTestMethod"),
"DummyBaseTestClass declares BaseTestMethod directly so it should always be discovered.");
}
public void GetTestFromMethodShouldInitiateTestMethodWithCorrectParameters()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var testElement = typeEnumerator.GetTestFromMethod(typeof(DummyTestClass).GetMethod("MethodWithVoidReturnType"), true, this.warnings);
Assert.IsNotNull(testElement);
Assert.AreEqual("MethodWithVoidReturnType", testElement.TestMethod.Name);
Assert.AreEqual(typeof(DummyTestClass).FullName, testElement.TestMethod.FullClassName);
Assert.AreEqual("DummyAssemblyName", testElement.TestMethod.AssemblyName);
Assert.IsFalse(testElement.TestMethod.IsAsync);
}
public void GetTestsShouldNotReturnBaseTestMethodsFromAnotherAssemblyByDefault()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: false);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyDerivedTestClass), Assembly.GetExecutingAssembly().FullName);
var tests = typeEnumerator.Enumerate(out this.warnings);
Assert.IsNotNull(tests);
Assert.IsTrue(
tests.All(t => t.TestMethod.Name != "BaseTestMethod"),
"DummyDerivedFromRemoteTestClass inherits DummyRemoteBaseTestClass from different assembly. BestTestMethod from DummyRemoteBaseTestClass should not be discovered by default.");
}
public void GetTestFromMethodShouldSetDoNotParallelize()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod("MethodWithVoidReturnType");
// Setup mocks
this.mockReflectHelper.Setup(rh => rh.GetCustomAttributes(It.IsAny <MemberInfo>(), typeof(UTF.DoNotParallelizeAttribute))).Returns(new[] { new UTF.DoNotParallelizeAttribute() });
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, true, this.warnings);
Assert.IsNotNull(testElement);
Assert.IsTrue(testElement.DoNotParallelize);
}
public void GetTestFromMethodShouldSetPriority()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod("MethodWithVoidReturnType");
// Setup mocks
this.mockReflectHelper.Setup(rh => rh.GetPriority(methodInfo)).Returns(1);
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, true, this.warnings);
Assert.IsNotNull(testElement);
Assert.AreEqual(1, testElement.Priority);
}
/// <summary>
/// Serializes the specified writer.
/// </summary>
/// <param name="serializer"> The serializer. </param>
/// <param name="writer"> The writer. </param>
/// <param name="value"> The value. </param>
/// <param name="element"> The element. </param>
public static void Serialize(this XmlSerializer serializer, XmlWriter writer, object value, string element)
{
if (value == null)
{
return;
}
try
{
if (value.GetType( )
.IsPrimitive || value is Guid || value is string)
{
writer.WriteStartElement(element);
writer.WriteStartAttribute("Type");
writer.WriteValue(value.GetType( )
.IsPrimitive ? TypeEnumerator.GetShortTypeNameFor(value.GetType( )) : value.GetType( )
.AssemblyQualifiedName);
writer.WriteEndAttribute( );
writer.WriteStartAttribute("Value");
writer.WriteValue(Convert.ToString(value));
writer.WriteEndAttribute( );
}
else
{
var xmlSerializer = new XmlSerializer(value.GetType( ));
writer.WriteStartElement(element);
writer.WriteStartAttribute("Type");
writer.WriteValue(value.GetType( )
.IsPrimitive ? TypeEnumerator.GetShortTypeNameFor(value.GetType( )) : value.GetType( )
.AssemblyQualifiedName);
writer.WriteEndAttribute( );
xmlSerializer.Serialize(writer, value);
}
}
catch
{
// object cannot be serialized
if (Log.IsWarnEnabled)
{
Log.WarnFormat("Object Type : {0} cannot be XmlSerialized", value.GetType( ));
}
}
writer.WriteEndElement( );
}
public void GetTestsShouldNotReturnBaseTestMethodsFromAnotherAssembly()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyDerivedTestClass), Assembly.GetExecutingAssembly().FullName);
var tests = typeEnumerator.Enumerate(out this.warnings);
// This would return basic object methods like ToString() as well.
var methodCount =
typeof(DummyDerivedTestClass).GetMethods(BindingFlags.Instance | BindingFlags.Public).Count();
Assert.IsNotNull(tests);
Assert.IsTrue(methodCount > tests.Count);
}
public void GetTestFromMethodShouldInitializeAsyncTypeNameCorrectly()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod("AsyncMethodWithTaskReturnType");
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, true, this.warnings);
var expectedAsyncTaskName =
(methodInfo.GetCustomAttribute(typeof(AsyncStateMachineAttribute)) as AsyncStateMachineAttribute)
.StateMachineType.FullName;
Assert.IsNotNull(testElement);
Assert.AreEqual(expectedAsyncTaskName, testElement.AsyncTypeName);
}
public void GetTestFromMethodShouldSetDisplayNameFromAttribute()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod(nameof(DummyTestClass.MethodWithVoidReturnType));
// Setup mocks to behave like we have [TestMethod("Test method display name.")] attribute on the method
this.mockReflectHelper.Setup(
rh => rh.GetCustomAttribute(methodInfo, typeof(TestMethodV2))).Returns(new TestMethodV2("Test method display name."));
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, true, this.warnings);
Assert.IsNotNull(testElement);
Assert.AreEqual("Test method display name.", testElement.DisplayName);
}
public void GetTestFromMethodShouldSetTestCategory()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod("MethodWithVoidReturnType");
var testCategories = new string[] { "foo", "bar" };
// Setup mocks
this.mockReflectHelper.Setup(rh => rh.GetCategories(methodInfo, typeof(DummyTestClass))).Returns(testCategories);
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, true, this.warnings);
Assert.IsNotNull(testElement);
CollectionAssert.AreEqual(testCategories, testElement.TestCategory);
}
public static string ToSerializableForm(this MethodInfo method)
{
string serializableName = TypeEnumerator.GetShortTypeNameFor(method.DeclaringType) + Environment.NewLine;
if (!method.IsGenericMethod)
{
serializableName += method.ToString( );
}
else
{
serializableName += method.GetGenericMethodDefinition( ) + Environment.NewLine +
String.Join(Environment.NewLine, method.GetGenericArguments( ).Select(ty => ty.ToSerializableForm( )).ToArray( ));
}
return(serializableName);
}
public void GetTestFromMethodShouldSetDeploymentItemsToNullIfNotPresent()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod("MethodWithVoidReturnType");
// Setup mocks
this.testablePlatformServiceProvider.MockTestDeployment.Setup(
td => td.GetDeploymentItems(It.IsAny <MethodInfo>(), It.IsAny <Type>(), this.warnings))
.Returns((KeyValuePair <string, string>[])null);
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, true, this.warnings);
Assert.IsNotNull(testElement);
Assert.IsNull(testElement.DeploymentItems);
}
public void GetTestFromMethodShouldFillTraitsWithTestProperties()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod("MethodWithVoidReturnType");
var testProperties = new List <Trait> {
new Trait("foo", "bar"), new Trait("fooprime", "barprime")
};
// Setup mocks
this.mockReflectHelper.Setup(rh => rh.GetTestPropertiesAsTraits(methodInfo)).Returns(testProperties);
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, true, this.warnings);
Assert.IsNotNull(testElement);
CollectionAssert.AreEqual(testProperties, testElement.Traits);
}
public void GetTestFromMethodShouldSetDeploymentItems()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod("MethodWithVoidReturnType");
var deploymentItems = new[] { new KeyValuePair <string, string>("C:\\temp", string.Empty) };
// Setup mocks
this.testablePlatformServiceProvider.MockTestDeployment.Setup(
td => td.GetDeploymentItems(methodInfo, typeof(DummyTestClass), this.warnings)).Returns(deploymentItems);
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, true, this.warnings);
Assert.IsNotNull(testElement);
Assert.IsNotNull(testElement.DeploymentItems);
CollectionAssert.AreEqual(deploymentItems, testElement.DeploymentItems.ToArray());
}
public void GetTestFromMethodShouldSetIgnoredPropertyToFalseIfNotSetOnTestClassAndTestMethod()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod("MethodWithVoidReturnType");
// Setup mocks
this.mockReflectHelper.Setup(
rh => rh.IsAttributeDefined(typeof(DummyTestClass), typeof(UTF.IgnoreAttribute), false)).Returns(false);
this.mockReflectHelper.Setup(
rh => rh.IsAttributeDefined(methodInfo, typeof(UTF.IgnoreAttribute), false)).Returns(false);
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, true, this.warnings);
Assert.IsNotNull(testElement);
Assert.IsFalse(testElement.Ignored);
}
public void GetTestFromMethodShouldSetDeclaringAssemblyName()
{
const bool isMethodFromSameAssemly = false;
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyTestClass), "DummyAssemblyName");
var methodInfo = typeof(DummyTestClass).GetMethod("MethodWithVoidReturnType");
// Setup mocks
string otherAssemblyName = "ADifferentAssembly";
this.testablePlatformServiceProvider.MockFileOperations.Setup(fo => fo.GetAssemblyPath(It.IsAny <Assembly>()))
.Returns(otherAssemblyName);
var testElement = typeEnumerator.GetTestFromMethod(methodInfo, isMethodFromSameAssemly, this.warnings);
Assert.IsNotNull(testElement);
Assert.AreEqual(otherAssemblyName, testElement.TestMethod.DeclaringAssemblyName);
}
public void GetTestsShouldReturnOverriddenTestMethods()
{
this.SetupTestClassAndTestMethods(isValidTestClass: true, isValidTestMethod: true, isMethodFromSameAssembly: true);
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(DummyOverridingTestClass), Assembly.GetExecutingAssembly().FullName);
var tests = typeEnumerator.Enumerate(out this.warnings);
Assert.IsNotNull(tests);
Assert.AreEqual(
1,
tests.Count(t => t.TestMethod.Name == "BaseTestMethod"),
"DummyOverridingTestClass inherits BaseTestMethod so it should be discovered.");
Assert.AreEqual(
1,
tests.Count(t => t.TestMethod.Name == "DerivedTestMethod"),
"DummyOverridingTestClass overrides DerivedTestMethod directly so it should always be discovered.");
Assert.AreEqual(
typeof(DummyHidingTestClass).FullName,
tests.Single(t => t.TestMethod.Name == "BaseTestMethod").TestMethod.DeclaringClassFullName,
"DummyOverridingTestClass inherits BaseTestMethod from DummyHidingTestClass specifically.");
Assert.IsNull(
tests.Single(t => t.TestMethod.Name == "DerivedTestMethod").TestMethod.DeclaringClassFullName,
"DummyOverridingTestClass overrides DerivedTestMethod so is the declaring class.");
}
public static string ToSerializableForm(this MemberInfo member)
{
//return member.DeclaringType.AssemblyQualifiedName + Environment.NewLine + member;
return(TypeEnumerator.GetShortTypeNameFor(member.DeclaringType) + Environment.NewLine + member);
}
/// <summary>
/// Initializes a new instance of the <see cref = "SystemVariable" /> class.
/// </summary>
/// <param name = "type">The type.</param>
public SystemVariable(Type type)
{
SystemType = TypeEnumerator.GetQualifiedNamesFor(type);
}
public void EnumerateShouldReturnNullIfTypeIsNotValid()
{
TypeEnumerator typeEnumerator = this.GetTypeEnumeratorInstance(typeof(IDummyInterface), string.Empty);
Assert.IsNull(typeEnumerator.Enumerate(out this.warnings));
}
