From 96e9d3f95617e3c4cd914a590217ba658082b29d Mon Sep 17 00:00:00 2001 From: Bruno Gomes Date: Thu, 4 Jul 2024 14:19:10 -0300 Subject: [PATCH] sdk executor and e2e tests --- cli-interface | 3 - example/bearer_auth/main.go | 129 ++++++++++++++ sdk/msgset.go | 5 + sdk/sdk.go | 15 ++ sdk/tx.go | 2 +- sdk/types.go | 1 + tests/e2e/sdk/sdk_test.go | 12 +- tests/integration/acp/ctx.go | 31 ++-- tests/integration/acp/executor.go | 160 +++++++++++++++++- .../acp/suite/object/register_test.go | 9 + .../acp/suite/object/unregister_test.go | 5 + .../acp/suite/policy/create_test.go | 3 + .../acp/suite/relationship/delete_test.go | 4 + .../acp/suite/relationship/set_test.go | 6 + tests/integration/acp/types.go | 6 +- tests/integration/acp/utils.go | 11 +- testutil/e2e/e2e.go | 2 +- x/acp/module/autocli.go | 6 - 18 files changed, 366 insertions(+), 44 deletions(-) delete mode 100644 cli-interface create mode 100644 example/bearer_auth/main.go diff --git a/cli-interface b/cli-interface deleted file mode 100644 index c508114..0000000 --- a/cli-interface +++ /dev/null @@ -1,3 +0,0 @@ -sourcehubd tx acp policy-cmd make-payload {cmd} {cmd args} -sourcehubd tx acp policy-cmd sign-payload keyring|jwk {payload file} / - > outputs to stdout -sourcehubd tx acp policy-cmd tx [normal tx stuff] diff --git a/example/bearer_auth/main.go b/example/bearer_auth/main.go new file mode 100644 index 0000000..7085f6b --- /dev/null +++ b/example/bearer_auth/main.go @@ -0,0 +1,129 @@ +package main + +import ( + "context" + "log" + + "github.com/cosmos/cosmos-sdk/codec" + cdctypes "github.com/cosmos/cosmos-sdk/codec/types" + cryptocdc "github.com/cosmos/cosmos-sdk/crypto/codec" + "github.com/cosmos/cosmos-sdk/crypto/keyring" + prototypes "github.com/cosmos/gogoproto/types" + + "github.com/sourcenetwork/sourcehub/sdk" + "github.com/sourcenetwork/sourcehub/x/acp/bearer_token" + "github.com/sourcenetwork/sourcehub/x/acp/did" + acptypes "github.com/sourcenetwork/sourcehub/x/acp/types" +) + +func main() { + ctx := context.Background() + + client, err := sdk.NewClient() + if err != nil { + log.Fatal(err) + } + + txBuilder, err := sdk.NewTxBuilder( + sdk.WithSDKClient(client), + sdk.WithChainID("sourcehub-dev"), + ) + if err != nil { + log.Fatal(err) + } + + reg := cdctypes.NewInterfaceRegistry() + cryptocdc.RegisterInterfaces(reg) + cdc := codec.NewProtoCodec(reg) + keyring, err := keyring.New("sourcehub", keyring.BackendTest, "~/.sourcehub", nil, cdc) + if err != nil { + log.Fatalf("could not load keyring: %v", err) + } + + txSigner, err := sdk.NewTxSignerFromKeyringKey(keyring, "validator") + if err != nil { + log.Fatalf("could not load keyring: %v", err) + } + + policy := ` +name: test +resources: + resource: + relations: + owner: + types: + - actor +` + + msgSet := sdk.MsgSet{} + policyMapper := msgSet.WithCreatePolicy(acptypes.NewMsgCreatePolicyNow(txSigner.GetAccAddress(), policy, acptypes.PolicyMarshalingType_SHORT_YAML)) + tx, err := txBuilder.Build(ctx, txSigner, &msgSet) + if err != nil { + log.Fatal(err) + } + + resp, err := client.BroadcastTx(ctx, tx) + if err != nil { + log.Fatal(err) + } + + result, err := client.AwaitTx(ctx, resp.TxHash) + if err != nil { + log.Fatal(err) + } + if result.Error() != nil { + log.Fatalf("Tx failed: %v", result.Error()) + } + + policyResponse, err := policyMapper.Map(result.TxPayload()) + if err != nil { + log.Fatal(err) + } + + log.Printf("policy created: %v", policyResponse.Policy.Id) + + alice, signer, err := did.ProduceDID() + if err != nil { + log.Fatalf("could not generate alice: %v", err) + } + log.Printf("alice's DID: %v", alice) + + token := bearer_token.NewBearerTokenNow(alice, txSigner.GetAccAddress()) + jws, err := token.ToJWS(signer) + if err != nil { + log.Fatalf("could not produce Bearer for alice: %v", err) + } + + log.Printf("alice's raw token: %v", token) + log.Printf("alice's JWS: %v", jws) + + bearerCmd := acptypes.MsgBearerPolicyCmd{ + Creator: txSigner.GetAccAddress(), + BearerToken: jws, + PolicyId: policyResponse.Policy.Id, + Cmd: acptypes.NewRegisterObjectCmd(acptypes.NewObject("resource", "foo")), + CreationTime: prototypes.TimestampNow(), + } + + log.Printf("Bearer Cmd: %v", bearerCmd) + msgSet = sdk.MsgSet{} + msgSet.WithBearerPolicyCmd(&bearerCmd) + tx, err = txBuilder.Build(ctx, txSigner, &msgSet) + if err != nil { + log.Fatal(err) + } + resp, err = client.BroadcastTx(ctx, tx) + if err != nil { + log.Fatal(err) + } + + result, err = client.AwaitTx(ctx, resp.TxHash) + if err != nil { + log.Fatal(err) + } + if result.Error() != nil { + log.Fatalf("Tx failed: %v", result.Error()) + } + + log.Printf("object registered") +} diff --git a/sdk/msgset.go b/sdk/msgset.go index 45d12bd..3696636 100644 --- a/sdk/msgset.go +++ b/sdk/msgset.go @@ -76,3 +76,8 @@ func (b *MsgSet) WithBearerPolicyCmd(msg *acptypes.MsgBearerPolicyCmd) Mapper[*a idx := b.addMsg(msg) return newMapper(idx, &acptypes.MsgBearerPolicyCmdResponse{}) } + +func (b *MsgSet) WithDirectPolicyCmd(msg *acptypes.MsgDirectPolicyCmd) Mapper[*acptypes.MsgDirectPolicyCmdResponse] { + idx := b.addMsg(msg) + return newMapper(idx, &acptypes.MsgDirectPolicyCmdResponse{}) +} diff --git a/sdk/sdk.go b/sdk/sdk.go index ae35c34..558169e 100644 --- a/sdk/sdk.go +++ b/sdk/sdk.go @@ -2,6 +2,7 @@ package sdk import ( "context" + "encoding/hex" "fmt" "log" @@ -181,3 +182,17 @@ func (c *Client) AwaitTx(ctx context.Context, txHash string) (*TxExecResult, err return newTxExecResult(result), nil } + +func (c *Client) GetTx(ctx context.Context, txHash string) (*TxExecResult, error) { + bytes, err := hex.DecodeString(txHash) + if err != nil { + return nil, fmt.Errorf("invalid tx hash: %v", err) + } + + txRPC, err := c.CometBFTRPCClient().Tx(ctx, bytes, false) + if err != nil { + return nil, fmt.Errorf("failed to get tx: %v", err) + } + + return newTxExecResult(txRPC), nil +} diff --git a/sdk/tx.go b/sdk/tx.go index a77741c..75e57b8 100644 --- a/sdk/tx.go +++ b/sdk/tx.go @@ -54,7 +54,7 @@ func NewTxBuilder(opts ...TxBuilderOpt) (TxBuilder, error) { } if builder.authClient == nil { - return TxBuilder{}, fmt.Errorf("TxBuilder: Auth GRPC Client is required: use either WithAuthQueryClient or WithClientConn to set it") + return TxBuilder{}, fmt.Errorf("TxBuilder: Auth GRPC Client is required: use either WithAuthQueryClient or WithSDKClient to set it") } return builder, nil diff --git a/sdk/types.go b/sdk/types.go index 76e8d8f..6124e65 100644 --- a/sdk/types.go +++ b/sdk/types.go @@ -10,6 +10,7 @@ func newTxExecResult(result *rpctypes.ResultTx) *TxExecResult { var err error if result.TxResult.Code != 0 { err = fmt.Errorf("%v: %v", ErrTxFailed, result.TxResult.Log) + result = nil } return &TxExecResult{ diff --git a/tests/e2e/sdk/sdk_test.go b/tests/e2e/sdk/sdk_test.go index 4a5f3bb..24282b7 100644 --- a/tests/e2e/sdk/sdk_test.go +++ b/tests/e2e/sdk/sdk_test.go @@ -2,7 +2,6 @@ package sdk import ( "context" - "encoding/hex" "testing" "github.com/sourcenetwork/sourcehub/sdk" @@ -47,15 +46,10 @@ name: test policy network.Network.WaitForNextBlock() - bytes, _ := hex.DecodeString(response.TxHash) - txRPC, err := client.CometBFTRPCClient().Tx(ctx, bytes, false) + result, err := network.Client.GetTx(ctx, response.TxHash) require.NoError(t, err) + require.NoError(t, result.Error()) - //execResult, err := client.AwaitTx(ctx, response.TxHash) - //require.NoError(t, err) - //require.NoError(t, execResult.Error()) - - msgResponse, err := mapper.Map(txRPC) + _, err = mapper.Map(result.TxPayload()) require.NoError(t, err) - require.Equal(t, "", msgResponse.Policy.Id) } diff --git a/tests/integration/acp/ctx.go b/tests/integration/acp/ctx.go index 09b0709..ac011f7 100644 --- a/tests/integration/acp/ctx.go +++ b/tests/integration/acp/ctx.go @@ -22,30 +22,26 @@ type TestState struct { PolicyCreator string } -func NewTestCtxFromConfig(t *testing.T, config TestConfig) (*TestCtx, error) { - baseCtx, executor, err := NewExecutor(config.ExecutorStrategy) - if err != nil { - return nil, err - } +func NewTestCtxFromConfig(t *testing.T, config TestConfig) *TestCtx { + baseCtx, executor := NewExecutor(t, config.ExecutorStrategy) root := MustNewSourceHubActorFromName("root") - _, err = executor.GetOrCreateAccountFromActor(baseCtx, root) - if err != nil { - return nil, err - } - ctx := &TestCtx{ Ctx: baseCtx, T: t, TxSigner: root, - Timestamp: time.Date(2024, 6, 21, 12, 10, 00, 0, time.UTC), - TokenIssueTs: time.Date(2024, 6, 21, 12, 00, 00, 0, time.UTC), + Timestamp: time.Now(), + TokenIssueTs: time.Now(), Executor: executor, Strategy: config.AuthStrategy, ActorType: config.ActorType, LogicalClock: &logicalClockImpl{}, } - return ctx, nil + + _, err := executor.GetOrCreateAccountFromActor(ctx, root) + require.NoError(t, err) + + return ctx } type TestCtx struct { @@ -67,8 +63,7 @@ type TestCtx struct { func NewTestCtx(t *testing.T) *TestCtx { initTest() config := MustNewTestConfigFromEnv() - ctx, err := NewTestCtxFromConfig(t, config) - require.NoError(t, err) + ctx := NewTestCtxFromConfig(t, config) return ctx } @@ -84,7 +79,7 @@ func (c *TestCtx) GetActor(alias string) *TestActor { return MustNewED25519ActorFromName(alias) case Actor_SECP256K1: acc := MustNewSourceHubActorFromName(alias) - _, err := c.Executor.GetOrCreateAccountFromActor(c.Ctx, acc) + _, err := c.Executor.GetOrCreateAccountFromActor(c, acc) require.NoError(c.T, err) return acc default: @@ -101,3 +96,7 @@ func (c *TestCtx) GetSourceHubAccount(alias string) *TestActor { func (c *TestCtx) GetParams() types.Params { return types.NewParams() } + +func (c *TestCtx) Cleanup() { + c.Executor.Cleanup() +} diff --git a/tests/integration/acp/executor.go b/tests/integration/acp/executor.go index b01ba7f..10248c1 100644 --- a/tests/integration/acp/executor.go +++ b/tests/integration/acp/executor.go @@ -3,8 +3,10 @@ package test import ( "context" "fmt" + "testing" "cosmossdk.io/log" + "cosmossdk.io/math" "cosmossdk.io/store" "cosmossdk.io/store/metrics" storetypes "cosmossdk.io/store/types" @@ -15,9 +17,15 @@ import ( "github.com/cosmos/cosmos-sdk/runtime" sdk "github.com/cosmos/cosmos-sdk/types" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" "github.com/sourcenetwork/sourcehub/x/acp/types" + "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + hubsdk "github.com/sourcenetwork/sourcehub/sdk" + "github.com/sourcenetwork/sourcehub/testutil/e2e" "github.com/sourcenetwork/sourcehub/x/acp/keeper" "github.com/sourcenetwork/sourcehub/x/acp/testutil" ) @@ -27,6 +35,8 @@ type KeeperExecutor struct { accountCreator *testutil.AccountKeeperStub } +func (e *KeeperExecutor) Cleanup() {} + func (e *KeeperExecutor) BearerPolicyCmd(ctx *TestCtx, msg *types.MsgBearerPolicyCmd) (*types.MsgBearerPolicyCmdResponse, error) { return e.k.BearerPolicyCmd(ctx, msg) } @@ -43,21 +53,26 @@ func (e *KeeperExecutor) CreatePolicy(ctx *TestCtx, msg *types.MsgCreatePolicy) return e.k.CreatePolicy(ctx, msg) } -func (e *KeeperExecutor) GetOrCreateAccountFromActor(_ context.Context, actor *TestActor) (sdk.AccountI, error) { +func (e *KeeperExecutor) GetOrCreateAccountFromActor(_ *TestCtx, actor *TestActor) (sdk.AccountI, error) { return e.accountCreator.NewAccount(actor.PubKey), nil } -func NewExecutor(strategy ExecutorStrategy) (context.Context, MsgExecutor, error) { +func NewExecutor(t *testing.T, strategy ExecutorStrategy) (context.Context, MsgExecutor) { switch strategy { case Keeper: ctx, exec, err := newKeeperExecutor() - return ctx, exec, err + require.NoError(t, err) + return ctx, exec case SDK: - panic("sdk executor not implemented") + network := &e2e.TestNetwork{} + network.Setup(t) + executor, err := newSDKExecutor(network) + require.NoError(t, err) + return context.Background(), executor case CLI: panic("sdk executor not implemented") default: - return nil, nil, fmt.Errorf("invalid executor strategy: %v", strategy) + panic(fmt.Sprintf("invalid executor strategy: %v", strategy)) } } @@ -100,3 +115,138 @@ func newKeeperExecutor() (context.Context, MsgExecutor, error) { } return ctx, executor, nil } + +func newSDKExecutor(network *e2e.TestNetwork) (*SDKClientExecutor, error) { + txBuilder, err := hubsdk.NewTxBuilder( + hubsdk.WithSDKClient(network.Client), + hubsdk.WithChainID(network.GetChainID()), + ) + + if err != nil { + return nil, err + } + return &SDKClientExecutor{ + Network: network, + txBuilder: &txBuilder, + }, nil +} + +type SDKClientExecutor struct { + Network *e2e.TestNetwork + txBuilder *hubsdk.TxBuilder +} + +func (e *SDKClientExecutor) BearerPolicyCmd(ctx *TestCtx, msg *types.MsgBearerPolicyCmd) (*types.MsgBearerPolicyCmdResponse, error) { + set := hubsdk.MsgSet{} + mapper := set.WithBearerPolicyCmd(msg) + result := e.broadcastTx(ctx, &set) + if result.Error() != nil { + return nil, result.Error() + } + response, err := mapper.Map(result.TxPayload()) + require.NoError(ctx.T, err) + return response, nil +} + +func (e *SDKClientExecutor) SignedPolicyCmd(ctx *TestCtx, msg *types.MsgSignedPolicyCmd) (*types.MsgSignedPolicyCmdResponse, error) { + set := hubsdk.MsgSet{} + mapper := set.WithSignedPolicyCmd(msg) + result := e.broadcastTx(ctx, &set) + if result.Error() != nil { + return nil, result.Error() + } + response, err := mapper.Map(result.TxPayload()) + require.NoError(ctx.T, err) + return response, nil +} + +func (e *SDKClientExecutor) DirectPolicyCmd(ctx *TestCtx, msg *types.MsgDirectPolicyCmd) (*types.MsgDirectPolicyCmdResponse, error) { + set := hubsdk.MsgSet{} + mapper := set.WithDirectPolicyCmd(msg) + result := e.broadcastTx(ctx, &set) + if result.Error() != nil { + return nil, result.Error() + } + response, err := mapper.Map(result.TxPayload()) + require.NoError(ctx.T, err) + return response, nil +} + +func (e *SDKClientExecutor) CreatePolicy(ctx *TestCtx, msg *types.MsgCreatePolicy) (*types.MsgCreatePolicyResponse, error) { + set := hubsdk.MsgSet{} + mapper := set.WithCreatePolicy(msg) + result := e.broadcastTx(ctx, &set) + if result.Error() != nil { + return nil, result.Error() + } + response, err := mapper.Map(result.TxPayload()) + require.NoError(ctx.T, err) + return response, nil +} + +func (e *SDKClientExecutor) GetOrCreateAccountFromActor(ctx *TestCtx, actor *TestActor) (sdk.AccountI, error) { + client := e.Network.Client + resp, err := client.AuthQueryClient().AccountInfo(ctx, &authtypes.QueryAccountInfoRequest{ + Address: actor.SourceHubAddr, + }) + if resp != nil { + return resp.Info, nil + } + // if error was not found, means account doesnt exist + // and we can create one + if err != nil && status.Code(err) != codes.NotFound { + require.NoError(ctx.T, err) + return nil, err + } + + var defaultSendAmt sdk.Coins = []sdk.Coin{ + { + Denom: "stake", + Amount: math.NewInt(10000), + }, + } + + msg := banktypes.MsgSend{ + FromAddress: e.Network.GetValidatorAddr(), + ToAddress: actor.SourceHubAddr, + Amount: defaultSendAmt, + } + tx, err := e.txBuilder.BuildFromMsgs(ctx, + hubsdk.TxSignerFromCosmosKey(e.Network.GetValidatorKey()), + &msg, + ) + require.NoError(ctx.T, err) + + _, err = client.BroadcastTx(ctx, tx) + require.NoError(ctx.T, err) + e.Network.Network.WaitForNextBlock() + + resp, err = client.AuthQueryClient().AccountInfo(ctx, &authtypes.QueryAccountInfoRequest{ + Address: actor.SourceHubAddr, + }) + require.NoError(ctx.T, err) + return resp.Info, nil +} + +func (e *SDKClientExecutor) broadcastTx(ctx *TestCtx, msgSet *hubsdk.MsgSet) *hubsdk.TxExecResult { + _, err := e.GetOrCreateAccountFromActor(ctx, ctx.TxSigner) + require.NoError(ctx.T, err) + + signer := hubsdk.TxSignerFromCosmosKey(ctx.TxSigner.PrivKey) + + tx, err := e.txBuilder.Build(ctx, signer, msgSet) + require.NoError(ctx.T, err) + + response, err := e.Network.Client.BroadcastTx(ctx, tx) + require.NoError(ctx.T, err) + + e.Network.Network.WaitForNextBlock() + result, err := e.Network.Client.GetTx(ctx, response.TxHash) + require.NoError(ctx.T, err) + + return result +} + +func (e *SDKClientExecutor) Cleanup() { + e.Network.TearDown() +} diff --git a/tests/integration/acp/suite/object/register_test.go b/tests/integration/acp/suite/object/register_test.go index e29ac20..ff43e6d 100644 --- a/tests/integration/acp/suite/object/register_test.go +++ b/tests/integration/acp/suite/object/register_test.go @@ -19,6 +19,7 @@ resources: func TestRegisterObject_RegisteringNewObjectIsSucessful(t *testing.T) { ctx := test.NewTestCtx(t) + defer ctx.Cleanup() a1 := test.CreatePolicyAction{ Policy: policyDef, @@ -59,6 +60,7 @@ func TestRegisterObject_RegisteringNewObjectIsSucessful(t *testing.T) { func TestRegisterObject_RegisteringObjectRegisteredToAnotherUserErrors(t *testing.T) { ctx := test.NewTestCtx(t) + defer ctx.Cleanup() // Given Bob as owner of foo a1 := test.CreatePolicyAction{ @@ -87,6 +89,7 @@ func TestRegisterObject_RegisteringObjectRegisteredToAnotherUserErrors(t *testin func TestRegisterObject_ReregisteringObjectOwnedByUserIsNoop(t *testing.T) { ctx := test.NewTestCtx(t) + defer ctx.Cleanup() // Given Bob as owner of foo a1 := test.CreatePolicyAction{ @@ -127,6 +130,7 @@ func TestRegisterObject_ReregisteringObjectOwnedByUserIsNoop(t *testing.T) { func TestRegisterObject_RegisteringAnotherUsersArchivedObjectErrors(t *testing.T) { ctx := test.NewTestCtx(t) + defer ctx.Cleanup() // Given Bob as previous owner of foo a1 := test.CreatePolicyAction{ @@ -162,6 +166,7 @@ func TestRegisterObject_RegisteringAnotherUsersArchivedObjectErrors(t *testing.T func TestRegisterObject_RegisteringArchivedUserObjectUnarchivesObject(t *testing.T) { ctx := test.NewTestCtx(t) + defer ctx.Cleanup() // Given Bob as previous owner of foo a1 := test.CreatePolicyAction{ @@ -216,6 +221,7 @@ func TestRegisterObject_RegisteringArchivedUserObjectUnarchivesObject(t *testing func TestRegisterObject_RegisteringObjectInAnUndefinedResourceErrors(t *testing.T) { ctx := test.NewTestCtx(t) + defer ctx.Cleanup() // Given Bob as previous owner of foo a1 := test.CreatePolicyAction{ @@ -234,6 +240,7 @@ func TestRegisterObject_RegisteringObjectInAnUndefinedResourceErrors(t *testing. func TestRegisterObject_RegisteringToUnknownPolicyReturnsError(t *testing.T) { ctx := test.NewTestCtx(t) + defer ctx.Cleanup() // Given Bob as previous owner of foo a2 := test.RegisterObjectAction{ @@ -247,6 +254,7 @@ func TestRegisterObject_RegisteringToUnknownPolicyReturnsError(t *testing.T) { func TestRegisterObject_BlankResourceErrors(t *testing.T) { ctx := test.NewTestCtx(t) + defer ctx.Cleanup() // Given Bob as previous owner of foo a1 := test.CreatePolicyAction{ @@ -265,6 +273,7 @@ func TestRegisterObject_BlankResourceErrors(t *testing.T) { func TestRegisterObject_BlankObjectIdErrors(t *testing.T) { ctx := test.NewTestCtx(t) + defer ctx.Cleanup() // Given Bob as previous owner of foo a1 := test.CreatePolicyAction{ diff --git a/tests/integration/acp/suite/object/unregister_test.go b/tests/integration/acp/suite/object/unregister_test.go index c8fcf12..0229b7b 100644 --- a/tests/integration/acp/suite/object/unregister_test.go +++ b/tests/integration/acp/suite/object/unregister_test.go @@ -44,6 +44,7 @@ func setupUnregister(t *testing.T) *test.TestCtx { func TestUnregisterObject_RegisteredObjectCanBeUnregisteredByAuthor(t *testing.T) { ctx := setupUnregister(t) + defer ctx.Cleanup() action := test.UnregisterObjectAction{ PolicyId: ctx.State.PolicyId, @@ -59,6 +60,7 @@ func TestUnregisterObject_RegisteredObjectCanBeUnregisteredByAuthor(t *testing.T func TestUnregisterObject_ActorCannotUnregisterObjectTheyDoNotOwn(t *testing.T) { ctx := setupUnregister(t) + defer ctx.Cleanup() action := test.UnregisterObjectAction{ PolicyId: ctx.State.PolicyId, @@ -71,6 +73,7 @@ func TestUnregisterObject_ActorCannotUnregisterObjectTheyDoNotOwn(t *testing.T) func TestUnregisterObject_UnregisteringAnObjectThatDoesNotExistReturnsUnauthorized(t *testing.T) { ctx := setupUnregister(t) + defer ctx.Cleanup() action := test.UnregisterObjectAction{ PolicyId: ctx.State.PolicyId, @@ -83,6 +86,7 @@ func TestUnregisterObject_UnregisteringAnObjectThatDoesNotExistReturnsUnauthoriz func TestUnregisterObject_UnregisteringAnAlreadyArchivedObjectIsANoop(t *testing.T) { ctx := setupUnregister(t) + defer ctx.Cleanup() action := test.UnregisterObjectAction{ PolicyId: ctx.State.PolicyId, @@ -104,6 +108,7 @@ func TestUnregisterObject_UnregisteringAnAlreadyArchivedObjectIsANoop(t *testing func TestUnregisterObject_SendingInvalidPolicyIdErrors(t *testing.T) { ctx := setupUnregister(t) + defer ctx.Cleanup() action := test.UnregisterObjectAction{ PolicyId: "abc1234", diff --git a/tests/integration/acp/suite/policy/create_test.go b/tests/integration/acp/suite/policy/create_test.go index 4d2450f..46e7862 100644 --- a/tests/integration/acp/suite/policy/create_test.go +++ b/tests/integration/acp/suite/policy/create_test.go @@ -10,6 +10,7 @@ import ( func TestCreatePolicy_ValidPolicyIsCreated(t *testing.T) { ctx := test.NewTestCtx(t) + defer ctx.Cleanup() policyStr := ` name: policy @@ -118,6 +119,7 @@ actor: func TestCreatePolicy_PolicyResourcesRequiresOwnerRelation(t *testing.T) { ctx := test.NewTestCtx(t) + defer ctx.Cleanup() action := test.CreatePolicyAction{ Policy: ` @@ -141,6 +143,7 @@ resources: func TestCreatePolicy_ManagementReferencingUndefinedRelationReturnsError(t *testing.T) { ctx := test.NewTestCtx(t) + defer ctx.Cleanup() action := test.CreatePolicyAction{ Policy: ` diff --git a/tests/integration/acp/suite/relationship/delete_test.go b/tests/integration/acp/suite/relationship/delete_test.go index d723176..807d02c 100644 --- a/tests/integration/acp/suite/relationship/delete_test.go +++ b/tests/integration/acp/suite/relationship/delete_test.go @@ -57,6 +57,7 @@ func setupDelete(t *testing.T) *test.TestCtx { func TestDeleteRelationship_ObjectOwnerCanRemoveRelationship(t *testing.T) { ctx := setupDelete(t) + defer ctx.Cleanup() action := test.DeleteRelationshipAction{ PolicyId: ctx.State.PolicyId, @@ -71,6 +72,7 @@ func TestDeleteRelationship_ObjectOwnerCanRemoveRelationship(t *testing.T) { func TestDeleteRelationship_ObjectManagerCanRemoveRelationshipsForRelationTheyManage(t *testing.T) { ctx := setupDelete(t) + defer ctx.Cleanup() action := test.DeleteRelationshipAction{ PolicyId: ctx.State.PolicyId, @@ -85,6 +87,8 @@ func TestDeleteRelationship_ObjectManagerCanRemoveRelationshipsForRelationTheyMa func TestDeleteRelationship_ObjectManagerCannotRemoveRelationshipForRelationTheyDontManage(t *testing.T) { ctx := setupDelete(t) + defer ctx.Cleanup() + action := test.DeleteRelationshipAction{ PolicyId: ctx.State.PolicyId, Relationship: types.NewActorRelationship("file", "foo", "writer", ctx.GetActor("writer").DID), diff --git a/tests/integration/acp/suite/relationship/set_test.go b/tests/integration/acp/suite/relationship/set_test.go index 791ca94..48b8f18 100644 --- a/tests/integration/acp/suite/relationship/set_test.go +++ b/tests/integration/acp/suite/relationship/set_test.go @@ -44,6 +44,7 @@ func setupSetRel(t *testing.T) *test.TestCtx { func TestSetRelationship_OwnerCanShareObjectTheyOwn(t *testing.T) { ctx := setupSetRel(t) + defer ctx.Cleanup() bob := ctx.GetActor("bob").DID a1 := test.SetRelationshipAction{ @@ -66,6 +67,7 @@ func TestSetRelationship_OwnerCanShareObjectTheyOwn(t *testing.T) { } func TestSetRelationship_ActorCannotSetRelationshipForUnregisteredObject(t *testing.T) { ctx := setupSetRel(t) + defer ctx.Cleanup() bob := ctx.GetActor("bob").DID a1 := test.SetRelationshipAction{ @@ -80,6 +82,7 @@ func TestSetRelationship_ActorCannotSetRelationshipForUnregisteredObject(t *test func TestSetRelationship_ActorCannotSetRelationshipForObjectTheyDoNotOwn(t *testing.T) { // Given Alice as the Owner of File Foo ctx := setupSetRel(t) + defer ctx.Cleanup() bob := ctx.GetActor("bob").DID a1 := test.SetRelationshipAction{ @@ -93,6 +96,7 @@ func TestSetRelationship_ActorCannotSetRelationshipForObjectTheyDoNotOwn(t *test func TestSetRelationship_ManagerActorCanDelegateAccessToAnotherActor(t *testing.T) { ctx := setupSetRel(t) + defer ctx.Cleanup() // Given object foo and Bob as a manager bob := ctx.GetActor("bob").DID @@ -126,6 +130,7 @@ func TestSetRelationship_ManagerActorCanDelegateAccessToAnotherActor(t *testing. func TestSetRelationship_ManagerActorCannotSetRelationshipToRelationshipsTheyDoNotManage(t *testing.T) { ctx := setupSetRel(t) + defer ctx.Cleanup() // Given object foo and Bob as a admin bob := ctx.GetActor("bob").DID @@ -150,6 +155,7 @@ func TestSetRelationship_ManagerActorCannotSetRelationshipToRelationshipsTheyDoN func TestSetRelationship_AdminIsNotAllowedToSetAnOwnerRelationship(t *testing.T) { ctx := setupSetRel(t) + defer ctx.Cleanup() // Given object foo and Bob as a admin bob := ctx.GetActor("bob").DID diff --git a/tests/integration/acp/types.go b/tests/integration/acp/types.go index 92b587e..3babd8d 100644 --- a/tests/integration/acp/types.go +++ b/tests/integration/acp/types.go @@ -29,7 +29,7 @@ type AccountCreator interface { // GetOrCreateActor retrieves an account from a TestActor's address // if the account does not exist in the chain, it must be created // and given credits (if required) - GetOrCreateAccountFromActor(context.Context, *TestActor) (sdk.AccountI, error) + GetOrCreateAccountFromActor(*TestCtx, *TestActor) (sdk.AccountI, error) } // MsgExecutor represents a component which can execute an ACP Msg and produce a result @@ -40,6 +40,8 @@ type MsgExecutor interface { BearerPolicyCmd(ctx *TestCtx, msg *types.MsgBearerPolicyCmd) (*types.MsgBearerPolicyCmdResponse, error) SignedPolicyCmd(ctx *TestCtx, msg *types.MsgSignedPolicyCmd) (*types.MsgSignedPolicyCmdResponse, error) DirectPolicyCmd(ctx *TestCtx, msg *types.MsgDirectPolicyCmd) (*types.MsgDirectPolicyCmdResponse, error) + + Cleanup() } // AuthenticationStrategy is an enum representing the Authentication format @@ -90,7 +92,7 @@ const ( var ExecutorStrategyMap map[string]ExecutorStrategy = map[string]ExecutorStrategy{ "KEEPER": Keeper, //"CLI": CLI, - //"SDK": SDK, + "SDK": SDK, } // TestConfig models how the tests suite will be run diff --git a/tests/integration/acp/utils.go b/tests/integration/acp/utils.go index 5029c6a..1d1e07b 100644 --- a/tests/integration/acp/utils.go +++ b/tests/integration/acp/utils.go @@ -1,6 +1,7 @@ package test import ( + "errors" "reflect" "time" @@ -34,7 +35,15 @@ func TimeToProto(ts time.Time) *gogotypes.Timestamp { func AssertResults(ctx *TestCtx, got, want any, gotErr, wantErr error) { if wantErr != nil { - assert.ErrorIs(ctx.T, gotErr, wantErr) + if errors.Is(gotErr, wantErr) { + assert.ErrorIs(ctx.T, gotErr, wantErr) + } else { + // Errors returned from SDK operations (RPC communication to a SourceHub node) + // no longer have the original errors wrapped, therefore we compare a string as fallback strat. + gotErrStr := gotErr.Error() + wantErrStr := wantErr.Error() + assert.Contains(ctx.T, gotErrStr, wantErrStr) + } } else { assert.NoError(ctx.T, gotErr) } diff --git a/testutil/e2e/e2e.go b/testutil/e2e/e2e.go index c90f281..fc256a7 100644 --- a/testutil/e2e/e2e.go +++ b/testutil/e2e/e2e.go @@ -50,7 +50,7 @@ func (n *TestNetwork) Setup(t *testing.T) { n.ValidatorKey = pkey } -func (n *TestNetwork) TearDown(t *testing.T) { +func (n *TestNetwork) TearDown() { n.Network.Cleanup() } diff --git a/x/acp/module/autocli.go b/x/acp/module/autocli.go index e4467f9..798267a 100644 --- a/x/acp/module/autocli.go +++ b/x/acp/module/autocli.go @@ -60,12 +60,6 @@ func (am AppModule) AutoCLIOptions() *autocliv1.ModuleOptions { RpcMethod: "UpdateParams", Skip: true, // skipped because authority gated }, - { - RpcMethod: "PolicyCmd", - Use: "policy-cmd", - Short: "Send a policy-cmd tx", - PositionalArgs: []*autocliv1.PositionalArgDescriptor{}, - }, { RpcMethod: "BearerPolicyCmd", Use: "bearer-policy-cmd",