public void CanExtractSingleItemAsClassModel()
{
var tree = CSharpSyntaxTree.ParseText(TestClasses.SampleClassTestFile);
var mscorlib = MetadataReference.CreateFromFile(typeof(object).Assembly.Location);
var compilation = CSharpCompilation.Create(
"MyTest",
syntaxTrees: new[] { tree },
references: new[] { mscorlib });
var semanticModel = compilation.GetSemanticModel(tree);
var root = tree.GetRoot();
var methodSyntax = root.DescendantNodes().OfType <MethodDeclarationSyntax>().FirstOrDefault();
var extractor = new TestableItemExtractor(tree, semanticModel);
var classModels = extractor.Extract(methodSyntax);
var classModel = classModels.FirstOrDefault();
Assert.That(classModel, Is.Not.Null);
var methodModel = classModel.Methods.FirstOrDefault();
Assert.That(methodModel, Is.Not.Null);
Assert.That(methodModel.Name, Is.EqualTo("ThisIsAMethod"));
}
private static ClassModel CreateModel(string classAsText)
{
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(Stream).Assembly.Location),
MetadataReference.CreateFromFile(typeof(System.Drawing.Brushes).Assembly.Location),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.dll")),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Core.dll")),
};
var compilation = CSharpCompilation.Create(
"MyTest",
syntaxTrees: new[] { tree },
references: references);
var semanticModel = compilation.GetSemanticModel(tree);
var model = new TestableItemExtractor(semanticModel.SyntaxTree, semanticModel);
return(model.Extract(null).First());
}
public void CanCallCreate()
{
var syntaxTree = TestSemanticModelFactory.CreateTree(TestClasses.IComparableTestFile);
var model = TestSemanticModelFactory.CreateSemanticModel(syntaxTree);
var extractor = new TestableItemExtractor(syntaxTree, model);
var classModel = extractor.Extract(syntaxTree.GetRoot().DescendantNodes().OfType <ClassDeclarationSyntax>().First()).First();
var result = _testClass.Create(classModel, classModel);
// 3 IComparable definitions on the test class
Assert.That(result.Count(), Is.EqualTo(classModel.Interfaces.Count));
}
public void GivenIHaveAClassThatImplements(string classAsText)
{
var syntaxTree = CSharpSyntaxTree.ParseText(classAsText);
var compilation = CSharpCompilation.Create("MyTest", new[] { syntaxTree }, SemanticModelHelper.References.Value);
var model = compilation.GetSemanticModel(syntaxTree);
_context.SemanticModel = model;
var extractor = new TestableItemExtractor(syntaxTree, model);
_context.ClassModel = extractor.Extract(syntaxTree.GetRoot().DescendantNodes().OfType <ClassDeclarationSyntax>().First()).First();
}
public void CanCallExtract()
{
var result = _testClass.Extract(null).Single();
Assert.That(result.Constructors.Count, Is.EqualTo(1));
Assert.That(result.Methods.Count, Is.EqualTo(2));
Assert.That(result.Indexers.Count, Is.EqualTo(1));
Assert.That(result.Properties.Count, Is.EqualTo(1));
}
public static void CanCallSetupMethod()
{
var extractor = new TestableItemExtractor(TestSemanticModelFactory.Tree, TestSemanticModelFactory.Model);
var model = extractor.Extract(null).First();
var targetTypeName = "TestValue1540739065";
var options = Substitute.For <IUnitTestGeneratorOptions>();
options.GenerationOptions.TestTypeNaming.Returns("{0}Tests");
options.GenerationOptions.FrameworkType.Returns(TestFrameworkTypes.NUnit3);
var frameworkSet = FrameworkSetFactory.Create(options);
var classDeclaration = TestSemanticModelFactory.Class;
var result = Generate.SetupMethod(model, targetTypeName, frameworkSet, ref classDeclaration);
Assert.That(result.NormalizeWhitespace().ToFullString().StartsWith("[SetUp]\r\npublic void SetUp()\r\n{\r\n _param = \"TestValue", StringComparison.Ordinal));
}
private static GenerationResult Generate(SemanticModel sourceModel, SyntaxNode sourceSymbol, bool withRegeneration, IUnitTestGeneratorOptions options, NamespaceDeclarationSyntax targetNamespace, HashSet <string> usingsEmitted, CompilationUnitSyntax compilation, NamespaceDeclarationSyntax originalTargetNamespace)
{
var frameworkSet = FrameworkSetFactory.Create(options);
var typeParametersEmitted = new HashSet <string>();
var model = new TestableItemExtractor(sourceModel.SyntaxTree, sourceModel);
var classModels = model.Extract(sourceSymbol).ToList();
foreach (var c in classModels)
{
if (c.Declaration.Parent is NamespaceDeclarationSyntax namespaceDeclaration)
{
targetNamespace = EmitUsingStatements(targetNamespace, usingsEmitted, SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(namespaceDeclaration.Name.ToString())));
}
}
foreach (var classModel in classModels)
{
var targetType = GetOrCreateTargetType(sourceSymbol, targetNamespace, frameworkSet, classModel, out var originalTargetType);
targetNamespace = AddTypeParameterAliases(classModel, typeParametersEmitted, targetNamespace);
targetType = ApplyStrategies(withRegeneration, targetType, frameworkSet, classModel);
targetNamespace = AddTypeToTargetNamespace(originalTargetType, targetNamespace, targetType);
foreach (var parameter in frameworkSet.Context.GenericTypes)
{
targetNamespace = targetNamespace.AddUsings(
SyntaxFactory.UsingDirective(SyntaxFactory.QualifiedName(SyntaxFactory.IdentifierName(Strings.UnitTestGenerator_AddUsingStatements_System), SyntaxFactory.IdentifierName("String")))
.WithAlias(SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(parameter))));
}
}
targetNamespace = AddUsingStatements(targetNamespace, usingsEmitted, frameworkSet, classModels);
compilation = AddTargetNamespaceToCompilation(originalTargetNamespace, compilation, targetNamespace);
var generationResult = CreateGenerationResult(compilation, classModels);
AddAssembliesToGenerationResult(sourceModel, frameworkSet, generationResult);
return(generationResult);
}
