Skip to content

Commit ebf9785

Browse files
ecPabloecPablo
committed
fix: reuse containers in set config tests
1 parent e07b5ca commit ebf9785

3 files changed

Lines changed: 135 additions & 136 deletions

File tree

‎mcms/changesets/set-config/helpers_test.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,8 +13,8 @@ import (
1313
cldf_chain "github.com/smartcontractkit/chainlink-deployments-framework/chain"
1414
cldf_evm "github.com/smartcontractkit/chainlink-deployments-framework/chain/evm"
1515
cldfsol "github.com/smartcontractkit/chainlink-deployments-framework/chain/solana"
16-
cldfdatastore "github.com/smartcontractkit/chainlink-deployments-framework/datastore"
1716
"github.com/smartcontractkit/chainlink-deployments-framework/datastore"
17+
cldfdatastore "github.com/smartcontractkit/chainlink-deployments-framework/datastore"
1818
cldf "github.com/smartcontractkit/chainlink-deployments-framework/deployment"
1919
mcmscontracts "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/contracts/mcms"
2020
cldfproposalutils "github.com/smartcontractkit/chainlink-deployments-framework/engine/cld/mcms/proposalutils"

‎mcms/solana/set-config/operation_test.go‎

Lines changed: 56 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,6 @@ import (
55
"testing"
66

77
"github.com/ethereum/go-ethereum/common"
8-
solanago "github.com/gagliardetto/solana-go"
98
"github.com/stretchr/testify/require"
109

1110
chainselectors "github.com/smartcontractkit/chain-selectors"
@@ -24,60 +23,65 @@ func TestSolanaSetConfig(t *testing.T) {
2423
}
2524

2625
func testOpSolanaSetConfigMCM(t *testing.T) {
27-
tests := []struct {
28-
name string
29-
noSend bool
30-
}{
31-
{name: "direct send", noSend: false},
32-
{name: "MCMS proposal", noSend: true},
33-
}
26+
selector := chainselectors.TEST_22222222222222222222222222222222222222222222.Selector
27+
rt := newSolanaSetConfigRuntime(t, selector)
28+
chain := rt.Environment().BlockChains.SolanaChains()[selector]
29+
refs := solanaSetConfigRefs(t, rt.Environment(), selector)
30+
fundSolanaSignerPDAs(t, chain, refs)
3431

35-
for _, tt := range tests { //nolint:paralleltest // global mcm.SetProgramID state
36-
t.Run(tt.name, func(t *testing.T) {
37-
selector := chainselectors.TEST_22222222222222222222222222222222222222222222.Selector
38-
rt := newSolanaSetConfigRuntime(t, selector)
39-
chain := rt.Environment().BlockChains.SolanaChains()[selector]
40-
refs := solanaSetConfigRefs(t, rt.Environment(), selector)
41-
fundSolanaSignerPDAs(t, chain, refs)
32+
t.Run("direct send", func(t *testing.T) { //nolint:paralleltest // shared runtime state
33+
cfg := cldftesthelpers.SingleGroupMCMS(t)
34+
cfg.Signers = append(cfg.Signers, common.HexToAddress("0x0000000000000000000000000000000000000909"))
35+
cfg.Quorum = 2
4236

43-
authorityAccount := solanago.PublicKey{}
44-
if tt.noSend {
45-
transferSolanaMCMSToTimelock(t, rt, selector)
46-
fundSolanaSignerPDAs(t, chain, refs)
47-
authorityAccount = refs.TimelockSigner
48-
}
49-
50-
cfg := cldftesthelpers.SingleGroupMCMS(t)
51-
cfg.Signers = append(cfg.Signers, common.HexToAddress("0x0000000000000000000000000000000000000909"))
52-
cfg.Quorum = 2
53-
54-
report, err := operations.ExecuteOperation(
55-
rt.Environment().OperationsBundle,
56-
OpSolanaSetConfigMCM,
57-
chain,
58-
OpSolanaSetConfigInput{
59-
Target: MCMSetConfigTarget{
60-
Address: refs.Canceller,
61-
Config: cfg,
62-
ContractType: string(mcmscontracts.CancellerManyChainMultisig),
63-
},
64-
NoSend: tt.noSend,
65-
AuthorityAccount: authorityAccount,
37+
report, err := operations.ExecuteOperation(
38+
rt.Environment().OperationsBundle,
39+
OpSolanaSetConfigMCM,
40+
chain,
41+
OpSolanaSetConfigInput{
42+
Target: MCMSetConfigTarget{
43+
Address: refs.Canceller,
44+
Config: cfg,
45+
ContractType: string(mcmscontracts.CancellerManyChainMultisig),
6646
},
67-
)
68-
require.NoError(t, err)
69-
require.Equal(t, !tt.noSend, report.Output.Confirmed)
47+
NoSend: false,
48+
},
49+
)
50+
require.NoError(t, err)
51+
require.True(t, report.Output.Confirmed)
52+
assertSolanaConfigEquals(t, mcmssolana.NewInspector(chain.Client), refs.Canceller, cfg)
53+
})
7054

71-
if tt.noSend {
72-
require.Equal(t, mcmstypes.ChainSelector(selector), report.Output.BatchOperation.ChainSelector)
73-
require.NotEmpty(t, report.Output.BatchOperation.Transactions)
74-
require.NoError(t, rt.Exec(
75-
newTimelockProposalTask([]mcmstypes.BatchOperation{report.Output.BatchOperation}, "solana set config operation test"),
76-
runtime.SignAndExecuteProposalsTask([]*ecdsa.PrivateKey{cldftesthelpers.TestXXXMCMSSigner}),
77-
))
78-
}
55+
t.Run("MCMS proposal", func(t *testing.T) { //nolint:paralleltest // shared runtime state
56+
transferSolanaMCMSToTimelock(t, rt, selector)
57+
fundSolanaSignerPDAs(t, chain, refs)
7958

80-
assertSolanaConfigEquals(t, mcmssolana.NewInspector(chain.Client), refs.Canceller, cfg)
81-
})
82-
}
59+
cfg := cldftesthelpers.SingleGroupMCMS(t)
60+
cfg.Signers = append(cfg.Signers, common.HexToAddress("0x0000000000000000000000000000000000000909"))
61+
cfg.Quorum = 2
62+
63+
report, err := operations.ExecuteOperation(
64+
rt.Environment().OperationsBundle,
65+
OpSolanaSetConfigMCM,
66+
chain,
67+
OpSolanaSetConfigInput{
68+
Target: MCMSetConfigTarget{
69+
Address: refs.Canceller,
70+
Config: cfg,
71+
ContractType: string(mcmscontracts.CancellerManyChainMultisig),
72+
},
73+
NoSend: true,
74+
AuthorityAccount: refs.TimelockSigner,
75+
},
76+
)
77+
require.NoError(t, err)
78+
require.False(t, report.Output.Confirmed)
79+
require.Equal(t, mcmstypes.ChainSelector(selector), report.Output.BatchOperation.ChainSelector)
80+
require.NotEmpty(t, report.Output.BatchOperation.Transactions)
81+
require.NoError(t, rt.Exec(
82+
newTimelockProposalTask([]mcmstypes.BatchOperation{report.Output.BatchOperation}, "solana set config operation test"),
83+
runtime.SignAndExecuteProposalsTask([]*ecdsa.PrivateKey{cldftesthelpers.TestXXXMCMSSigner}),
84+
))
85+
assertSolanaConfigEquals(t, mcmssolana.NewInspector(chain.Client), refs.Canceller, cfg)
86+
})
8387
}

‎mcms/solana/set-config/sequence_test.go‎

Lines changed: 78 additions & 83 deletions
Original file line numberDiff line numberDiff line change
@@ -42,94 +42,89 @@ import (
4242

4343
//nolint:paralleltest // global mcm.SetProgramID state; serialized via soltestutils.PreloadMCMS lock
4444
func testRunSolanaSetConfig(t *testing.T) {
45-
tests := []struct {
46-
name string
47-
noSend bool
48-
}{
49-
{name: "direct send", noSend: false},
50-
{name: "MCMS proposal", noSend: true},
51-
}
45+
selector := chainselectors.TEST_22222222222222222222222222222222222222222222.Selector
46+
rt := newSolanaSetConfigRuntime(t, selector)
47+
chain := rt.Environment().BlockChains.SolanaChains()[selector]
48+
refs := solanaSetConfigRefs(t, rt.Environment(), selector)
49+
fundSolanaSignerPDAs(t, chain, refs)
50+
51+
proposerCfg := cldftesthelpers.SingleGroupMCMS(t)
52+
proposerCfg.Signers = append(proposerCfg.Signers, common.HexToAddress("0x0000000000000000000000000000000000000101"))
53+
proposerCfg.Quorum = 2
54+
55+
cancellerCfg := cldftesthelpers.SingleGroupMCMS(t)
56+
cancellerCfg.Signers = append(cancellerCfg.Signers, common.HexToAddress("0x0000000000000000000000000000000000000202"))
57+
cancellerCfg.Quorum = 2
58+
59+
t.Run("direct send", func(t *testing.T) { //nolint:paralleltest // shared runtime state
60+
targets := []setconfig.ContractSetConfig{
61+
{
62+
Ref: refkey.New(selector, datastore.ContractType(mcmscontracts.ProposerManyChainMultisig), &semvers.V1_0_0, ""),
63+
Config: proposerCfg,
64+
},
65+
{
66+
Ref: refkey.New(selector, datastore.ContractType(mcmscontracts.CancellerManyChainMultisig), &semvers.V1_0_0, ""),
67+
Config: cancellerCfg,
68+
},
69+
}
5270

53-
for _, tt := range tests { //nolint:paralleltest // global mcm.SetProgramID state
54-
t.Run(tt.name, func(t *testing.T) {
55-
selector := chainselectors.TEST_22222222222222222222222222222222222222222222.Selector
56-
rt := newSolanaSetConfigRuntime(t, selector)
57-
chain := rt.Environment().BlockChains.SolanaChains()[selector]
58-
refs := solanaSetConfigRefs(t, rt.Environment(), selector)
59-
fundSolanaSignerPDAs(t, chain, refs)
71+
out, err := runSolanaSetConfig(
72+
rt.Environment().OperationsBundle,
73+
setconfig.Deps{
74+
BlockChains: rt.Environment().BlockChains,
75+
DataStore: rt.Environment().DataStore,
76+
},
77+
setconfig.ChainInput{
78+
ChainSelector: selector,
79+
Targets: targets,
80+
},
81+
)
82+
require.NoError(t, err)
83+
require.Empty(t, out.BatchOps)
6084

61-
if tt.noSend {
62-
transferSolanaMCMSToTimelock(t, rt, selector)
63-
fundSolanaSignerPDAs(t, chain, refs)
64-
}
85+
inspector := mcmssolana.NewInspector(chain.Client)
86+
assertSolanaConfigEquals(t, inspector, refs.Proposer, proposerCfg)
87+
assertSolanaConfigEquals(t, inspector, refs.Canceller, cancellerCfg)
88+
})
6589

66-
proposerCfg := cldftesthelpers.SingleGroupMCMS(t)
67-
proposerCfg.Signers = append(proposerCfg.Signers, common.HexToAddress("0x0000000000000000000000000000000000000101"))
68-
proposerCfg.Quorum = 2
90+
t.Run("MCMS proposal", func(t *testing.T) { //nolint:paralleltest // shared runtime state
91+
transferSolanaMCMSToTimelock(t, rt, selector)
92+
fundSolanaSignerPDAs(t, chain, refs)
6993

70-
cancellerCfg := cldftesthelpers.SingleGroupMCMS(t)
71-
cancellerCfg.Signers = append(cancellerCfg.Signers, common.HexToAddress("0x0000000000000000000000000000000000000202"))
72-
cancellerCfg.Quorum = 2
94+
mcmsInput := &cldf.MCMSTimelockProposalInput{
95+
TimelockAction: mcmstypes.TimelockActionSchedule,
96+
ValidUntil: uint32(time.Now().Add(2 * time.Hour).UTC().Unix()), //nolint:gosec // test timestamp
97+
TimelockDelay: mcmstypes.NewDuration(time.Second),
98+
}
99+
targets := []setconfig.ContractSetConfig{
100+
{
101+
Ref: refkey.New(selector, datastore.ContractType(mcmscontracts.CancellerManyChainMultisig), &semvers.V1_0_0, ""),
102+
Config: cancellerCfg,
103+
},
104+
}
73105

74-
targets := []setconfig.ContractSetConfig{
75-
{
76-
Ref: refkey.New(selector, datastore.ContractType(mcmscontracts.ProposerManyChainMultisig), &semvers.V1_0_0, ""),
77-
Config: proposerCfg,
78-
},
79-
{
80-
Ref: refkey.New(selector, datastore.ContractType(mcmscontracts.CancellerManyChainMultisig), &semvers.V1_0_0, ""),
81-
Config: cancellerCfg,
82-
},
83-
}
84-
var mcmsInput *cldf.MCMSTimelockProposalInput
85-
if tt.noSend {
86-
targets = []setconfig.ContractSetConfig{
87-
{
88-
Ref: refkey.New(selector, datastore.ContractType(mcmscontracts.CancellerManyChainMultisig), &semvers.V1_0_0, ""),
89-
Config: cancellerCfg,
90-
},
91-
}
92-
mcmsInput = &cldf.MCMSTimelockProposalInput{
93-
TimelockAction: mcmstypes.TimelockActionSchedule,
94-
ValidUntil: uint32(time.Now().Add(2 * time.Hour).UTC().Unix()), //nolint:gosec // test timestamp
95-
TimelockDelay: mcmstypes.NewDuration(time.Second),
96-
}
97-
}
98-
99-
out, err := runSolanaSetConfig(
100-
rt.Environment().OperationsBundle,
101-
setconfig.Deps{
102-
BlockChains: rt.Environment().BlockChains,
103-
DataStore: rt.Environment().DataStore,
104-
},
105-
setconfig.ChainInput{
106-
ChainSelector: selector,
107-
Targets: targets,
108-
MCMS: mcmsInput,
109-
},
110-
)
111-
require.NoError(t, err)
112-
113-
if tt.noSend {
114-
require.Len(t, out.BatchOps, 1)
115-
require.NotEmpty(t, out.BatchOps[0].Transactions)
116-
require.NoError(t, rt.Exec(
117-
newTimelockProposalTask(out.BatchOps, "solana set config sequence test"),
118-
runtime.SignAndExecuteProposalsTask([]*ecdsa.PrivateKey{cldftesthelpers.TestXXXMCMSSigner}),
119-
))
120-
} else {
121-
require.Empty(t, out.BatchOps)
122-
}
123-
124-
inspector := mcmssolana.NewInspector(chain.Client)
125-
if tt.noSend {
126-
assertSolanaConfigEquals(t, inspector, refs.Canceller, cancellerCfg)
127-
} else {
128-
assertSolanaConfigEquals(t, inspector, refs.Proposer, proposerCfg)
129-
assertSolanaConfigEquals(t, inspector, refs.Canceller, cancellerCfg)
130-
}
131-
})
132-
}
106+
out, err := runSolanaSetConfig(
107+
rt.Environment().OperationsBundle,
108+
setconfig.Deps{
109+
BlockChains: rt.Environment().BlockChains,
110+
DataStore: rt.Environment().DataStore,
111+
},
112+
setconfig.ChainInput{
113+
ChainSelector: selector,
114+
Targets: targets,
115+
MCMS: mcmsInput,
116+
},
117+
)
118+
require.NoError(t, err)
119+
require.Len(t, out.BatchOps, 1)
120+
require.NotEmpty(t, out.BatchOps[0].Transactions)
121+
require.NoError(t, rt.Exec(
122+
newTimelockProposalTask(out.BatchOps, "solana set config sequence test"),
123+
runtime.SignAndExecuteProposalsTask([]*ecdsa.PrivateKey{cldftesthelpers.TestXXXMCMSSigner}),
124+
))
125+
126+
assertSolanaConfigEquals(t, mcmssolana.NewInspector(chain.Client), refs.Canceller, cancellerCfg)
127+
})
133128
}
134129

135130
func newSolanaSetConfigRuntime(t *testing.T, selector uint64) *runtime.Runtime {

0 commit comments

Comments
 (0)