CodeGenTests.cs

namespace ImmutableObjectGraph.Generation.Tests
{
    using System;
    using System.Collections.Generic;
    using System.Collections.Immutable;
    using System.IO;
    using System.Linq;
    using System.Reflection;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using ImmutableObjectGraph.Generation.Roslyn;
    using Microsoft.CodeAnalysis;
    using Microsoft.CodeAnalysis.CSharp;
    using Microsoft.CodeAnalysis.Diagnostics;
    using Microsoft.CodeAnalysis.Text;
    using Validation;
    using Xunit;
    using Xunit.Abstractions;

    public class CodeGenTests
    {
        protected Solution solution;
        protected ProjectId projectId;
        protected DocumentId inputDocumentId;

        private readonly ITestOutputHelper logger;

        public CodeGenTests(ITestOutputHelper logger)
        {
            Requires.NotNull(logger, nameof(logger));

            this.logger = logger;
            var workspace = new AdhocWorkspace();
            var project = workspace.CurrentSolution.AddProject("test", "test", "C#")
                .WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
                .AddMetadataReferences(GetNetStandard20References())
                .AddMetadataReference(MetadataReference.CreateFromFile(typeof(GenerateImmutableAttribute).Assembly.Location))
                .AddMetadataReference(MetadataReference.CreateFromFile(typeof(Optional).Assembly.Location))
                .AddMetadataReference(MetadataReference.CreateFromFile(typeof(ImmutableArray).Assembly.Location));
            var inputDocument = project.AddDocument("input.cs", string.Empty);
            this.inputDocumentId = inputDocument.Id;
            project = inputDocument.Project;
            this.projectId = inputDocument.Project.Id;
            this.solution = project.Solution;
        }

        [Fact]
        public async Task UsingImmutableObjectGraph_Compiles()
        {
            await this.GenerateFromStreamAsync("UsingImmutableObjectGraph");
        }

        [Fact]
        public async Task NoFieldsAndNoFieldsDerived_HasCreateMethod()
        {
            var result = await this.GenerateFromStreamAsync("NoFieldsAndNoFieldsDerived");
            Assert.Equal(2, result.DeclaredMethods.Count(m => m.Name == "Create" && m.Parameters.Length == 0 && m.IsStatic));
        }

        [Fact]
        public async Task NoFieldsAndOneScalarFieldDerived_HasCreateMethod()
        {
            var result = await this.GenerateFromStreamAsync("NoFieldsAndOneScalarFieldDerived");
            Assert.Equal(1, result.DeclaredMethods.Count(m => m.ContainingType.Name == "Empty" && m.Name == "Create" && m.Parameters.Length == 0 && m.IsStatic));
            Assert.Equal(1, result.DeclaredMethods.Count(m => m.ContainingType.Name == "NotSoEmptyDerived" && m.Name == "Create" && m.Parameters.Length == 1 && m.IsStatic));
        }

        [Fact]
        public async Task ByteArray_CanBuild()
        {
            var result = await this.GenerateFromStreamAsync("ByteArray");
        }

        [Fact]
        public async Task ImmutableArray_CanBuild()
        {
            var result = await this.GenerateFromStreamAsync("ImmutableArray");
        }

        [Fact]
        public async Task OneScalarFieldAndEmptyDerived_HasCreateMethod()
        {
            var result = await this.GenerateFromStreamAsync("OneScalarFieldAndEmptyDerived");
            Assert.Equal(2, result.DeclaredMethods.Count(m => m.Name == "Create" && m.Parameters.Length == 1 && m.IsStatic));
        }

        [Fact]
        public async Task OneScalarField_HasWithMethod()
        {
            var result = await this.GenerateFromStreamAsync("OneScalarField");
            Assert.Contains(result.DeclaredMethods, m => m.Name == "With" && m.Parameters.Single().Name == "seeds" && !m.IsStatic);
        }

        [Fact]
        public async Task OneScalarField_HasCreateMethod()
        {
            var result = await this.GenerateFromStreamAsync("OneScalarField");
            Assert.Contains(result.DeclaredMethods, m => m.Name == "Create" && m.Parameters.Single().Name == "seeds");
        }

        [Fact]
        public async Task OneScalarFieldWithBuilder_HasToBuilderMethod()
        {
            var result = await this.GenerateFromStreamAsync("OneScalarFieldWithBuilder");
            Assert.Contains(result.DeclaredMethods, m => m.Name == "ToBuilder" && m.Parameters.Length == 0 && !m.IsStatic);
        }

        [Fact]
        public async Task OneScalarFieldWithBuilder_HasCreateBuilderMethod()
        {
            var result = await this.GenerateFromStreamAsync("OneScalarFieldWithBuilder");
            Assert.Contains(result.DeclaredMethods, m => m.Name == "CreateBuilder" && m.Parameters.Length == 0 && m.IsStatic);
        }

        [Fact]
        public async Task OneScalarFieldWithBuilder_BuilderHasMutableProperties()
        {
            var result = await this.GenerateFromStreamAsync("OneScalarFieldWithBuilder");
            Assert.Contains(result.DeclaredProperties, p => p.ContainingType?.Name == "Builder" && p.Name == "Seeds" && p.SetMethod != null && p.GetMethod != null);
        }

        [Fact]
        public async Task OneScalarFieldWithBuilder_BuilderHasToImmutableMethod()
        {
            var result = await this.GenerateFromStreamAsync("OneScalarFieldWithBuilder");
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Builder" && m.Name == "ToImmutable" && m.Parameters.Length == 0 && !m.IsStatic);
        }

        [Fact]
        public async Task ClassDerivesFromAnotherWithFields_DerivedCreateParametersIncludeBaseFields()
        {
            var result = await this.GenerateFromStreamAsync("ClassDerivesFromAnotherWithFields");
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Fruit" && m.Name == "Create" && m.Parameters.Length == 1);
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Apple" && m.Name == "Create" && m.Parameters.Length == 2);
        }

        [Fact]
        public async Task ClassDerivesFromAnotherWithFields_DerivedWithParametersIncludeBaseFields()
        {
            var result = await this.GenerateFromStreamAsync("ClassDerivesFromAnotherWithFields");
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Fruit" && m.Name == "With" && m.Parameters.Length == 1);
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Apple" && m.Name == "With" && m.Parameters.Length == 2);
        }

        [Fact]
        public async Task ClassDerivesFromAnotherWithFields_DerivedWithCoreParametersIncludeBaseFields()
        {
            var result = await this.GenerateFromStreamAsync("ClassDerivesFromAnotherWithFields");
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Fruit" && m.Name == "WithCore" && m.Parameters.Length == 1 && m.IsVirtual);
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Apple" && m.Name == "WithCore" && m.Parameters.Length == 1 && m.IsOverride);
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Apple" && m.Name == "WithCore" && m.Parameters.Length == 2 && m.IsVirtual);
        }

        [Fact]
        public async Task ClassDerivesFromAnotherWithFieldsAndBuilder_BuildersReflectTypeRelationship()
        {
            var result = await this.GenerateFromStreamAsync("ClassDerivesFromAnotherWithFieldsAndBuilder");
            var fruitBuilder = result.DeclaredTypes.Single(t => t.Name == "Builder" && t.ContainingType.Name == "Fruit");
            Assert.Same(fruitBuilder, result.DeclaredTypes.Single(t => t.Name == "Builder" && t.ContainingType.Name == "Apple").BaseType);
        }

        [Fact]
        public async Task AbstractNonEmptyWithDerivedEmpty_HasCreateOnlyInNonAbstractClass()
        {
            var result = await this.GenerateFromStreamAsync("AbstractNonEmptyWithDerivedEmpty");
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "EmptyDerivedFromAbstract" && m.Name == "Create" && m.Parameters.Single().Name == "oneField");
            Assert.DoesNotContain(result.DeclaredMethods, m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "Create");
        }

        [Fact]
        public async Task AbstractNonEmptyWithDerivedEmpty_HasValidateMethodOnBothTypes()
        {
            var result = await this.GenerateFromStreamAsync("AbstractNonEmptyWithDerivedEmpty");
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "EmptyDerivedFromAbstract" && m.Name == "Validate");
            Assert.DoesNotContain(result.DeclaredMethods, m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "Validate");
        }

        [Fact]
        public async Task AbstractNonEmptyWithDerivedEmpty_HasWithMethodOnBothTypes()
        {
            var result = await this.GenerateFromStreamAsync("AbstractNonEmptyWithDerivedEmpty");
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "With" && m.Parameters.Single().Name == "oneField");
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "With" && m.Parameters.Single().Name == "oneField");
        }

        [Fact]
        public async Task AbstractNonEmptyWithDerivedEmpty_HasWithCoreMethodOnBothTypes()
        {
            var result = await this.GenerateFromStreamAsync("AbstractNonEmptyWithDerivedEmpty");
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "EmptyDerivedFromAbstract" && m.Name == "WithCore" && m.Parameters.Single().Name == "oneField");
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "WithCore" && m.Parameters.Single().Name == "oneField");
        }

        [Fact]
        public async Task AbstractNonEmptyWithDerivedEmpty_HasWithFactoryMethodOnConcreteTypeOnly()
        {
            var result = await this.GenerateFromStreamAsync("AbstractNonEmptyWithDerivedEmpty");
            Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "EmptyDerivedFromAbstract" && m.Name == "WithFactory" && m.Parameters.Length == 2);
            Assert.DoesNotContain(result.DeclaredMethods, m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "WithFactory" && m.Parameters.Length == 2);
        }

        [Fact]
        public async Task IgnoreField_Compiles()
        {
            var result = await this.GenerateFromStreamAsync("IgnoreField");
        }

        [Fact]
        public async Task DefineRootedStruct_NotApplicable()
        {
            var result = await this.GenerateFromStreamAsync("DefineRootedStruct_NotApplicable");
            var warning = result.GeneratorDiagnostics.Single();
            Assert.Equal(Diagnostics.NotApplicableSetting, warning.Id);

            var location = warning.Location.GetLineSpan();
            Assert.Equal(9, location.StartLinePosition.Line);
            Assert.Equal(23, location.StartLinePosition.Character);
            Assert.Equal(9, location.EndLinePosition.Line);
            Assert.Equal(48, location.EndLinePosition.Character);
        }

        [Fact]
        public async Task RootedStruct_Without_WithMethodsPerProperty()
        {
            var result = await this.GenerateFromStreamAsync("RootedStruct_Without_WithMethodsPerProperty");
        }

        [Fact]
        public async Task OneImmutableFieldToAnotherWithOneScalarField_Compiles()
        {
            var result = await this.GenerateFromStreamAsync("OneImmutableFieldToAnotherWithOneScalarField");

        }

        [Fact]
        public async Task HierarchyLevels_Compiles()
        {
            await this.GenerateFromStreamAsync("HierarchyLevels");
        }

        [Fact]
        public async Task AlmostRecursive_Compiles()
        {
            await this.GenerateFromStreamAsync("AlmostRecursive");
        }

        protected async Task<GenerationResult> GenerateFromStreamAsync(string testName)
        {
            using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(this.GetType().Namespace + ".TestSources." + testName + ".cs"))
            {
                var result = await this.GenerateAsync(SourceText.From(stream));

                Assert.Empty(result.CompilationDiagnostics.Where(
                    d => !d.IsSuppressed && d.Severity != DiagnosticSeverity.Hidden));

                return result;
            }
        }

        protected async Task<GenerationResult> GenerateAsync(SourceText inputSource)
        {
            var solution = this.solution.WithDocumentText(this.inputDocumentId, inputSource);
            var inputDocument = solution.GetDocument(this.inputDocumentId);
            var inputCompilation = (CSharpCompilation)await inputDocument.Project.GetCompilationAsync();
            var driver = CSharpGeneratorDriver.Create(new CodeGenerator());
            var runResult = driver.RunGenerators(inputCompilation).GetRunResult();
            var generatorDiagnostics = runResult.Diagnostics;
            var project = inputDocument.Project;

            var i = 0;
            var syntaxTrees = ImmutableArray.CreateBuilder<SyntaxTree>();
            foreach (var t in runResult.GeneratedTrees)
            {
                var document = project.AddDocument($"output{i++}.cs", t.GetRoot());

                SourceText outputDocumentText = await document.GetTextAsync();
                this.logger.WriteLine("{0}", outputDocumentText);

                // Verify all line endings are consistent (otherwise VS can bug the heck out of the user if they have the generated file open).
                string firstLineEnding = null;
                foreach (var line in outputDocumentText.Lines)
                {
                    string actualNewLine = line.Text.GetSubText(TextSpan.FromBounds(line.End, line.EndIncludingLineBreak)).ToString();
                    if (firstLineEnding == null)
                    {
                        firstLineEnding = actualNewLine;
                    }
                    else if (actualNewLine != firstLineEnding && actualNewLine.Length > 0)
                    {
                        string expected = EscapeLineEndingCharacters(firstLineEnding);
                        string actual = EscapeLineEndingCharacters(actualNewLine);
                        Assert.True(false, $"Expected line ending characters '{expected}' but found '{actual}' on line {line.LineNumber + 1}.\nContent: {line}");
                    }
                }

                var syntaxTree = await document.GetSyntaxTreeAsync();
                syntaxTrees.Add(syntaxTree);

                project = document.Project;
            }

            // Make sure the result compiles without errors or warnings.
            var compilation = await project.GetCompilationAsync();
            var compilationDiagnostics = compilation.GetDiagnostics();

            var result = new GenerationResult(compilation, syntaxTrees.ToImmutable(), generatorDiagnostics, compilationDiagnostics);

            foreach (var diagnostic in generatorDiagnostics)
            {
                this.logger.WriteLine(diagnostic.ToString());
            }

            foreach (var diagnostic in result.CompilationDiagnostics)
            {
                this.logger.WriteLine(diagnostic.ToString());
            }

            return result;
        }

        private static string EscapeLineEndingCharacters(string whitespace)
        {
            Requires.NotNull(whitespace, nameof(whitespace));
            var builder = new StringBuilder(whitespace.Length * 2);
            foreach (char ch in whitespace)
            {
                switch (ch)
                {
                    case '\n':
                        builder.Append("\\n");
                        break;
                    case '\r':
                        builder.Append("\\r");
                        break;
                    default:
                        builder.Append(ch);
                        break;
                }
            }

            return builder.ToString();
        }

        private static IEnumerable<MetadataReference> GetNetStandard20References()
        {
            var nugetPackageRoot = Environment.GetEnvironmentVariable("NUGET_PACKAGES") ?? Environment.ExpandEnvironmentVariables(@"%USERPROFILE%\.nuget\packages");
            foreach (var dir in Directory.GetDirectories(Path.Combine(nugetPackageRoot, "netstandard.library"), "2.*"))
            {
                var netstandardRoot = Path.Combine(dir, @"build\netstandard2.0\ref");
                foreach (string assembly in Directory.GetFiles(netstandardRoot, "*.dll"))
                {
                    yield return MetadataReference.CreateFromFile(assembly);
                }
                break;
            }
        }

        protected class GenerationResult
        {
            public GenerationResult(
                Compilation compilation,
                ImmutableArray<SyntaxTree> syntaxTrees,
                IReadOnlyList<Diagnostic> generatorDiagnostics,
                IReadOnlyList<Diagnostic> compilationDiagnostics)
            {
                this.Compilation = compilation;
                this.SyntaxTrees = syntaxTrees;
                this.SemanticModels = syntaxTrees.Select(s => compilation.GetSemanticModel(s)).ToImmutableArray();
                this.Declarations = SemanticModels.SelectMany(semanticModel => CSharpDeclarationComputer.GetDeclarationsInSpan(semanticModel, TextSpan.FromBounds(0, semanticModel.SyntaxTree.Length), true, CancellationToken.None)).ToImmutableArray();
                this.GeneratorDiagnostics = generatorDiagnostics;
                this.CompilationDiagnostics = compilationDiagnostics;
            }

            public Compilation Compilation { get; }

            public ImmutableArray<SemanticModel> SemanticModels { get; private set; }

            public ImmutableArray<SyntaxTree> SyntaxTrees { get; }

            internal ImmutableArray<DeclarationInfo> Declarations { get; private set; }

            public IEnumerable<ISymbol> DeclaredSymbols
            {
                get { return this.Declarations.Select(d => d.DeclaredSymbol); }
            }

            public IEnumerable<IMethodSymbol> DeclaredMethods
            {
                get { return this.DeclaredSymbols.OfType<IMethodSymbol>(); }
            }

            public IEnumerable<IPropertySymbol> DeclaredProperties
            {
                get { return this.DeclaredSymbols.OfType<IPropertySymbol>(); }
            }

            public IEnumerable<INamedTypeSymbol> DeclaredTypes
            {
                get { return this.DeclaredSymbols.OfType<INamedTypeSymbol>(); }
            }

            public IReadOnlyList<Diagnostic> GeneratorDiagnostics { get; }

            public IReadOnlyList<Diagnostic> CompilationDiagnostics { get; }
        }

        private class SynchronousProgress<T> : IProgress<T>
        {
            private readonly Action<T> action;

            public SynchronousProgress(Action<T> action)
            {
                Requires.NotNull(action, nameof(action));

                this.action = action;
            }

            public void Report(T value)
            {
                this.action(value);
            }
        }
    }
}