Add typed aliases around Xunit

docs/FsUnitTyped.fsx

@@ -9,9 +9,9 @@ What is FsUnitTyped?
 ===============
 
 **FsUnitTyped** is a statically typed set of FsUnit operators that makes
-unit-testing with `FsUnit` even more safe and enjoyable (Available only for `NUnit`).
+unit-testing with `FsUnit` even more safe and enjoyable (Available only for `NUnit` and `Xunit`).
 
-No more untyped constrains and tests like
+No more untyped constraints and tests like
 
     1 |> should equal "1"
 

src/FsUnit.NUnit/FsUnit.fs

@@ -42,8 +42,11 @@ module TopLevelOperators =
         else
             Assert.That(y, c)
 
-    let equal x =
-        Equality.IsEqualTo(x)
+    /// Constraint that attempts to use a number of more specific equality
+    /// checks available to NUnit, ultimately calling `expected.Equals(actual)`
+    /// if no more specific checks apply.
+    let equal expected =
+        Equality.IsEqualTo(expected)
 
     let equivalent x =
         CollectionEquivalentConstraint(x)

src/FsUnit.Xunit/CustomMatchers.fs

@@ -7,6 +7,9 @@ open NHamcrest
 open NHamcrest.Core
 open System.Reflection
 
+/// The `equal x` matcher, when applied to an object `a`, matches if `a = x`.
+/// Note that this is inconsistent with FsUnit.NUnit
+/// (see https://github.com/fsprojects/FsUnit/issues/207).
 let equal x =
     CustomMatcher<obj>($"Equals %A{x}", (fun a -> a = x))
 

src/FsUnit.Xunit/FsUnit.Xunit.fsproj

@@ -14,6 +14,7 @@
     </Compile>
     <Compile Include="CustomMatchers.fs" />
     <Compile Include="FsUnit.fs" />
+    <Compile Include="FsUnitTyped.fs" />
     <None Include="paket.references" />
     <None Include="paket.template" />
     <None Include="FsUnitSample.fs.pp">
@@ -22,4 +23,4 @@
     <None Include="sample.paket.template" />
   </ItemGroup>
   <Import Project="..\..\.paket\Paket.Restore.targets" />
-</Project>
+</Project>

src/FsUnit.Xunit/FsUnit.fs

@@ -41,6 +41,7 @@ let inline shouldFail(f: unit -> unit) =
         raise(MatchException("Method should fail", "No exception raised", null))
 
 
+/// Constraint requiring that `actual.Equals(expected)`.
 let equal expected =
     CustomMatchers.equal expected
 

src/FsUnit.Xunit/FsUnitTyped.fs

@@ -0,0 +1,61 @@
+namespace FsUnitTyped
+
+open System.Diagnostics
+open FsUnit.Xunit
+
+[<AutoOpen>]
+module TopLevelOperators =
+
+    /// Asserts that `expected` is equal to `actual`.
+    /// The equality instance on `actual` is used, if available.
+    [<DebuggerStepThrough>]
+    let shouldEqual<'a> (expected: 'a) (actual: 'a) =
+        should equal expected actual
+
+    /// Asserts that `expected` is not equal to `actual`.
+    /// The equality instance on `actual` is used, if available.
+    [<DebuggerStepThrough>]
+    let shouldNotEqual<'a> (expected: 'a) (actual: 'a) =
+        should not' (equal expected) actual
+
+    [<DebuggerStepThrough>]
+    let shouldContain<'a when 'a: equality> (x: 'a) (y: 'a seq) =
+        y |> should contain x
+
+    [<DebuggerStepThrough>]
+    let shouldBeEmpty<'a>(list: 'a seq) =
+        list |> should be Empty
+
+    [<DebuggerStepThrough>]
+    let shouldNotContain<'a when 'a: equality> (x: 'a) (y: 'a seq) =
+        if Seq.exists ((=) x) y then
+            failwith $"Seq %A{y} should not contain %A{x}"
+
+    [<DebuggerStepThrough>]
+    let shouldBeSmallerThan<'a when 'a: comparison> (x: 'a) (y: 'a) =
+        should be (lessThan x) y
+
+    [<DebuggerStepThrough>]
+    let shouldBeGreaterThan<'a when 'a: comparison> (x: 'a) (y: 'a) =
+        should be (greaterThan x) y
+
+    [<DebuggerStepThrough>]
+    let shouldFail<'exn when 'exn :> exn>(f: unit -> unit) =
+        should throw typeof<'exn> f
+
+    [<DebuggerStepThrough>]
+    let shouldContainText (x: string) (y: string) =
+        if y.Contains(x) |> not then
+            failwith $"\"{x}\" is not a substring of \"{y}\""
+
+    [<DebuggerStepThrough>]
+    let shouldNotContainText (x: string) (y: string) =
+        if y.Contains(x) then
+            failwith $"\"{x}\" is a substring of \"{y}\""
+
+    [<DebuggerStepThrough>]
+    let shouldHaveLength<'a> (expected: int) (list: 'a seq) =
+        let actual = Seq.length list
+
+        if actual <> expected then
+            failwith $"Invalid length in %A{list}\r\nExpected: {expected}\r\nActual: {actual}"

tests/FsUnit.Xunit.Test/FsUnit.Xunit.Test.fsproj

@@ -36,10 +36,19 @@
     <Compile Include="instanceOfTests.fs" />
     <Compile Include="NaNTests.fs" />
     <Compile Include="beUniqueTests.fs" />
+    <Compile Include="typed.beEmptyTests.fs" />
+    <Compile Include="typed.haveLengthTests.fs" />
+    <Compile Include="typed.shouldBeGreaterThanTests.fs" />
+    <Compile Include="typed.shouldBeSmallerThanTests.fs" />
+    <Compile Include="typed.shouldContainTests.fs" />
+    <Compile Include="typed.shouldContainText.fs" />
+    <Compile Include="typed.shouldEqualNullTests.fs" />
+    <Compile Include="typed.shouldFailTests.fs" />
+    <Compile Include="typed.shouldEqualTests.fs" />
     <None Include="paket.references" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="../../src/FsUnit.Xunit/FsUnit.Xunit.fsproj" />
   </ItemGroup>
   <Import Project="..\..\.paket\Paket.Restore.targets" />
-</Project>
+</Project>

tests/FsUnit.Xunit.Test/equalTests.fs

@@ -61,6 +61,12 @@ type ``equal Tests``() =
     member __.``reference type should fail to not equal itself``() =
         anObj |> should equal anObj
 
+    [<Fact>]
+    member __.``should pass when Equals returns true``() =
+        // See https://github.com/fsprojects/FsUnit/issues/207 for why
+        // this test differs from the corresponding NUnit one.
+        box(new AlwaysEqual()) |> should equal anObj
+
     [<Fact>]
     member __.``should fail when Equals returns false``() =
         anObj |> should not' (equal(NeverEqual()))
@@ -69,6 +75,12 @@ type ``equal Tests``() =
     member __.``should pass when negated and Equals returns false``() =
         anObj |> should not' (equal(NeverEqual()))
 
+    [<Fact>]
+    member __.``should fail when negated and Equals returns true``() =
+        // See https://github.com/fsprojects/FsUnit/issues/207 for why
+        // this test differs from the corresponding NUnit one.
+        shouldFail(fun () -> box(new AlwaysEqual()) |> should not' (equal anObj))
+
     [<Fact>]
     member __.``should pass when comparing two lists that have the same values``() =
         [ 1 ] |> should equal [ 1 ]

tests/FsUnit.Xunit.Test/shouldFailTests.fs

@@ -17,7 +17,7 @@ type ``shouldFail tests``() =
         shouldFail(fun () -> shouldFail id)
 
     [<Fact>]
-    member __.``shouldFaild should throw an exception``() =
+    member __.``shouldFail should throw an exception``() =
         (fun () -> shouldFail id) |> should throw typeof<MatchException>
 
     [<Fact>]

tests/FsUnit.Xunit.Test/typed.beEmptyTests.fs

@@ -0,0 +1,29 @@
+namespace FsUnit.Typed.Test
+
+open Xunit
+open FsUnitTyped
+
+type ``shouldBeEmpty tests``() =
+    [<Fact>]
+    member __.``empty List should be Empty``() =
+        [] |> shouldBeEmpty
+
+    [<Fact>]
+    member __.``non-empty List should fail to be Empty``() =
+        shouldFail(fun () -> [ 1 ] |> shouldBeEmpty)
+
+    [<Fact>]
+    member __.``empty Array should be Empty``() =
+        [||] |> shouldBeEmpty
+
+    [<Fact>]
+    member __.``non-empty Array should fail to be Empty``() =
+        shouldFail(fun () -> [| 1 |] |> shouldBeEmpty)
+
+    [<Fact>]
+    member __.``empty Seq should be Empty``() =
+        Seq.empty |> shouldBeEmpty
+
+    [<Fact>]
+    member __.``non-empty Seq should fail to be Empty``() =
+        shouldFail(fun () -> seq { 1 } |> shouldBeEmpty)

tests/FsUnit.Xunit.Test/typed.haveLengthTests.fs

@@ -0,0 +1,23 @@
+namespace FsUnit.Typed.Test
+
+open Xunit
+open FsUnitTyped
+
+type ``haveLength tests``() =
+    // F# List
+    [<Fact>]
+    member __.``List with 1 item should have Length 1``() =
+        [ 1 ] |> shouldHaveLength 1
+
+    [<Fact>]
+    member __.``empty List should fail to have Length 1``() =
+        shouldFail(fun () -> [] |> shouldHaveLength 1)
+
+    // Array
+    [<Fact>]
+    member __.``Array with 1 item should have Length 1``() =
+        [| 1 |] |> shouldHaveLength 1
+
+    [<Fact>]
+    member __.``empty Array should fail to have Length 1``() =
+        shouldFail(fun () -> [||] |> shouldHaveLength 1)

tests/FsUnit.Xunit.Test/typed.shouldBeGreaterThanTests.fs

@@ -0,0 +1,13 @@
+namespace FsUnit.Typed.Test
+
+open Xunit
+open FsUnitTyped
+
+type ``shouldBeGreaterThan tests``() =
+    [<Fact>]
+    member __.``11 should be greater than 10``() =
+        11 |> shouldBeGreaterThan 10
+
+    [<Fact>]
+    member __.``11[dot]1 should be greater than 11[dot]0``() =
+        11.1 |> shouldBeGreaterThan 11.0

tests/FsUnit.Xunit.Test/typed.shouldBeSmallerThanTests.fs

@@ -0,0 +1,24 @@
+namespace FsUnit.Typed.Test
+
+open FsUnit.Xunit
+open Xunit
+open FsUnitTyped
+
+type ``shouldBeSmallerThan tests``() =
+    [<Fact>]
+    member __.``10 should be less than 11``() =
+        10 |> shouldBeSmallerThan 11
+
+    [<Fact>]
+    member __.``10 should not be less than 10``() =
+        (fun () -> 10 |> shouldBeSmallerThan 10) |> shouldFail<MatchException>
+
+    [<Fact>]
+    member __.``10[dot]0 should be less than 10[dot]1``() =
+        10.0 |> shouldBeSmallerThan 10.1
+
+    [<Fact>]
+    member __.``10[dot]0 should not be less than 10[dot]0``() =
+        (fun () -> 10.0 |> shouldBeSmallerThan 10.0)
+        |> should throw typeof<MatchException>
+//|> shouldFail<MatchException>

tests/FsUnit.Xunit.Test/typed.shouldContainTests.fs

@@ -0,0 +1,53 @@
+namespace FsUnit.Typed.Test
+
+open Xunit
+open FsUnitTyped
+
+type ``shouldContain tests``() =
+    [<Fact>]
+    member __.``List with item should contain item``() =
+        [ 1 ] |> shouldContain 1
+
+    [<Fact>]
+    member __.``empty List should fail to contain item``() =
+        shouldFail(fun () -> [] |> shouldContain 1)
+
+    [<Fact>]
+    member __.``empty List should not contain item``() =
+        [] |> shouldNotContain 1
+
+    [<Fact>]
+    member __.``List with item should fail to not contain item``() =
+        shouldFail(fun () -> [ 1 ] |> shouldNotContain 1)
+
+    [<Fact>]
+    member __.``Array with item should contain item``() =
+        [| 1 |] |> shouldContain 1
+
+    [<Fact>]
+    member __.``empty Array should fail to contain item``() =
+        shouldFail(fun () -> [||] |> shouldContain 1)
+
+    [<Fact>]
+    member __.``empty Array should not contain item``() =
+        [||] |> shouldNotContain 1
+
+    [<Fact>]
+    member __.``Array with item should fail to not contain item``() =
+        shouldFail(fun () -> [| 1 |] |> shouldNotContain 1)
+
+    [<Fact>]
+    member __.``Seq with item should contain item``() =
+        seq { 1 } |> shouldContain 1
+
+    [<Fact>]
+    member __.``empty Seq should fail to contain item``() =
+        shouldFail(fun () -> Seq.empty |> shouldContain 1)
+
+    [<Fact>]
+    member __.``empty Seq should not contain item``() =
+        Seq.empty |> shouldNotContain 1
+
+    [<Fact>]
+    member __.``Seq with item should fail to not contain item``() =
+        shouldFail(fun () -> seq { 1 } |> shouldNotContain 1)

tests/FsUnit.Xunit.Test/typed.shouldContainText.fs

@@ -0,0 +1,13 @@
+namespace FsUnit.Typed.Test
+
+open Xunit
+open FsUnitTyped
+
+type ``shouldContainText tests``() =
+    [<Fact>]
+    member __.``empty string should contain ""``() =
+        "" |> shouldContainText ""
+
+    [<Fact>]
+    member __.``ships should contain hip``() =
+        "ships" |> shouldContainText "hip"

tests/FsUnit.Xunit.Test/typed.shouldEqualNullTests.fs

@@ -0,0 +1,13 @@
+namespace FsUnit.Typed.Test
+
+open Xunit
+open FsUnitTyped
+
+type ``Typed: shouldEqual null tests``() =
+    [<Fact>]
+    member __.``null should be null``() =
+        null |> shouldEqual null
+
+    [<Fact>]
+    member __.``null should fail to not be null``() =
+        shouldFail(fun () -> null |> shouldNotEqual null)