expose cobra command vars + commands

cmd/check_quorum.go

@@ -16,13 +16,13 @@ var CheckQuorumCmd = &cobra.Command{
 	Long:  ``,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		// Load proposal
-		proposal, err := LoadProposal(proposalType, proposalPath)
+		proposal, err := LoadProposal(ProposalType, ProposalPath)
 		if err != nil {
 			return err
 		}
 
 		// Dial the RPC
-		clientBackend, err := ethclient.Dial(rpc)
+		clientBackend, err := ethclient.Dial(Rpc)
 		if err != nil {
 			return err
 		}
@@ -34,7 +34,7 @@ var CheckQuorumCmd = &cobra.Command{
 		}
 
 		// Check quorum
-		quorumMet, err := e.CheckQuorum(clientBackend, mcms.ChainIdentifier(chainSelector))
+		quorumMet, err := e.CheckQuorum(clientBackend, mcms.ChainIdentifier(ChainSelector))
 		if err != nil {
 			return err
 		}

cmd/check_quorum_test.go

@@ -9,14 +9,14 @@ import (
 
 func Test_CheckQuorumCommand(t *testing.T) {
 	actual := new(bytes.Buffer)
-	rootCmd.SetOut(actual)
-	rootCmd.SetErr(actual)
-	rootCmd.SetArgs([]string{"check-quorum", "--rpc", "http://localhost:8545", "--proposal", "./proposal.json", "--selector", "1"})
-	rootCmd.Execute()
+	RootCmd.SetOut(actual)
+	RootCmd.SetErr(actual)
+	RootCmd.SetArgs([]string{"check-quorum", "--rpc", "http://localhost:8545", "--proposal", "./proposal.json", "--selector", "1"})
+	RootCmd.Execute()
 
-	assert.Equal(t, "http://localhost:8545", rpc)
-	assert.Equal(t, "./proposal.json", proposalPath)
-	assert.Equal(t, uint64(1), chainSelector)
+	assert.Equal(t, "http://localhost:8545", Rpc)
+	assert.Equal(t, "./proposal.json", ProposalPath)
+	assert.Equal(t, uint64(1), ChainSelector)
 
 	expectedDescription := "help for check-quorum"
 	assert.Containsf(t, actual.String(), expectedDescription, "expected description to contain '%s'", expectedDescription)

cmd/execute_chain.go

@@ -26,13 +26,13 @@ var ExecuteChainCmd = &cobra.Command{
 		}
 
 		// Load proposal
-		proposal, err := LoadProposal(proposalType, proposalPath)
+		proposal, err := LoadProposal(ProposalType, ProposalPath)
 		if err != nil {
 			return err
 		}
 
 		// Dial the RPC
-		clientBackend, err := ethclient.Dial(rpc)
+		clientBackend, err := ethclient.Dial(Rpc)
 		if err != nil {
 			return err
 		}
@@ -44,7 +44,7 @@ var ExecuteChainCmd = &cobra.Command{
 		}
 
 		// Get EVM chain ID
-		chain, exists := chain_selectors.ChainBySelector(chainSelector)
+		chain, exists := chain_selectors.ChainBySelector(ChainSelector)
 		if !exists {
 			return errors.New("chain not found")
 		}
@@ -56,7 +56,7 @@ var ExecuteChainCmd = &cobra.Command{
 		}
 
 		for i, op := range e.Proposal.Transactions {
-			if op.ChainIdentifier == mcms.ChainIdentifier(chainSelector) {
+			if op.ChainIdentifier == mcms.ChainIdentifier(ChainSelector) {
 				transaction, err := e.ExecuteOnChain(clientBackend, auth, i)
 				if err != nil {
 					return err

cmd/execute_chain_test.go

@@ -9,14 +9,14 @@ import (
 
 func Test_ExecuteChainCommand(t *testing.T) {
 	actual := new(bytes.Buffer)
-	rootCmd.SetOut(actual)
-	rootCmd.SetErr(actual)
-	rootCmd.SetArgs([]string{"execute-chain", "--rpc", "http://localhost:8545", "--proposal", "./proposal.json", "--selector", "1"})
-	rootCmd.Execute()
+	RootCmd.SetOut(actual)
+	RootCmd.SetErr(actual)
+	RootCmd.SetArgs([]string{"execute-chain", "--rpc", "http://localhost:8545", "--proposal", "./proposal.json", "--selector", "1"})
+	RootCmd.Execute()
 
-	assert.Equal(t, "http://localhost:8545", rpc)
-	assert.Equal(t, "./proposal.json", proposalPath)
-	assert.Equal(t, uint64(1), chainSelector)
+	assert.Equal(t, "http://localhost:8545", Rpc)
+	assert.Equal(t, "./proposal.json", ProposalPath)
+	assert.Equal(t, uint64(1), ChainSelector)
 
 	expectedDescription := "help for execute"
 	assert.Containsf(t, actual.String(), expectedDescription, "expected description to contain '%s'", expectedDescription)

cmd/execute_operation.go

@@ -28,13 +28,13 @@ var ExecuteOperationCmd = &cobra.Command{
 		}
 
 		// Load proposal
-		proposal, err := LoadProposal(proposalType, proposalPath)
+		proposal, err := LoadProposal(ProposalType, ProposalPath)
 		if err != nil {
 			return err
 		}
 
 		// Dial the RPC
-		clientBackend, err := ethclient.Dial(rpc)
+		clientBackend, err := ethclient.Dial(Rpc)
 		if err != nil {
 			return err
 		}
@@ -46,7 +46,7 @@ var ExecuteOperationCmd = &cobra.Command{
 		}
 
 		// Get EVM chain ID
-		chain, exists := chain_selectors.ChainBySelector(chainSelector)
+		chain, exists := chain_selectors.ChainBySelector(ChainSelector)
 		if !exists {
 			return errors.New("chain not found")
 		}
@@ -58,7 +58,7 @@ var ExecuteOperationCmd = &cobra.Command{
 		}
 
 		for i, op := range e.Proposal.Transactions {
-			if op.ChainIdentifier == mcms.ChainIdentifier(chainSelector) {
+			if op.ChainIdentifier == mcms.ChainIdentifier(ChainSelector) {
 				transaction, err := e.ExecuteOnChain(clientBackend, auth, i)
 				if err != nil {
 					return err

cmd/execute_operation_test.go

@@ -9,14 +9,14 @@ import (
 
 func Test_ExecuteCommand(t *testing.T) {
 	actual := new(bytes.Buffer)
-	rootCmd.SetOut(actual)
-	rootCmd.SetErr(actual)
-	rootCmd.SetArgs([]string{"execute-operation", "--rpc", "http://localhost:8545", "--proposal", "./proposal.json", "--selector", "1", "--index", "3"})
-	rootCmd.Execute()
+	RootCmd.SetOut(actual)
+	RootCmd.SetErr(actual)
+	RootCmd.SetArgs([]string{"execute-operation", "--rpc", "http://localhost:8545", "--proposal", "./proposal.json", "--selector", "1", "--index", "3"})
+	RootCmd.Execute()
 
-	assert.Equal(t, "http://localhost:8545", rpc)
-	assert.Equal(t, "./proposal.json", proposalPath)
-	assert.Equal(t, uint64(1), chainSelector)
+	assert.Equal(t, "http://localhost:8545", Rpc)
+	assert.Equal(t, "./proposal.json", ProposalPath)
+	assert.Equal(t, uint64(1), ChainSelector)
 	assert.Equal(t, uint64(3), index)
 
 	expectedDescription := "help for execute"

cmd/root.go

@@ -7,36 +7,38 @@ import (
 	"github.com/spf13/cobra"
 )
 
-var rpc string
-var proposalPath string
-var proposalType proposal.ProposalType
-var chainSelector uint64
+var (
+	Rpc           string
+	ProposalPath  string
+	ProposalType  proposal.ProposalType
+	ChainSelector uint64
+)
 
-// rootCmd represents the base command when called without any subcommands
-var rootCmd = &cobra.Command{
+// RootCmd represents the base command when called without any subcommands
+var RootCmd = &cobra.Command{
 	Use:   "mcms",
 	Short: "Tools for on-chain interactions with the MCMS ",
 	Long:  ``,
 }
 
 func Execute() {
-	err := rootCmd.Execute()
+	err := RootCmd.Execute()
 	if err != nil {
 		os.Exit(1)
 	}
 }
 
 func init() {
-	rootCmd.AddCommand(CheckQuorumCmd)
-	rootCmd.AddCommand(ExecuteOperationCmd)
-	rootCmd.AddCommand(SetMerkleCmd)
-	rootCmd.AddCommand(ExecuteChainCmd)
+	RootCmd.AddCommand(CheckQuorumCmd)
+	RootCmd.AddCommand(ExecuteOperationCmd)
+	RootCmd.AddCommand(SetMerkleCmd)
+	RootCmd.AddCommand(ExecuteChainCmd)
 
-	rootCmd.PersistentFlags().StringVar(&rpc, "rpc", "", "rpc to be used in the proposal")
-	rootCmd.PersistentFlags().StringVar(&proposalPath, "proposal", "p", "Absolute file path containing the proposal to be submitted")
-	rootCmd.PersistentFlags().Uint64Var(&chainSelector, "selector", 0, "Chain selector for the command to connect to")
+	RootCmd.PersistentFlags().StringVar(&Rpc, "rpc", "", "rpc to be used in the proposal")
+	RootCmd.PersistentFlags().StringVar(&ProposalPath, "proposal", "p", "Absolute file path containing the proposal to be submitted")
+	RootCmd.PersistentFlags().Uint64Var(&ChainSelector, "selector", 0, "Chain selector for the command to connect to")
 
 	var proposalTypeStr string
-	rootCmd.PersistentFlags().StringVar(&proposalTypeStr, "proposalType", string(proposal.MCMS), "The type of proposal being ingested")
-	proposalType = proposal.StringToProposalType[proposalTypeStr]
+	RootCmd.PersistentFlags().StringVar(&proposalTypeStr, "proposalType", string(proposal.MCMS), "The type of proposal being ingested")
+	ProposalType = proposal.StringToProposalType[proposalTypeStr]
 }

cmd/root_test.go

@@ -10,10 +10,10 @@ import (
 func Test_cliRootCommand(t *testing.T) {
 
 	actual := new(bytes.Buffer)
-	rootCmd.SetOut(actual)
-	rootCmd.SetErr(actual)
-	rootCmd.SetArgs([]string{})
-	rootCmd.Execute()
+	RootCmd.SetOut(actual)
+	RootCmd.SetErr(actual)
+	RootCmd.SetArgs([]string{})
+	RootCmd.Execute()
 
 	expectedDescription := "Tools for on-chain interactions with the MCMS"
 	assert.Containsf(t, actual.String(), expectedDescription, "expected description to contain '%s'", expectedDescription)

cmd/set_root.go

@@ -27,13 +27,13 @@ var SetMerkleCmd = &cobra.Command{
 		}
 
 		// Load proposal
-		proposal, err := LoadProposal(proposalType, proposalPath)
+		proposal, err := LoadProposal(ProposalType, ProposalPath)
 		if err != nil {
 			return err
 		}
 
 		// Dial the RPC
-		clientBackend, err := ethclient.Dial(rpc)
+		clientBackend, err := ethclient.Dial(Rpc)
 		if err != nil {
 			return err
 		}
@@ -45,7 +45,7 @@ var SetMerkleCmd = &cobra.Command{
 		}
 
 		// Get EVM chain ID
-		chain, exists := chain_selectors.ChainBySelector(chainSelector)
+		chain, exists := chain_selectors.ChainBySelector(ChainSelector)
 		if !exists {
 			return errors.New("chain not found")
 		}
@@ -57,7 +57,7 @@ var SetMerkleCmd = &cobra.Command{
 		}
 
 		// Set the root on chain
-		transaction, err := e.SetRootOnChain(clientBackend, auth, mcms.ChainIdentifier(chainSelector))
+		transaction, err := e.SetRootOnChain(clientBackend, auth, mcms.ChainIdentifier(ChainSelector))
 		if err != nil {
 			return err
 		}

cmd/set_root_test.go

@@ -9,14 +9,14 @@ import (
 
 func Test_SetRootCommand(t *testing.T) {
 	actual := new(bytes.Buffer)
-	rootCmd.SetOut(actual)
-	rootCmd.SetErr(actual)
-	rootCmd.SetArgs([]string{"set-root", "--rpc", "http://localhost:8545", "--proposal", "./proposal.json", "--selector", "1"})
-	rootCmd.Execute()
+	RootCmd.SetOut(actual)
+	RootCmd.SetErr(actual)
+	RootCmd.SetArgs([]string{"set-root", "--rpc", "http://localhost:8545", "--proposal", "./proposal.json", "--selector", "1"})
+	RootCmd.Execute()
 
-	assert.Equal(t, "http://localhost:8545", rpc)
-	assert.Equal(t, "./proposal.json", proposalPath)
-	assert.Equal(t, uint64(1), chainSelector)
+	assert.Equal(t, "http://localhost:8545", Rpc)
+	assert.Equal(t, "./proposal.json", ProposalPath)
+	assert.Equal(t, uint64(1), ChainSelector)
 
 	expectedDescription := "no such file or directory"
 	assert.Containsf(t, actual.String(), expectedDescription, "expected description to contain '%s'", expectedDescription)

cmd/sign_private_key.go

@@ -17,7 +17,7 @@ var SignPrivateKeyCmd = &cobra.Command{
 		}
 
 		// Load proposal
-		proposal, err := LoadProposal(proposalType, proposalPath)
+		proposal, err := LoadProposal(ProposalType, ProposalPath)
 		if err != nil {
 			return err
 		}
@@ -28,7 +28,7 @@ var SignPrivateKeyCmd = &cobra.Command{
 		}
 
 		// Write proposal to file
-		err = WriteProposalToFile(proposal, proposalPath)
+		err = WriteProposalToFile(proposal, ProposalPath)
 		if err != nil {
 			return err
 		}