private static TypeDeclarationSyntax GetOrCreateTargetType(SyntaxNode sourceSymbol, SyntaxNode targetNamespace, IFrameworkSet frameworkSet, ClassModel classModel, out TypeDeclarationSyntax originalTargetType)
{
TypeDeclarationSyntax targetType = null;
originalTargetType = null;
if (targetNamespace != null && sourceSymbol != null)
{
var types = TestableItemExtractor.GetTypeDeclarations(targetNamespace);
var targetClassName = frameworkSet.GetTargetTypeName(classModel, true);
originalTargetType = targetType = types.FirstOrDefault(x => string.Equals(x.GetClassName(), targetClassName, StringComparison.OrdinalIgnoreCase));
if (originalTargetType == null)
{
targetClassName = frameworkSet.GetTargetTypeName(classModel, false);
originalTargetType = targetType = types.FirstOrDefault(x => string.Equals(x.GetClassName(), targetClassName, StringComparison.OrdinalIgnoreCase));
}
}
if (targetType == null)
{
targetType = new ClassGenerationStrategyFactory(frameworkSet).CreateFor(classModel);
}
else
{
targetType = EnsureAllConstructorParametersHaveFields(frameworkSet, classModel, targetType);
}
return(targetType);
}
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 CanCallGetTypeDeclarations()
{
var root = TestSemanticModelFactory.Tree.GetRoot();
var result = TestableItemExtractor.GetTypeDeclarations(root);
Assert.That(result.Count, Is.EqualTo(1));
Assert.That(result[0].GetClassName(), Is.EqualTo("ModelSource"));
}
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();
}
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);
}
public void SetUp()
{
_tree = TestSemanticModelFactory.Tree;
_semanticModel = TestSemanticModelFactory.Model;
_testClass = new TestableItemExtractor(_tree, _semanticModel);
}
public void CannotCallGetTypeDeclarationsWithNullRoot()
{
Assert.Throws <ArgumentNullException>(() => TestableItemExtractor.GetTypeDeclarations(default(SyntaxNode)));
}
