ShouldBeEquivalentTo with option RespectingRuntimeTypes does not respect runtime types

This test should fail IMHO, but it doesn’t. Am I wrong, or is this a bug? Maybe I misunderstood RespectingRuntimeTypes.

using System.Collections.Generic;
using FluentAssertions;
using Xunit;

public class Container
{
	public Container(params IItem[] items) { this.Items = items; }
	public IReadOnlyCollection<IItem> Items { get; }
}

public interface IItem
{
}

public class A : IItem
{
	public A(string s) { this.S = s; }
	public string S { get; }
}

public class B : IItem
{
	public B(string s) { this.S = s; }
	public string S { get; }
}

public class Repro
{
	[Fact]
	public void DifferentRuntimeTypesShouldNotBeEquivalentWhenUsingRespectingRuntimeTypes()
	{
		var a = new Container(new A("A"));
		var b = new Container(new B("A"));

		// this should fail but succeeds
		a.Should().BeEquivalentTo(b, o => o.RespectingRuntimeTypes());
	}
}

Expected behavior:

The above test should fail because the elements in the lists of the containers have a different A vs. B and I specified to RespectRuntimeTypes.

Actual behavior:

The test succeeds and does not detect the difference.

Versions

<PropertyGroup>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="FluentAssertions" Version="5.5.3" />
    <PackageReference Include="xunit.core" Version="2.4.1" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.7.2" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
    <Reference Include="Microsoft.CSharp" />
  </ItemGroup>

[ursenzler]

Got it working for my scenarios:

	public class MatchTypeEquivalencyStep : IEquivalencyStep
	{
		public bool CanHandle(
			IEquivalencyValidationContext context,
			IEquivalencyAssertionOptions config)
		{
			Type subjectType = config.GetExpectationType(context);

			return !IsCollection(subjectType) && !IsAnonymousType(subjectType);
		}

		public bool Handle(
			IEquivalencyValidationContext context,
			IEquivalencyValidator parent,
			IEquivalencyAssertionOptions config)
		{
			if (context.Subject != null && context.Expectation != null)
			{
				context.Subject.GetType().Should().Be(context.Expectation.GetType());
			}

			return false;
		}

		private static bool IsCollection(
			Type type)
		{
			return !typeof(string).IsAssignableFrom(type) && typeof(IEnumerable).IsAssignableFrom(type);
		}

		private static bool IsAnonymousType(
			Type type)
		{
			bool hasCompilerGeneratedAttribute = type.GetCustomAttributes(typeof(CompilerGeneratedAttribute), false).Any();
			bool nameContainsAnonymousType = type.FullName.Contains("AnonymousType");
			bool isAnonymousType = hasCompilerGeneratedAttribute && nameContainsAnonymousType;

			return isAnonymousType;
		}
	}
}

I really like the extensibility provided by FluentAssertions 😃

[ursenzler]

This is a great idea.

Unfortunately, I struggle to implement my own EquivalencyStep.

I have this:

public class MatchTypeEquivalencyStep : IEquivalencyStep
{
	public bool CanHandle(
		IEquivalencyValidationContext context,
		IEquivalencyAssertionOptions config)
	{
		return true; // what to write here?
	}

	public bool Handle(
		IEquivalencyValidationContext context,
		IEquivalencyValidator parent,
		IEquivalencyAssertionOptions config)
	{
		context.Subject.GetType().Should().Be(context.Expectation.GetType());

		return false;
	}

	private static bool IsCollection(Type type)
	{
		return !typeof(string).IsAssignableFrom(type) && typeof(IEnumerable).IsAssignableFrom(type);
	}
}

But, whatever I write in the CanHandle method, the result is a NullReferenceException somewhere in FluentAssertions.

It should not handle any kind of collections (that’s why I copied the IsCollection method from FluentAssertions).

Do you have a tip for me?

Additionally, I’m not sure whether the Handle method is correct. I’m a bit rusty with these RuntimeTypes.