Marconi index utxo for aditional slot info Add CLI golden tests for marconi… - input-output-hk/plutus-apps@8a271445 - Cardano Updates

Home / Input Output / plutus-apps / 8a271445

View on GitHub

File Changes

m

marconi-mamba/app/Main.hs

+2/-22

module Main where

-

import Options.Applicative qualified as Opt

-

-

import Control.Applicative (optional)

import Control.Concurrent.Async (race_)

import Marconi.Api.Types (CliArgs (CliArgs))

import Marconi.Bootstrap (bootstrapHttp, bootstrapJsonRpc, bootstrapUtxoIndexers)

-

import Marconi.CLI (multiString, pNetworkId)

-

-

-

args :: Opt.Parser CliArgs

-

args = CliArgs

-

  <$> Opt.strOption (Opt.long "socket-path" <> Opt.metavar "FILE" <> Opt.help "Socket path to node")

-

  <*> Opt.strOption (Opt.long "utxo-db" <> Opt.metavar "FILE" <> Opt.help "Path to the utxo database.")

-

  <*> (optional . Opt.option  Opt.auto) (

-

        Opt.long "http-port" <> Opt.metavar "HTTP-PORT" <> Opt.help "JSON-RPC http port number, default is port 3000.")

-

  <*> pNetworkId

-

  <*> multiString (Opt.long "addresses-to-index"

-

                        <> Opt.help ("Becch32 Shelley addresses to index."

-

                                 <> " i.e \"--address-to-index address-1 --address-to-index address-2 ...\"" ) )

-

-

-

opts :: Opt.ParserInfo CliArgs

-

opts = Opt.info (args Opt.<**> Opt.helper)

-

    ( Opt.fullDesc <> Opt.header "marconi-mamba - Cardano blockchain indexer" )

+

import Marconi.MambaCli (parseCli)

-- | concurrently start:

-- JSON-RPC server

--

main :: IO ()

main = do

-

    [email protected](CliArgs _ _ maybePort _ tAddress)  <- Opt.execParser opts

+

    [email protected](CliArgs _ _ maybePort _ tAddress)  <- parseCli

    rpcEnv <- bootstrapJsonRpc maybePort tAddress

    race_

       (bootstrapHttp rpcEnv)                            -- start http server

m

marconi-mamba/examples/json-rpc-server/src/Main.hs

+1/-1

                          unUtxoIndex)

import Marconi.Bootstrap (bootstrapHttp, bootstrapJsonRpc)

import Marconi.CLI (multiString)

-

import Marconi.Index.Utxos (Depth (Depth), open)

+

import Marconi.Index.Utxo (Depth (Depth), open)

data CliOptions = CliOptions

m

marconi-mamba/marconi-mamba.cabal

+58/-6

    Marconi.Api.Types

    Marconi.Api.UtxoIndexersQuery

    Marconi.Bootstrap

+

    Marconi.MambaCli

  --------------------

  -- Local components

  build-depends:

    , aeson

    , async

-

    , base            >=4.9 && <5

+

    , base                  >=4.9 && <5

    , lens

+

    , optparse-applicative

    , prettyprinter

    , servant

    , servant-server

  --------------------

  -- Local components

  --------------------

-

  build-depends:

-

    , marconi

-

    , marconi-mamba

+

  build-depends:  marconi-mamba

  ------------------------

  -- Non-IOG dependencies

  ------------------------

  build-depends:

    , async

-

    , base                  >=4.9 && <5

-

    , optparse-applicative

+

    , base   >=4.9 && <5

executable examples-json-rpc-server

  import:         lang

  build-depends:

    , base                  >=4.9 && <5

    , optparse-applicative

+

+

test-suite marconi-mamba-test

+

  import:         lang

+

  ghc-options:    -Wno-unused-packages

+

  type:           exitcode-stdio-1.0

+

  main-is:        Spec.hs

+

  hs-source-dirs: test

+

  other-modules:  Spec.Cli

+

+

  --------------------

+

  -- Local components

+

  --------------------

+

  build-depends:

+

    , marconi

+

    , marconi-mamba

+

+

  --------------------------

+

  -- Other IOG dependencies

+

  --------------------------

+

  build-depends:

+

    , cardano-api:{cardano-api, gen}

+

    , cardano-testnet

+

    , iohk-monitoring

+

    , ouroboros-network

+

    , plutus-ledger-api

+

    , plutus-tx

+

    , plutus-tx-plugin

+

+

  ------------------------

+

  -- Non-IOG dependencies

+

  ------------------------

+

  build-depends:

+

    , aeson

+

    , base                  >=4.9 && <5

+

    , bytestring

+

    , containers

+

    , directory

+

    , filepath

+

    , hedgehog

+

    , hedgehog-extras

+

    , lens

+

    , optparse-applicative

+

    , prettyprinter

+

    , serialise

+

    , sqlite-simple

+

    , stm

+

    , streaming

+

    , tasty

+

    , tasty-golden

+

    , tasty-hedgehog

+

    , tasty-hunit

+

    , temporary

+

    , text

m

marconi-mamba/src/Marconi/Api/Types.hs

+1/-1

import Network.Wai.Handler.Warp (Settings)

import Cardano.Api (NetworkId)

-

import Marconi.Index.Utxos (UtxoRow)

+

import Marconi.Index.Utxo (UtxoRow)

import Marconi.Indexers (UtxoQueryTMVar (UtxoQueryTMVar, unUtxoIndex))

import Marconi.Types as Export (TargetAddresses)

m

marconi-mamba/src/Marconi/Api/UtxoIndexersQuery.hs

+8/-8

    , findByAddress

    , findAll

    , reportQueryAddresses

-

    , Utxos.UtxoRow(..)

-

    , Utxos.UtxoIndex

+

    , Utxo.UtxoRow(..)

+

    , Utxo.UtxoIndex

    , reportQueryCardanoAddresses

    , reportBech32Addresses

    , withQueryAction

                          HasDBQueryEnv (queryAddresses, queryTMVar),

                          QueryExceptions (AddressNotInListError, QueryError), TargetAddresses,

                          UtxoTxOutReport (UtxoTxOutReport))

-

import Marconi.Index.Utxos qualified as Utxos

+

import Marconi.Index.Utxo qualified as Utxo

import Marconi.Indexers (UtxoQueryTMVar (UtxoQueryTMVar, unUtxoIndex))

-- | Bootstraps the utxo query environment.

    :: TargetAddresses          -- ^ user provided target addresses

    -> IO DBQueryEnv            -- ^ returns Query runtime environment

bootstrap targetAddresses = do

-

    ix <- atomically (newEmptyTMVar :: STM (TMVar Utxos.UtxoIndex) )

+

    ix <- atomically (newEmptyTMVar :: STM (TMVar Utxo.UtxoIndex) )

    pure $ DBQueryEnv

        {_queryTMVar = UtxoQueryTMVar ix

        , _queryAddresses = targetAddresses

findByCardanoAddress

    :: DBQueryEnv                   -- ^ Query run time environment

    -> C.AddressAny      -- ^ Cardano address to query

-

    -> IO [Utxos.UtxoRow]

+

    -> IO [Utxo.UtxoRow]

findByCardanoAddress env address = withQueryAction env  address

-- | Retrieve a Set of TxOutRefs associated with the given Cardano Era address

withQueryAction

    :: DBQueryEnv                                           -- ^ Query run time environment

    -> C.AddressAny                                      -- ^ Cardano address to query

-

    -> IO [Utxos.UtxoRow]

+

    -> IO [Utxo.UtxoRow]

withQueryAction env address =

let

        utxoIndexer = unUtxoIndex  $ env ^. queryTMVar

-

        action :: Utxos.UtxoIndex -> IO [Utxos.UtxoRow]

-

        action ndxr = (Utxos.queryPlusVolatile ndxr address) >>= pure . (\case { Just x -> x; _ -> [] })

+

        action :: Utxo.UtxoIndex -> IO [Utxo.UtxoRow]

+

        action ndxr = (Utxo.queryPlusVolatile ndxr address) >>= pure . (\case { Just x -> x; _ -> [] })

in

        bracket

          (atomically $ takeTMVar  utxoIndexer)

a

marconi-mamba/src/Marconi/MambaCli.hs

+28/-0

+

module Marconi.MambaCli where

+

+

import Options.Applicative (Parser, ParserInfo, auto, execParser, fullDesc, header, help, helper, info, long, metavar,

+

                            option, optional, strOption, (<**>))

+

+

import Marconi.Api.Types (CliArgs (CliArgs))

+

import Marconi.CLI (multiString, pNetworkId)

+

+

+

-- | parse cli arguments

+

--

+

parserCliArgs :: Parser CliArgs

+

parserCliArgs = CliArgs

+

  <$> strOption (long "socket-path" <> metavar "FILE" <> help "Socket path to node")

+

  <*> strOption (long "utxo-db" <> metavar "FILE" <> help "Path to the utxo database.")

+

  <*> (optional . option  auto) (

+

        long "http-port" <> metavar "HTTP-PORT" <> help "JSON-RPC http port number, default is port 3000.")

+

  <*> pNetworkId

+

  <*> multiString (long "addresses-to-index"

+

                        <> help ("Becch32 Shelley addresses to index."

+

                                 <> " i.e \"--address-to-index address-1 --address-to-index address-2 ...\"" ) )

+

+

parserOpts :: ParserInfo CliArgs

+

parserOpts = info (parserCliArgs <**> helper)

+

    ( fullDesc <> header "marconi-mamba - Cardano blockchain indexer" )

+

+

parseCli :: IO CliArgs

+

parseCli = execParser parserOpts

a

marconi-mamba/test/Spec.hs

+27/-0

+

{-# LANGUAGE NamedFieldPuns    #-}

+

{-# LANGUAGE OverloadedStrings #-}

+

+

module Main (main) where

+

+

+

import Hedgehog (Gen, Property, assert, forAll, property)

+

import Hedgehog.Gen qualified as Gen

+

import Hedgehog.Range qualified as Range

+

import Test.Tasty (TestTree, defaultMain, testGroup)

+

import Test.Tasty.Hedgehog (testPropertyNamed)

+

+

import Cardano.Api qualified as C

+

import Cardano.Api.Shelley qualified as Shelley

+

import Gen.Cardano.Api.Typed qualified as CGen

+

+

import Spec.Cli qualified

+

+

main :: IO ()

+

main = defaultMain tests

+

+

tests :: TestTree

+

tests = testGroup "marconi-mamba"

+

+

  -- , Spec.UtxoIndexersQuery.tests

+

   Spec.Cli.tests

+

a

marconi-mamba/test/Spec/Cli.hs

+59/-0

+

{-# LANGUAGE OverloadedStrings #-}

+

+

module Spec.Cli where

+

+

import Control.Monad (forM_)

+

import Data.ByteString.Lazy qualified as BSL

+

import Data.Text qualified as T

+

import Data.Text.Encoding (encodeUtf8)

+

import Options.Applicative (ParserInfo, ParserResult (CompletionInvoked, Failure, Success), defaultPrefs,

+

                            execParserPure, renderFailure, (<**>))

+

import Options.Applicative qualified as OptA

+

import Test.Tasty (TestTree, testGroup)

+

import Test.Tasty.Golden (goldenVsStringDiff)

+

import Test.Tasty.HUnit (Assertion, assertBool, testCase)

+

+

import Marconi.CLI (Options, optionsParser)

+

+

tests :: TestTree

+

tests = testGroup "marconi-cli all tests" [

+

    genTest commands | commands <- [

+

[]

+

            , ["--help"]

+

            , ["--socket"]]]

+

+

+

opts :: OptA.ParserInfo Options

+

opts = OptA.info (optionsParser <**> OptA.helper) OptA.idm

+

+

run :: ParserInfo a -> [String] -> ParserResult a

+

run = execParserPure defaultPrefs

+

+

-- | Test generate golden tests from the list of commands

+

genTest :: [T.Text] -> TestTree

+

genTest commands = do

+

  let goldenFile = T.unpack $

+

        "test/Spec/Golden/Cli/"

+

          <> T.intercalate "_" ("marconi" : (  T.replace "-" "_"  <$> commands))

+

          <> ".help"

+

+

  goldenVsStringDiff

+

    ( T.unpack $ T.unwords commands)

+

    (\expected actual -> ["diff", "--color=always", expected, actual])

+

    (goldenFile)

+

    (generateHelpScreen commands)

+

+

-- | Test generate  cli tests and parse the help screen.

+

-- All generated tests are bad cli invocations that will result in

+

--   - printng the cli produced error

+

--   - help screen

+

generateHelpScreen :: [T.Text] -> IO BSL.ByteString

+

generateHelpScreen commands = do

+

let

+

      commandLine = commands

+

      text = case execParserPure defaultPrefs opts  (T.unpack <$>commandLine) of

+

        Failure failure     -> failure

+

        Success _           -> error "Parser expected to fail"

+

        CompletionInvoked _ -> error "Parser expected to fail"

+

  -- pure $ BSL.fromStrict $ encodeUtf8 <$> fst $ renderFailure text "marconi"

+

  pure $ BSL.fromStrict ( encodeUtf8 . T.pack  <$> fst $ renderFailure text "marconi")

a

marconi-mamba/test/Spec/Golden/Cli/marconi.help

+9/-0

+

Missing:

+

(-s|--socket-path ARG) (--mainnet | --testnet-magic NATURAL)

+

  (-d|--database-directory-path ARG)

+

+

Usage: marconi (-s|--socket-path ARG) (--mainnet | --testnet-magic NATURAL)

+

               [(-n|--slot-no SLOT-NO) (-b|--block-hash BLOCK-HASH)]

+

               (-d|--database-directory-path ARG) [--disable-utxo]

+

               [--disable-datum] [--disable-script-tx]

+

               [(-a|--addresses-to-index ARG)]

\ No newline at end of file

a

marconi-mamba/test/Spec/Golden/Cli/marconi___help.help

+20/-0

+

Usage: marconi (-s|--socket-path ARG) (--mainnet | --testnet-magic NATURAL)

+

               [(-n|--slot-no SLOT-NO) (-b|--block-hash BLOCK-HASH)]

+

               (-d|--database-directory-path ARG) [--disable-utxo]

+

               [--disable-datum] [--disable-script-tx]

+

               [(-a|--addresses-to-index ARG)]

+

+

Available options:

+

  -s,--socket-path ARG     Path to node socket.

+

  --mainnet                Use the mainnet magic id.

+

  --testnet-magic NATURAL  Specify a testnet magic id.

+

  -d,--database-directory-path ARG

+

                           Dirctory Path for SQLite database.

+

  --disable-utxo           disable utxo indexers.

+

  --disable-datum          disable datum indexers.

+

  --disable-script-tx      disable script-tx indexers.

+

  -a,--addresses-to-index ARG

+

                           Becch32 Shelley addresses to index. i.e

+

                           "--address-to-index address-1 --address-to-index

+

                           address-2 ..."

+

  -h,--help                Show this help text

\ No newline at end of file

a

marconi-mamba/test/Spec/Golden/Cli/marconi___socket.help

+7/-0

+

Invalid option `--socket'

+

+

Usage: marconi (-s|--socket-path ARG) (--mainnet | --testnet-magic NATURAL)

+

               [(-n|--slot-no SLOT-NO) (-b|--block-hash BLOCK-HASH)]

+

               (-d|--database-directory-path ARG) [--disable-utxo]

+

               [--disable-datum] [--disable-script-tx]

+

               [(-a|--addresses-to-index ARG)]

\ No newline at end of file

m

marconi/marconi.cabal

+7/-3

    Marconi.CLI

    Marconi.Index.Datum

    Marconi.Index.ScriptTx

-

    Marconi.Index.Utxos

+

    Marconi.Index.Utxo

    Marconi.Indexers

    Marconi.Logging

    Marconi.Orphans

  main-is:        Spec.hs

  hs-source-dirs: test

  other-modules:

-

    Index.Spec

    Integration

+

    Spec.Cli

+

    Spec.Utxo

  --------------------

  -- Local components

  ------------------------

  build-depends:

    , aeson

-

    , base             >=4.9 && <5

+

    , base                  >=4.9 && <5

    , bytestring

    , containers

    , directory

    , filepath

    , hedgehog

    , hedgehog-extras

    , lens

+

    , optparse-applicative

    , prettyprinter

    , serialise

    , sqlite-simple

    , stm

    , streaming

    , tasty

+

    , tasty-golden

    , tasty-hedgehog

    , tasty-hunit

    , temporary

+

    , text

m

marconi/src/Marconi/CLI.hs

+1/-0

    , parseCardanoAddresses

    , pNetworkId

    , Options (..)

+

    , optionsParser

    , parseOptions

    , utxoDbPath

    , datumDbPath

r

marconi/src/Marconi/Index/Utxo.hs

+1/-1

| Slot

| BlockNumber

| transactionIndexWithinTheBlock (-}

-

module Marconi.Index.Utxos

+

module Marconi.Index.Utxo

    ( eventAtAddress

    , Utxo (..)

    , utxoAddress

m

marconi/src/Marconi/Indexers.hs

+16/-16

import Marconi.Index.Datum (DatumIndex)

import Marconi.Index.Datum qualified as Datum

import Marconi.Index.ScriptTx qualified as ScriptTx

-

import Marconi.Index.Utxos qualified as Utxos

+

import Marconi.Index.Utxo qualified as Utxo

import Marconi.Types (TargetAddresses, TxOut, pattern CurrentEra)

import RewindableIndex.Index.VSplit qualified as Ix

  :: C.IsCardanoEra era

  => Maybe TargetAddresses

  -> C.Tx era

-

  -> [Utxos.Utxo]

+

  -> [Utxo.Utxo]

uTxo maybeTargetAddresses (C.Tx [email protected](C.TxBody C.TxBodyContent{C.txOuts}) _) =

    either (const []) addressDiscriminator (uTxo' txOuts)

    where

-

        addressDiscriminator :: [Utxos.Utxo] -> [Utxos.Utxo]

+

        addressDiscriminator :: [Utxo.Utxo] -> [Utxo.Utxo]

        addressDiscriminator = case maybeTargetAddresses of

            Just targetAddresses -> filter ( isAddressInTarget targetAddresses)

            _                    -> id

-

        uTxo' :: C.IsCardanoEra era => [C.TxOut C.CtxTx  era] -> Either C.EraCastError [Utxos.Utxo]

+

        uTxo' :: C.IsCardanoEra era => [C.TxOut C.CtxTx  era] -> Either C.EraCastError [Utxo.Utxo]

        uTxo' = fmap (imap txoutToUtxo) . traverse (C.eraCast CurrentEra)

-

        txoutToUtxo :: Int -> TxOut -> Utxos.Utxo

+

        txoutToUtxo :: Int -> TxOut -> Utxo.Utxo

        txoutToUtxo  ix out =

let

                _utxoTxIx = C.TxIx $ fromIntegral ix

                _utxoTxId = C.getTxId txBody

                (C.TxOut address' value' datum' _ ) = out

-

                _utxoAddress = Utxos.toAddr address'

+

                _utxoAddress = Utxo.toAddr address'

                _utxoValue = C.txOutValueToValue value'

                _utxoDatumHash = case datum' of

                    (C.TxOutDatumHash _ d ) -> Just d

                    (C.TxOutDatumInline _ d ) -> Just d

                    _                         ->  Nothing

in

-

                Utxos.Utxo {..}

+

                Utxo.Utxo {..}

uTxoEvents

  :: C.IsCardanoEra era

  => Maybe TargetAddresses

  -> C.SlotNo

  -> C.BlockNo

  -> [C.Tx era]

-

  -> Maybe Utxos.UtxoEvent

+

  -> Maybe Utxo.UtxoEvent

uTxoEvents maybeTargetAddresses slotNo blkNo txs =

let

        utxos = (concat . fmap (uTxo maybeTargetAddresses) $ txs )

        if null utxos then

            Nothing

        else

-

            Just (Utxos.UtxoEvent utxos ins slotNo blkNo)

+

            Just (Utxo.UtxoEvent utxos ins slotNo blkNo)

getInputs

  :: C.Tx era

-- | does the transaction contain a targetAddress

isAddressInTarget

    :: TargetAddresses

-

    -> Utxos.Utxo

+

    -> Utxo.Utxo

    -> Bool

isAddressInTarget targetAddresses utxo =

-

    case (utxo ^. Utxos.utxoAddress) of

+

    case (utxo ^. Utxo.utxoAddress) of

        C.AddressByron _      -> False

        C.AddressShelley addr -> addr `elem` targetAddresses

utxoWorker

-

    :: (Utxos.UtxoIndex -> IO Utxos.UtxoIndex)  -- ^ Callback used for the query therad

+

    :: (Utxo.UtxoIndex -> IO Utxo.UtxoIndex)  -- ^ Callback used for the query therad

    -> Maybe TargetAddresses                    -- ^ Target addresses to filter for

    -> Worker

utxoWorker indexerCallback maybeTargetAddresses Coordinator{_barrier} ch path =

-

    Utxos.open path (Utxos.Depth 2160) >>= indexerCallback >>= innerLoop

+

    Utxo.open path (Utxo.Depth 2160) >>= indexerCallback >>= innerLoop

  where

-

    innerLoop :: Utxos.UtxoIndex -> IO ()

+

    innerLoop :: Utxo.UtxoIndex -> IO ()

    innerLoop index = do

      signalQSemN _barrier 1

      event <- atomically $ readTChan ch

          innerLoop $

            fromMaybe index $ do

              slot   <- chainPointToSlotNo cp

-

              offset <- findIndex  (\u -> (u ^. Utxos.utxoEventSlotNo) < slot) events

+

              offset <- findIndex  (\u -> (u ^. Utxo.utxoEventSlotNo) < slot) events

              Ix.rewind offset index

scriptTxWorker_

txScriptValidityToScriptValidity (C.TxScriptValidity _ scriptValidity) = scriptValidity

newtype UtxoQueryTMVar = UtxoQueryTMVar

-

    { unUtxoIndex  :: TMVar Utxos.UtxoIndex      -- ^ for query thread to access in-memory utxos

+

    { unUtxoIndex  :: TMVar Utxo.UtxoIndex      -- ^ for query thread to access in-memory utxos

m

marconi/test/Spec.hs

+4/-2

import Cardano.Api.Shelley qualified as Shelley

import Gen.Cardano.Api.Typed qualified as CGen

-

import Index.Spec qualified

import Integration qualified

import Marconi.Index.ScriptTx qualified as ScriptTx

+

import Spec.Cli qualified

+

import Spec.Utxo qualified

main :: IO ()

main = defaultMain tests

tests :: TestTree

tests = testGroup "Marconi"

  [ testPropertyNamed "prop_script_hashes_in_tx_match" "getTxBodyScriptsRoundtrip" getTxBodyScriptsRoundtrip

-

  , Index.Spec.tests

+

  , Spec.Utxo.tests

  , Integration.tests

+

  , Spec.Cli.tests

-- | Create @[email protected] scripts, add them to a transaction body, then

a

marconi/test/Spec/Cli.hs

+109/-0

+

{-# LANGUAGE OverloadedStrings #-}

+

+

module Spec.Cli where

+

+

import Control.Monad (forM_)

+

import Data.ByteString.Lazy qualified as BSL

+

import Data.Text qualified as T

+

import Data.Text.Encoding (encodeUtf8)

+

import Options.Applicative (ParserInfo, ParserResult (CompletionInvoked, Failure, Success), defaultPrefs,

+

                            execParserPure, renderFailure, (<**>))

+

import Options.Applicative qualified as OptA

+

import Test.Tasty (TestTree, testGroup)

+

import Test.Tasty.Golden (goldenVsStringDiff)

+

import Test.Tasty.HUnit (Assertion, assertBool, testCase)

+

+

import Marconi.CLI (Options, optionsParser)

+

+

tests :: TestTree

+

tests = testGroup "marconi-cli all tests" [

+

    testGroup "marconi-cli invalid commands"

+

        [testCase "marconi-cli invalid command" testInValidClis

+

        , testCase "marconi-cli valid command" testValidClis

+

+

    , testGroup "marconi-cli generated golden tests"

+

        [genTest commands | commands <- [

+

[]

+

                                         , ["--help"]

+

                                         , ["--socket"]]]

+

+

+

-- | input files for this testGroup. The test group executes the tests in `batch`

+

validBatchFile, inValidBatchFile :: FilePath

+

validBatchFile      = "test/Spec/validClis.txt"

+

inValidBatchFile    = "test/Spec/invalidClis.txt"

+

+

-- | Parse the Cli commands from file

+

--

+

clisFromFile :: FilePath -> IO [(String, OptA.ParserResult Options)]

+

clisFromFile cliFile =

+

  mapM asOpt . lines =<< readFile cliFile

+

  where

+

    asOpt' =

+

      run opts

+

        . words

+

    asOpt line = pure (line, asOpt' line)

+

+

+

opts :: OptA.ParserInfo Options

+

opts = OptA.info (optionsParser <**> OptA.helper) OptA.idm

+

+

run :: ParserInfo a -> [String] -> ParserResult a

+

run = execParserPure defaultPrefs

+

+

-- | Test inValid CLIs from input file.

+

testInValidClis :: Assertion

+

testInValidClis = do

+

    ps <- clisFromFile inValidBatchFile

+

    forM_ ps $ \(aLine, input) ->

+

        case input of

+

            Success a ->

+

                assertBool

+

                ("Result `" <> show a <>  "` should've been invalid. CLI parser for: " <> show aLine <> " should fail!")

+

                False

+

            Failure pf ->

+

                assertBool

+

                ("CLI parser for: `" <> show aLine <> "` failed with: " <> show pf )

+

                True

+

            _ -> assertBool ("some other failure for the `invalid` cliInput of: `" <> aLine <> "`") False

+

+

-- | Test inValid CLIs from input file.

+

testValidClis :: Assertion

+

testValidClis = do

+

    ps <- clisFromFile validBatchFile

+

    print ps

+

    forM_ ps $ \(aLine, input) ->

+

        case input of

+

            Success a -> assertBool ("Result `" <> show a <>  "` should've been invalid. CLI parser for: " <> show aLine <> " should fail!") True

+

            Failure pf -> assertBool ("failure for the `valid` cliInput of: "

+

                                      <> show aLine <> " " <> show pf ) False

+

            _ ->  assertBool ("some other failure for the `invalid` cliInput of: `" <> aLine <> "`") False

+

+

-- | Test generate golden tests from the list of commands

+

genTest :: [T.Text] -> TestTree

+

genTest commands = do

+

  let goldenFile = T.unpack $

+

        "test/Spec/Golden/Cli/"

+

          <> T.intercalate "_" ("marconi" : (  T.replace "-" "_"  <$> commands))

+

          <> ".help"

+

+

  goldenVsStringDiff

+

    ( T.unpack $ T.unwords commands)

+

    (\expected actual -> ["diff", "--color=always", expected, actual])

+

    (goldenFile)

+

    (generateHelpScreen commands)

+

+

-- | Test generate  cli tests and parse the help screen.

+

-- All generated tests are bad cli invocations that will result in

+

--   - printng the cli produced error

+

--   - help screen

+

generateHelpScreen :: [T.Text] -> IO BSL.ByteString

+

generateHelpScreen commands = do

+

let

+

      commandLine = commands

+

      text = case execParserPure defaultPrefs opts  (T.unpack <$>commandLine) of

+

        Failure failure     -> failure

+

        Success _           -> error "Parser expected to fail"

+

        CompletionInvoked _ -> error "Parser expected to fail"

+

  -- pure $ BSL.fromStrict $ encodeUtf8 <$> fst $ renderFailure text "marconi"

+

  pure $ BSL.fromStrict ( encodeUtf8 . T.pack  <$> fst $ renderFailure text "marconi")

a

marconi/test/Spec/Golden/Cli/marconi.help

+9/-0

+

Missing:

+

(-s|--socket-path ARG) (--mainnet | --testnet-magic NATURAL)

+

  (-d|--database-directory-path ARG)

+

+

Usage: marconi (-s|--socket-path ARG) (--mainnet | --testnet-magic NATURAL)

+

               [(-n|--slot-no SLOT-NO) (-b|--block-hash BLOCK-HASH)]

+

               (-d|--database-directory-path ARG) [--disable-utxo]

+

               [--disable-datum] [--disable-script-tx]

+

               [(-a|--addresses-to-index ARG)]

\ No newline at end of file

a

marconi/test/Spec/Golden/Cli/marconi___help.help

+20/-0

+

Usage: marconi (-s|--socket-path ARG) (--mainnet | --testnet-magic NATURAL)

+

               [(-n|--slot-no SLOT-NO) (-b|--block-hash BLOCK-HASH)]

+

               (-d|--database-directory-path ARG) [--disable-utxo]

+

               [--disable-datum] [--disable-script-tx]

+

               [(-a|--addresses-to-index ARG)]

+

+

Available options:

+

  -s,--socket-path ARG     Path to node socket.

+

  --mainnet                Use the mainnet magic id.

+

  --testnet-magic NATURAL  Specify a testnet magic id.

+

  -d,--database-directory-path ARG

+

                           Dirctory Path for SQLite database.

+

  --disable-utxo           disable utxo indexers.

+

  --disable-datum          disable datum indexers.

+

  --disable-script-tx      disable script-tx indexers.

+

  -a,--addresses-to-index ARG

+

                           Becch32 Shelley addresses to index. i.e

+

                           "--address-to-index address-1 --address-to-index

+

                           address-2 ..."

+

  -h,--help                Show this help text

\ No newline at end of file

a

marconi/test/Spec/Golden/Cli/marconi___socket.help

+7/-0

+

Invalid option `--socket'

+

+

Usage: marconi (-s|--socket-path ARG) (--mainnet | --testnet-magic NATURAL)

+

               [(-n|--slot-no SLOT-NO) (-b|--block-hash BLOCK-HASH)]

+

               (-d|--database-directory-path ARG) [--disable-utxo]

+

               [--disable-datum] [--disable-script-tx]

+

               [(-a|--addresses-to-index ARG)]

\ No newline at end of file

r

marconi/test/Spec/Utxo.hs

+23/-23

Diff too large – View on GitHub

Yesterday's Report

Tuesday, February 7, 2023

698 commits in 78 repos

New Repo Discovered

Mon, 06 Feb 23 14:49:07 +0000 · grants-ui

TypeScript · No license

New Releases

Wed, 08 Feb 23 14:50:47 +0000 · Mithril v2306.0-prerelease mithril Wed, 08 Feb 23 11:01:04 +0000 · Unstable Development Builds mithril Wed, 08 Feb 23 10:15:54 +0000 · 0.5.3 blockfrost-python Wed, 08 Feb 23 06:21:21 +0000 · fix rust nightly install catalyst-gh-mdbook-doc Wed, 08 Feb 23 06:21:21 +0000 · fix rust nightly install catalyst-gh-tools Wed, 08 Feb 23 01:54:24 +0000 · Update rust to 1.67, add nightly and cargo depgraph catalyst-gh-mdbook-doc

3,400 commits this week Feb 01, 2023 - Feb 08, 2023

Showing 25 of 3400 recent commits.