Bump deps (#54)

WoofWare.Myriad.Plugins.Test/TestHttpClient/TestAllowAnyStatusCode.fs

@@ -0,0 +1,62 @@
+namespace WoofWare.Myriad.Plugins.Test
+
+open System
+open System.Net
+open System.Net.Http
+open NUnit.Framework
+open FsUnitTyped
+open PureGym
+
+[<TestFixture>]
+module TestAllowAnyStatusCode =
+
+    [<Test>]
+    let ``Without AllowAnyStatusCode we throw`` () =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+                let content = new StringContent ("nothing was here :(")
+                let resp = new HttpResponseMessage (HttpStatusCode.NotFound)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make (Uri "https://example.com") proc
+        let api = PureGymApi.make client
+
+        let exc =
+            async {
+                let! message = Async.AwaitTask (api.GetWithoutAnyReturnCode ()) |> Async.Catch
+
+                match message with
+                | Choice1Of2 _ -> return failwith "test failure"
+                | Choice2Of2 exc -> return exc
+            }
+            |> Async.RunSynchronously
+
+        let exc =
+            match exc with
+            | :? AggregateException as exc -> exc
+            | exc -> failwith $"Test failure: expected AggregateException, got %+A{exc}"
+
+        match exc.InnerException with
+        | :? HttpRequestException as exc -> exc.Message.Contains "404 (Not Found)" |> shouldEqual true
+        | e -> failwith $"Test failure: %+A{e}"
+
+    [<Test>]
+    let ``With AllowAnyStatusCode we do not throw`` () =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+                let content = new StringContent ("nothing was here :(")
+                let resp = new HttpResponseMessage (HttpStatusCode.NotFound)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make (Uri "https://example.com") proc
+        let api = PureGymApi.make client
+
+        let message = api.GetWithAnyReturnCode().Result
+        message.StatusCode |> shouldEqual HttpStatusCode.NotFound
+        message.Content.ReadAsStringAsync().Result |> shouldEqual "nothing was here :("

WoofWare.Myriad.Plugins.Test/TestHttpClient/TestBasePath.fs

@@ -0,0 +1,80 @@
+namespace WoofWare.Myriad.Plugins.Test
+
+open System
+open System.Net
+open System.Net.Http
+open NUnit.Framework
+open PureGym
+open FsUnitTyped
+
+[<TestFixture>]
+module TestBasePath =
+    [<Test>]
+    let ``Base address is respected`` () =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+                let content = new StringContent (message.RequestUri.ToString ())
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.makeNoUri proc
+        let api = PureGymApi.make client
+
+        let observedUri = api.GetPathParam("param").Result
+        observedUri |> shouldEqual "https://whatnot.com/endpoint/param"
+
+    [<Test>]
+    let ``Without a base address attr but with BaseAddress on client, request goes through`` () =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+                let content = new StringContent (message.RequestUri.ToString ())
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make (System.Uri "https://baseaddress.com") proc
+        let api = ApiWithoutBaseAddress.make client
+
+        let observedUri = api.GetPathParam("param").Result
+        observedUri |> shouldEqual "https://baseaddress.com/endpoint/param"
+
+    [<Test>]
+    let ``Without a base address attr or BaseAddress on client, request throws`` () =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+                let content = new StringContent (message.RequestUri.ToString ())
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.makeNoUri proc
+        let api = ApiWithoutBaseAddress.make client
+
+        let observedExc =
+            async {
+                let! result = api.GetPathParam ("param") |> Async.AwaitTask |> Async.Catch
+
+                match result with
+                | Choice1Of2 _ -> return failwith "test failure"
+                | Choice2Of2 exc -> return exc
+            }
+            |> Async.RunSynchronously
+
+        let observedExc =
+            match observedExc with
+            | :? AggregateException as exc ->
+                match exc.InnerException with
+                | :? ArgumentNullException as exc -> exc
+                | _ -> failwith "test failure"
+            | _ -> failwith "test failure"
+
+        observedExc.Message
+        |> shouldEqual
+            "No base address was supplied on the type, and no BaseAddress was on the HttpClient. (Parameter 'BaseAddress')"

WoofWare.Myriad.Plugins.Test/TestHttpClient/TestBodyParam.fs

@@ -0,0 +1,105 @@
+namespace WoofWare.Myriad.Plugins.Test
+
+open System
+open System.IO
+open System.Net
+open System.Net.Http
+open System.Text.Json.Nodes
+open NUnit.Framework
+open PureGym
+open FsUnitTyped
+
+[<TestFixture>]
+module TestBodyParam =
+
+    [<Test>]
+    let ``Body param of string`` () =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Post
+                let! content = message.Content.ReadAsStringAsync () |> Async.AwaitTask
+                let content = new StringContent (content)
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make (Uri "https://example.com") proc
+        let api = PureGymApi.make client
+
+        let observedUri = api.CreateUserString("username?not!url%encoded").Result
+        observedUri |> shouldEqual "username?not!url%encoded"
+
+    [<Test>]
+    let ``Body param of stream`` () =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Post
+                let! content = message.Content.ReadAsStreamAsync () |> Async.AwaitTask
+                let content = new StreamContent (content)
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        let contents = [| 1uy ; 2uy ; 3uy ; 4uy |]
+
+        use client = HttpClientMock.make (Uri "https://example.com") proc
+        let api = PureGymApi.make client
+
+        use stream = new MemoryStream (contents)
+        let observedContent = api.CreateUserStream(stream).Result
+        let buf = Array.zeroCreate 10
+        let written = observedContent.ReadAtLeast (buf.AsSpan (), 5, false)
+        buf |> Array.take written |> shouldEqual contents
+
+    [<Test>]
+    let ``Body param of HttpContent`` () =
+        let mutable observedContent = None
+
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Post
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                observedContent <- Some message.Content
+                resp.Content <- new StringContent ("oh hi")
+                return resp
+            }
+
+        use client = HttpClientMock.make (Uri "https://example.com") proc
+        let api = PureGymApi.make client
+
+        use content = new StringContent ("hello!")
+
+        api.CreateUserHttpContent(content).Result |> shouldEqual "oh hi"
+        Object.ReferenceEquals (Option.get observedContent, content) |> shouldEqual true
+
+    [<TestCase "ByteArr">]
+    [<TestCase "ByteArr'">]
+    [<TestCase "ByteArr''">]
+    let ``Body param of byte arr`` (case : string) =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Post
+                let! content = message.Content.ReadAsStreamAsync () |> Async.AwaitTask
+                let content = new StreamContent (content)
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make (Uri "https://example.com") proc
+        let api = PureGymApi.make client
+
+        let contents = [| 1uy ; 2uy ; 3uy ; 4uy |]
+
+        let observedContent =
+            match case with
+            | "ByteArr" -> api.CreateUserByteArr(contents).Result
+            | "ByteArr'" -> api.CreateUserByteArr'(contents).Result
+            | "ByteArr''" -> api.CreateUserByteArr''(contents).Result
+            | _ -> failwith $"Unrecognised case: %s{case}"
+
+        let buf = Array.zeroCreate 10
+        let written = observedContent.ReadAtLeast (buf.AsSpan (), 5, false)
+        buf |> Array.take written |> shouldEqual contents

WoofWare.Myriad.Plugins.Test/TestHttpClient/TestPathParam.fs

@@ -0,0 +1,36 @@
+namespace WoofWare.Myriad.Plugins.Test
+
+open System
+open System.Net
+open System.Net.Http
+open NUnit.Framework
+open FsUnitTyped
+open PureGym
+
+[<TestFixture>]
+module TestPathParam =
+
+    [<Test>]
+    let ``Path params are escaped`` () =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+
+                let expectedUriPrefix = "https://example.com/endpoint/"
+
+                let actualUri = message.RequestUri.ToString ()
+
+                if not (actualUri.StartsWith (expectedUriPrefix, StringComparison.Ordinal)) then
+                    failwith $"wrong prefix on %s{actualUri}"
+
+                let content = new StringContent (actualUri.Substring expectedUriPrefix.Length)
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make (Uri "https://example.com") proc
+        let api = PureGymApi.make client
+
+        api.GetPathParam("hello/world?(hi)").Result
+        |> shouldEqual "hello%2fworld%3f(hi)"

WoofWare.Myriad.Plugins.Test/TestHttpClient/TestPureGymRestApi.fs

@@ -0,0 +1,238 @@
+namespace WoofWare.Myriad.Plugins.Test
+
+open System
+open System.Net
+open System.Net.Http
+open NUnit.Framework
+open PureGym
+open FsUnitTyped
+
+[<TestFixture>]
+module TestPureGymRestApi =
+    // several of these, to check behaviour around treatment of initial slashes
+    let baseUris =
+        [
+            // Everything is relative to the root:
+            "https://example.com"
+            // Everything is also relative to the root, because `foo` is not a subdir:
+            "https://example.com/foo"
+            // Everything is relative to `foo`, because `foo` is a subdir
+            "https://example.com/foo/"
+        ]
+        |> List.map Uri
+
+    let gymsCases =
+        PureGymDtos.gymCases
+        |> List.collect (fun (json, gym) -> [ $"[%s{json}]", [ gym ] ; $"[%s{json}, %s{json}]", [ gym ; gym ] ])
+        |> List.allPairs baseUris
+        |> List.map TestCaseData
+
+    [<TestCaseSource(nameof gymsCases)>]
+    let ``Test GetGyms`` (baseUri : Uri, (json : string, expected : Gym list)) =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+
+                // URI is relative in the attribute on the IPureGymApi member,
+                // so this never gets redirected
+                let expectedUri =
+                    match baseUri.ToString () with
+                    | "https://example.com/" -> "https://example.com/v1/gyms/"
+                    | "https://example.com/foo" -> "https://example.com/v1/gyms/"
+                    | "https://example.com/foo/" -> "https://example.com/foo/v1/gyms/"
+                    | s -> failwith $"Unrecognised base URI: %s{s}"
+
+                message.RequestUri.ToString () |> shouldEqual expectedUri
+
+                let content = new StringContent (json)
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make baseUri proc
+        let api = PureGymApi.make client
+
+        api.GetGyms().Result |> shouldEqual expected
+
+    let gymAttendanceCases =
+        PureGymDtos.gymAttendanceCases
+        |> List.allPairs baseUris
+        |> List.map TestCaseData
+
+    [<TestCaseSource(nameof gymAttendanceCases)>]
+    let ``Test GetGymAttendance`` (baseUri : Uri, (json : string, expected : GymAttendance)) =
+        let requestedGym = 3
+
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+
+                // URI is relative in the attribute on the IPureGymApi member,
+                // so this never gets redirected
+                let expectedUri =
+                    match baseUri.ToString () with
+                    | "https://example.com/" -> $"https://example.com/v1/gyms/%i{requestedGym}/attendance"
+                    | "https://example.com/foo" -> $"https://example.com/v1/gyms/%i{requestedGym}/attendance"
+                    | "https://example.com/foo/" -> $"https://example.com/foo/v1/gyms/%i{requestedGym}/attendance"
+                    | s -> failwith $"Unrecognised base URI: %s{s}"
+
+                message.RequestUri.ToString () |> shouldEqual expectedUri
+
+                let content = new StringContent (json)
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make baseUri proc
+        let api = PureGymApi.make client
+
+        api.GetGymAttendance(requestedGym).Result |> shouldEqual expected
+
+    let memberCases =
+        PureGymDtos.memberCases |> List.allPairs baseUris |> List.map TestCaseData
+
+    [<TestCaseSource(nameof memberCases)>]
+    let ``Test GetMember`` (baseUri : Uri, (json : string, expected : Member)) =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+
+                // URI is relative in the attribute on the IPureGymApi member,
+                // so this never gets redirected
+                let expectedUri =
+                    match baseUri.ToString () with
+                    | "https://example.com/" -> "https://example.com/v1/member"
+                    | "https://example.com/foo" -> "https://example.com/v1/member"
+                    | "https://example.com/foo/" -> "https://example.com/foo/v1/member"
+                    | s -> failwith $"Unrecognised base URI: %s{s}"
+
+                message.RequestUri.ToString () |> shouldEqual expectedUri
+
+                let content = new StringContent (json)
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make baseUri proc
+        let api = PureGymApi.make client
+
+        api.GetMember().Result |> shouldEqual expected
+
+    let gymCases =
+        PureGymDtos.gymCases |> List.allPairs baseUris |> List.map TestCaseData
+
+    [<TestCaseSource(nameof gymCases)>]
+    let ``Test GetGym`` (baseUri : Uri, (json : string, expected : Gym)) =
+        let requestedGym = 3
+
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+
+                // URI is relative in the attribute on the IPureGymApi member,
+                // so this never gets redirected
+                let expectedUri =
+                    match baseUri.ToString () with
+                    | "https://example.com/" -> $"https://example.com/v1/gyms/%i{requestedGym}"
+                    | "https://example.com/foo" -> $"https://example.com/v1/gyms/%i{requestedGym}"
+                    | "https://example.com/foo/" -> $"https://example.com/foo/v1/gyms/%i{requestedGym}"
+                    | s -> failwith $"Unrecognised base URI: %s{s}"
+
+                message.RequestUri.ToString () |> shouldEqual expectedUri
+
+                let content = new StringContent (json)
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make baseUri proc
+        let api = PureGymApi.make client
+
+        api.GetGym(requestedGym).Result |> shouldEqual expected
+
+    let memberActivityCases =
+        PureGymDtos.memberActivityDtoCases
+        |> List.allPairs baseUris
+        |> List.map TestCaseData
+
+    [<TestCaseSource(nameof memberActivityCases)>]
+    let ``Test GetMemberActivity`` (baseUri : Uri, (json : string, expected : MemberActivityDto)) =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+
+                // URI is relative in the attribute on the IPureGymApi member,
+                // so this never gets redirected
+                let expectedUri =
+                    match baseUri.ToString () with
+                    | "https://example.com/" -> "https://example.com/v1/member/activity"
+                    | "https://example.com/foo" -> "https://example.com/v1/member/activity"
+                    | "https://example.com/foo/" -> "https://example.com/foo/v1/member/activity"
+                    | s -> failwith $"Unrecognised base URI: %s{s}"
+
+                message.RequestUri.ToString () |> shouldEqual expectedUri
+
+                let content = new StringContent (json)
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make baseUri proc
+        let api = PureGymApi.make client
+
+        api.GetMemberActivity().Result |> shouldEqual expected
+
+    let dates =
+        [
+            for month = 1 to 3 do
+                // span the number 12, to catch muddling up month and day
+                for day = 11 to 13 do
+                    yield DateOnly (2023, month, day)
+        ]
+
+    let sessionsCases =
+        PureGymDtos.sessionsCases
+        |> List.allPairs dates
+        |> List.allPairs dates
+        |> List.allPairs baseUris
+        |> List.map TestCaseData
+
+    let inline dateOnlyToString (d : DateOnly) : string =
+        let month = if d.Month < 10 then $"0%i{d.Month}" else $"%i{d.Month}"
+        let day = if d.Day < 10 then $"0%i{d.Day}" else $"%i{d.Day}"
+        $"{d.Year}-{month}-{day}"
+
+    [<TestCaseSource(nameof sessionsCases)>]
+    let ``Test GetSessions``
+        (
+            baseUri : Uri,
+            (startDate : DateOnly, (endDate : DateOnly, (json : string, expected : Sessions)))
+        )
+        =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+
+                // This one is specified as being absolute, in its attribute on the IPureGymApi type
+                let expectedUri =
+                    let fromDate = dateOnlyToString startDate
+                    let toDate = dateOnlyToString endDate
+                    $"https://example.com/v2/gymSessions/member?fromDate=%s{fromDate}&toDate=%s{toDate}"
+
+                message.RequestUri.ToString () |> shouldEqual expectedUri
+
+                let content = new StringContent (json)
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make baseUri proc
+        let api = PureGymApi.make client
+
+        api.GetSessions(startDate, endDate).Result |> shouldEqual expected

WoofWare.Myriad.Plugins.Test/TestHttpClient/TestReturnTypes.fs

@@ -0,0 +1,88 @@
+namespace WoofWare.Myriad.Plugins.Test
+
+open System
+open System.IO
+open System.Net
+open FsUnitTyped
+open System.Net.Http
+open PureGym
+open NUnit.Framework
+
+[<TestFixture>]
+module TestReturnTypes =
+
+    [<Test>]
+    let ``String return`` () =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+                let content = new StringContent ("this is not a JSON string")
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make (Uri "https://example.com") proc
+        let api = PureGymApi.make client
+
+        api.GetPathParam("hi").Result |> shouldEqual "this is not a JSON string"
+
+    [<TestCase "GetStream">]
+    [<TestCase "GetStream'">]
+    [<TestCase "GetStream''">]
+    let ``Stream return`` (case : string) =
+        let result = [| 1uy ; 2uy ; 3uy ; 4uy |]
+
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+                let result = new MemoryStream (result)
+                let content = new StreamContent (result)
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make (Uri "https://example.com") proc
+        let api = PureGymApi.make client
+
+        use stream =
+            match case with
+            | "GetStream" -> api.GetStream().Result
+            | "GetStream'" -> api.GetStream'().Result
+            | "GetStream''" -> api.GetStream''().Result
+            | _ -> failwith $"unrecognised case: %s{case}"
+
+        let buf = Array.zeroCreate 10
+        let written = stream.ReadAtLeast (buf.AsSpan (), 10, false)
+        Array.take written buf |> shouldEqual result
+
+    [<TestCase "GetResponseMessage">]
+    [<TestCase "GetResponseMessage'">]
+    [<TestCase "GetResponseMessage''">]
+    [<TestCase "GetResponseMessage'''">]
+    let ``HttpResponseMessage return`` (case : string) =
+        let mutable responseMessage = None
+
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+                let content = new StringContent ("a response!")
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                responseMessage <- Some resp
+                return resp
+            }
+
+        use client = HttpClientMock.make (Uri "https://example.com") proc
+        let api = PureGymApi.make client
+
+        let message =
+            match case with
+            | "GetResponseMessage" -> api.GetResponseMessage().Result
+            | "GetResponseMessage'" -> api.GetResponseMessage'().Result
+            | "GetResponseMessage''" -> api.GetResponseMessage''().Result
+            | "GetResponseMessage'''" -> api.GetResponseMessage'''().Result
+            | _ -> failwith $"unrecognised case: %s{case}"
+
+        Object.ReferenceEquals (message, Option.get responseMessage) |> shouldEqual true