Проверка правильности сопоставления набора объектов

Во-первых, спасибо всем за участие. Я почти ничего не знал о SemanticComparer<'T>, и это определенно обеспечивает хороший набор строительных блоков для создания общих объектов в этом пространстве. пост Никоса дает отличную еду для мысли в области тоже. Меня не должно было удивить, что File тоже существует — у @ptrelford действительно есть библиотека для всего (FSharpValue тоже очень ценно)!

К счастью, мы пришли к такому выводу. К сожалению, это не единый всеобъемлющий инструмент или метод, а, что еще лучше, набор методов, которые можно использовать по мере необходимости в данном контексте.

Во-первых, проблема обеспечения полноты отображения на самом деле является ортогональной проблемой. Вопрос относится к оператору ====: -

let (====) x y = (x |> Set.ofSeq) = (y |> Set.ofSeq)

Это определенно лучший подход по умолчанию — опираться на структурное равенство. Следует отметить, что, поскольку он зависит от постоянных наборов F#, он требует, чтобы ваш тип поддерживал : comparison (а не только : equality).

При сравнении наборов с проверенным путем структурного равенства полезным методом является использование HashSet<T> с пользовательским IEqualityComparer:-

[<AutoOpen>]
module UnorderedSeqComparisons = 
    let seqSetEquals ec x y = 
        HashSet<_>( x, ec).SetEquals( y)

    let (==|==) x y equals =
        let funEqualityComparer = {
            new IEqualityComparer<_> with
                member this.GetHashCode(obj) = 0 
                member this.Equals(x,y) = 
                    equals x y }
        seqSetEquals funEqualityComparer x y 

параметр equals для ==|== равен 'a -> 'a -> bool, что позволяет использовать сопоставление с образцом для деструктуризации аргументов в целях сравнения. Это хорошо работает, если входная или результирующая сторона, естественно, уже являются кортежами. Пример:

sut.Store( inputs)
let results = sut.Read() 

let expecteds = seq { for x in inputs -> x.Name,x.ValidUntil } 

test <@ expecteds ==|== results 
    <| fun (xN,xD) (yN,yD) -> 
        xF=yF 
        && xD |> equalsWithinASecond <| yD @>

Хотя SemanticComparer<'T> может выполнять свою работу, просто не стоит возиться с для кортежей, когда у вас есть возможность сопоставления с образцом. например Используя SemanticComparer<'T>, приведенный выше тест можно выразить как:

test <@ expecteds ==~== results 
    <| [ funNamedMemberComparer "Item2" equalsWithinASecond ] @>

с помощью помощника:

[<AutoOpen>]
module MemberComparerHelpers = 
    let funNamedMemberComparer<'T> name equals = {                
        new IMemberComparer with 
            member this.IsSatisfiedBy(request: PropertyInfo) = 
                request.PropertyType = typedefof<'T> 
                && request.Name = name
            member this.IsSatisfiedBy(request: FieldInfo) = 
                request.FieldType = typedefof<'T> 
                && request.Name = name
            member this.GetHashCode(obj) = 0
            member this.Equals(x, y) = 
                equals (x :?> 'T) (y :?> 'T) }
    let valueObjectMemberComparer() = { 
        new IMemberComparer with 
            member this.IsSatisfiedBy(request: PropertyInfo) = true
            member this.IsSatisfiedBy(request: FieldInfo) = true
            member this.GetHashCode(obj) = hash obj
            member this.Equals(x, y) = 
                x.Equals( y) }
    let (==~==) x y mcs = 
        let ec = SemanticComparer<'T>( seq { 
            yield valueObjectMemberComparer()
            yield! mcs } )
        seqSetEquals ec x y

Все вышеизложенное лучше всего понять, прочитав Nikos Пост Баксеваниса СЕЙЧАС!

Для типов или записей может работать метод ==|== (за исключением того, что критически вы теряете Likeness<'T>s при проверке покрытия полей). Однако краткость может сделать его ценным инструментом для определенных видов тестов:

sut.Save( inputs)

let expected = inputs |> Seq.map (fun x -> Mapped( base + x.ttl, x.Name))

let likeExpected x = expected ==|== x <| (fun x y -> x.Name = y.Name && x.ValidUntil = y.ValidUntil)

verify <@ repo.Store( is( likeExpected)) @> once