InternalSpec.hs

{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE OverloadedStrings #-}

module OpenTelemetry.Propagator.Datadog.InternalSpec where

import qualified Data.ByteString.Char8 as BC
import Data.ByteString.Short (ShortByteString)
import qualified Data.ByteString.Short as SB
import Data.Word (Word64)
import Hexdump (simpleHex)
import OpenTelemetry.Propagator.Datadog.Internal
import qualified String
import Test.Hspec
import Test.QuickCheck


spec :: Spec
spec = do
  context "newTraceIdFromHeader" $ do
    it "is equal to the old implementation" $
      property $ \x -> do
        let x' = BC.pack $ show (x :: Word64)
        HexString (newTraceIdFromHeader x')
          `shouldBe` HexString (String.newTraceIdFromHeader x')

  context "newSpanIdFromHeader" $ do
    it "is equal to the old implementation" $
      property $ \x -> do
        let x' = BC.pack $ show (x :: Word64)
        HexString (newSpanIdFromHeader x')
          `shouldBe` HexString (String.newSpanIdFromHeader x')

  context "newHeaderFromTraceId" $ do
    it "is equal to the old implementation" $
      property $ \(x1, x2, x3, x4, x5, x6, x7, x8, x9, (x10, x11, x12, x13, x14, x15, x16)) -> do
        let x' = SB.pack [x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16]
        newHeaderFromTraceId x'
          `shouldBe` String.newHeaderFromTraceId x'

  context "newHeaderFromSpanId" $ do
    it "is equal to the old implementation" $
      property $ \(x1, x2, x3, x4, x5, x6, x7, x8) -> do
        let x' = SB.pack [x1, x2, x3, x4, x5, x6, x7, x8]
        newHeaderFromSpanId x'
          `shouldBe` String.newHeaderFromSpanId x'

  context "composition of newTraceIdFromHeader and newHeaderFromTraceId" $ do
    it "is identical" $
      property $ \(x1, x2, x3, x4, x5, x6, x7, x8) -> do
        let x' = SB.pack $ replicate 8 0 ++ [x1, x2, x3, x4, x5, x6, x7, x8]
        HexString (newTraceIdFromHeader $ newHeaderFromTraceId x') `shouldBe` HexString x'

  context "composition of newHeaderFromTraceId and newTraceIdFromHeader" $ do
    it "is identical" $
      property $ \x -> do
        let x' = BC.pack $ show (x :: Word64)
        newHeaderFromTraceId (newTraceIdFromHeader x') `shouldBe` x'

  context "composition of newSpanIdFromHeader and newHeaderFromSpanId" $ do
    it "is identical" $
      property $ \(x1, x2, x3, x4, x5, x6, x7, x8) -> do
        let x' = SB.pack [x1, x2, x3, x4, x5, x6, x7, x8]
        newSpanIdFromHeader (newHeaderFromSpanId x') `shouldBe` x'

  context "composition of newHeaderFromSpanId and newSpanIdFromHeader" $ do
    it "is identical" $
      property $ \x -> do
        let x' = BC.pack $ show (x :: Word64)
        newHeaderFromSpanId (newSpanIdFromHeader x') `shouldBe` x'


newtype HexString = HexString ShortByteString deriving (Eq)


instance Show HexString where
  show (HexString s) = simpleHex $ SB.fromShort s