public void CanCallContent(TestFrameworkTypes frameworkTypes)
{
var targetNamespace = "TestValue927446416";
var result = _testClass.Content(targetNamespace, frameworkTypes);
Assert.That(result, Contains.Substring(targetNamespace));
}
public void CanCallGetUsings(TestFrameworkTypes frameworkTypes, string expectedOutput)
{
var testClass = CreateFramework(frameworkTypes);
var result = testClass.GetUsings().ToList();
Assert.That(result.Any(x => x.NormalizeWhitespace().ToFullString().Contains(expectedOutput)));
}
public void CanCallCreateSetupMethod(TestFrameworkTypes frameworkTypes, string expectedOutput)
{
var testClass = CreateFramework(frameworkTypes);
var targetTypeName = "TestValue1801609112";
var result = testClass.CreateSetupMethod(targetTypeName);
Assert.That(result.NormalizeWhitespace().ToFullString(), Is.EqualTo(expectedOutput));
}
public void CanCallAssertFail(TestFrameworkTypes frameworkTypes, string expectedOutput)
{
var testClass = CreateFramework(frameworkTypes);
var message = "TestValue538721341";
var result = testClass.AssertFail(message);
Assert.That(result.NormalizeWhitespace().ToFullString(), Is.EqualTo(expectedOutput));
}
public void CanCallAssertNotNull(TestFrameworkTypes frameworkTypes, string expectedOutput)
{
var testClass = CreateFramework(frameworkTypes);
var value = Generate.Literal(1);
var result = testClass.AssertNotNull(value);
Assert.That(result.NormalizeWhitespace().ToFullString(), Is.EqualTo(expectedOutput));
}
public void CanCallAssertIsInstanceOf(TestFrameworkTypes frameworkTypes, string expectedOutput)
{
var testClass = CreateFramework(frameworkTypes);
var value = Generate.Literal(1);
var type = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword));
var result = testClass.AssertIsInstanceOf(value, type);
Assert.That(result.NormalizeWhitespace().ToFullString(), Is.EqualTo(expectedOutput));
}
public void CanCallAssertThrows(TestFrameworkTypes frameworkTypes, string expectedOutput)
{
var testClass = CreateFramework(frameworkTypes);
var exceptionType = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword));
var methodCall = Generate.Literal(1);
var result = testClass.AssertThrows(exceptionType, methodCall);
Assert.That(result.NormalizeWhitespace().ToFullString(), Is.EqualTo(expectedOutput));
}
public void CanCallCreateTestMethod(TestFrameworkTypes frameworkTypes, string expectedOutput)
{
var testClass = CreateFramework(frameworkTypes);
var name = "TestValue1606901338";
var isAsync = false;
var isStatic = true;
var result = testClass.CreateTestMethod(name, isAsync, isStatic);
Assert.That(result.NormalizeWhitespace().ToFullString(), Is.EqualTo(expectedOutput));
}
public static void CanCallCreateForTestFramework(TestFrameworkTypes type, Type expectedType)
{
var options = Substitute.For <IUnitTestGeneratorOptions>();
options.GenerationOptions.TestTypeNaming.Returns("{0}Tests");
options.GenerationOptions.FrameworkType.Returns(type);
options.GenerationOptions.MockingFrameworkType.Returns(MockingFrameworkType.Moq);
var result = FrameworkSetFactory.Create(options);
Assert.That(result.TestFramework, Is.InstanceOf(expectedType));
}
public void CanCallCreateTestCaseMethod(TestFrameworkTypes frameworkTypes, string expectedOutput)
{
var testClass = CreateFramework(frameworkTypes);
var name = "TestValue947022583";
var isAsync = false;
var isStatic = false;
var valueType = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword));
var testValues = new object[] { 1, 2 };
var result = testClass.CreateTestCaseMethod(name, isAsync, isStatic, valueType, testValues);
Assert.That(result.NormalizeWhitespace().ToFullString(), Is.EqualTo(expectedOutput));
}
public static void CanCallGetReferencedAssemblies(TestFrameworkTypes testFramework, MockingFrameworkType mockingFramework, string expectedTestFramework, string expectedMockingFramework)
{
var options = Substitute.For <IUnitTestGeneratorOptions>();
options.GenerationOptions.TestTypeNaming.Returns("{0}Tests");
options.GenerationOptions.FrameworkType.Returns(testFramework);
options.GenerationOptions.MockingFrameworkType.Returns(mockingFramework);
var result = StandardReferenceHelper.GetReferencedNugetPackages(options);
Assert.That(result.Any(x => string.Equals(x.Name, expectedTestFramework, StringComparison.OrdinalIgnoreCase)));
Assert.That(result.Any(x => string.Equals(x.Name, expectedMockingFramework, StringComparison.OrdinalIgnoreCase)));
}
public string Content(string targetNamespace, TestFrameworkTypes testFrameworkTypes)
{
if (string.IsNullOrWhiteSpace(targetNamespace))
{
throw new ArgumentNullException(nameof(targetNamespace));
}
if ((testFrameworkTypes & TestFrameworkTypes.XUnit) > 0)
{
return(AssetResources.PropertyTesterXUnit.Replace("%targetNamespace%", targetNamespace));
}
if ((testFrameworkTypes & (TestFrameworkTypes.NUnit2 | TestFrameworkTypes.NUnit3)) > 0)
{
return(AssetResources.PropertyTesterNUnit.Replace("%targetNamespace%", targetNamespace));
}
return(AssetResources.PropertyTesterMSTest.Replace("%targetNamespace%", targetNamespace));
}
private static IEnumerable <PortableExecutableReference> GetReferences(TestFrameworkTypes testFrameworkTypes)
{
if ((testFrameworkTypes & TestFrameworkTypes.XUnit) > 0)
{
yield return(MetadataReference.CreateFromFile(typeof(FactAttribute).Assembly.Location));
yield return(MetadataReference.CreateFromFile(typeof(Xunit.Assert).Assembly.Location));
}
if ((testFrameworkTypes & (TestFrameworkTypes.NUnit3 | TestFrameworkTypes.NUnit2)) > 0)
{
yield return(MetadataReference.CreateFromFile(typeof(TestFixtureAttribute).Assembly.Location));
}
if ((testFrameworkTypes & TestFrameworkTypes.MsTest) > 0)
{
yield return(MetadataReference.CreateFromFile(typeof(Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute).Assembly.Location));
}
}
private static ITestFramework CreateFramework(TestFrameworkTypes frameworkTypes)
{
switch (frameworkTypes)
{
case TestFrameworkTypes.MsTest:
return(new MsTestTestFramework());
case TestFrameworkTypes.NUnit2:
return(new NUnit2TestFramework());
case TestFrameworkTypes.NUnit3:
return(new NUnit3TestFramework());
case TestFrameworkTypes.XUnit:
return(new XUnitTestFramework());
default:
throw new ArgumentOutOfRangeException(nameof(frameworkTypes));
}
}
private static ITestFramework Create(TestFrameworkTypes testFrameworkTypes)
{
if ((testFrameworkTypes & TestFrameworkTypes.XUnit) > 0)
{
return(new XUnitTestFramework());
}
if ((testFrameworkTypes & TestFrameworkTypes.NUnit3) > 0)
{
return(new NUnit3TestFramework());
}
if ((testFrameworkTypes & TestFrameworkTypes.NUnit2) > 0)
{
return(new NUnit2TestFramework());
}
if ((testFrameworkTypes & TestFrameworkTypes.MsTest) > 0)
{
return(new MsTestTestFramework());
}
throw new NotSupportedException(Strings.FrameworkSetFactory_Create_Couldn_t_find_the_required_testing_framework);
}
public static async Task AssertTestGeneration(string resourceName, TestFrameworkTypes testFrameworkTypes, MockingFrameworkType mockingFrameworkType)
{
var classAsText = TestClasses.ResourceManager.GetString(resourceName, TestClasses.Culture);
var tree = CSharpSyntaxTree.ParseText(classAsText, new CSharpParseOptions(LanguageVersion.Latest));
var assemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location);
var references = new List <MetadataReference>
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(INotifyPropertyChanged).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Expression).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Brush).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Stream).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Form).Assembly.Location),
MetadataReference.CreateFromFile(typeof(SqlConnection).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Window).Assembly.Location),
MetadataReference.CreateFromFile(typeof(UIElement).Assembly.Location),
MetadataReference.CreateFromFile(typeof(DependencyObject).Assembly.Location),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.dll")),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Core.dll")),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Runtime.dll")),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Threading.Tasks.dll")),
};
references.AddRange(GetReferences(mockingFrameworkType));
references.AddRange(GetReferences(testFrameworkTypes));
var compilation = CSharpCompilation.Create(
"MyTest",
syntaxTrees: new[] { tree },
references: references);
var semanticModel = compilation.GetSemanticModel(tree);
IUnitTestGeneratorOptions options = Substitute.For <IUnitTestGeneratorOptions>();
options.GenerationOptions.FrameworkType.Returns(testFrameworkTypes);
options.GenerationOptions.MockingFrameworkType.Returns(mockingFrameworkType);
options.GenerationOptions.TestFileNaming.Returns("{0}Tests");
options.GenerationOptions.TestTypeNaming.Returns("{0}Tests");
options.GenerationOptions.TestProjectNaming.Returns("{0}.Tests");
var core = await CoreGenerator.Generate(semanticModel, null, null, false, options, x => "Tests").ConfigureAwait(true);
Assert.IsNotNull(core);
Console.WriteLine(core.FileContent);
Assert.IsNotNull(core.FileContent);
var generatedTree = CSharpSyntaxTree.ParseText(core.FileContent, new CSharpParseOptions(LanguageVersion.Latest));
var syntaxTrees = new List <SyntaxTree> {
tree, generatedTree
};
if (core.RequiredAssets.Any(x => x == TargetAsset.PropertyTester))
{
var testerAsset = AssetFactory.Create(TargetAsset.PropertyTester);
var propertyTester = testerAsset.Content("Tests", testFrameworkTypes);
syntaxTrees.Add(CSharpSyntaxTree.ParseText(propertyTester, new CSharpParseOptions(LanguageVersion.Latest)));
}
var validateCompilation = CSharpCompilation.Create(
"MyTest",
syntaxTrees: syntaxTrees,
references: references,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var stream = new MemoryStream();
var result = validateCompilation.Emit(stream);
var streamLength = stream.Length;
stream.Dispose();
Assert.IsTrue(result.Success, string.Join(",", result.Diagnostics.Select(x => x.Location.GetLineSpan().StartLinePosition.Line + ": " + x.GetMessage())));
Assert.That(streamLength, Is.GreaterThan(0));
}
public void GivenISetMyGenerationFrameworkTo(TestFrameworkTypes frameworkType)
{
_context.TargetFramework = frameworkType;
}
public GenerationOptions(TestFrameworkTypes testFramework, MockingFrameworkType mockFramework)
{
FrameworkType = testFramework;
MockingFrameworkType = mockFramework;
}
public void CanGetTestClassAttribute(TestFrameworkTypes frameworkTypes, string expected)
{
var testClass = CreateFramework(frameworkTypes);
Assert.That(testClass.TestClassAttribute, Is.EqualTo(expected));
}
public void CanGetSingleThreadedApartmentAttribute(TestFrameworkTypes frameworkTypes, string expected)
{
var testClass = CreateFramework(frameworkTypes);
Assert.That(testClass.SingleThreadedApartmentAttribute?.ToFullString(), Is.EqualTo(expected));
}
