Fließende Behauptung für OR Bedingung

Question

Ich versuche, die fließende Behauptung für die folgende Bedingung aufzustellen. Aber eine Methode mit Ausdruck oder eine ObjectAssertion mit Or() konnte nicht gefunden werden.

Ich habe den Status meiner Service-Wert von Enum Pending oder Active

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

Ich möchte wie etwas zu überprüfen,

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

Könnte mir jemand bitte helfen dieses Ziel zu erreichen.

FluentAsserstions Version: 4.1.1 (Neu von Nuget) Den 4.1 FluentAssertions.Primitive-Namespace anhängen.

// 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

Sie können für diesen Fall Match verwenden.

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

FluentAssertions unterstützt keine Or() - Anweisung. Verwenden Sie Match() für allgemeine Behauptungen.

Answer 2

OR ist viel schwieriger, dann AND, wie das, was tut

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

bedeuten?

Das eigentliche Problem ist zu versuchen, Orzu unterstützen, während auch unterstütztAnd. Deshalb I

services.ShouldDoAtLeastOneof(params Predicate predicates) 

als etwas flexibler ist fraglich schriftlich behauptet in Unit-Tests ein Verfahren wie suchen würde.

(Da ich Fluent Assertions noch nie benutzt habe, weiß ich nicht, ob es eine eingebaute Methode hat, die das tut. Ich denke, die BeOneOf löst den sehr begrenzten Fall von "OR" in der Frage in Matthew Watsons Antwort gezeigt.)

Answer 3

auf diese Weise versuchen:

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