[WIP, fixup] Add integration tests

Author: andrewMacmurray

devbox.json

@@ -15,6 +15,10 @@
       "test": [
         "cd tests/",
         "./run-tests.sh"
+      ],
+      "integration": [
+        "cd integration_tests",
+        "./run-tests.sh"
       ]
     }
   }

integration_tests/run-tests.sh

@@ -0,0 +1,4 @@
+set -e
+
+gren make src/Main.gren
+node app

integration_tests/src/Main.gren

@@ -4,7 +4,8 @@ module Main exposing ( .. )
 {-|-}
 
 import Test.Crypto as Crypto
-import Test.Runner.Effectful
+import Test.Task as Task
+import Test.Runner.Effectful exposing (concat)
 import Node
 
 
@@ -13,5 +14,10 @@ import Node
 main : Test.Runner.Effectful.Program a
 main =
     Node.defineSimpleProgram (\env ->
-        Test.Runner.Effectful.run env Crypto.tests
+        Test.Runner.Effectful.run env
+            (concat
+                [ Crypto.tests
+                , Task.tests
+                ]
+            )
     )

integration_tests/src/Test/Task.gren

@@ -0,0 +1,153 @@
+module Test.Task exposing (tests)
+
+{-| -}
+
+import Array exposing (..)
+import Basics exposing (..)
+import Bytes exposing (Bytes)
+import Bytes.Decode
+import Crypto
+import Expect exposing (Expectation)
+import Math
+import Maybe exposing (Maybe(..))
+import Process
+import Task exposing (Task)
+import Test.Runner.Effectful exposing (await, awaitError, concat, describe, fuzz, run, test)
+import Time
+
+
+{-| -}
+tests : Test.Runner.Effectful.Test
+tests =
+    describe "Task.concurrent"
+        [ let
+            durations : Array Float
+            durations =
+                Array.range 1 1000 |> Array.map toFloat
+          in
+          await
+            (durations
+                |> Array.map sleep
+                |> Task.concurrent
+                |> withDuration
+            )
+            "concurrent array of tasks"
+            (\res ->
+                concat
+                    [ test "preserves order of results"
+                        (\_ -> Expect.equal durations res.val)
+                    , test "runs tasks concurrently"
+                        (\_ -> expectDurationLessThan 2000 res)
+                    ]
+            )
+        , await
+            (Array.repeat 1000000 (sleep 10)
+                |> Task.concurrent
+                |> withDuration
+            )
+            "large concurrent array of tasks"
+            (\res ->
+                test "completes in reasonable time"
+                    (\_ -> expectDurationLessThan 2000 res)
+            )
+        , await
+            (Task.map2 (++)
+                (Task.map2 (++)
+                    (Task.concurrent
+                        [ sleep 30
+                        , sleep 40
+                        ]
+                    )
+                    (Task.concurrent
+                        [ sleep 50
+                        , Task.map2 (+)
+                            (sleep 100)
+                            (sleep 100)
+                        ]
+                    )
+                )
+                (Task.concurrent
+                    [ sleep 150
+                    , sleep 80
+                    ]
+                )
+                |> withDuration
+            )
+            "deeply nested concurrent task"
+            (\res ->
+                concat
+                    [ test "runs deeply nested concurrent tasks at the same time"
+                        (\_ -> expectDurationLessThan 500 res)
+                    , test "preserves result order"
+                        (\_ -> Expect.equal [ 30, 40, 50, 200, 150, 80 ] res.val)
+                    ]
+            )
+        ]
+
+
+sleep : Float -> Task x Float
+sleep ms =
+    Process.sleep ms |> Task.map (\_ -> ms)
+
+
+
+-- Timing helpers
+
+
+type alias Timed a =
+    { start : Time.Posix
+    , end : Time.Posix
+    , val : a
+    }
+
+
+expectDurationLessThan : Int -> Timed a -> Expectation
+expectDurationLessThan ms a =
+    if duration a < ms then
+        Expect.pass
+
+    else
+        Expect.fail
+            ("Duration was: "
+                ++ String.fromInt (duration a)
+                ++ ", Expected less than: "
+                ++ String.fromInt ms
+                ++ "ms"
+            )
+
+
+duration : Timed a -> Int
+duration timed =
+    Time.posixToMillis timed.end - Time.posixToMillis timed.start
+
+
+withDuration : Task x a -> Task (Timed x) (Timed a)
+withDuration task =
+    Time.now
+        |> Task.andThen
+            (\start ->
+                task
+                    |> Task.onError
+                        (\e ->
+                            Time.now
+                                |> Task.andThen
+                                    (\end ->
+                                        Task.fail
+                                            { start = start
+                                            , end = end
+                                            , val = e
+                                            }
+                                    )
+                        )
+                    |> Task.andThen
+                        (\a ->
+                            Time.now
+                                |> Task.map
+                                    (\end ->
+                                        { start = start
+                                        , end = end
+                                        , val = a
+                                        }
+                                    )
+                        )
+            )