384 lines
16 KiB
Elm
384 lines
16 KiB
Elm
module Test.Values.Timeline exposing (..)
|
|
|
|
import Expect
|
|
import Fuzz exposing (Fuzzer)
|
|
import Internal.Filter.Timeline as Filter
|
|
import Internal.Tools.Json as Json
|
|
import Internal.Values.Timeline as Timeline exposing (Batch, Timeline)
|
|
import Json.Decode as D
|
|
import Test exposing (..)
|
|
import Test.Filter.Timeline as TestFilter
|
|
|
|
|
|
fuzzer : Fuzzer Timeline
|
|
fuzzer =
|
|
TestFilter.fuzzer
|
|
|> Fuzz.andThen
|
|
(\globalFilter ->
|
|
Fuzz.oneOf
|
|
[ Fuzz.map2
|
|
(\start batches ->
|
|
List.foldl
|
|
(\b ( s, f ) ->
|
|
( b.end
|
|
, f >> Timeline.insert { b | start = Just s, filter = globalFilter }
|
|
)
|
|
)
|
|
( start, identity )
|
|
batches
|
|
|> Tuple.second
|
|
)
|
|
Fuzz.string
|
|
(Fuzz.listOfLengthBetween 0 10 fuzzerBatch)
|
|
, Fuzz.map2
|
|
(\start batches ->
|
|
List.foldl
|
|
(\b ( s, f ) ->
|
|
( b.end
|
|
, f >> Timeline.insert { b | start = Just s, filter = Filter.and globalFilter b.filter }
|
|
)
|
|
)
|
|
( start, identity )
|
|
batches
|
|
|> Tuple.second
|
|
)
|
|
Fuzz.string
|
|
(Fuzz.listOfLengthBetween 0 4 fuzzerBatch)
|
|
, Fuzz.map2
|
|
(\start batches ->
|
|
List.foldl
|
|
(\b ( s, f ) ->
|
|
( b.end
|
|
, f >> Timeline.addSync { b | start = Just s, filter = globalFilter }
|
|
)
|
|
)
|
|
( start, identity )
|
|
batches
|
|
|> Tuple.second
|
|
)
|
|
Fuzz.string
|
|
(Fuzz.listOfLengthBetween 0 10 fuzzerBatch)
|
|
, Fuzz.map2
|
|
(\start batches ->
|
|
List.foldl
|
|
(\b ( s, f ) ->
|
|
( b.end
|
|
, f >> Timeline.addSync { b | start = Just s, filter = Filter.and globalFilter b.filter }
|
|
)
|
|
)
|
|
( start, identity )
|
|
batches
|
|
|> Tuple.second
|
|
)
|
|
Fuzz.string
|
|
(Fuzz.listOfLengthBetween 0 4 fuzzerBatch)
|
|
]
|
|
|> Fuzz.listOfLengthBetween 0 10
|
|
|> Fuzz.map (List.foldl (<|) Timeline.empty)
|
|
)
|
|
|
|
|
|
fuzzerBatch : Fuzzer Batch
|
|
fuzzerBatch =
|
|
Fuzz.map4 Batch
|
|
(Fuzz.list Fuzz.string)
|
|
TestFilter.fuzzer
|
|
(Fuzz.maybe Fuzz.string)
|
|
Fuzz.string
|
|
|
|
|
|
suite : Test
|
|
suite =
|
|
describe "Timeline"
|
|
[ describe "most recent events with filters"
|
|
[ fuzz TestFilter.fuzzer
|
|
"Events are returned properly"
|
|
(\filter ->
|
|
Timeline.empty
|
|
|> Timeline.insert
|
|
{ events = [ "a", "b", "c" ]
|
|
, filter = filter
|
|
, start = Just "token_1"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = [ "d", "e", "f" ]
|
|
, filter = filter
|
|
, start = Just "token_2"
|
|
, end = "token_3"
|
|
}
|
|
|> Timeline.mostRecentEventsFrom filter "token_3"
|
|
|> Expect.equal
|
|
[ [ "a", "b", "c", "d", "e", "f" ] ]
|
|
)
|
|
, fuzz2 TestFilter.fuzzer
|
|
TestFilter.fuzzer
|
|
"Sub-events get the same results"
|
|
(\f1 f2 ->
|
|
let
|
|
subFilter =
|
|
Filter.and f1 f2
|
|
in
|
|
Timeline.empty
|
|
|> Timeline.insert
|
|
{ events = [ "a", "b", "c" ]
|
|
, filter = f1
|
|
, start = Just "token_1"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = [ "d", "e", "f" ]
|
|
, filter = f1
|
|
, start = Just "token_2"
|
|
, end = "token_3"
|
|
}
|
|
|> Timeline.mostRecentEventsFrom subFilter "token_3"
|
|
|> Expect.equal
|
|
[ [ "a", "b", "c", "d", "e", "f" ] ]
|
|
)
|
|
, fuzz2 TestFilter.fuzzer
|
|
TestFilter.fuzzer
|
|
"ONLY same result if sub-filter"
|
|
(\f1 f2 ->
|
|
Timeline.empty
|
|
|> Timeline.insert
|
|
{ events = [ "a", "b", "c" ]
|
|
, filter = f1
|
|
, start = Just "token_1"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = [ "d", "e", "f" ]
|
|
, filter = f1
|
|
, start = Just "token_2"
|
|
, end = "token_3"
|
|
}
|
|
|> Timeline.mostRecentEventsFrom f2 "token_3"
|
|
|> (\events ->
|
|
Expect.equal
|
|
(Filter.subsetOf f1 f2)
|
|
(events == [ [ "a", "b", "c", "d", "e", "f" ] ])
|
|
)
|
|
)
|
|
]
|
|
, describe "Forks in the road"
|
|
[ fuzz2 TestFilter.fuzzer
|
|
TestFilter.fuzzer
|
|
"Two options returned"
|
|
(\f1 f2 ->
|
|
let
|
|
subFilter =
|
|
Filter.and f1 f2
|
|
in
|
|
Timeline.empty
|
|
|> Timeline.insert
|
|
{ events = [ "a", "b", "c" ]
|
|
, filter = f1
|
|
, start = Just "token_1"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = [ "d", "e", "f" ]
|
|
, filter = f2
|
|
, start = Just "token_3"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = [ "g", "h", "i" ]
|
|
, filter = subFilter
|
|
, start = Just "token_2"
|
|
, end = "token_4"
|
|
}
|
|
|> Timeline.mostRecentEventsFrom subFilter "token_4"
|
|
|> Expect.equal
|
|
[ [ "a", "b", "c", "g", "h", "i" ]
|
|
, [ "d", "e", "f", "g", "h", "i" ]
|
|
]
|
|
)
|
|
]
|
|
, describe "Gaps"
|
|
[ fuzz TestFilter.fuzzer
|
|
"Gaps leave behind old events"
|
|
(\filter ->
|
|
Timeline.empty
|
|
|> Timeline.insert
|
|
{ events = [ "a", "b", "c" ]
|
|
, filter = filter
|
|
, start = Just "token_1"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = [ "d", "e", "f" ]
|
|
, filter = filter
|
|
, start = Just "token_3"
|
|
, end = "token_4"
|
|
}
|
|
|> Timeline.mostRecentEventsFrom filter "token_4"
|
|
|> Expect.equal [ [ "d", "e", "f" ] ]
|
|
)
|
|
, fuzz3 TestFilter.fuzzer
|
|
(Fuzz.list Fuzz.string)
|
|
(Fuzz.pair (Fuzz.list Fuzz.string) (Fuzz.list Fuzz.string))
|
|
"Gaps can be bridged"
|
|
(\filter l1 ( l2, l3 ) ->
|
|
Timeline.empty
|
|
|> Timeline.insert
|
|
{ events = l1
|
|
, filter = filter
|
|
, start = Just "token_1"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = l3
|
|
, filter = filter
|
|
, start = Just "token_3"
|
|
, end = "token_4"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = l2
|
|
, filter = filter
|
|
, start = Just "token_2"
|
|
, end = "token_3"
|
|
}
|
|
|> Timeline.mostRecentEventsFrom filter "token_4"
|
|
|> Expect.equal [ List.concat [ l1, l2, l3 ] ]
|
|
)
|
|
]
|
|
, describe "JSON"
|
|
[ fuzz fuzzer
|
|
"Encode + Decode gives same output"
|
|
(\timeline ->
|
|
timeline
|
|
|> Json.encode Timeline.coder
|
|
|> D.decodeValue (Json.decode Timeline.coder)
|
|
|> Result.map Tuple.first
|
|
|> Result.map (Timeline.mostRecentEvents Filter.pass)
|
|
|> Expect.equal (Ok <| Timeline.mostRecentEvents Filter.pass timeline)
|
|
)
|
|
]
|
|
, describe "Weird loops"
|
|
[ fuzz TestFilter.fuzzer
|
|
"Weird loops stop looping"
|
|
(\filter ->
|
|
Timeline.empty
|
|
|> Timeline.insert
|
|
{ events = [ "a", "b", "c" ]
|
|
, filter = filter
|
|
, start = Just "token_1"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = [ "d", "e", "f" ]
|
|
, filter = filter
|
|
, start = Just "token_2"
|
|
, end = "token_3"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = [ "g", "h", "i" ]
|
|
, filter = filter
|
|
, start = Just "token_3"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.mostRecentEventsFrom filter "token_2"
|
|
|> Expect.equal
|
|
[ [ "a", "b", "c" ]
|
|
, [ "d", "e", "f", "g", "h", "i" ]
|
|
]
|
|
)
|
|
]
|
|
, describe "Sync"
|
|
[ fuzz TestFilter.fuzzer
|
|
"Sync fills gaps"
|
|
(\filter ->
|
|
Timeline.empty
|
|
|> Timeline.addSync
|
|
{ events = [ "a", "b", "c" ]
|
|
, filter = filter
|
|
, start = Just "token_1"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.addSync
|
|
{ events = [ "f", "g", "h" ]
|
|
, filter = filter
|
|
, start = Just "token_3"
|
|
, end = "token_4"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = [ "d", "e" ]
|
|
, filter = filter
|
|
, start = Just "token_2"
|
|
, end = "token_3"
|
|
}
|
|
|> Timeline.mostRecentEvents filter
|
|
|> Expect.equal [ [ "a", "b", "c", "d", "e", "f", "g", "h" ] ]
|
|
)
|
|
, fuzz TestFilter.fuzzer
|
|
"Sync doesn't fill open gaps"
|
|
(\filter ->
|
|
Timeline.empty
|
|
|> Timeline.addSync
|
|
{ events = [ "a", "b", "c" ]
|
|
, filter = filter
|
|
, start = Just "token_1"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.addSync
|
|
{ events = [ "f", "g", "h" ]
|
|
, filter = filter
|
|
, start = Just "token_3"
|
|
, end = "token_4"
|
|
}
|
|
|> Timeline.mostRecentEvents filter
|
|
|> Expect.equal [ [ "f", "g", "h" ] ]
|
|
)
|
|
, fuzz3 (Fuzz.pair Fuzz.string Fuzz.string)
|
|
fuzzer
|
|
TestFilter.fuzzer
|
|
"Getting /sync is the same as getting from the token"
|
|
(\( start, end ) timeline filter ->
|
|
let
|
|
t : Timeline
|
|
t =
|
|
Timeline.addSync
|
|
{ events = [ "a", "b", "c" ]
|
|
, filter = filter
|
|
, start = Just start
|
|
, end = end
|
|
}
|
|
timeline
|
|
in
|
|
Expect.equal
|
|
(Timeline.mostRecentEvents filter t)
|
|
(Timeline.mostRecentEventsFrom filter end t)
|
|
)
|
|
, fuzz TestFilter.fuzzer
|
|
"Weird loops stop looping"
|
|
(\filter ->
|
|
Timeline.empty
|
|
|> Timeline.insert
|
|
{ events = [ "a", "b", "c" ]
|
|
, filter = filter
|
|
, start = Just "token_1"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = [ "d", "e", "f" ]
|
|
, filter = filter
|
|
, start = Just "token_2"
|
|
, end = "token_3"
|
|
}
|
|
|> Timeline.insert
|
|
{ events = [ "g", "h", "i" ]
|
|
, filter = filter
|
|
, start = Just "token_3"
|
|
, end = "token_2"
|
|
}
|
|
|> Timeline.mostRecentEventsFrom filter "token_2"
|
|
|> Expect.equal
|
|
[ [ "a", "b", "c" ]
|
|
, [ "d", "e", "f", "g", "h", "i" ]
|
|
]
|
|
)
|
|
]
|
|
]
|