Asserzione fluente per condizione OR

Question

Sto tentando di impostare l'asserzione fluente per la condizione sottostante. Ma non riusciva a trovare un metodo con expression o ObjectAssertion con Or().

ho avuto modo di verificare lo stato del mio servizio è di valore enum Pending o Active

services.Should().HaveCount(totalServices).And.BeOfType<Service>().Which.ServiceStatusKey.Should().Be(Status.Pending); 

voglio qualcosa di simile,

.Be(Status.Pending).Or().Be(Status.Active) 

Potrebbe qualcuno soddisfare per aiutarlo raggiungimento di questo.

FluentAsserstions Versione: 4.1.1 (Ultime da Nuget) Collegamento dello spazio dei nomi 4.1 FluentAssertions.Primitive.

// Decompiled with JetBrains decompiler 
// Type: FluentAssertions.Primitives.ObjectAssertions 
// Assembly: FluentAssertions.Core, Version=4.1.1.0, Culture=neutral, PublicKeyToken=33f2691a05b67b6a 
// MVID: 090116C5-E9A5-4878-B62E-DE0EBFEBBE14 
// Assembly location: C:\RA\P4V\BOSS\trunk\M5Portal\packages\FluentAssertions.4.1.1\lib\net45\FluentAssertions.Core.dll 

using FluentAssertions; 
using FluentAssertions.Common; 
using FluentAssertions.Execution; 
using System; 
using System.Diagnostics; 

namespace FluentAssertions.Primitives 
{ 
    /// <summary> 
    /// Contains a number of methods to assert that an <see cref="T:System.Object"/> is in the expected state. 
    /// 
    /// </summary> 
    [DebuggerNonUserCode] 
    public class ObjectAssertions : ReferenceTypeAssertions<object, ObjectAssertions> 
    { 
    /// <summary> 
    /// Returns the type of the subject the assertion applies on. 
    /// 
    /// </summary> 
    protected override string Context 
    { 
     get 
     { 
     return "object"; 
     } 
    } 

    public ObjectAssertions(object value) 
    { 
     this.Subject = value; 
    } 

    /// <summary> 
    /// Asserts that an object equals another object using its <see cref="M:System.Object.Equals(System.Object)"/> implementation. 
    /// 
    /// </summary> 
    /// <param name="expected">The expected value</param><param name="because">A formatted phrase as is supported by <see cref="M:System.String.Format(System.String,System.Object[])"/> explaining why the assertion 
    ///    is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically. 
    ///    </param><param name="reasonArgs">Zero or more objects to format using the placeholders in <see cref="!:because"/>. 
    ///    </param> 
    public AndConstraint<ObjectAssertions> Be(object expected, string because = "", params object[] reasonArgs) 
    { 
     Execute.Assertion.BecauseOf(because, reasonArgs).ForCondition(ObjectExtensions.IsSameOrEqualTo(this.Subject, expected)).FailWith("Expected {context:object} to be {0}{reason}, but found {1}.", expected, this.Subject); 
     return new AndConstraint<ObjectAssertions>(this); 
    } 

    /// <summary> 
    /// Asserts that an object does not equal another object using its <see cref="M:System.Object.Equals(System.Object)"/> method. 
    /// 
    /// </summary> 
    /// <param name="unexpected">The unexpected value</param><param name="because">A formatted phrase explaining why the assertion should be satisfied. If the phrase does not 
    ///    start with the word <i>because</i>, it is prepended to the message. 
    ///    </param><param name="reasonArgs">Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders. 
    ///    </param> 
    public AndConstraint<ObjectAssertions> NotBe(object unexpected, string because = "", params object[] reasonArgs) 
    { 
     Execute.Assertion.ForCondition(!ObjectExtensions.IsSameOrEqualTo(this.Subject, unexpected)).BecauseOf(because, reasonArgs).FailWith("Did not expect {context:object} to be equal to {0}{reason}.", unexpected); 
     return new AndConstraint<ObjectAssertions>(this); 
    } 

    /// <summary> 
    /// Asserts that an object is an enum and has a specified flag 
    /// 
    /// </summary> 
    /// <param name="expectedFlag">The expected flag.</param><param name="because">A formatted phrase explaining why the assertion should be satisfied. If the phrase does not 
    ///    start with the word <i>because</i>, it is prepended to the message. 
    ///    </param><param name="reasonArgs">Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders. 
    ///    </param> 
    public AndConstraint<ObjectAssertions> HaveFlag(Enum expectedFlag, string because = "", params object[] reasonArgs) 
    { 
     Execute.Assertion.BecauseOf(because, reasonArgs).ForCondition(this.Subject != null).FailWith("Expected type to be {0}{reason}, but found <null>.", (object) expectedFlag.GetType()).Then.ForCondition(this.Subject.GetType() == expectedFlag.GetType()).FailWith("Expected the enum to be of type {0} type but found {1}{reason}.", (object) expectedFlag.GetType(), (object) this.Subject.GetType()).Then.Given<Enum>((Func<Enum>) (() => this.Subject as Enum)).ForCondition((Func<Enum, bool>) (@enum => @enum.HasFlag(expectedFlag))).FailWith("The enum was expected to have flag {0} but found {1}{reason}.", (Func<Enum, object>) (_ => (object) expectedFlag), (Func<Enum, object>) (@enum => (object) @enum)); 
     return new AndConstraint<ObjectAssertions>(this); 
    } 

    /// <summary> 
    /// Asserts that an object is an enum and does not have a specified flag 
    /// 
    /// </summary> 
    /// <param name="unexpectedFlag">The unexpected flag.</param><param name="because">A formatted phrase explaining why the assertion should be satisfied. If the phrase does not 
    ///    start with the word <i>because</i>, it is prepended to the message. 
    ///    </param><param name="reasonArgs">Zero or more values to use for filling in any <see cref="M:System.String.Format(System.String,System.Object[])"/> compatible placeholders. 
    ///    </param> 
    public AndConstraint<ObjectAssertions> NotHaveFlag(Enum unexpectedFlag, string because = "", params object[] reasonArgs) 
    { 
     Execute.Assertion.BecauseOf(because, reasonArgs).ForCondition(this.Subject != null).FailWith("Expected type to be {0}{reason}, but found <null>.", (object) unexpectedFlag.GetType()).Then.ForCondition(this.Subject.GetType() == unexpectedFlag.GetType()).FailWith("Expected the enum to be of type {0} type but found {1}{reason}.", (object) unexpectedFlag.GetType(), (object) this.Subject.GetType()).Then.Given<Enum>((Func<Enum>) (() => this.Subject as Enum)).ForCondition((Func<Enum, bool>) (@enum => !@enum.HasFlag(unexpectedFlag))).FailWith("Did not expect the enum to have flag {0}{reason}.", new object[1] 
     { 
     (object) unexpectedFlag 
     }); 
     return new AndConstraint<ObjectAssertions>(this); 
    } 
    } 
} 

Answer 1

È possibile utilizzare la corrispondenza per questo caso.

ServiceStatusKey.Should().Match<Status>(p=>p==Status.Pending || p == Status.Active); 

FluentAssertions non supporta un'istruzione Or(). Usa Match() per affermazioni di carattere generale.

Answer 2

OR è molto più difficile poi AND, come quello che fa

A().Or.B().And.C().Or.D() 

significa?

Il vero problema è provare a supportare Ormentre supporta ancheAnd. Pertanto sarei guardando la scrittura di un metodo come

services.ShouldDoAtLeastOneof(params Predicate predicates) 

come qualcosa di più flessibile è discutibile per asserisce in unit test.

(Come non ho mai usato Fluent Assertions, non so se ha un metodo integrato che lo fa. Penso che BeOneOf risolva bene il caso molto limitato di "OR" richiesto nella domanda, come mostrato nella risposta di Matthew Watson.)

Answer 3

provare in questo modo:

(services.Status == Status.Pending || services.Status == Status.Active).Should().BeTrue("Message when it is false.");