elm-pages 3.0.0-beta.1 → 3.0.0-beta.12

package/src/SimulatedEffect/Cmd.elm

@@ -0,0 +1,69 @@
+module SimulatedEffect.Cmd exposing
+    ( none, batch
+    , map
+    )
+
+{-| This module parallels [elm/core's `Platform.Cmd` module](https://package.elm-lang.org/packages/elm/core/1.0.2/Platform-Cmd).
+
+The functions here produce `SimulatedEffect`s instead of `Cmd`s, which are meant to be used
+to help you implement the function to provide when using [`ProgramTest.withSimulatedEffects`](ProgramTest#withSimulatedEffects).
+
+@docs none, batch
+
+@docs map
+
+-}
+
+import ProgramTest exposing (SimulatedEffect)
+import SimulatedEffect
+import SimulatedEffect.Task as Task
+
+
+{-| Tell the runtime that there are no commands.
+-}
+none : SimulatedEffect msg
+none =
+    SimulatedEffect.None
+
+
+{-| When you need the runtime system to perform a couple commands, you can batch them together.
+-}
+batch : List (SimulatedEffect msg) -> SimulatedEffect msg
+batch =
+    SimulatedEffect.Batch
+
+
+{-| Transform the messages produced by a command.
+-}
+map : (a -> msg) -> SimulatedEffect a -> SimulatedEffect msg
+map f effect =
+    case effect of
+        SimulatedEffect.None ->
+            SimulatedEffect.None
+
+        SimulatedEffect.Batch effects ->
+            SimulatedEffect.Batch (List.map (map f) effects)
+
+        SimulatedEffect.Task t ->
+            t
+                |> Task.map f
+                |> Task.mapError f
+                |> SimulatedEffect.Task
+
+        SimulatedEffect.PortEffect portName value ->
+            SimulatedEffect.PortEffect portName value
+
+        SimulatedEffect.PushUrl url ->
+            SimulatedEffect.PushUrl url
+
+        SimulatedEffect.ReplaceUrl url ->
+            SimulatedEffect.ReplaceUrl url
+
+        SimulatedEffect.Back n ->
+            SimulatedEffect.Back n
+
+        SimulatedEffect.Load url ->
+            SimulatedEffect.Load url
+
+        SimulatedEffect.Reload skipCache ->
+            SimulatedEffect.Reload skipCache

package/src/SimulatedEffect/Http.elm

@@ -0,0 +1,330 @@
+module SimulatedEffect.Http exposing
+    ( get, post, request
+    , Header, header
+    , Body, emptyBody, stringBody, jsonBody
+    , Expect, expectString, expectJson, expectWhatever, Error
+    , expectStringResponse, Response
+    , task, Resolver, stringResolver
+    )
+
+{-| This module parallels [elm/http's `Http` module](https://package.elm-lang.org/packages/elm/http/2.0.0/Http).
+_Pull requests are welcome to add any functions that are missing._
+
+The functions here produce `SimulatedEffect`s instead of `Cmd`s, which are meant to be used
+to help you implement the function to provide when using [`ProgramTest.withSimulatedEffects`](ProgramTest#withSimulatedEffects).
+
+
+# Requests
+
+@docs get, post, request
+
+
+# Header
+
+@docs Header, header
+
+
+# Body
+
+@docs Body, emptyBody, stringBody, jsonBody
+
+
+# Expect
+
+@docs Expect, expectString, expectJson, expectWhatever, Error
+
+
+# Elaborate Expectations
+
+@docs expectStringResponse, Response
+
+
+# Tasks
+
+@docs task, Resolver, stringResolver
+
+-}
+
+import Http
+import Json.Decode exposing (Decoder)
+import Json.Encode
+import ProgramTest exposing (SimulatedEffect, SimulatedTask)
+import SimulatedEffect
+
+
+{-| Create a `GET` request.
+-}
+get :
+    { url : String
+    , expect : Expect msg
+    }
+    -> SimulatedEffect msg
+get r =
+    request
+        { method = "GET"
+        , headers = []
+        , url = r.url
+        , body = emptyBody
+        , expect = r.expect
+        , timeout = Nothing
+        , tracker = Nothing
+        }
+
+
+{-| Create a `POST` request.
+-}
+post :
+    { url : String
+    , body : Body
+    , expect : Expect msg
+    }
+    -> SimulatedEffect msg
+post r =
+    request
+        { method = "POST"
+        , headers = []
+        , url = r.url
+        , body = r.body
+        , expect = r.expect
+        , timeout = Nothing
+        , tracker = Nothing
+        }
+
+
+{-| Create a custom request.
+-}
+request :
+    { method : String
+    , headers : List Header
+    , url : String
+    , body : Body
+    , expect : Expect msg
+    , timeout : Maybe Float
+    , tracker : Maybe String
+    }
+    -> SimulatedEffect msg
+request r =
+    let
+        (Expect onResult) =
+            r.expect
+    in
+    SimulatedEffect.HttpTask
+        { method = r.method
+        , url = r.url
+        , headers =
+            case r.body of
+                EmptyBody ->
+                    r.headers
+
+                StringBody body ->
+                    header "Content-Type" body.contentType :: r.headers
+        , body =
+            case r.body of
+                EmptyBody ->
+                    ""
+
+                StringBody body ->
+                    body.content
+        , onRequestComplete = onResult >> SimulatedEffect.Succeed
+        }
+        |> SimulatedEffect.Task
+
+
+{-| An HTTP header for configuring requests.
+-}
+type alias Header =
+    ( String, String )
+
+
+{-| Create a `Header`.
+-}
+header : String -> String -> Header
+header =
+    Tuple.pair
+
+
+{-| Represents the body of a `Request`.
+-}
+type Body
+    = EmptyBody
+    | StringBody
+        { contentType : String
+        , content : String
+        }
+
+
+{-| Create an empty body for your `Request`.
+-}
+emptyBody : Body
+emptyBody =
+    EmptyBody
+
+
+{-| Put some JSON value in the body of your `Request`. This will automatically
+add the `Content-Type: application/json` header.
+-}
+jsonBody : Json.Encode.Value -> Body
+jsonBody value =
+    StringBody
+        { contentType = "application/json"
+        , content = Json.Encode.encode 0 value
+        }
+
+
+{-| Put some string in the body of your `Request`.
+-}
+stringBody : String -> String -> Body
+stringBody contentType content =
+    StringBody
+        { contentType = contentType
+        , content = content
+        }
+
+
+{-| Logic for interpreting a response body.
+-}
+type Expect msg
+    = Expect (Http.Response String -> msg)
+
+
+{-| Expect the response body to be a `String`.
+-}
+expectString : (Result Http.Error String -> msg) -> Expect msg
+expectString onResult =
+    Expect <|
+        \response ->
+            case response of
+                Http.BadUrl_ s ->
+                    onResult (Err <| Http.BadUrl s)
+
+                Http.Timeout_ ->
+                    onResult (Err Http.Timeout)
+
+                Http.NetworkError_ ->
+                    onResult (Err Http.NetworkError)
+
+                Http.BadStatus_ metadata body ->
+                    onResult (Err <| Http.BadStatus metadata.statusCode)
+
+                Http.GoodStatus_ _ body ->
+                    onResult (Ok body)
+
+
+{-| Expect a Response with a String body.
+-}
+expectStringResponse : (Result x a -> msg) -> (Response String -> Result x a) -> Expect msg
+expectStringResponse toMsg onResponse =
+    Expect (onResponse >> toMsg)
+
+
+{-| Expect the response body to be JSON.
+-}
+expectJson : (Result Http.Error a -> msg) -> Decoder a -> Expect msg
+expectJson onResult decoder =
+    Expect <|
+        \response ->
+            case response of
+                Http.BadUrl_ s ->
+                    onResult (Err <| Http.BadUrl s)
+
+                Http.Timeout_ ->
+                    onResult (Err Http.Timeout)
+
+                Http.NetworkError_ ->
+                    onResult (Err Http.NetworkError)
+
+                Http.BadStatus_ metadata _ ->
+                    onResult (Err <| Http.BadStatus metadata.statusCode)
+
+                Http.GoodStatus_ _ body ->
+                    case Json.Decode.decodeString decoder body of
+                        Err jsonError ->
+                            onResult (Err <| Http.BadBody <| Json.Decode.errorToString jsonError)
+
+                        Ok value ->
+                            onResult (Ok value)
+
+
+{-| Expect the response body to be whatever.
+-}
+expectWhatever : (Result Error () -> msg) -> Expect msg
+expectWhatever onResult =
+    Expect <|
+        \response ->
+            case response of
+                Http.BadUrl_ s ->
+                    onResult (Err <| Http.BadUrl s)
+
+                Http.Timeout_ ->
+                    onResult (Err Http.Timeout)
+
+                Http.NetworkError_ ->
+                    onResult (Err Http.NetworkError)
+
+                Http.BadStatus_ metadata _ ->
+                    onResult (Err <| Http.BadStatus metadata.statusCode)
+
+                Http.GoodStatus_ _ _ ->
+                    onResult (Ok ())
+
+
+{-| -}
+type alias Error =
+    Http.Error
+
+
+{-| -}
+type alias Response body =
+    Http.Response body
+
+
+{-| Just like [`request`](#request), but it creates a `Task`.
+-}
+task :
+    { method : String
+    , headers : List Header
+    , url : String
+    , body : Body
+    , resolver : Resolver x a
+    , timeout : Maybe Float
+    }
+    -> SimulatedTask x a
+task r =
+    SimulatedEffect.HttpTask
+        { method = r.method
+        , url = r.url
+        , headers = r.headers
+        , body =
+            case r.body of
+                EmptyBody ->
+                    ""
+
+                StringBody body ->
+                    body.content
+        , onRequestComplete =
+            case r.resolver of
+                StringResolver f ->
+                    f
+        }
+
+
+{-| Describes how to resolve an HTTP task.
+-}
+type Resolver x a
+    = StringResolver (Response String -> SimulatedTask x a)
+
+
+{-| Turn a response with a `String` body into a result.
+-}
+stringResolver : (Response String -> Result x a) -> Resolver x a
+stringResolver f =
+    let
+        fromResult result =
+            case result of
+                Err x ->
+                    SimulatedEffect.Fail x
+
+                Ok a ->
+                    SimulatedEffect.Succeed a
+    in
+    StringResolver (f >> fromResult)

package/src/SimulatedEffect/Navigation.elm

@@ -0,0 +1,69 @@
+module SimulatedEffect.Navigation exposing
+    ( pushUrl, replaceUrl, back
+    , load, reload, reloadAndSkipCache
+    )
+
+{-| This module parallels [elm/browsers's `Browser.Navigation` module](https://package.elm-lang.org/packages/elm/browser/1.0.1/Browser-Navigation).
+_Pull requests are welcome to add any functions that are missing._
+
+The functions here produce `SimulatedEffect`s instead of `Cmd`s, which are meant to be used
+to help you implement the function to provide when using [`ProgramTest.withSimulatedEffects`](ProgramTest#withSimulatedEffects).
+
+
+# Navigate within Page
+
+@docs pushUrl, replaceUrl, back
+
+
+# Navigate to other Pages
+
+@docs load, reload, reloadAndSkipCache
+
+-}
+
+import ProgramTest exposing (SimulatedEffect)
+import SimulatedEffect
+
+
+{-| Change the URL, but do not trigger a page load.
+This will add a new entry to the browser history.
+-}
+pushUrl : String -> SimulatedEffect msg
+pushUrl =
+    SimulatedEffect.PushUrl
+
+
+{-| Change the URL, but do not trigger a page load.
+This _will not_ add a new entry to the browser history.
+-}
+replaceUrl : String -> SimulatedEffect msg
+replaceUrl =
+    SimulatedEffect.ReplaceUrl
+
+
+{-| Go back some number of pages.
+-}
+back : Int -> SimulatedEffect msg
+back =
+    SimulatedEffect.Back
+
+
+{-| Leave the current page and load the given URL.
+-}
+load : String -> SimulatedEffect msg
+load =
+    SimulatedEffect.Load
+
+
+{-| Reload the current page.
+-}
+reload : SimulatedEffect msg
+reload =
+    SimulatedEffect.Reload False
+
+
+{-| Reload the current page without using the browser cache.
+-}
+reloadAndSkipCache : SimulatedEffect msg
+reloadAndSkipCache =
+    SimulatedEffect.Reload True

package/src/SimulatedEffect/Ports.elm

@@ -0,0 +1,62 @@
+module SimulatedEffect.Ports exposing (send, subscribe)
+
+{-| This module provides functions that allow you to create `SimulatedEffect`s
+that parallel [Elm ports](https://guide.elm-lang.org/interop/ports.html) used in your real program.
+This is meant to be used
+to help you implement the function to provide when using
+[`ProgramTest.withSimulatedEffects`](ProgramTest#withSimulatedEffects)
+and [`ProgramTest.withSimulatedSubscriptions`](ProgramTest#withSimulatedSubscriptions).
+
+For a detailed example, see the [“Testing programs with ports” guidebook](https://elm-program-test.netlify.com/ports.html).
+
+@docs send, subscribe
+
+-}
+
+import Json.Decode
+import Json.Encode
+import ProgramTest exposing (SimulatedEffect, SimulatedSub)
+import SimulatedEffect
+
+
+{-| Creates a `SimulatedEffect` that parallels using an outgoing Elm port.
+
+For example, if your production code uses a port like this:
+
+    port logMessage : String -> Cmd msg
+
+    logMessage "hello"
+
+Then the corresponding `SimulatedEffect` would be:
+
+    SimulatedEffect.Ports.send "logMessage" (Json.Encode.string "hello")
+
+-}
+send : String -> Json.Encode.Value -> SimulatedEffect msg
+send =
+    SimulatedEffect.PortEffect
+
+
+{-| Creates a `SimulatedSub` that parallels using an incoming Elm port.
+
+For example, if your production code uses a port like this:
+
+    port activeUsers : (List String -> msg) -> Sub msg
+
+    subscriptions : Model -> Sub Msg
+    subscriptions model =
+        activeUsers OnActiveUsersLoaded
+
+Then the corresponding `SimulatedSub` would be:
+
+    simulatedSubscriptions : Model -> SimulatedSub Msg
+    simulatedSubscriptions model =
+        SimulatedEffect.Ports.subscribe
+            "activeUsers"
+            (Json.Decode.list Json.Decode.string)
+            OnActiveUsersLoaded
+
+-}
+subscribe : String -> Json.Decode.Decoder a -> (a -> msg) -> SimulatedSub msg
+subscribe portName decoder toMsg =
+    SimulatedEffect.PortSub portName (Json.Decode.map toMsg decoder)

package/src/SimulatedEffect/Process.elm

@@ -0,0 +1,24 @@
+module SimulatedEffect.Process exposing (sleep)
+
+{-| This module parallels [elm/core's `Process` module](https://package.elm-lang.org/packages/elm/core/1.0.2/Process).
+_Pull requests are welcome to add any functions that are missing._
+
+The functions here produce `SimulatedEffect`s instead of `Cmd`s, which are meant to be used
+to help you implement the function to provide when using [`ProgramTest.withSimulatedEffects`](ProgramTest#withSimulatedEffects).
+
+
+# Processes
+
+@docs sleep
+
+-}
+
+import ProgramTest exposing (SimulatedTask)
+import SimulatedEffect
+
+
+{-| Block progress on the current process for the given number of milliseconds.
+-}
+sleep : Float -> SimulatedTask x ()
+sleep delay =
+    SimulatedEffect.SleepTask delay SimulatedEffect.Succeed

package/src/SimulatedEffect/Sub.elm

@@ -0,0 +1,48 @@
+module SimulatedEffect.Sub exposing
+    ( none, batch
+    , map
+    )
+
+{-| This module parallels [elm/core's `Platform.Sub` module](https://package.elm-lang.org/packages/elm/core/1.0.2/Platform-Sub).
+
+The functions here produce `SimulatedSub`s instead of `Sub`s, which are meant to be used
+to help you implement the function to provide when using [`ProgramTest.withSimulatedSubscriptions`](ProgramTest#withSimulatedSubscriptions).
+
+@docs none, batch
+
+@docs map
+
+-}
+
+import Json.Decode
+import ProgramTest exposing (SimulatedEffect, SimulatedSub)
+import SimulatedEffect
+
+
+{-| Tell the runtime that there are no subscriptions.
+-}
+none : SimulatedSub msg
+none =
+    SimulatedEffect.NoneSub
+
+
+{-| When you need to subscribe to multiple things, you can create a `batch` of subscriptions.
+-}
+batch : List (SimulatedSub msg) -> SimulatedSub msg
+batch =
+    SimulatedEffect.BatchSub
+
+
+{-| Transform the messages produced by a subscription.
+-}
+map : (a -> msg) -> SimulatedSub a -> SimulatedSub msg
+map f effect =
+    case effect of
+        SimulatedEffect.NoneSub ->
+            SimulatedEffect.NoneSub
+
+        SimulatedEffect.BatchSub effects ->
+            SimulatedEffect.BatchSub (List.map (map f) effects)
+
+        SimulatedEffect.PortSub name decoder ->
+            SimulatedEffect.PortSub name (Json.Decode.map f decoder)