Add collection constraints from NUnit

[CaptnCodr]

Description

I just wrote some tests and wanted to test a collection that has the equivalent item than another.

Could you please implement the collection constraints from NUnit?

Repro steps

I have to use NUnit's function with like:
let areCollectionsEqual = CollectionAssert.AreEquivalent([1;2;3], [3;1;2])

It's not so "F#-ish".

Known workarounds

I "extended" FsUnit with an extra function:

module FsUnit = 
  open NUnit.Framework.Constraints

  let equalsToCollection x = CollectionEquivalentConstraint x

So I can use this function like:

let areCollectionsEqual () = [1;2;3] |> should equalsToCollection [3;1;2]

Collection contraints implemented:

• equivalent
• supersetOf
• subsetOf

[sergey-tihon]

It should be possible to do, but we need to add support for all frameworks (as we do for other operators) - http://fsprojects.github.io/FsUnit/operators.html

[lucasteles]

Hi, I want to work on this.

In NUnit assertion, we have the CollectionAssert.AreEquivalent (which order don't matter) and CollectionAssert.AreEqual (which order matter), I think both should exist in FSUnit,

We those 2 assertion functions in MSTest and NUnit, but not in XUnit, XUnit have only a function which compares considering the order.

How do you think we can handle this?
Brad Wilson from xunit.net told here that one should use LINQ's OrderBy operator and afterward Assert.Equal to verify that two collections contain equal items without regarding their order.

Another option is to use something like FluentAssertions

What do you think?

[sergey-tihon]

I guess CollectionAssert.AreEqual case should be covered by equal operator due to structured equality

[1;2;3] |> should equal [1;2;3]

(we may add such test-cases and check)

for NUnit and MSTest is make sense to wrap CollectionAssert.AreEquivalent into equivalent operator. I am not sure about xUnit, we can leave it not implemented because it is not idiomatic for framework or reimplement logic from NUnit on our side

[lucasteles]

I opened a PR for NUnit in #139

Next step is to implement it for MSTest, I saw that we are not using MSTest lib for asserts, we reimplemented some of the assertions,

Should we do the same for XUnit? makes sense?

[CaptnCodr]

Sorry for "only" commenting to this issue and the changes that @lucasteles made.
I'm freshly new to F# and very unsteady to the development like this. 😄

[sergey-tihon]

I saw that we are not using MSTest lib for asserts, we reimplemented some of the assertions,
Should we do the same for XUnit? makes sense?

I believe that we should implement as less as possible, so you may reuse MSTest assertions where you can.

Also feel free to open PR that replace existing custom implementation by native assertions provided by framework (where possible)

[CaptnCodr]

Is it possible to implement the CollectionSubsetConstraint, too?

i.e.: I want to check if a sequence ([1..10]) has the values [8;1;5] in it.

Now, I have a function:
let containInCollection x = Is.SubsetOf(x)

to check it like:

[1;8;5] |> should containInCollection [1..10]

But this is not what FsUnit follows I think (from Syntax).
Is it possible to have an assert like:
[1..10] |> should contain [8;1;5]?

[CaptnCodr]

Ah, I got it. I use the CollectionSupersetConstraint to check this.

let contain (x: IEnumerable<_>) = Is.SupersetOf(x)

and use it as follows:

[1..10] |> should contain [8;1;5]

May I implement this @sergey-tihon?

[sergey-tihon]

We already have contain operator

What to you think about

[1..10] |> should be (supersetOf [8;1;5])

?

[CaptnCodr]

Yea, sounds good. I'll try it and make a PR.

[CaptnCodr]

I created a PR #141. I hope you like it.

[CaptnCodr]

I would like to implement the subsetOf operator, too. To have the counterpart of supersetOf.

Like: [4;5] |> should be (subsetOf [1..10])

Is this okay?