c# - fluent assertions should throw

¿Cómo usar Excluir en FluentAssertions para la propiedad en la colección?

Question

Tengo dos clases:

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;}
}

Quiero usar aserciones fluidas para comparar con las instancias de ClassA. Sin embargo, quiero ignorar las ID (porque las ID se habrán asignado después de guardar).

Sé que puedo hacerlo:

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

Que obviamente puedo repetir para cada ClassB en la colección. Sin embargo, estoy buscando una forma de excluir todos los ID (en lugar de hacer una exclusión para cada elemento).

He leído esta pregunta, sin embargo, si elimino los indizadores [0], las aserciones fallan.

es posible?

Answer 1

¿Qué pasa?

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

O podría hacer una coincidencia RegEx en la ruta de la propiedad, como

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

De hecho, me gusta la última, pero las cosas de expresiones regulares hacen que sea un poco difícil de leer. Tal vez debería extender ISubjectInfo con un método para hacer coincidir la ruta con un patrón de comodín, para que pueda hacer esto:

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

Answer 2

Acabo de encontrar un problema similar y la última versión de FluentAssertions ha cambiado un poco las cosas.

Mis objetos contiene diccionarios de otros objetos. Los objetos en los diccionarios contienen otros objetos que quiero excluir. El escenario que tengo está relacionado con la prueba de serialización de Json, donde ignoro ciertas propiedades.

Esto funciona para mí:

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))
  );

Tomó algo de tiempo para averiguar cómo hacerlo, ¡pero es realmente útil!

Answer 3

Basado en la idea de partido RegEx de la respuesta de Dennis Doomen, pude hacerlo funcionar

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

Diferencia con la respuesta de Dennis: pasando su.SelectedMemberPath, doble barra diagonal para escapar entre corchetes.

Answer 4

La forma más fácil es:

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

Answer 5

La forma simple sería establecer aserciones en la colección directamente, combinadas con su exclusión en la ClassA equivalencia de ClassA :

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