How to use Exclude in FluentAssertions for property in collection?

Question

I have two classes:

public class ClassA
{
  public int? ID {get; set;}
  public IEnumerable<ClassB> Children {get; set;}
}

public class ClassB
{
  public int? ID {get; set;}
  public string Name {get; set;}
}

I want to use fluent assertions to compare to ClassA instances. However I want to ignore the IDs (because the IDs will have been assigned after the save).

I know I can do this:

expectedA.ShouldBeEquivalentTo(actualA, options => options.Excluding(x => x.PropertyPath == "Children[0].ID"));

Which I can obviously repeat for each ClassB in the collection. However I'm looking for a way to exclude the all the IDs (rather than doing an exclude for each element).

I've read this question however if I remove the [0] indexers the assertions fail.

Is this possible?

Archi

Answer 1

What about?

expected.ShouldBeEquivalentTo(actualA, options => options.Excluding(su => 
   (su.RuntimeType == typeof(ClassB)) && (su.PropertyPath.EndsWith("Id")));`

Or you could do a RegEx match on the property path, such as

expected.ShouldBeEquivalentTo(actualA, options => options.Excluding(su => (Regex.IsMatch
   ("Children\[.+\]\.ID"));

I actually like that last one, but the regex stuff makes it a bit difficult to read. Maybe I should extend ISubjectInfo with a method to match the path against a wildcard pattern, so that you can do this:

expected.ShouldBeEquivalentTo(actualA, options => options
  .Excluding(su => su.PathMatches("Children[*].ID")));

Usher

I'm going to mark this one as the answer as the regex in an extension method is the approach I went with in the end – Archi

How has this changed in more recent versions of FluentAssertions? I'm not sure PropertyPath is still there – Mainsheet

I tried both options without success, but was able to fix RegEx option to work with current version - see #22143076 . By the way, the new name for PropertyPath is SelectedMemberPath – Megilp

Regex.IsMatch(x.SelectedMemberPath, @"Children\[\d+\]\.ID") – Rathbun

FluentAssertions v6 removed SelectedMemberPath the solution here is: options => options.Excluding((IMemberInfo x) => x.DeclaringType == typeof(ClassB) && x.Path.EndsWith("Id")) – Scission

SelectedMemeberPath was renamed to Path in v.6.0.0: fluentassertions.com/releases/#600 – Sublingual

Answer 2

I've just come across a similar problem and the latest version of FluentAssertions has changed things a bit.

My objects contains dictionaries of other objects. The objects in the dictionaries contain other objects that I want to exclude. The scenario I have is around testing Json serialization where I ignore certain properties.

This works for me:

gotA.ShouldBeEquivalentTo(expectedB , config => 
  config
    .Excluding(ctx => ctx.SelectedMemberInfo.MemberType == typeof(Venue))
    .Excluding(ctx => ctx.SelectedMemberInfo.MemberType == typeof(Exhibit))
    .Excluding(ctx => ctx.SelectedMemberInfo.MemberType == typeof(Content))
    .Excluding(ctx => ctx.SelectedMemberInfo.MemberType == typeof(Survey))
    .Excluding(ctx => ctx.SelectedMemberInfo.MemberType == typeof(Media))
  );

Took some time to work out how to do it, but it's really useful!

Axinomancy

For what it is worth, you can also pass in an anonymous object as the expectation since FA 5 and include only the properties you care about. – Usher

Answer 3

This is supported by FluentAssertions 6.7

actualA.Should().BeEquivalentTo(expectedA, options =>
    options
       .For(a => a.Children)
       .Exclude(b => b.ID));

Profitsharing

I know this is an old question but this answer should be the accepted one. – Ellyellyn

Is there equivalent for including apparently, I want to validate only few properties from object. – Never

Answer 4

Simple way would be to set assertions on collection directly, combined with its exclusion on ClassA equivalency assertion:

expectedA.ShouldBeEquivalentTo(expectedB,
   o => o.Excluding(s => s.PropertyInfo.Name == "Children"));
expectedA.Children.ShouldBeEquivalentTo(expectedB.Children,
   o => o.Excluding(s => s.PropertyInfo.Name = "Id"));

Sarazen

I think Propertyinfo does no longer exist. SelectedMemberInfo.Name should do it instead. – Septuplet

Answer 5

There are a few valid answers here, but I am adding another one that does not involve stringly-typed expressions.

expectedA.ShouldBeEquivalentTo(expectedB, o => o.Excluding(s => s.Children));
expectedA.Children.ShouldBeEquivalentTo(expectedB.Children, o => o.Excluding(s => s.Id));

Anastigmatic

Answer 6

The ShouldBeEquivalentTo method seems to be obsolete now, in order to get path for the accepted answer you can use the Excluding overload with IMemberInfo.SelectedMemberPath instead:

expected.Should().BeEquivalentTo(actualA, options => 
    options.Excluding((IMemberInfo mi) => mi.SelectedMemberPath.EndsWith("ID")));

Beaconsfield

Answer 7

actual.Should().BeEquivalentTo(expected,
  assertionOptions => assertionOptions
    .Excluding(x => x.CreationTimestamp))

BUT if you work with structs and class overriding equals, then you should change the default comparing with ComparingByMembers https://fluentassertions.com/objectgraphs/#value-types

actual.Should().BeEquivalentTo(expected,
  assertionOptions => assertionOptions
    .Excluding(x => x.CreationTimestamp)
    .ComparingByMembers<T>())

Graft

Answer 8

Based on RegEx match idea from Dennis Doomen‘s answer I was able to make it working

expected.ShouldBeEquivalentTo(actualA, options =>
  options.Excluding(su => 
     (Regex.IsMatch(su.SelectedMemberPath, "Children\\[.+\\].ID"));

Difference with Dennis answer: passing su.SelectedMemberPath, double back slashes to escape square brackets.

Megilp

SelectedMemeberPath was renamed to Path in v.6.0.0 fluentassertions.com/releases/#600 – Sublingual

Answer 9

The easiest way is:

expected.ShouldBeEquivalentTo(actual, config => config.ExcludingMissingMembers());

Warram

OP asked to exclude some existing (NOT Missing) members. – Megilp

Answer 10

I thinks the syntax is something like

       actual.Should().BeEquivalentTo(
        expected, 
        config => config.Excluding(o => o.Id).Excluding(o => o.CreateDateUtc) });

Dysteleology

Answer 11

An extension class where you can pass a list of expressions

public static class FluentAssertionsExtensions {
    public static EquivalencyAssertionOptions<T> ExcludingNextProperties<T>(
        this EquivalencyAssertionOptions<T> options,
        params Expression<Func<T, object>>[] expressions) {
        foreach (var expression in expressions) {
            options.Excluding(expression);
        }

        return options;
    }
}

Usage

actual.Should().BeEquivalentTo(expected, 
            config => config.ExcludingNextProperties(
                o => o.Id, 
                o => o.CreateDateUtc))

Tenant