Allow modifying HtmlComparers HtmlDiffer

[md-at-slashwhy]

Is the feature request related to a problem? Please elaborate.
When using bUnit to diff only element types a naive approach could be:

public void ExampleTest()
{
    const string expected = "<BlazorElement diff:ignoreAttributes></BlazorElement>";
    const string markup = """<DifferentBlazorElement some-attribute="value"></DifferentBlazorElement>""";

    var component = Render(markup.ToMarkupRenderFragment());

    component.MarkupMatches(expected);
}

However, this comparison does not fail and would cause the test to pass - which is unexpected.

The suggested solution
This could be fixed without changing existing behaviour by:
a) Allow changing the DiffingStrategyPipeline used in the HtmlComparer e.g. by providing a protected constructor and unsealing the class
b) Extract an interface for IHtmlComparer that can be injected into the DI

Describe any alternative solutions
The issue could be resolved by changing the existing behaviour to throw an exception which in turn would cause the test to fail. This would still not allow bUnit to be extended with further diffing strategy changes and might break existing tests.

Additional context
AngleSharp is highly extensible. The improved performance of sealing the class does not seem to be worth the lack of such extensibility in bUnit.

[linkdotnet]

Hey @md-at-slashwhy

We checked the issue and it is very likely an issue in AngleSharp.Diffing itself. So it is more a bug rather than an issue of the pipeline itself.

That said, there is no real need at the moment to either open up the class to inheritance nor to have extensibility in another way (DI).

PS: We did not seal the class for performance, but as a documentation of architecture/design decisions.

[md-at-slashwhy]

The test using AngleSharp fails as expected:

public void ExampleTest()
{
    // Arrange
    const string expected = "<BlazorElement diff:ignoreAttributes></BlazorElement>";
    const string markup = """<DifferentBlazorElement some-attribute="value"></DifferentBlazorElement>""";
    var strategy = new DiffingStrategyPipeline();
    strategy.AddDefaultOptions();
    var differ = new HtmlDiffer(strategy);

    // Act
    var component = Render(markup.ToMarkupRenderFragment());

    // Assert
    var diffs = differ.Compare(expected, component.Markup);
    Assert.Empty(diffs);
}

[linkdotnet]

True that, if you would do:

var diffs = DiffBuilder
	.Compare(expected)
	.WithTest(markup)
	.WithOptions(o => o
		.AddMatcher(BlazorDiffingHelpers.UnknownElementMatch))
	.Build()
	.ToArray();

Then you also get diffs. So the matcher itself isn't the issue.
It is more about how certain things are treated when applying diff:ignore*

[md-at-slashwhy]

That is true, yet, when changing your example to closer reflect the code of the HtmlComparer the test no longer detects the diffs.

var diffs = DiffBuilder
	.Compare(expected)
	.WithTest(markup)
	.WithOptions(o => o
		.AddDefaultOptions()
		.AddMatcher(BlazorDiffingHelpers.UnknownElementMatch))
	.Build()
	.ToArray();

Note the additional .AddDefaultOptions().

I agree that the matcher alone is not the issue, but the combination used in the HtmlComparer is an issue.

I understood you aren't intending to open up the library to be more extensible. Are you considering alternative solution?

[linkdotnet]

The solution is fixing the bug, which we did over on https://github.com/AngleSharp/AngleSharp.Diffing

The last step is making a new stable release and using this in bUnit.

[md-at-slashwhy]

Awesome! I didn't get that from the messages before. Thank you for your effort.

I'll close this issue and we'll be waiting for the next release.

[linkdotnet]

There we go: v2.2.2 should do the trick for you.

Thanks for reporting and if you can, would be nice to know if it fixes your issue.