{-# LANGUAGE OverloadedStrings #-}

module SubSpec (spec) where

import           Control.Monad
import           Data.ByteString
import qualified Data.ByteString.Lazy      as LBS
import           Data.Either               (isLeft)
import           Fixtures                  (invalidSubjectCases)
import           Subscription.Types
import           Test.Hspec
import           Text.Printf
import           Transformers.Transformers
import           Types.Sub
import           Validators.Validators

spec :: Spec
spec = do
  subscribeOptionCases
  transformerCases
  validateCases
  validateSubjectCases

subscribeOptionCases = parallel $ do
  describe "subscribe config" $ do
    it "stores the queue group" $ do
      subscribeQueueGroup (SubscribeConfig Nothing (Just "WORKERS"))
        `shouldBe` Just "WORKERS"

explicitTransformerCases :: [(Sub, ByteString)]
explicitTransformerCases = [
  (Sub "SOME.SUBJ" Nothing "uuid", "SUB SOME.SUBJ uuid\r\n"),
  (Sub "SOME.SUBJ" (Just "QUEUE.GROUP.A") "uuid", "SUB SOME.SUBJ QUEUE.GROUP.A uuid\r\n")
  ]

transformerCases = parallel $ do
  describe "SUB transformer" $ do
    forM_ explicitTransformerCases $ \(input, want) ->
      it (printf "correctly transforms %s" (show input)) $ do
        LBS.toStrict (transform input) `shouldBe` want

explicitValidaterCases :: [(Sub, Either ByteString ())]
explicitValidaterCases = [
  (Sub ">" Nothing "a", Right ()),
  (Sub ">" (Just "1") "a", Right ()),
  (Sub "" Nothing "a", Left "explicit empty subject"),
  (Sub ">" (Just "") "a", Left "explicit empty queue group"),
  (Sub ">" Nothing "", Left "explicit empty sid")
  ]

validateCases = parallel $ do
  describe "SUB validater" $ do
    forM_ explicitValidaterCases $ \(input, want) ->
      it (printf "correctly validates %s" (show input)) $ do
        validate input `shouldBe` want

validateSubjectCases = parallel $ do
  describe "SUB subject validater" $ do
    forM_ invalidSubjectCases $ \input ->
      it (printf "rejects invalid subscription subject %s" (show input)) $ do
        validate (Sub input Nothing "a") `shouldSatisfy` isLeft

    it "rejects queue groups containing whitespace" $ do
      validate (Sub "FOO" (Just "bad queue") "a") `shouldSatisfy` isLeft