module Signet.Unstable.Type.TimestampTest where

import qualified Data.ByteString.Char8 as Ascii
import qualified Data.Time as Time
import qualified Signet.Unstable.Exception.InvalidTimestamp as InvalidTimestamp
import qualified Signet.Unstable.Extra.Tasty as Tasty
import qualified Signet.Unstable.Type.Timestamp as Timestamp
import Test.Tasty.HUnit ((@?=))

spec :: Tasty.Spec
spec :: Spec
spec = TestName -> Spec -> Spec
Tasty.describe TestName
"Signet.Unstable.Type.Timestamp" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
  TestName -> Spec -> Spec
Tasty.describe TestName
"parse" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
    TestName -> Assertion -> Spec
Tasty.it TestName
"fails with invalid timestamp format" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      let byteString :: ByteString
byteString = TestName -> ByteString
Ascii.pack TestName
"invalid-timestamp"
      let result :: Either InvalidTimestamp Timestamp
result = ByteString -> Either InvalidTimestamp Timestamp
Timestamp.parse ByteString
byteString
      Either InvalidTimestamp Timestamp
result Either InvalidTimestamp Timestamp
-> Either InvalidTimestamp Timestamp -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= InvalidTimestamp -> Either InvalidTimestamp Timestamp
forall a b. a -> Either a b
Left (ByteString -> InvalidTimestamp
InvalidTimestamp.MkInvalidTimestamp ByteString
byteString)

    TestName -> Assertion -> Spec
Tasty.it TestName
"succeeds with valid timestamp format" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      let byteString :: ByteString
byteString = TestName -> ByteString
Ascii.pack TestName
"1617235200"
      let result :: Either InvalidTimestamp Timestamp
result = ByteString -> Either InvalidTimestamp Timestamp
Timestamp.parse ByteString
byteString
      case Either InvalidTimestamp Timestamp
result of
        Right Timestamp
timestamp -> do
          let utcTime :: UTCTime
utcTime = Timestamp -> UTCTime
Timestamp.unwrap Timestamp
timestamp
          let expectedTime :: UTCTime
expectedTime = Day -> DiffTime -> UTCTime
Time.UTCTime (Year -> MonthOfYear -> MonthOfYear -> Day
Time.fromGregorian Year
2021 MonthOfYear
4 MonthOfYear
1) DiffTime
0
          UTCTime
utcTime UTCTime -> UTCTime -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= UTCTime
expectedTime
        Left InvalidTimestamp
_ -> TestName -> Assertion
forall a. TestName -> IO a
forall (m :: * -> *) a. MonadFail m => TestName -> m a
fail TestName
"Expected Right but got Left"

  TestName -> Spec -> Spec
Tasty.describe TestName
"render" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
    TestName -> Assertion -> Spec
Tasty.it TestName
"returns the correct ByteString representation" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      let utcTime :: UTCTime
utcTime = Day -> DiffTime -> UTCTime
Time.UTCTime (Year -> MonthOfYear -> MonthOfYear -> Day
Time.fromGregorian Year
2021 MonthOfYear
4 MonthOfYear
1) DiffTime
0
      let timestamp :: Timestamp
timestamp = UTCTime -> Timestamp
Timestamp.MkTimestamp UTCTime
utcTime
      let expected :: ByteString
expected = TestName -> ByteString
Ascii.pack TestName
"1617235200"
      Timestamp -> ByteString
Timestamp.render Timestamp
timestamp ByteString -> ByteString -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= ByteString
expected