[DEVOPS-834] Get test suite running

Author: Ben Ford

faucet/cardano-sl-faucet.cabal

@@ -35,6 +35,7 @@ library
                      , ekg-statsd
                      , exceptions
                      , filepath
+                     , generic-arbitrary
                      , http-api-data
                      , http-client
                      , http-client-tls
@@ -106,15 +107,22 @@ executable faucet
                 , warp
   default-language: Haskell2010
 
-test-suite cardano-sl-faucet-test
+test-suite faucet-test
   type: exitcode-stdio-1.0
   main-is: Spec.hs
   hs-source-dirs:
       test
   ghc-options: -threaded -rtsopts -with-rtsopts=-N
   build-depends:
-                    base
-                , cardano-sl-faucet
-                , cardano-sl-wallet
-                , QuickCheck
+                       base
+                     , aeson
+                     , bytestring
+                     , cardano-sl-faucet
+                     , cardano-sl-core
+                     , cardano-sl-wallet
+                     , cardano-sl-wallet-new
+                     , hspec
+                     , QuickCheck
+                     , mtl
+                     , time
   default-language: Haskell2010

faucet/src/Cardano/Faucet/Types/API.hs

@@ -31,6 +31,7 @@ import           Data.Swagger
 import           Data.Text (Text)
 import           Data.Typeable (Typeable)
 import           GHC.Generics (Generic)
+import           Test.QuickCheck.Arbitrary.Generic
 import           Web.FormUrlEncoded
 
 import           Cardano.Wallet.API.V1.Types (Transaction, V1 (..))
@@ -39,21 +40,25 @@ import           Pos.Core (Address (..), Coin (..))
 
 --------------------------------------------------------------------------------
 -- | The "g-recaptcha-response" field
-newtype GCaptchaResponse = GCaptchaResponse Text deriving (Show)
+newtype GCaptchaResponse = GCaptchaResponse Text deriving (Eq, Show, Generic)
 
 makeWrapped ''GCaptchaResponse
 
 instance IsString GCaptchaResponse where
     fromString = GCaptchaResponse . fromString
 
+instance Arbitrary GCaptchaResponse where
+    arbitrary = genericArbitrary
+    shrink = genericShrink
+
 --------------------------------------------------------------------------------
 -- | A request to withdraw ADA from the faucet wallet
 data WithdrawalRequest = WithdrawalRequest {
     -- | The address to send the ADA to
     _wAddress           :: !(V1 Address)
     -- | The "g-recaptcha-response" field sent by the form
   , _gRecaptchaResponse :: !GCaptchaResponse
-  } deriving (Show, Typeable, Generic)
+  } deriving (Eq, Show, Typeable, Generic)
 
 makeLenses ''WithdrawalRequest
 
@@ -83,6 +88,10 @@ instance ToJSON WithdrawalRequest where
                , "g-recaptcha-response" .= (g ^. _Wrapped)]
 
 
+instance Arbitrary WithdrawalRequest where
+    arbitrary = genericArbitrary
+    shrink = genericShrink
+
 --------------------------------------------------------------------------------
 data WithdrawalQFull = WithdrawalQFull deriving (Show, Generic, Exception)
 

faucet/src/Cardano/Faucet/Types/Config.hs

@@ -1,5 +1,6 @@
 {-# LANGUAGE ConstraintKinds            #-}
 {-# LANGUAGE DataKinds                  #-}
+{-# LANGUAGE DeriveAnyClass              #-}
 {-# LANGUAGE DeriveGeneric              #-}
 {-# LANGUAGE DuplicateRecordFields      #-}
 {-# LANGUAGE FlexibleInstances          #-}
@@ -45,8 +46,10 @@ import           System.Remote.Monitoring.Statsd (StatsdOptions (..))
 import           Cardano.Wallet.API.V1.Types (AccountIndex, Payment,
                      PaymentSource (..), V1, WalletId (..))
 import           Cardano.Wallet.Client (ClientError (..), WalletClient (..))
-import           Pos.Core (Address (..), Coin (..))
+import           Pos.Core (Address (..))
 import           Pos.Util.Mnemonic (Mnemonic)
+import Test.QuickCheck (Arbitrary(..), choose)
+import           Test.QuickCheck.Arbitrary.Generic
 
 import           Cardano.Faucet.Types.API
 import           Cardano.Faucet.Types.Recaptcha
@@ -104,16 +107,23 @@ cfgToPaymentSource (SourceWalletConfig wId aIdx _) = PaymentSource wId aIdx
 --   'paymentMean' + randomFloat(-1, 1) * 'paymentScale'
 -- @
 data PaymentDistribution = PaymentDistribution {
-    _mean  :: Coin
-  , _scale :: Coin
-  }
+    _mean  :: Int
+  , _scale :: Int
+  } deriving (Show)
 
 makeLenses ''PaymentDistribution
 
 instance FromJSON PaymentDistribution where
     parseJSON = withObject "PaymentDistibution" $ \v -> PaymentDistribution
-      <$> (Coin <$> v .: "mean")
-      <*> (Coin <$> v .: "scale")
+      <$> (v .: "mean")
+      <*> (v .: "scale")
+
+instance Arbitrary PaymentDistribution where
+    arbitrary = do
+        m <- choose (1000, 10000)
+        s <- choose (0, m)
+        return $ PaymentDistribution m s
+
 
 --------------------------------------------------------------------------------
 -- | Config for the wallet used by the faucet as a source of ADA
@@ -194,7 +204,7 @@ data CreatedWallet = CreatedWallet {
   , _createdAcctIdx  :: AccountIndex
     -- | Sending address within the account in the created wallet
   , _createdAddress  :: Address
-  } deriving (Show, Generic)
+  } deriving (Eq, Show, Generic)
 
 instance ToJSON CreatedWallet where
     toJSON (CreatedWallet wId phrase acctIdx addr) =
@@ -211,6 +221,10 @@ instance FromJSON CreatedWallet where
       <*> v .: "account-index"
       <*> v .: "address"
 
+instance Arbitrary CreatedWallet where
+    arbitrary = genericArbitrary
+    shrink = genericShrink
+
 --------------------------------------------------------------------------------
 -- | Sum type for possible errors encountered at faucet startup time
 data InitFaucetError =

faucet/src/Cardano/Faucet/Types/Recaptcha.hs

@@ -58,7 +58,7 @@ data CaptchaResponse = CaptchaResponse {
   , _hostname    :: Maybe Text
     -- | Any errors present
   , _errorCodes  :: [Text]
-  } deriving (Show)
+  } deriving (Eq, Show)
 
 makeLenses ''CaptchaResponse
 

faucet/src/Cardano/WalletClient.hs

@@ -6,6 +6,7 @@
 {-# OPTIONS_GHC -Wall #-}
 module Cardano.WalletClient (
     withdraw
+  , randomAmount
   ) where
 
 import           Cardano.Wallet.API.V1.Types (Payment (..), V1 (..))
@@ -22,18 +23,18 @@ import qualified Data.ByteArray as BA
 import           Data.ByteString (ByteString)
 import           Data.List.NonEmpty (NonEmpty (..))
 import           Data.Text.Strict.Lens (utf8)
-import           Pos.Core (Address (..), Coin (..), getCoin)
+import           Pos.Core (Address (..), Coin (..))
 import           Pos.Crypto.Signing (PassPhrase)
 import           System.Random
 import           System.Wlog (logError, logInfo, withSublogger)
 
 import           Cardano.Faucet.Types
 
 -- | Computes the amount of ADA (units in lovelace) to send in 'withdraw'
-randomAmount :: (MonadIO m) => PaymentDistribution -> m (V1 Coin)
-randomAmount (PaymentDistribution (getCoin -> amt) (getCoin -> var))= do
+randomAmount :: (MonadIO m) => PaymentDistribution -> m Int
+randomAmount (PaymentDistribution amt var)= do
     (f :: Float) <- liftIO $ randomRIO ((-1), 1)
-    return $ V1 $ Coin $ round $ ((fromIntegral amt) + ((fromIntegral var) * f))
+    return $ round $ ((fromIntegral amt) + ((fromIntegral var) * f))
 
 -- | Client function for the handler for the @/withdraw@ action
 --
@@ -43,7 +44,8 @@ withdraw :: (MonadFaucet c m) => V1 Address -> m (Either WithdrawalQFull Withdra
 withdraw addr = withSublogger "WalletClient.withdraw" $ do
     paymentSource <- view (feSourceWallet . to cfgToPaymentSource)
     spendingPassword <- view (feSourceWallet . srcSpendingPassword)
-    coin <- randomAmount =<< view (feFaucetConfig . fcPaymentDistribution)
+    coin <- V1 . Coin . fromIntegral
+              <$> (randomAmount =<< view (feFaucetConfig . fcPaymentDistribution))
     q <- view feWithdrawalQ
     let paymentDist = (V1.PaymentDistribution addr coin :| [])
         sp =  spendingPassword <&> view (re utf8 . to hashPwd . to V1)

faucet/test/Spec.hs

@@ -1,2 +1,49 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# OPTIONS_GHC -Wall #-}
+module Main where
+
+import           Control.Monad.IO.Class (liftIO)
+import           Data.Aeson
+import qualified Data.ByteString.Lazy as BSL
+import           Data.Time.Clock (UTCTime)
+import           Data.Time.Clock.POSIX (posixSecondsToUTCTime)
+import           Test.Hspec
+import           Test.QuickCheck
+import           Test.QuickCheck.Monadic
+
+import           Cardano.Faucet.Types
+import           Cardano.Faucet.Types.Recaptcha
+import           Cardano.WalletClient
+
 main :: IO ()
-main = putStrLn "Test suite not yet implemented"
+main = hspec $ do
+    describe "randomAmount" $ do
+        it "should be within PaymentDistribution" $ do
+            property $ prop_randomAmount
+
+    describe "Aeson encode and decode" $ do
+        it "CreatedWallet" $ property (prop_aeson_id :: CreatedWallet -> Bool)
+        it "WithdrawalRequest" $ property (prop_aeson_id :: WithdrawalRequest -> Bool)
+        it "CaptchaResponse decode" $ captchaDecode
+
+prop_randomAmount :: PaymentDistribution -> Property
+prop_randomAmount pd = monadicIO $ do
+    c <- run (liftIO $ randomAmount pd)
+    assert (between pd c)
+  where
+    between (PaymentDistribution m s) c = c <= m + s
+                                      && c >= m - s
+
+prop_aeson_id :: (Arbitrary a, ToJSON a, FromJSON a, Eq a) => a -> Bool
+prop_aeson_id a = Just a == (decode $ encode a)
+
+
+t :: UTCTime
+t = posixSecondsToUTCTime 1527811200
+
+getJSON :: FromJSON a => FilePath -> IO (Either String a)
+getJSON f = eitherDecode <$> BSL.readFile f
+
+captchaDecode :: Expectation
+captchaDecode = do
+    getJSON "test/captcha-resp-ok.json" `shouldReturn` Right (CaptchaResponse True (Just t) (Just "test") [])

faucet/test/captcha-resp-err.json

@@ -0,0 +1,4 @@
+{
+  "success": false,
+  "error-codes": ["error"]
+}

faucet/test/captcha-resp-ok.json

@@ -0,0 +1,6 @@
+{
+  "success": true,
+  "challenge_ts": "2018-06-01T00:00:00Z",
+  "hostname": "test",
+  "error-codes": []
+}