module Signet.Unstable.Type.VerifierTest where

import qualified Control.Monad.Catch as Exception
import qualified Data.ByteString.Char8 as Ascii
import qualified Signet.Unstable.Exception.InvalidVerifier as InvalidVerifier
import qualified Signet.Unstable.Exception.VerificationException as VerificationException
import qualified Signet.Unstable.Extra.Either as Either
import qualified Signet.Unstable.Type.AsymmetricSignature as AsymmetricSignature
import qualified Signet.Unstable.Type.Message as Message
import qualified Signet.Unstable.Type.PublicKey as PublicKey
import qualified Signet.Unstable.Type.Secret as Secret
import qualified Signet.Unstable.Type.Signature as Signature
import qualified Signet.Unstable.Type.Signatures as Signatures
import qualified Signet.Unstable.Type.SymmetricSignature as SymmetricSignature
import qualified Signet.Unstable.Type.Test as Test
import qualified Signet.Unstable.Type.Verifier as Verifier

spec :: (Exception.MonadThrow io, Monad tree) => Test.Test io tree -> tree ()
spec :: forall (io :: * -> *) (tree :: * -> *).
(MonadThrow io, Monad tree) =>
Test io tree -> tree ()
spec Test io tree
test = Test io tree -> String -> tree () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> tree () -> tree ()
Test.describe Test io tree
test String
"Signet.Unstable.Type.Verifier" (tree () -> tree ()) -> tree () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
  Test io tree -> String -> tree () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> tree () -> tree ()
Test.describe Test io tree
test String
"parse" (tree () -> tree ()) -> tree () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"succeeds with a valid public key" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      let byteString :: ByteString
byteString = String -> ByteString
Ascii.pack String
"whpk_wuzPrKxPfWpJSsXgyg/MEoMGvjs5SjDO4ad6X4ZYqqg="
      let actual :: Either InvalidVerifier Verifier
actual = ByteString -> Either InvalidVerifier Verifier
Verifier.parse ByteString
byteString
      PublicKey
publicKey <- Either InvalidPublicKey PublicKey -> io PublicKey
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidPublicKey PublicKey -> io PublicKey)
-> Either InvalidPublicKey PublicKey -> io PublicKey
forall a b. (a -> b) -> a -> b
$ ByteString -> Either InvalidPublicKey PublicKey
PublicKey.parse ByteString
byteString
      Test io tree
-> Either InvalidVerifier Verifier
-> Either InvalidVerifier Verifier
-> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test Either InvalidVerifier Verifier
actual (Verifier -> Either InvalidVerifier Verifier
forall a b. b -> Either a b
Right (PublicKey -> Verifier
Verifier.Asymmetric PublicKey
publicKey))

    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"succeeds with a valid secret" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      let byteString :: ByteString
byteString = String -> ByteString
Ascii.pack String
"whsec_bXlzZWNyZXRrZXkxMjM0NQ=="
      let actual :: Either InvalidVerifier Verifier
actual = ByteString -> Either InvalidVerifier Verifier
Verifier.parse ByteString
byteString
      Secret
secret <- Either InvalidSecret Secret -> io Secret
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSecret Secret -> io Secret)
-> Either InvalidSecret Secret -> io Secret
forall a b. (a -> b) -> a -> b
$ ByteString -> Either InvalidSecret Secret
Secret.parse ByteString
byteString
      Test io tree
-> Either InvalidVerifier Verifier
-> Either InvalidVerifier Verifier
-> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test Either InvalidVerifier Verifier
actual (Verifier -> Either InvalidVerifier Verifier
forall a b. b -> Either a b
Right (Secret -> Verifier
Verifier.Symmetric Secret
secret))

    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"fails with invalid input" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      let byteString :: ByteString
byteString = String -> ByteString
Ascii.pack String
"invalid"
      let actual :: Either InvalidVerifier Verifier
actual = ByteString -> Either InvalidVerifier Verifier
Verifier.parse ByteString
byteString
      Test io tree
-> Either InvalidVerifier Verifier
-> Either InvalidVerifier Verifier
-> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test Either InvalidVerifier Verifier
actual (InvalidVerifier -> Either InvalidVerifier Verifier
forall a b. a -> Either a b
Left (ByteString -> InvalidVerifier
InvalidVerifier.MkInvalidVerifier ByteString
byteString))

  Test io tree -> String -> tree () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> tree () -> tree ()
Test.describe Test io tree
test String
"render" (tree () -> tree ()) -> tree () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"works with a public key" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      let byteString :: ByteString
byteString = String -> ByteString
Ascii.pack String
"whpk_wuzPrKxPfWpJSsXgyg/MEoMGvjs5SjDO4ad6X4ZYqqg="
      PublicKey
publicKey <- Either InvalidPublicKey PublicKey -> io PublicKey
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidPublicKey PublicKey -> io PublicKey)
-> (ByteString -> Either InvalidPublicKey PublicKey)
-> ByteString
-> io PublicKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidPublicKey PublicKey
PublicKey.parse (ByteString -> io PublicKey) -> ByteString -> io PublicKey
forall a b. (a -> b) -> a -> b
$ ByteString
byteString
      Test io tree -> ByteString -> ByteString -> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test (Verifier -> ByteString
Verifier.render (PublicKey -> Verifier
Verifier.Asymmetric PublicKey
publicKey)) ByteString
byteString

    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"works with a secret" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      let byteString :: ByteString
byteString = String -> ByteString
Ascii.pack String
"whsec_bXlzZWNyZXRrZXkxMjM0NQ=="
      Secret
secret <- Either InvalidSecret Secret -> io Secret
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSecret Secret -> io Secret)
-> (ByteString -> Either InvalidSecret Secret)
-> ByteString
-> io Secret
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidSecret Secret
Secret.parse (ByteString -> io Secret) -> ByteString -> io Secret
forall a b. (a -> b) -> a -> b
$ ByteString
byteString
      Test io tree -> ByteString -> ByteString -> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test (Verifier -> ByteString
Verifier.render (Secret -> Verifier
Verifier.Symmetric Secret
secret)) ByteString
byteString

  Test io tree -> String -> tree () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> tree () -> tree ()
Test.describe Test io tree
test String
"verify" (tree () -> tree ()) -> tree () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"succeeds with a valid asymmetric signature" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      Verifier
verifier <- Either InvalidVerifier Verifier -> io Verifier
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidVerifier Verifier -> io Verifier)
-> (ByteString -> Either InvalidVerifier Verifier)
-> ByteString
-> io Verifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidVerifier Verifier
Verifier.parse (ByteString -> io Verifier) -> ByteString -> io Verifier
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"whpk_wuzPrKxPfWpJSsXgyg/MEoMGvjs5SjDO4ad6X4ZYqqg="
      Message
message <- Either InvalidMessage Message -> io Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> io Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> io Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> io Message) -> ByteString -> io Message
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> io ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> io ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> io ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> io ([UnknownSignature], Signatures))
-> ByteString -> io ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"v1a,CV1O+PvrwXM42OMUX+tmm6bA3cS0tgLp0qo3YKuu0MGmBrsUhA0MHXF11HsEUJtPfTKs80WE7WUKVt9TueLDCQ=="
      let actual :: Either VerificationException Signature
actual = Verifier
-> Message -> Signatures -> Either VerificationException Signature
Verifier.verify Verifier
verifier Message
message Signatures
signatures
      Signature
signature <- Either UnknownSignature Signature -> io Signature
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either UnknownSignature Signature -> io Signature)
-> io (Either UnknownSignature Signature) -> io Signature
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Either InvalidSignature (Either UnknownSignature Signature)
-> io (Either UnknownSignature Signature)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (ByteString
-> Either InvalidSignature (Either UnknownSignature Signature)
Signature.parse (ByteString
 -> Either InvalidSignature (Either UnknownSignature Signature))
-> ByteString
-> Either InvalidSignature (Either UnknownSignature Signature)
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"v1a,CV1O+PvrwXM42OMUX+tmm6bA3cS0tgLp0qo3YKuu0MGmBrsUhA0MHXF11HsEUJtPfTKs80WE7WUKVt9TueLDCQ==")
      Test io tree
-> Either VerificationException Signature
-> Either VerificationException Signature
-> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test Either VerificationException Signature
actual (Signature -> Either VerificationException Signature
forall a b. b -> Either a b
Right Signature
signature)

    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"fails with an invalid asymmetric signature" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      Verifier
verifier <- Either InvalidVerifier Verifier -> io Verifier
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidVerifier Verifier -> io Verifier)
-> (ByteString -> Either InvalidVerifier Verifier)
-> ByteString
-> io Verifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidVerifier Verifier
Verifier.parse (ByteString -> io Verifier) -> ByteString -> io Verifier
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"whpk_wuzPrKxPfWpJSsXgyg/MEoMGvjs5SjDO4ad6X4ZYqqg="
      Message
message <- Either InvalidMessage Message -> io Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> io Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> io Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> io Message) -> ByteString -> io Message
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> io ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> io ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> io ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> io ([UnknownSignature], Signatures))
-> ByteString -> io ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"v1a,00000000000000000000000000000000000000000000000000000000000000000000000000000000000000=="
      let actual :: Either VerificationException Signature
actual = Verifier
-> Message -> Signatures -> Either VerificationException Signature
Verifier.verify Verifier
verifier Message
message Signatures
signatures
      Test io tree
-> Either VerificationException Signature
-> Either VerificationException Signature
-> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test Either VerificationException Signature
actual (VerificationException -> Either VerificationException Signature
forall a b. a -> Either a b
Left (Id -> VerificationException
VerificationException.MkVerificationException (Id -> VerificationException) -> Id -> VerificationException
forall a b. (a -> b) -> a -> b
$ Message -> Id
Message.id_ Message
message))

    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"succeeds with a valid symmetric signature" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      Verifier
verifier <- Either InvalidVerifier Verifier -> io Verifier
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidVerifier Verifier -> io Verifier)
-> (ByteString -> Either InvalidVerifier Verifier)
-> ByteString
-> io Verifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidVerifier Verifier
Verifier.parse (ByteString -> io Verifier) -> ByteString -> io Verifier
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"whsec_bXlzZWNyZXRrZXkxMjM0NQ=="
      Message
message <- Either InvalidMessage Message -> io Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> io Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> io Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> io Message) -> ByteString -> io Message
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> io ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> io ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> io ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> io ([UnknownSignature], Signatures))
-> ByteString -> io ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"v1,IywpE5NXy+JdAScgR7j5Pt59GjmazD7iJuVsQoRZFyw="
      let actual :: Either VerificationException Signature
actual = Verifier
-> Message -> Signatures -> Either VerificationException Signature
Verifier.verify Verifier
verifier Message
message Signatures
signatures
      Signature
signature <- Either UnknownSignature Signature -> io Signature
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either UnknownSignature Signature -> io Signature)
-> io (Either UnknownSignature Signature) -> io Signature
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Either InvalidSignature (Either UnknownSignature Signature)
-> io (Either UnknownSignature Signature)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (ByteString
-> Either InvalidSignature (Either UnknownSignature Signature)
Signature.parse (ByteString
 -> Either InvalidSignature (Either UnknownSignature Signature))
-> ByteString
-> Either InvalidSignature (Either UnknownSignature Signature)
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"v1,IywpE5NXy+JdAScgR7j5Pt59GjmazD7iJuVsQoRZFyw=")
      Test io tree
-> Either VerificationException Signature
-> Either VerificationException Signature
-> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test Either VerificationException Signature
actual (Signature -> Either VerificationException Signature
forall a b. b -> Either a b
Right Signature
signature)

    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"fails with an invalid symmetric signature" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      Verifier
verifier <- Either InvalidVerifier Verifier -> io Verifier
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidVerifier Verifier -> io Verifier)
-> (ByteString -> Either InvalidVerifier Verifier)
-> ByteString
-> io Verifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidVerifier Verifier
Verifier.parse (ByteString -> io Verifier) -> ByteString -> io Verifier
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"whsec_bXlzZWNyZXRrZXkxMjM0NQ=="
      Message
message <- Either InvalidMessage Message -> io Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> io Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> io Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> io Message) -> ByteString -> io Message
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> io ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> io ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> io ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> io ([UnknownSignature], Signatures))
-> ByteString -> io ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"v1,0000000000000000000000000000000000000000000="
      let actual :: Either VerificationException Signature
actual = Verifier
-> Message -> Signatures -> Either VerificationException Signature
Verifier.verify Verifier
verifier Message
message Signatures
signatures
      Test io tree
-> Either VerificationException Signature
-> Either VerificationException Signature
-> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test Either VerificationException Signature
actual (VerificationException -> Either VerificationException Signature
forall a b. a -> Either a b
Left (Id -> VerificationException
VerificationException.MkVerificationException (Id -> VerificationException) -> Id -> VerificationException
forall a b. (a -> b) -> a -> b
$ Message -> Id
Message.id_ Message
message))

  Test io tree -> String -> tree () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> tree () -> tree ()
Test.describe Test io tree
test String
"asymmetric" (tree () -> tree ()) -> tree () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"succeeds with a valid signature" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      PublicKey
publicKey <- Either InvalidPublicKey PublicKey -> io PublicKey
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidPublicKey PublicKey -> io PublicKey)
-> (ByteString -> Either InvalidPublicKey PublicKey)
-> ByteString
-> io PublicKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidPublicKey PublicKey
PublicKey.parse (ByteString -> io PublicKey) -> ByteString -> io PublicKey
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"whpk_wuzPrKxPfWpJSsXgyg/MEoMGvjs5SjDO4ad6X4ZYqqg="
      Message
message <- Either InvalidMessage Message -> io Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> io Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> io Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> io Message) -> ByteString -> io Message
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> io ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> io ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> io ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> io ([UnknownSignature], Signatures))
-> ByteString -> io ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"v1a,CV1O+PvrwXM42OMUX+tmm6bA3cS0tgLp0qo3YKuu0MGmBrsUhA0MHXF11HsEUJtPfTKs80WE7WUKVt9TueLDCQ=="
      let actual :: Either VerificationException AsymmetricSignature
actual = PublicKey
-> Message
-> Signatures
-> Either VerificationException AsymmetricSignature
Verifier.asymmetric PublicKey
publicKey Message
message Signatures
signatures
      AsymmetricSignature
asymmetricSignature <- Either InvalidAsymmetricSignature AsymmetricSignature
-> io AsymmetricSignature
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidAsymmetricSignature AsymmetricSignature
 -> io AsymmetricSignature)
-> (ByteString
    -> Either InvalidAsymmetricSignature AsymmetricSignature)
-> ByteString
-> io AsymmetricSignature
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidAsymmetricSignature AsymmetricSignature
AsymmetricSignature.parse (ByteString -> io AsymmetricSignature)
-> ByteString -> io AsymmetricSignature
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"CV1O+PvrwXM42OMUX+tmm6bA3cS0tgLp0qo3YKuu0MGmBrsUhA0MHXF11HsEUJtPfTKs80WE7WUKVt9TueLDCQ=="
      Test io tree
-> Either VerificationException AsymmetricSignature
-> Either VerificationException AsymmetricSignature
-> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test Either VerificationException AsymmetricSignature
actual (AsymmetricSignature
-> Either VerificationException AsymmetricSignature
forall a b. b -> Either a b
Right AsymmetricSignature
asymmetricSignature)

    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"fails with an invalid signature" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      PublicKey
publicKey <- Either InvalidPublicKey PublicKey -> io PublicKey
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidPublicKey PublicKey -> io PublicKey)
-> (ByteString -> Either InvalidPublicKey PublicKey)
-> ByteString
-> io PublicKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidPublicKey PublicKey
PublicKey.parse (ByteString -> io PublicKey) -> ByteString -> io PublicKey
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"whpk_wuzPrKxPfWpJSsXgyg/MEoMGvjs5SjDO4ad6X4ZYqqg="
      Message
message <- Either InvalidMessage Message -> io Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> io Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> io Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> io Message) -> ByteString -> io Message
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> io ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> io ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> io ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> io ([UnknownSignature], Signatures))
-> ByteString -> io ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"v1a,00000000000000000000000000000000000000000000000000000000000000000000000000000000000000=="
      let actual :: Either VerificationException AsymmetricSignature
actual = PublicKey
-> Message
-> Signatures
-> Either VerificationException AsymmetricSignature
Verifier.asymmetric PublicKey
publicKey Message
message Signatures
signatures
      Test io tree
-> Either VerificationException AsymmetricSignature
-> Either VerificationException AsymmetricSignature
-> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test Either VerificationException AsymmetricSignature
actual (VerificationException
-> Either VerificationException AsymmetricSignature
forall a b. a -> Either a b
Left (Id -> VerificationException
VerificationException.MkVerificationException (Id -> VerificationException) -> Id -> VerificationException
forall a b. (a -> b) -> a -> b
$ Message -> Id
Message.id_ Message
message))

  Test io tree -> String -> tree () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> tree () -> tree ()
Test.describe Test io tree
test String
"symmetric" (tree () -> tree ()) -> tree () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"succeeds with a valid signature" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      Secret
secret <- Either InvalidSecret Secret -> io Secret
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSecret Secret -> io Secret)
-> (ByteString -> Either InvalidSecret Secret)
-> ByteString
-> io Secret
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidSecret Secret
Secret.parse (ByteString -> io Secret) -> ByteString -> io Secret
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"whsec_bXlzZWNyZXRrZXkxMjM0NQ=="
      Message
message <- Either InvalidMessage Message -> io Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> io Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> io Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> io Message) -> ByteString -> io Message
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> io ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> io ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> io ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> io ([UnknownSignature], Signatures))
-> ByteString -> io ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"v1,IywpE5NXy+JdAScgR7j5Pt59GjmazD7iJuVsQoRZFyw="
      let actual :: Either VerificationException SymmetricSignature
actual = Secret
-> Message
-> Signatures
-> Either VerificationException SymmetricSignature
Verifier.symmetric Secret
secret Message
message Signatures
signatures
      SymmetricSignature
symmetricSignature <- Either InvalidSymmetricSignature SymmetricSignature
-> io SymmetricSignature
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSymmetricSignature SymmetricSignature
 -> io SymmetricSignature)
-> (ByteString
    -> Either InvalidSymmetricSignature SymmetricSignature)
-> ByteString
-> io SymmetricSignature
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidSymmetricSignature SymmetricSignature
SymmetricSignature.parse (ByteString -> io SymmetricSignature)
-> ByteString -> io SymmetricSignature
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"IywpE5NXy+JdAScgR7j5Pt59GjmazD7iJuVsQoRZFyw="
      Test io tree
-> Either VerificationException SymmetricSignature
-> Either VerificationException SymmetricSignature
-> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test Either VerificationException SymmetricSignature
actual (SymmetricSignature
-> Either VerificationException SymmetricSignature
forall a b. b -> Either a b
Right SymmetricSignature
symmetricSignature)

    Test io tree -> String -> io () -> tree ()
forall (io :: * -> *) (tree :: * -> *).
Test io tree -> String -> io () -> tree ()
Test.it Test io tree
test String
"fails with an invalid signature" (io () -> tree ()) -> io () -> tree ()
forall a b. (a -> b) -> a -> b
$ do
      Secret
secret <- Either InvalidSecret Secret -> io Secret
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSecret Secret -> io Secret)
-> (ByteString -> Either InvalidSecret Secret)
-> ByteString
-> io Secret
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidSecret Secret
Secret.parse (ByteString -> io Secret) -> ByteString -> io Secret
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"whsec_bXlzZWNyZXRrZXkxMjM0NQ=="
      Message
message <- Either InvalidMessage Message -> io Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> io Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> io Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> io Message) -> ByteString -> io Message
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> io ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> io ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> io ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> io ([UnknownSignature], Signatures))
-> ByteString -> io ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ String -> ByteString
Ascii.pack String
"v1,0000000000000000000000000000000000000000000="
      let actual :: Either VerificationException SymmetricSignature
actual = Secret
-> Message
-> Signatures
-> Either VerificationException SymmetricSignature
Verifier.symmetric Secret
secret Message
message Signatures
signatures
      Test io tree
-> Either VerificationException SymmetricSignature
-> Either VerificationException SymmetricSignature
-> io ()
forall (io :: * -> *) a (tree :: * -> *).
(HasCallStack, Applicative io, Eq a, Show a) =>
Test io tree -> a -> a -> io ()
Test.assertEq Test io tree
test Either VerificationException SymmetricSignature
actual (VerificationException
-> Either VerificationException SymmetricSignature
forall a b. a -> Either a b
Left (Id -> VerificationException
VerificationException.MkVerificationException (Id -> VerificationException) -> Id -> VerificationException
forall a b. (a -> b) -> a -> b
$ Message -> Id
Message.id_ Message
message))