GeneratorTestHelper.cs

using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;
using System.Text;
using Microsoft.CodeAnalysis;
using HotChocolate;
using HotChocolate.Language;
using StrawberryShake.CodeGeneration.Analyzers;
using StrawberryShake.CodeGeneration.Analyzers.Models;
using StrawberryShake.CodeGeneration.Utilities;
using RequestStrategyGen = StrawberryShake.Tools.Configuration.RequestStrategy;
using static StrawberryShake.CodeGeneration.CSharp.CSharpGenerator;

namespace StrawberryShake.CodeGeneration.CSharp;

public static class GeneratorTestHelper
{
    public static IReadOnlyList<IError> AssertError(params string[] fileNames)
    {
        var result = Generate(
            fileNames,
            new CSharpGeneratorSettings
            {
                Namespace = "Foo.Bar",
                ClientName = "FooClient",
                AccessModifier = AccessModifier.Public
            });

        Assert.True(
            result.Errors.Any(),
            "It is expected that the result has no generator errors!");

        return result.Errors;
    }

    public static void AssertResult([StringSyntax("graphql")] params string[] sourceTexts) =>
        AssertResult(true, sourceTexts);

    public static void AssertResult(
        bool strictValidation,
        [StringSyntax("graphql")] params string[] sourceTexts) =>
        AssertResult(
            new AssertSettings { StrictValidation = strictValidation },
            sourceTexts);

    public static void AssertResult(
        AssertSettings settings,
        [StringSyntax("graphql")] params string[] sourceTexts)
    {
        AssertResult(settings, false, sourceTexts);
    }

    public static void AssertResult(
        AssertSettings settings,
        bool skipWarnings,
        params string[] sourceTexts)
    {
        var clientModel = CreateClientModel(sourceTexts, settings.StrictValidation, settings.NoStore);

        var documents = new StringBuilder();
        var documentNames = new HashSet<string>();

        documents.AppendLine("// ReSharper disable ArrangeObjectCreationWhenTypeEvident");
        documents.AppendLine("// ReSharper disable BuiltInTypeReferenceStyle");
        documents.AppendLine("// ReSharper disable ConvertToAutoProperty");
        documents.AppendLine("// ReSharper disable InconsistentNaming");
        documents.AppendLine("// ReSharper disable PartialTypeWithSinglePart");
        documents.AppendLine("// ReSharper disable PreferConcreteValueOverDefault");
        documents.AppendLine("// ReSharper disable RedundantNameQualifier");
        documents.AppendLine("// ReSharper disable SuggestVarOrType_SimpleTypes");
        documents.AppendLine("// ReSharper disable UnusedMember.Global");
        documents.AppendLine("// ReSharper disable UnusedMethodReturnValue.Local");
        documents.AppendLine("// ReSharper disable UnusedType.Global");
        documents.AppendLine("// ReSharper disable UnusedVariable");
        documents.AppendLine();

        if (settings.Profiles.Count == 0)
        {
            settings.Profiles.Add(TransportProfile.Default);
        }

        var result = Generate(
            clientModel,
            new CSharpGeneratorSettings
            {
                Namespace = settings.Namespace ?? "Foo.Bar",
                ClientName = settings.ClientName ?? "FooClient",
                AccessModifier = settings.AccessModifier,
                StrictSchemaValidation = settings.StrictValidation,
                RequestStrategy = settings.RequestStrategy,
                TransportProfiles = settings.Profiles,
                NoStore = settings.NoStore,
                InputRecords = settings.InputRecords,
                EntityRecords = settings.EntityRecords,
                RazorComponents = settings.RazorComponents
            });

        Assert.False(
            result.Errors.Any(),
            "It is expected that the result has no generator errors!");

        foreach (var document in result.Documents)
        {
            if (!documentNames.Add(document.Name))
            {
                Assert.Fail($"Document name duplicated {document.Name}");
            }

            if (document.Kind == SourceDocumentKind.CSharp)
            {
                documents.AppendLine("// " + document.Name);
                documents.AppendLine();
                documents.AppendLine(document.SourceText);
                documents.AppendLine();
            }
            else if (document.Kind == SourceDocumentKind.GraphQL)
            {
                documents.AppendLine("// " + document.Name);
                documents.AppendLine("// " + document.Hash);
                documents.AppendLine();

                using var reader = new StringReader(document.SourceText);
                string? line;

                do
                {
                    line = reader.ReadLine();
                    if (line is not null)
                    {
                        documents.AppendLine("// " + line);
                    }
                } while (line is not null);

                documents.AppendLine();
            }
        }

        if (settings.SnapshotFile is not null)
        {
            MatchSnapshotAtPath(documents.ToString(), settings.SnapshotFile);
        }
        else
        {
            documents.ToString().MatchSnapshot();
        }

        var diagnostics = CSharpCompiler.GetDiagnosticErrors(documents.ToString());

        if (skipWarnings)
        {
            diagnostics = diagnostics
                .Where(x => x.Severity == DiagnosticSeverity.Error)
                .ToList();
        }

        if (diagnostics.Any())
        {
            Assert.Fail("Diagnostic Errors: \n"
                + diagnostics
                    .Select(x =>
                        $"{x.GetMessage()}"
                        + $" (Line: {x.Location.GetLineSpan().StartLinePosition.Line})")
                    .Aggregate((acc, val) => acc + "\n" + val));
        }
    }

    public static void AssertStarWarsResult([StringSyntax("graphql")] params string[] sourceTexts) =>
        AssertStarWarsResult(
            new AssertSettings { StrictValidation = true },
            sourceTexts);

    public static void AssertStarWarsResult(
        AssertSettings settings,
        [StringSyntax("graphql")] params string[] sourceTexts)
    {
        var source = new string[sourceTexts.Length + 2];

        source[0] = FileResource.Open("Schema.graphql");
        source[1] = FileResource.Open("Schema.extensions.graphql");

        Array.Copy(
            sourceTexts,
            sourceIndex: 0,
            source,
            destinationIndex: 2,
            length: sourceTexts.Length);

        AssertResult(settings, true, source);
    }

    public static AssertSettings CreateIntegrationTest(
        RequestStrategyGen requestStrategy = RequestStrategyGen.Default,
        TransportProfile[]? profiles = null,
        AccessModifier accessModifier = AccessModifier.Public,
        bool noStore = false,
        [CallerMemberName] string? testName = null,
        [CallerFilePath] string? callerFilePath = null)
    {
        ArgumentException.ThrowIfNullOrEmpty(testName);
        ArgumentException.ThrowIfNullOrEmpty(callerFilePath);

        var folder = System.IO.Path.GetDirectoryName(callerFilePath)
            ?? throw new ArgumentException(
                $"Could not determine directory from caller file path '{callerFilePath}'.",
                nameof(callerFilePath));
        var testFile = System.IO.Path.Combine(folder, testName + "Test.cs");
        var ns = "StrawberryShake.CodeGeneration.CSharp.Integration." + testName;

        if (!File.Exists(testFile))
        {
            File.WriteAllText(
                testFile,
                FileResource.Open("TestTemplate.txt")
                    .Replace("{TestName}", testName)
                    .Replace("{Namespace}", ns));
        }

        return new AssertSettings
        {
            ClientName = testName + "Client",
            Namespace = ns,
            AccessModifier = accessModifier,
            StrictValidation = true,
            SnapshotFile = System.IO.Path.Combine(folder, testName + "Test.Client.cs"),
            RequestStrategy = requestStrategy,
            NoStore = noStore,
            Profiles = (profiles ??
            [
                TransportProfile.Default
            ]).ToList()
        };
    }

    private static void MatchSnapshotAtPath(string content, string snapshotFile)
    {
        content = content.Replace("\r\n", "\n");

        if (!File.Exists(snapshotFile))
        {
            CheckStrictMode();
            File.WriteAllText(snapshotFile, content);
            return;
        }

        var existing = File.ReadAllText(snapshotFile).Replace("\r\n", "\n");
        if (string.Equals(existing, content, StringComparison.Ordinal))
        {
            return;
        }

        var folder = System.IO.Path.GetDirectoryName(snapshotFile)!;
        var mismatchDir = System.IO.Path.Combine(folder, "__snapshots__", "__mismatch__");
        Directory.CreateDirectory(mismatchDir);
        var mismatchFile = System.IO.Path.Combine(mismatchDir, System.IO.Path.GetFileName(snapshotFile));
        File.WriteAllText(mismatchFile, content);

        Assert.Fail($"Snapshot mismatch. Mismatch file written to {mismatchFile}");
    }

    private static void CheckStrictMode()
    {
        var value = Environment.GetEnvironmentVariable("COOKIE_CRUMBLE_STRICT_MODE");

        if (string.Equals(value, "on", StringComparison.Ordinal)
            || (bool.TryParse(value, out var b) && b))
        {
            Assert.Fail(
                "Strict mode is enabled and no snapshot has been found "
                + "for the current test. Create a new snapshot locally and "
                + "rerun your tests.");
        }
    }

    private static ClientModel CreateClientModel(
        string[] sourceText,
        bool strictValidation,
        bool noStore)
    {
        var files = sourceText
            .Select(s => new GraphQLFile(Utf8GraphQLParser.Parse(s)))
            .ToList();

        var typeSystemDocs = files.GetTypeSystemDocuments().ToList();
        var executableDocs = files.GetExecutableDocuments().ToList();

        var analyzer = new DocumentAnalyzer();

        analyzer.SetSchema(SchemaHelper.Load(typeSystemDocs, strictValidation, noStore));

        foreach (var executable in executableDocs.Select(file => file.Document))
        {
            analyzer.AddDocument(executable);
        }

        return analyzer.Analyze();
    }

    public class AssertSettings
    {
        public string? ClientName { get; set; }

        public string? Namespace { get; set; }

        public AccessModifier AccessModifier { get; set; }
            = AccessModifier.Public;

        public bool StrictValidation { get; set; }

        public string? SnapshotFile { get; set; }

        public bool NoStore { get; set; }

        public bool InputRecords { get; set; }

        public bool EntityRecords { get; set; }

        public bool RazorComponents { get; set; }

        public List<TransportProfile> Profiles { get; set; } = [];

        public RequestStrategyGen RequestStrategy { get; set; } =
            RequestStrategyGen.Default;
    }
}