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.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/FsUnitTyped.fs

@@ -0,0 +1,61 @@
+namespace FsUnitTyped
+
+open System.Diagnostics
+open Xunit
+open System.Collections.Generic
+open FsUnit.Xunit
+
+[<AutoOpen>]
+module TopLevelOperators =
+
+    [<DebuggerStepThrough>]
+    let shouldEqual (expected: 'a) (actual: 'a) =
+        expected |> should equal actual
+
+    [<DebuggerStepThrough>]
+    let shouldNotEqual (expected: 'a) (actual: 'a) =
+        expected |> should not' (equal actual)
+
+    [<DebuggerStepThrough>]
+    let shouldContain (x: 'a) (y: 'a seq) =
+        y |> should contain x
+
+    [<DebuggerStepThrough>]
+    let shouldBeEmpty(list: 'a seq) =
+        list |> should be Empty
+
+    [<DebuggerStepThrough>]
+    let shouldNotContain (x: 'a) (y: 'a seq) =
+        if Seq.exists ((=) x) y then
+            failwith $"Seq %A{y} should not contain %A{x}"
+
+    [<DebuggerStepThrough>]
+    let shouldBeSmallerThan (x: 'a) (y: 'a) =
+        if not(x < y) then
+            failwith $"Expected:\n  %A{x}\nto be smaller than:\n  %A{y}"
+
+    [<DebuggerStepThrough>]
+    let shouldBeGreaterThan (x: 'a) (y: 'a) =
+        if not(x > y) then
+            failwith $"Expected:\n  %A{x}\nto be greater than:\n  %A{y}"
+
+    [<DebuggerStepThrough>]
+    let shouldFail<'exn when 'exn :> exn>(f: unit -> unit) =
+        f |> should throw typeof<'exn>
+
+    [<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 expected list =
+        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/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,23 @@
+namespace FsUnit.Typed.Test
+
+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<System.NullReferenceException>
+
+    [<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)
+        |> shouldFail<System.NullReferenceException>

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)