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); }