verifytests / verify.blazor Goto Github PK

using AngleSharp;
using AngleSharp.Diffing.Core;
using AngleSharp.Dom;
using AngleSharp.Text;
using Bunit.Diffing;
using Bunit.Rendering;
using Microsoft.AspNetCore.Components;
using System.Runtime.CompilerServices;

namespace VerifyTests;

public static class VerifyBunit
{
    private const string BunitFileExtension = "html";

    public static bool Initialized { get; private set; }

    public static void Initialize(bool verifyMarkupOnly = true)
    {
        if (Initialized)
        {
            throw new("Already Initialized");
        }

        Initialized = true;

        InnerVerifier.ThrowIfVerifyHasBeenRun();

        VerifierSettings.RegisterFileConverter<IRenderedFragment>(verifyMarkupOnly ? ConvertFragmentMarkupOnly : ConvertFragment);
        VerifierSettings.AddExtraSettings(settings => settings.Converters.Add(new RenderedFragmentConverter()));
        VerifierSettings.RegisterStringComparer(BunitFileExtension, BunitMarkupComparer);
    }

    private static Task<CompareResult> BunitMarkupComparer(string received, string verified, IReadOnlyDictionary<string, object> context)
    {
        using var parser = new BunitHtmlParser();
        var receivedNodes = parser.Parse(received);
        var verifiedNodes = parser.Parse(verified);
        var diffs = receivedNodes.CompareTo(verifiedNodes);

        var result = diffs.Count == 0
            ? CompareResult.Equal
              : CompareResult.NotEqual(CreateDiffMessage(received, verified, diffs));

        return Task.FromResult(result);
    }

    private static string CreateDiffMessage(string received, string verified, IReadOnlyList<IDiff> diffs)
    {
        var builder = StringBuilderPool.Obtain();
        builder.AppendLine();
        builder.AppendLine("HTML comparison failed. The following errors were found:");

        for (int i = 0; i < diffs.Count; i++)
        {
            builder.Append($"  {i + 1}: ");
            builder.AppendLine(diffs[i] switch
            {
                NodeDiff diff when diff.Target == DiffTarget.Text && diff.Control.Path.Equals(diff.Test.Path, StringComparison.Ordinal)
                    => $"The text in {diff.Control.Path} is different.",
                NodeDiff diff when diff.Target == DiffTarget.Text
                    => $"The expected {NodeName(diff.Control)} at {diff.Control.Path} and the actual {NodeName(diff.Test)} at {diff.Test.Path} is different.",
                NodeDiff diff when diff.Control.Path.Equals(diff.Test.Path, StringComparison.Ordinal)
                    => $"The {NodeName(diff.Control)}s at {diff.Control.Path} are different.",
                NodeDiff diff => $"The expected {NodeName(diff.Control)} at {diff.Control.Path} and the actual {NodeName(diff.Test)} at {diff.Test.Path} are different.",
                AttrDiff diff when diff.Control.Path.Equals(diff.Test.Path, StringComparison.Ordinal)
                    => $"The values of the attributes at {diff.Control.Path} are different.",
                AttrDiff diff => $"The value of the attribute {diff.Control.Path} and actual attribute {diff.Test.Path} are different.",
                MissingNodeDiff diff => $"The {NodeName(diff.Control)} at {diff.Control.Path} is missing.",
                MissingAttrDiff diff => $"The attribute at {diff.Control.Path} is missing.",
                UnexpectedNodeDiff diff => $"The {NodeName(diff.Test)} at {diff.Test.Path} was not expected.",
                UnexpectedAttrDiff diff => $"The attribute at {diff.Test.Path} was not expected.",
                _ => throw new SwitchExpressionException($"Unknown diff type detected: {diffs[i].GetType()}"),
            });
        }

        builder.AppendLine();
        builder.AppendLine("Actual HTML:");
        builder.AppendLine();
        builder.AppendLine(received);
        builder.AppendLine();
        builder.AppendLine("Expected HTML:");
        builder.AppendLine();
        builder.AppendLine(verified);

        return builder.ToPool();

        static string NodeName(ComparisonSource source) => source.Node.NodeType.ToString().ToLowerInvariant();
    }

    private static ConversionResult ConvertFragmentMarkupOnly(IRenderedFragment fragment, IReadOnlyDictionary<string, object> context)
    {
        var markup = fragment.Nodes.ToHtml(DiffMarkupFormatter.Instance).Trim();
        return new ConversionResult(null, BunitFileExtension, markup);
    }

    private static ConversionResult ConvertFragment(IRenderedFragment fragment, IReadOnlyDictionary<string, object> context)
    {
        var markup = fragment.Nodes.ToHtml(DiffMarkupFormatter.Instance).Trim();
        var allNodes = fragment.Nodes.Select(x => x.GetDescendantsAndSelf().Count()).Sum();
        var info = new ComponentInfo(GetInstance(fragment), allNodes);
        return new ConversionResult(info, BunitFileExtension, markup);
    }

    private static IComponent? GetInstance(IRenderedFragment fragment)
    {
        var type = fragment.GetType();
        if (!type.IsGenericType)
        {
            return null;
        }

        var renderComponentInterface = type
            .GetInterfaces()
            .SingleOrDefault(_ =>
                _.IsGenericType &&
                _.GetGenericTypeDefinition() == typeof(IRenderedComponentBase<>));

        if (renderComponentInterface == null)
        {
            return null;
        }

        var instanceProperty = renderComponentInterface.GetProperty("Instance")!;
        return (IComponent)instanceProperty.GetValue(fragment)!;
    }

    private sealed class ComponentInfo
    {
        public string? Component { get; }

        public IComponent? Instance { get; }

        public int NodeCount { get; }

        public ComponentInfo(IComponent? instance, int nodeCount)
        {
            Component = instance?.GetType().FullName;
            Instance = instance;
            NodeCount = nodeCount;
        }
    }

    private sealed class RenderedFragmentConverter : WriteOnlyJsonConverter<IRenderedFragment>
    {
        public override void Write(VerifyJsonWriter writer, IRenderedFragment fragment)
        {
            writer.WriteStartObject();

            writer.WriteMember(fragment, GetInstance(fragment), "Instance");

            writer.WriteMember(fragment, fragment.Markup, "Markup");

            writer.WriteEndObject();
        }
    }
}