PureSpec.hs

-- SPDX-License-Identifier: Apache-2.0
--
-- Copyright (C) 2026 Bin Jin. All Rights Reserved.

module Network.HProx.PureSpec
  ( spec
  ) where

import Data.List.NonEmpty qualified as NE

import Network.HProx.Log
import Network.HProx.Util

import Test.Hspec

spec :: Spec
spec = do
    describe "parseHostPort" $ do
        it "parses a valid host and port" $
            parseHostPort "example.com:443" `shouldBe` Just ("example.com", 443)

        it "uses the last colon as the port separator" $
            parseHostPort "example.com:proxy:8080" `shouldBe` Just ("example.com:proxy", 8080)

        it "accepts an empty host portion" $
            parseHostPort ":123" `shouldBe` Just ("", 123)

        it "rejects missing, invalid, trailing, and out-of-range ports" $
            map parseHostPort ["example.com", "example.com:http", "example.com:80x", "example.com:0", "example.com:65536", "example.com:"]
                `shouldBe` replicate 6 Nothing

    describe "parseHostPortWithDefault" $ do
        it "returns an explicit port when parsing succeeds" $
            parseHostPortWithDefault 80 "example.com:443" `shouldBe` ("example.com", 443)

        it "returns the original input and default port when parsing fails" $
            parseHostPortWithDefault 80 "example.com:not-a-port" `shouldBe` ("example.com:not-a-port", 80)

    describe "passwordReader" $ do
        it "parses plaintext password lines" $
            passwordReader "user:pass" `shouldBe` Just ("user", PlainText "pass")

        it "parses salted password lines by base64-decoding salt and hash" $
            passwordReader "user:c2FsdA==:aGFzaA==" `shouldBe` Just ("user", Salted "salt" "hash")

        it "rejects invalid salted and over-split password lines" $
            map passwordReader ["user:not-base64:also-not-base64", "user:pass:extra:field"]
                `shouldBe` [Nothing, Nothing]

    describe "passwordWriter" $
        it "writes salted password lines with base64 salt and hash" $
            passwordWriter "user" (PasswordSalted "salt" "hash") `shouldBe` "user:c2FsdA==:aGFzaA=="

    describe "hashPasswordWithSalt" $ do
        it "returns a typed failure when Argon2 rejects hashing parameters" $
            case hashPasswordWithSalt "" (PlainText "pass") of
                Left (PasswordHashError msg) -> msg `shouldContain` "unable to hash password with salt"
                Right _                      -> expectationFailure "expected typed hash failure"

        it "keeps already salted passwords without rehashing" $
            hashPasswordWithSalt "" (Salted "salt" "hash") `shouldBe` Right (PasswordSalted "salt" "hash")

    describe "logLevelReader" $ do
        it "parses all current log levels" $
            map logLevelReader ["trace", "debug", "info", "warn", "error", "none"]
                `shouldBe` map Just [TRACE, DEBUG, INFO, WARN, ERROR, NONE]

        it "rejects unknown log levels and different casing" $
            map logLevelReader ["", "warning", "INFO"] `shouldBe` replicate 3 Nothing

    describe "parseLogOutput" $
        it "preserves current log destination parsing policy" $
            map parseLogOutput ["none", "stdout", "stderr", "hprox.log"]
                `shouldBe` [LogOutputNone, LogOutputStdout, LogOutputStderr, LogOutputFile "hprox.log"]

    describe "splitBy" $ do
        it "preserves empty segments between, before, and after separators" $
            NE.toList (splitBy ':' ":a::b:") `shouldBe` ["", "a", "", "b", ""]

        it "returns one empty segment for empty input" $
            NE.toList (splitBy ':' "") `shouldBe` [""]