FluentAssertions - wie make ShouldBe EquivalentTo leer und null als gleich

Question

Ich verwende Fluent Assertion-Bibliothek als Teil meiner Komponententests für einige benutzerdefinierte Serialisierungscode und ich bin auf der Suche nach einer Möglichkeit zum Fordern von ShouldBeEquivalentTo als gleich Null und leere Liste zu vergleichen .

Grundsätzlich meine Tests etwas wie folgt aussehen:

[Test] 
    public void Should_be_xxx() 
    { 
     ClassWithList one = new ClassWithList { Id = "ten", Items = null }; 

     string serialized = Serialize(one); 
     ClassWithList two = Deserialize(serialized); 

     two.ShouldBeEquivalentTo(one); 
    } 

jedoch eines der Merkmale des Deserialize Methode ist, dass, wenn eine Sammlung Typ wird in den Eingangsdaten fehlt, ist es die Eigenschaft auf der entserialisierten Klasse setzt zu einer leeren Liste statt null. Also, sehr vereinfacht, ich am Ende mit einer Situation, in der in Beispiel zwei, Items = new List<string> eher als null.

Offensichtlich könnte ich one.Items = new List<string>() vor dem Vergleich setzen, aber in Wirklichkeit habe ich eine große Anzahl von komplexen Domain-Objekten, die ich in diesen Methoden behaupte, und ich suche nach einer allgemeinen Lösung. Um es anders auszudrücken, weiß jemand, wie den folgenden Testdurchlauf zu machen:

public class ClassWithList 
    { 
     public string Id { get; set; } 
     public List<string> Items { get; set; } 
    } 

    [Test] 
    public void Should_be_xxx() 
    { 
     ClassWithList one = new ClassWithList { Id = "ten", Items = null }; 
     ClassWithList two = new ClassWithList { Id = "ten", Items = new List<string>() }; 

     two.ShouldBeEquivalentTo(one); 
    } 

Um es anders auszudrücken, ich bin auf der Suche den folgenden Test für alle Sammlungen in einer Klasse X als Teil des Vergleich Gleichwertigkeit anzuwenden :

if (subject.Items == null) 
    { 
    expected.Items.Should().BeEmpty(); 
    } 
    else 
    { 
    expected.Items.Should().BeEquivalentTo(subject.Items); 
    } 

Answer 1

Basierend auf den Informationen von Dennis oben, konnte ich dies wird den folgenden eigentlichen Code lösen:

public class ClassWithList 
    { 
     public string Id { get; set; } 
     public List<string> Items { get; set; } 
     public List<ClassWithList> Nested { get; set; } 
    } 

    [TestClass] 
    public class Test 
    { 
     [TestMethod] 
     public void Should_compare_null_to_empty() 
     { 
      ClassWithList one = new ClassWithList { Id = "ten", Items = null, Nested = new List<ClassWithList> { new ClassWithList { Id = "a" } } }; 
      ClassWithList two = new ClassWithList { Id = "ten", Items = new List<string>(), Nested = new List<ClassWithList> { new ClassWithList { Id = "a", Items = new List<string>(), Nested = new List<ClassWithList> { } } } }; 

      two.ShouldBeEquivalentTo(one, opt => opt 
       .Using<IEnumerable>(CheckList) 
       .When(info => typeof(IEnumerable).IsAssignableFrom(info.CompileTimeType))); 
     } 

     private void CheckList(IAssertionContext<IEnumerable> a) 
     { 
      if (a.Expectation == null) 
      { 
       a.Subject.Should().BeEmpty(); 
      } 
      else 
      { 
       a.Subject.ShouldBeEquivalentTo(a.Expectation, opt => opt 
        .Using<IEnumerable>(CheckList) 
        .When(info => typeof(IEnumerable).IsAssignableFrom(info.CompileTimeType))); 
      } 
     } 
    } 

Answer 2

Sie erhalten eine individuelle 'IEquivalencyStep' oder u.se ‚options.Using (benutzerdefinierte Aktion) .WhenTypeIs (Prädikat) haben zu implementieren.