elm-pages-v3-beta/tests/Pages/RouteParamsTest.elm

246 lines
9.9 KiB
Elm
Raw Normal View History

module Pages.RouteParamsTest exposing (..)
2022-09-12 21:59:36 +03:00
import Elm
import Elm.Annotation
2022-09-13 01:08:11 +03:00
import Elm.Case
import Elm.CodeGen
import Elm.Pretty
import Elm.ToString
import Expect exposing (Expectation)
import Pages.Internal.RoutePattern as RoutePattern
import Pretty
import Pretty.Renderer
import Test exposing (Test, describe, test)
suite : Test
suite =
describe "RouteParams"
[ test "no dynamic segments" <|
\() ->
RoutePattern.fromModuleName [ "No", "Dynamic", "Segments" ]
|> Maybe.map RoutePattern.toRouteParamsRecord
|> Expect.equal
(Just [])
, test "single dynamic segments" <|
\() ->
RoutePattern.fromModuleName [ "User", "Id_" ]
|> Maybe.map RoutePattern.toRouteParamsRecord
|> Expect.equal
(Just
[ ( "id", Elm.Annotation.string )
]
)
, test "two dynamic segments" <|
\() ->
RoutePattern.fromModuleName [ "UserId_", "ProductId_" ]
|> Maybe.map RoutePattern.toRouteParamsRecord
|> Expect.equal
(Just
[ ( "userId", Elm.Annotation.string )
, ( "productId", Elm.Annotation.string )
]
)
, test "splat ending" <|
\() ->
RoutePattern.fromModuleName [ "UserName_", "RepoName_", "Blob", "SPLAT_" ]
|> Maybe.map RoutePattern.toRouteParamsRecord
|> Expect.equal
(Just
[ ( "userName", Elm.Annotation.string )
, ( "repoName", Elm.Annotation.string )
, ( "splat"
, Elm.Annotation.tuple
Elm.Annotation.string
(Elm.Annotation.list Elm.Annotation.string)
)
]
)
, test "optional splat ending" <|
\() ->
RoutePattern.fromModuleName [ "SPLAT__" ]
|> Maybe.map RoutePattern.toRouteParamsRecord
|> Expect.equal
(Just
[ ( "splat", Elm.Annotation.list Elm.Annotation.string )
]
)
, test "ending with optional segment" <|
\() ->
RoutePattern.fromModuleName [ "Docs", "Section__" ]
|> Maybe.map RoutePattern.toRouteParamsRecord
|> Expect.equal
(Just
[ ( "section", Elm.Annotation.maybe Elm.Annotation.string )
]
)
2022-09-12 21:59:36 +03:00
, describe "toRouteVariant"
[ test "root route" <|
\() ->
[]
|> expectRouteDefinition
(Elm.variant "Index")
2022-09-12 21:59:36 +03:00
, test "static-only route" <|
\() ->
RoutePattern.fromModuleName [ "About" ]
|> Maybe.map RoutePattern.toVariant
|> Expect.equal
(Just (Elm.variant "About"))
2022-09-12 22:16:18 +03:00
, test "dynamic param" <|
\() ->
[ "User", "Id_" ]
|> expectRouteDefinition
(Elm.variantWith "User__Id_"
[ Elm.Annotation.record
[ ( "id", Elm.Annotation.string )
2022-09-12 22:16:18 +03:00
]
]
)
, test "required splat" <|
\() ->
[ "Username_", "Repo_", "Blob", "SPLAT_" ]
|> expectRouteDefinition
(Elm.variantWith "Username___Repo___Blob__SPLAT_"
[ Elm.Annotation.record
[ ( "username", Elm.Annotation.string )
, ( "repo", Elm.Annotation.string )
, ( "splat"
, Elm.Annotation.tuple
Elm.Annotation.string
(Elm.Annotation.list Elm.Annotation.string)
)
]
]
2022-09-12 22:16:18 +03:00
)
2022-09-12 23:20:44 +03:00
, test "optional splat" <|
\() ->
[ "SPLAT__" ]
|> expectRouteDefinition
(Elm.variantWith "SPLAT__"
[ Elm.Annotation.record
[ ( "splat"
, Elm.Annotation.list Elm.Annotation.string
)
]
]
)
2022-09-12 23:21:41 +03:00
, test "optional param" <|
\() ->
[ "Docs", "Section__" ]
|> expectRouteDefinition
(Elm.variantWith "Docs__Section__"
[ Elm.Annotation.record
[ ( "section"
, Elm.Annotation.maybe Elm.Annotation.string
)
]
]
)
2022-09-12 21:59:36 +03:00
]
2022-09-13 01:08:11 +03:00
, describe "toCase"
[ test "root route" <|
\() ->
[]
|> testCaseGenerator
[ ( Elm.CodeGen.listPattern []
, Elm.CodeGen.val "Index"
)
]
, test "dynamic segment" <|
\() ->
[ "User", "Id_" ]
|> testCaseGenerator
[ ( Elm.CodeGen.listPattern
[ Elm.CodeGen.stringPattern "user"
, Elm.CodeGen.varPattern "id"
]
, Elm.CodeGen.val "User__Id_ { id = id }"
)
]
2022-09-13 07:24:14 +03:00
, test "optional ending" <|
\() ->
[ "Docs", "Section__" ]
|> testCaseGenerator
[ ( Elm.CodeGen.listPattern
[ Elm.CodeGen.stringPattern "docs"
, Elm.CodeGen.varPattern "section"
]
, Elm.CodeGen.val "Docs__Section__ { section = Just section }"
)
, ( Elm.CodeGen.listPattern
[ Elm.CodeGen.stringPattern "docs"
]
, Elm.CodeGen.val "Docs__Section__ { section = Nothing }"
)
]
, test "required splat" <|
\() ->
[ "Username_", "Repo_", "Blob", "SPLAT_" ]
|> testCaseGenerator
[ ( --Elm. """username :: repo :: "blob" :: splatFirst :: splatRest"""
--( Elm.CodeGen.unConsPattern
unconsPattern
[ Elm.CodeGen.varPattern "username"
, Elm.CodeGen.varPattern "repo"
, Elm.CodeGen.stringPattern "blob"
, Elm.CodeGen.varPattern "splatFirst"
, Elm.CodeGen.varPattern "splatRest"
]
, Elm.CodeGen.val
"Username___Repo___Blob__SPLAT_ { username = username, repo = repo, splat = ( splatFirst, splatRest ) }"
)
]
2022-09-13 01:08:11 +03:00
]
]
unconsPattern : List Elm.CodeGen.Pattern -> Elm.CodeGen.Pattern
unconsPattern list =
case list of
[] ->
Debug.todo ""
listFirst :: listRest ->
List.foldl
(\soFar item ->
soFar
|> Elm.CodeGen.unConsPattern item
)
listFirst
listRest
testCaseGenerator : List ( Elm.CodeGen.Pattern, Elm.CodeGen.Expression ) -> List String -> Expectation
2022-09-13 01:08:11 +03:00
testCaseGenerator expected moduleName =
RoutePattern.fromModuleName moduleName
|> Maybe.map (RoutePattern.routeToBranch >> List.map toStringCase)
|> Maybe.withDefault [ ( "<ERROR>", "<ERROR>" ) ]
|> Expect.equal (expected |> List.map toStringCase)
2022-09-13 01:08:11 +03:00
toStringCase : ( Elm.CodeGen.Pattern, Elm.CodeGen.Expression ) -> ( String, String )
2022-09-13 01:08:11 +03:00
toStringCase branch =
branch
|> Tuple.mapBoth
(Elm.Pretty.prettyPattern
>> Pretty.pretty 120
)
(Elm.Pretty.prettyExpression
>> Pretty.pretty 120
)
2022-09-13 01:08:11 +03:00
expectRouteDefinition : Elm.Variant -> List String -> Expectation
expectRouteDefinition expected moduleName =
RoutePattern.fromModuleName moduleName
|> Maybe.map (RoutePattern.toVariant >> toString)
|> Maybe.withDefault "<ERROR>"
|> Expect.equal (expected |> toString)
toString : Elm.Variant -> String
toString variants =
Elm.customType "Route" [ variants ]
|> Elm.ToString.declaration
|> .body