content: module Taskell.Data.DateTest
      ( test_date
      ) where
  
  import ClassyPrelude
  
  import Test.Tasty
  import Test.Tasty.HUnit
  
  import Data.Time
  import Data.Time.Zones     (utcTZ)
  import Data.Time.Zones.All (TZLabel (America__New_York), tzByLabel)
  import Taskell.Data.Date
  
  testDate :: UTCTime
  testDate = UTCTime (fromGregorian 2018 5 18) (secondsToDiffTime 0)
  
  -- sorting test data
  sort1 :: Due
  sort1 = DueTime (UTCTime (fromGregorian 2017 2 4) 0)
  
  sort2 :: Due
  sort2 = DueDate (fromGregorian 2016 12 15)
  
  sort3 :: Due
  sort3 = DueTime (UTCTime (fromGregorian 2020 8 9) 44000)
  
  sort4 :: Due
  sort4 = DueDate (fromGregorian 2019 8 30)
  
  -- tests
  test_date :: TestTree
  test_date =
      testGroup
          "Data.Taskell.Date"
          [ testCase
                "Sorting"
                (assertEqual
                     "Sorted in date order"
                     [sort2, sort1, sort4, sort3]
                     (sort [sort1, sort2, sort3, sort4]))
          , testGroup
                "Date Output"
                [ testGroup
                      "timeToDisplay"
                      [ testCase
                            "timeToDisplay time"
                            (assertEqual
                                 "Date in yyyy-mm-dd format"
                                 "2018-05-18 00:00"
                                 (timeToDisplay utcTZ (DueTime testDate)))
                      , testCase
                            "timeToDisplay time - non-utc"
                            (assertEqual
                                 "Date in yyyy-mm-dd format"
                                 "2018-05-17 20:00"
                                 (timeToDisplay (tzByLabel America__New_York) (DueTime testDate)))
                      , testCase
                            "timeToDisplay date"
                            (assertEqual
                                 "Date in yyyy-mm-dd format"
                                 "2018-05-18"
                                 (timeToDisplay utcTZ (DueDate (fromGregorian 2018 05 18))))
                      ]
                , testGroup
                      "timeToOutput"
                      [ testCase
                            "timeToOutput time"
                            (assertEqual
                                 "Date in yyyy-mm-dd format"
                                 "2018-05-18 00:00 UTC"
                                 (timeToOutput (DueTime testDate)))
                      , testCase
                            "timeToOutput date"
                            (assertEqual
                                 "Date in yyyy-mm-dd format"
                                 "2018-05-18"
                                 (timeToOutput (DueDate (fromGregorian 2018 05 18))))
                      ]
                , testGroup
                      "timeToOutputLocal"
                      [ testCase
                            "timeToOutputLocal time"
                            (assertEqual
                                 "Date in yyyy-mm-dd format"
                                 "2018-05-18 00:00 UTC"
                                 (timeToOutputLocal utcTZ (DueTime testDate)))
                      , testCase
                            "timeToOutputLocal time - non-utc"
                            (assertEqual
                                 "Date in yyyy-mm-dd format"
                                 "2018-05-17 20:00 EDT"
                                 (timeToOutputLocal (tzByLabel America__New_York) (DueTime testDate)))
                      , testCase
                            "timeToOutputLocal date"
                            (assertEqual
                                 "Date in yyyy-mm-dd format"
                                 "2018-05-18"
                                 (timeToOutputLocal utcTZ (DueDate (fromGregorian 2018 05 18))))
                      , testCase
                            "timeToOutputLocal date - non-utc"
                            (assertEqual
                                 "Date in yyyy-mm-dd format"
                                 "2018-05-18"
                                 (timeToOutputLocal
                                      (tzByLabel America__New_York)
                                      (DueDate (fromGregorian 2018 05 18))))
                      ]
                , testGroup
                      "timeToText"
                      [ testCase
                            "time"
                            (assertEqual
                                 "Date in 18-May format"
                                 "00:00 18-May"
                                 (timeToText utcTZ testDate (DueTime testDate)))
                      , testCase
                            "time - non-utc"
                            (assertEqual
                                 "Date in 17-May format"
                                 "20:00 17-May"
                                 (timeToText (tzByLabel America__New_York) testDate (DueTime testDate)))
                      , testCase
                            "same year"
                            (assertEqual
                                 "Date in 18-May format"
                                 "18-May"
                                 (timeToText utcTZ testDate (DueDate (fromGregorian 2018 5 18))))
                      , testCase
                            "different year"
                            (assertEqual
                                 "Date in 18-May 2019 format"
                                 "18-May 2019"
                                 (timeToText utcTZ testDate (DueDate (fromGregorian 2019 5 18))))
                      , testCase
                            "different year"
                            (assertEqual
                                 "Date in 18-May 2017 format"
                                 "18-May 2017"
                                 (timeToText utcTZ testDate (DueDate (fromGregorian 2017 5 18))))
                      ]
                ]
          , testGroup
                "Input"
                [ testGroup
                      "textToTime"
                      [ testCase
                            "simple date"
                            (assertEqual
                                 "A valid Day"
                                 (DueDate <$> fromGregorianValid 2018 05 18)
                                 (textToTime "2018-05-18"))
                      , testCase
                            "simple time"
                            (assertEqual
                                 "A valid time"
                                 (DueTime . flip UTCTime 64800 <$> fromGregorianValid 2018 05 18)
                                 (textToTime "2018-05-18 18:00 UTC"))
                      , testCase
                            "time with timezone"
                            (assertEqual
                                 "A valid time"
                                 (DueTime . flip UTCTime 0 <$> fromGregorianValid 2018 05 18)
                                 (textToTime "2018-05-17 20:00 EDT"))
                      ]
                , testGroup
                      "inputToTime"
                      [ testCase
                            "simple date"
                            (assertEqual
                                 "A valid Day"
                                 (DueDate <$> fromGregorianValid 2018 05 18)
                                 (inputToTime utcTZ testDate "2018-05-18"))
                      , testCase
                            "simple time"
                            (assertEqual
                                 "A valid time"
                                 (DueTime . flip UTCTime 64800 <$> fromGregorianValid 2018 05 18)
                                 (inputToTime utcTZ testDate "2018-05-18 18:00"))
                      , testCase
                            "time with timezone"
                            (assertEqual
                                 "A valid time"
                                 (DueTime . flip UTCTime 79200 <$> fromGregorianValid 2018 05 18)
                                 (inputToTime
                                      (tzByLabel America__New_York)
                                      testDate
                                      "2018-05-18 18:00"))
                      , testCase
                            "relative time - seconds"
                            (assertEqual
                                 "Adds 7 seconds"
                                 (DueTime . flip UTCTime 7 <$> fromGregorianValid 2018 05 18)
                                 (inputToTime utcTZ testDate "7s"))
                      , testCase
                            "relative time - days"
                            (assertEqual
                                 "Adds 29 days, 12 hours"
                                 (DueTime . flip UTCTime 43200 <$> fromGregorianValid 2018 06 16)
                                 (inputToTime utcTZ testDate "29 d 12h"))
                      , testCase
                            "relative time - weeks"
                            (assertEqual
                                 "Adds four weeks, two days, 12 hours"
                                 (DueTime . flip UTCTime 43200 <$> fromGregorianValid 2018 06 17)
                                 (inputToTime utcTZ testDate "4w 2d 12h"))
                      ]
                , testCase
                      "isoToTime"
                      (assertEqual
                           "Gives back time"
                           (Just (DueTime (UTCTime (fromGregorian 2020 8 11) 82800)))
                           (isoToTime "2020-08-11T23:00:00.000Z"))
                ]
          , testGroup
                "deadline"
                [ testCase
                      "Plenty"
                      (assertEqual
                           "Plenty of time"
                           Plenty
                           (deadline testDate (DueDate (fromGregorian 2018 05 28))))
                , testCase
                      "ThisWeek"
                      (assertEqual
                           "This week"
                           ThisWeek
                           (deadline testDate (DueDate (fromGregorian 2018 05 24))))
                , testCase
                      "Tomorrow"
                      (assertEqual
                           "Tomorrow"
                           Tomorrow
                           (deadline testDate (DueDate (fromGregorian 2018 05 19))))
                , testCase "Today" (assertEqual "Today" Today (deadline testDate (DueTime testDate)))
                , testCase
                      "Passed"
                      (assertEqual
                           "Passed"
                           Passed
                           (deadline testDate (DueDate (fromGregorian 2018 05 17))))
                ]
          ]
  