content: module Taskell.Data.ListsTest
      ( test_lists
      ) where
  
  import ClassyPrelude hiding (delete)
  
  import Test.Tasty
  import Test.Tasty.HUnit
  
  import Control.Lens ((.~))
  
  import           Taskell.Data.Date  (textToTime)
  import qualified Taskell.Data.List  as L
  import           Taskell.Data.Lists
  import qualified Taskell.Data.Task  as T
  import           Taskell.Types      (ListIndex (ListIndex), TaskIndex (TaskIndex))
  
  -- test data
  list1, list2, list3 :: L.List
  list1 =
      foldl'
          (flip L.append)
          (L.empty "List 1")
          [T.new "One", (T.due .~ textToTime "2019-08-14") (T.new "Two"), T.new "Three"]
  
  list2 =
      foldl'
          (flip L.append)
          (L.empty "List 2")
          [T.new "1", T.new "2", (T.due .~ textToTime "2018-12-03") (T.new "3")]
  
  list3 =
      foldl'
          (flip L.append)
          (L.empty "List 3")
          [(T.due .~ textToTime "2019-04-05") (T.new "01"), T.new "10", T.new "11"]
  
  testLists :: Lists
  testLists = fromList [list1, list2, list3]
  
  -- tests
  test_lists :: TestTree
  test_lists =
      testGroup
          "Data.Taskell.Lists"
          [ testCase "initial" (assertEqual "Returns empty" (fromList []) initial)
          , testCase
                "updateLists"
                (assertEqual
                     "Replaces the middle list"
                     (fromList [list1, list1, list3])
                     (updateLists 1 list1 testLists))
          , testGroup
                "count"
                [ testCase
                      "list exists"
                      (assertEqual "Returns length of middle list" 3 (count 1 testLists))
                , testCase "list does not exist" (assertEqual "Returns 0" 0 (count 10 testLists))
                ]
          , testGroup
                "get"
                [ testCase
                      "list exists"
                      (assertEqual "Returns the list" (Just list2) (get testLists 1))
                , testCase "list does not exist" (assertEqual "Nothing" Nothing (get testLists 10))
                ]
          , testGroup
                "changeList"
                [ testCase
                      "right"
                      (assertEqual
                           "Returns updated lists"
                           (Just
                                (fromList
                                     [ list1
                                     , foldl'
                                           (flip L.append)
                                           (L.empty "List 2")
                                           [T.new "1", (T.due .~ textToTime "2018-12-03") (T.new "3")]
                                     , foldl'
                                           (flip L.append)
                                           (L.empty "List 3")
                                           [ (T.due .~ textToTime "2019-04-05") (T.new "01")
                                           , T.new "10"
                                           , T.new "11"
                                           , T.new "2"
                                           ]
                                     ]))
                           (changeList Bottom (ListIndex 1, TaskIndex 1) testLists 1))
                , testCase
                      "left"
                      (assertEqual
                           "Returns updated lists"
                           (Just
                                (fromList
                                     [ foldl'
                                           (flip L.append)
                                           (L.empty "List 1")
                                           [ T.new "One"
                                           , (T.due .~ textToTime "2019-08-14") (T.new "Two")
                                           , T.new "Three"
                                           , T.new "2"
                                           ]
                                     , foldl'
                                           (flip L.append)
                                           (L.empty "List 2")
                                           [T.new "1", (T.due .~ textToTime "2018-12-03") (T.new "3")]
                                     , list3
                                     ]))
                           (changeList Bottom (ListIndex 1, TaskIndex 1) testLists (-1)))
                , testCase
                      "out of bounds list"
                      (assertEqual
                           "Nothing"
                           Nothing
                           (changeList Bottom (ListIndex 5, TaskIndex 1) testLists 1))
                , testCase
                      "out of bounds task"
                      (assertEqual
                           "Nothing"
                           Nothing
                           (changeList Bottom (ListIndex 1, TaskIndex 10) testLists 1))
                ]
          , testCase
                "newList"
                (assertEqual
                     "Returns lists with new list"
                     (fromList [list1, list2, list3, L.empty "Hello"])
                     (newList "Hello" testLists))
          , testCase
                "delete"
                (assertEqual
                     "Returns lists with middle list removed"
                     (fromList [list1, list3])
                     (delete 1 testLists))
          , testGroup
                "exists"
                [ testCase "list exists" (assertEqual "Returns True" True (exists 1 testLists))
                , testCase
                      "list does not exist"
                      (assertEqual "Returns False" False (exists 10 testLists))
                ]
          , testGroup
                "shiftBy"
                [ testCase
                      "right"
                      (assertEqual
                           "Returns updated lists"
                           (Just (fromList [list1, list3, list2]))
                           (shiftBy 1 1 testLists))
                , testCase
                      "left"
                      (assertEqual
                           "Returns updated lists"
                           (Just (fromList [list2, list1, list3]))
                           (shiftBy 1 (-1) testLists))
                , testCase
                      "out of bounds list"
                      (assertEqual "Nothing" Nothing (shiftBy 5 1 testLists))
                , testCase
                      "out of bounds shift"
                      (assertEqual
                           "Returns updated lists"
                           (Just (fromList [list2, list1, list3]))
                           (shiftBy 1 (-10) testLists))
                ]
          , testGroup
                "search"
                [ testCase
                      "term exists"
                      (assertEqual
                           "Returns filtered lists"
                           (fromList
                                [ foldl' (flip L.append) (L.empty "List 1") [T.new "One"]
                                , L.empty "List 2"
                                , L.empty "List 3"
                                ])
                           (search "One" testLists))
                , testCase
                      "term doesn't exist"
                      (assertEqual
                           "Returns updated lists"
                           (fromList [L.empty "List 1", L.empty "List 2", L.empty "List 3"])
                           (search "Fish" testLists))
                ]
          , testGroup
                "appendToLast"
                [ testCase
                      "previous list exists"
                      (assertEqual
                           "Returns updated lists"
                           (fromList
                                [ list1
                                , list2
                                , foldl'
                                      (flip L.append)
                                      (L.empty "List 3")
                                      [ (T.due .~ textToTime "2019-04-05") (T.new "01")
                                      , T.new "10"
                                      , T.new "11"
                                      , T.new "Blah"
                                      ]
                                ])
                           (appendToLast (T.new "Blah") testLists))
                , testCase
                      "previous list doesn't exist"
                      (assertEqual "Returns original list" empty (appendToLast (T.new "Blah") empty))
                ]
          , testCase
                "analyse"
                (assertEqual
                     "Returns an analysis"
                     "test.md\nLists: 3\nTasks: 9"
                     (analyse "test.md" testLists))
          , testCase
                "due"
                (assertEqual
                     "returns just due list"
                     (fromList
                          [ ( (ListIndex 1, TaskIndex 2)
                            , (T.due .~ textToTime "2018-12-03") (T.new "3"))
                          , ( (ListIndex 2, TaskIndex 0)
                            , (T.due .~ textToTime "2019-04-05") (T.new "01"))
                          , ( (ListIndex 0, TaskIndex 1)
                            , (T.due .~ textToTime "2019-08-14") (T.new "Two"))
                          ])
                     (due testLists))
          ]
  