Płynna asercja dla warunku OR

Question

Próbuję ustawić płynne asercje dla poniższego warunku. Ale nie mógł znaleźć metody z wyrażeniem lub ObjectAssertion z Or().

Muszę sprawdzić stan mojej służby ma wartość enum Pending lub Active

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

chcę coś,

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

Może ktoś mi pomóc osiągnąć ten cel.

Wersja FluentAsserstions: 4.1.1 (najnowsze od Nuget) Dołączanie przestrzeni nazw 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

Możesz użyć Dopasuj w tym przypadku.

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

FluentAssertions nie obsługuje instrukcji Or() -. Użyj Dopasuj() w przypadku asercji ogólnych.

Answer 2

OR jest dużo trudniejszy następnie AND, jak to, co robi

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

oznacza?

Prawdziwym problemem jest stara się wspierać Orjednocześnie wspierającAnd. Dlatego będę patrząc na piśmie do metod jak

services.ShouldDoAtLeastOneof(params Predicate predicates) 

jako coś bardziej elastyczny jest wątpliwa dla twierdzi w testach jednostkowych.

(Ponieważ nigdy nie użyłem Fluent Assuranceions, nie wiem, czy ma wbudowaną metodę, która to robi. Myślę, że BeOneOf dobrze rozwiązuje bardzo ograniczony przypadek "OR", o który zapytano w pytaniu, jako przedstawione w odpowiedzi Matthew Watsona.)

Answer 3

Spróbuj w ten sposób:

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