From 15e15aa9219abac9fc231957e456faed6f7c66d3 Mon Sep 17 00:00:00 2001 From: Orion Kindel Date: Sun, 1 Dec 2024 17:14:19 -0600 Subject: [PATCH] fmt --- scripts/common.js | 2 +- test/Test/Axon.Request.Parts.purs | 197 +++++++++++++++++++++++------- 2 files changed, 157 insertions(+), 42 deletions(-) diff --git a/scripts/common.js b/scripts/common.js index 1f8bd75..c000d57 100644 --- a/scripts/common.js +++ b/scripts/common.js @@ -3,7 +3,7 @@ import Path from 'path' export const rootDir = Path.resolve(__dirname, '..') -export const packageDirs = async () => ['./src'] +export const packageDirs = async () => ['./src', './test'] export const packageSources = async () => { const packages = await packageDirs() diff --git a/test/Test/Axon.Request.Parts.purs b/test/Test/Axon.Request.Parts.purs index 03c0a88..acdfcaf 100644 --- a/test/Test/Axon.Request.Parts.purs +++ b/test/Test/Axon.Request.Parts.purs @@ -5,7 +5,13 @@ import Prelude import Axon.Request (Request) import Axon.Request as Request import Axon.Request.Method (Method(..)) -import Axon.Request.Parts.Class (Json(..), Patch(..), Path(..), Post(..), extractRequestParts) +import Axon.Request.Parts.Class + ( Json(..) + , Patch(..) + , Path(..) + , Post(..) + , extractRequestParts + ) import Axon.Request.Parts.Path (type (/), IgnoreRest) import Control.Monad.Error.Class (liftEither, liftMaybe) import Data.Bifunctor (lmap) @@ -28,96 +34,205 @@ import Test.Spec.Assertions (shouldEqual) spec :: Spec Unit spec = describe "Parts" do it "extracts the whole request" do - req <- liftEffect $ Request.make {body: Request.BodyEmpty, url: URL.fromString "http://localhost:80/foo" # unsafePartial fromJust, headers: Map.empty, address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 {address: "127.0.0.1", port: 81}, method: GET} - void $ extractRequestParts @Request req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") + req <- liftEffect $ Request.make + { body: Request.BodyEmpty + , url: URL.fromString "http://localhost:80/foo" # unsafePartial fromJust + , headers: Map.empty + , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 + { address: "127.0.0.1", port: 81 } + , method: GET + } + void $ extractRequestParts @Request req <#> lmap (error <<< show) + >>= liftEither + >>= liftMaybe (error "was nothing") it "extracts method, path, JSON body" do - stream <- Buffer.fromString """{"firstName": "henry"}""" UTF8 >>= Stream.readableFromBuffer # liftEffect - req <- liftEffect $ Request.make {body: Request.BodyReadable stream, url: URL.fromString "http://localhost:80/users/12" # unsafePartial fromJust, headers: Map.empty, address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 {address: "127.0.0.1", port: 81}, method: PATCH} - a <- extractRequestParts @(Patch ((Path ("users" / Int) _) /\ Json {firstName :: String})) req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") - a `shouldEqual` Patch (Path 12 /\ Json {firstName: "henry"}) + stream <- Buffer.fromString """{"firstName": "henry"}""" UTF8 + >>= Stream.readableFromBuffer + # liftEffect + req <- liftEffect $ Request.make + { body: Request.BodyReadable stream + , url: URL.fromString "http://localhost:80/users/12" # unsafePartial + fromJust + , headers: Map.empty + , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 + { address: "127.0.0.1", port: 81 } + , method: PATCH + } + a <- + extractRequestParts + @(Patch ((Path ("users" / Int) _) /\ Json { firstName :: String })) + req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe + (error "was nothing") + a `shouldEqual` Patch (Path 12 /\ Json { firstName: "henry" }) describe "Path" do it "matches a route matching literal" do - req <- liftEffect $ Request.make {body: Request.BodyCachedString "foo", url: URL.fromString "http://localhost:80/foo" # unsafePartial fromJust, headers: Map.empty, address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 {address: "127.0.0.1", port: 81}, method: GET} - a <- extractRequestParts @(Path "foo" _) req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") + req <- liftEffect $ Request.make + { body: Request.BodyCachedString "foo" + , url: URL.fromString "http://localhost:80/foo" # unsafePartial fromJust + , headers: Map.empty + , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 + { address: "127.0.0.1", port: 81 } + , method: GET + } + a <- extractRequestParts @(Path "foo" _) req <#> lmap (error <<< show) + >>= liftEither + >>= liftMaybe (error "was nothing") a `shouldEqual` (Path unit) it "matches a route matching multiple literals" do - req <- liftEffect $ Request.make {body: Request.BodyCachedString "foo", url: URL.fromString "http://localhost:80/foo/bar/baz" # unsafePartial fromJust, headers: Map.empty, address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 {address: "127.0.0.1", port: 81}, method: GET} - a <- extractRequestParts @(Path ("foo" / "bar" / "baz") _) req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") + req <- liftEffect $ Request.make + { body: Request.BodyCachedString "foo" + , url: URL.fromString "http://localhost:80/foo/bar/baz" # unsafePartial + fromJust + , headers: Map.empty + , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 + { address: "127.0.0.1", port: 81 } + , method: GET + } + a <- extractRequestParts @(Path ("foo" / "bar" / "baz") _) req + <#> lmap (error <<< show) + >>= liftEither + >>= liftMaybe (error "was nothing") a `shouldEqual` (Path unit) it "does not partially match a route ..." do req <- liftEffect $ Request.make { body: Request.BodyCachedString "foo" - , url: URL.fromString "http://localhost:80/foo/bar/baz" # unsafePartial fromJust + , url: URL.fromString "http://localhost:80/foo/bar/baz" # unsafePartial + fromJust , headers: Map.empty - , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 {address: "127.0.0.1", port: 81} + , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 + { address: "127.0.0.1", port: 81 } , method: GET } - a <- extractRequestParts @(Path ("foo" / "bar") _) req <#> lmap (error <<< show) >>= liftEither + a <- extractRequestParts @(Path ("foo" / "bar") _) req + <#> lmap (error <<< show) + >>= liftEither a `shouldEqual` Nothing it "... but does if ends in IgnoreRest" do req <- liftEffect $ Request.make { body: Request.BodyCachedString "foo" - , url: URL.fromString "http://localhost:80/foo/bar/baz" # unsafePartial fromJust + , url: URL.fromString "http://localhost:80/foo/bar/baz" # unsafePartial + fromJust , headers: Map.empty - , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 {address: "127.0.0.1", port: 81} + , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 + { address: "127.0.0.1", port: 81 } , method: GET } - a <- extractRequestParts @(Path ("foo" / "bar" / IgnoreRest) _) req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") + a <- extractRequestParts @(Path ("foo" / "bar" / IgnoreRest) _) req + <#> lmap (error <<< show) + >>= liftEither + >>= liftMaybe (error "was nothing") a `shouldEqual` (Path unit) it "extracts an int" do req <- liftEffect $ Request.make { body: Request.BodyCachedString "foo" - , url: URL.fromString "http://localhost:80/foo/123/bar" # unsafePartial fromJust + , url: URL.fromString "http://localhost:80/foo/123/bar" # unsafePartial + fromJust , headers: Map.empty - , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 {address: "127.0.0.1", port: 81} + , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 + { address: "127.0.0.1", port: 81 } , method: GET } - a <- extractRequestParts @(Path ("foo" / Int / "bar") _) req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") + a <- extractRequestParts @(Path ("foo" / Int / "bar") _) req + <#> lmap (error <<< show) + >>= liftEither + >>= liftMaybe (error "was nothing") a `shouldEqual` (Path 123) it "extracts an int and a string" do req <- liftEffect $ Request.make { body: Request.BodyCachedString "foo" - , url: URL.fromString "http://localhost:80/foo/123/bar/baz" # unsafePartial fromJust + , url: URL.fromString "http://localhost:80/foo/123/bar/baz" # + unsafePartial fromJust , headers: Map.empty - , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 {address: "127.0.0.1", port: 81} + , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 + { address: "127.0.0.1", port: 81 } , method: GET } - a <- extractRequestParts @(Path ("foo" / Int / "bar" / String) _) req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") + a <- extractRequestParts @(Path ("foo" / Int / "bar" / String) _) req + <#> lmap (error <<< show) + >>= liftEither + >>= liftMaybe (error "was nothing") a `shouldEqual` (Path $ 123 /\ "baz") describe "Body" do it "extracts a string body from a cached string" do - req <- liftEffect $ Request.make {body: Request.BodyCachedString "foo", url: URL.fromString "http://localhost:80/foo" # unsafePartial fromJust, headers: Map.empty, address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 {address: "127.0.0.1", port: 81}, method: GET} - a <- extractRequestParts @(Either Request.BodyStringError String) req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") + req <- liftEffect $ Request.make + { body: Request.BodyCachedString "foo" + , url: URL.fromString "http://localhost:80/foo" # unsafePartial fromJust + , headers: Map.empty + , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 + { address: "127.0.0.1", port: 81 } + , method: GET + } + a <- extractRequestParts @(Either Request.BodyStringError String) req + <#> lmap (error <<< show) + >>= liftEither + >>= liftMaybe (error "was nothing") a `shouldEqual` (Right "foo") - + it "extracts a string body from a readable stream" do - stream <- Buffer.fromString "foo" UTF8 >>= Stream.readableFromBuffer # liftEffect - req <- liftEffect $ Request.make {body: Request.BodyReadable stream, url: URL.fromString "http://localhost:80/foo" # unsafePartial fromJust, headers: Map.empty, address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 {address: "127.0.0.1", port: 81}, method: GET} - a <- extractRequestParts @(Either Request.BodyStringError String) req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") + stream <- Buffer.fromString "foo" UTF8 >>= Stream.readableFromBuffer # + liftEffect + req <- liftEffect $ Request.make + { body: Request.BodyReadable stream + , url: URL.fromString "http://localhost:80/foo" # unsafePartial fromJust + , headers: Map.empty + , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 + { address: "127.0.0.1", port: 81 } + , method: GET + } + a <- extractRequestParts @(Either Request.BodyStringError String) req + <#> lmap (error <<< show) + >>= liftEither + >>= liftMaybe (error "was nothing") a `shouldEqual` (Right "foo") - - a' <- extractRequestParts @String req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") + + a' <- extractRequestParts @String req <#> lmap (error <<< show) + >>= liftEither + >>= liftMaybe (error "was nothing") a' `shouldEqual` "foo" - + it "extracts a string body from a buffer" do buf <- Buffer.fromString "foo" UTF8 # liftEffect - req <- liftEffect $ Request.make {body: Request.BodyCached buf, url: URL.fromString "http://localhost:80/foo" # unsafePartial fromJust, headers: Map.empty, address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 {address: "127.0.0.1", port: 81}, method: GET} - a <- extractRequestParts @(Either Request.BodyStringError String) req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") + req <- liftEffect $ Request.make + { body: Request.BodyCached buf + , url: URL.fromString "http://localhost:80/foo" # unsafePartial fromJust + , headers: Map.empty + , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 + { address: "127.0.0.1", port: 81 } + , method: GET + } + a <- extractRequestParts @(Either Request.BodyStringError String) req + <#> lmap (error <<< show) + >>= liftEither + >>= liftMaybe (error "was nothing") a `shouldEqual` (Right "foo") - - a' <- extractRequestParts @String req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") + + a' <- extractRequestParts @String req <#> lmap (error <<< show) + >>= liftEither + >>= liftMaybe (error "was nothing") a' `shouldEqual` "foo" - + it "extracts a JSON body" do - stream <- Buffer.fromString """{"foo": 123, "bar": "abc"}""" UTF8 >>= Stream.readableFromBuffer # liftEffect - req <- liftEffect $ Request.make {body: Request.BodyReadable stream, url: URL.fromString "http://localhost:80/foo" # unsafePartial fromJust, headers: Map.empty, address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 {address: "127.0.0.1", port: 81}, method: POST} - a <- extractRequestParts @(Post (Json {foo :: Int, bar :: String})) req <#> lmap (error <<< show) >>= liftEither >>= liftMaybe (error "was nothing") - a `shouldEqual` Post (Json {foo: 123, bar: "abc"}) + stream <- Buffer.fromString """{"foo": 123, "bar": "abc"}""" UTF8 + >>= Stream.readableFromBuffer + # liftEffect + req <- liftEffect $ Request.make + { body: Request.BodyReadable stream + , url: URL.fromString "http://localhost:80/foo" # unsafePartial fromJust + , headers: Map.empty + , address: Left $ unsafePerformEffect $ SocketAddress.newIpv4 + { address: "127.0.0.1", port: 81 } + , method: POST + } + a <- extractRequestParts @(Post (Json { foo :: Int, bar :: String })) req + <#> lmap (error <<< show) + >>= liftEither + >>= liftMaybe (error "was nothing") + a `shouldEqual` Post (Json { foo: 123, bar: "abc" })