Better tests

x/wasm/migrations/v2/params_legacy.go

@@ -6,8 +6,11 @@ for migration purposes and will be removed in a future release.
 package v2
 
 import (
+	"encoding/json"
 	"fmt"
 
+	"github.com/cosmos/gogoproto/jsonpb"
+
 	errorsmod "cosmossdk.io/errors"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -96,3 +99,44 @@ func assertValidAddresses(addrs []string) error {
 	}
 	return nil
 }
+
+func (a AccessType) String() string {
+	switch a {
+	case AccessTypeNobody:
+		return "Nobody"
+	case AccessTypeOnlyAddress:
+		return "OnlyAddress"
+	case AccessTypeEverybody:
+		return "Everybody"
+	case AccessTypeAnyOfAddresses:
+		return "AnyOfAddresses"
+	}
+	return "Unspecified"
+}
+
+func (a *AccessType) UnmarshalText(text []byte) error {
+	for _, v := range AllAccessTypes {
+		if v.String() == string(text) {
+			*a = v
+			return nil
+		}
+	}
+	*a = AccessTypeUnspecified
+	return nil
+}
+
+func (a AccessType) MarshalText() ([]byte, error) {
+	return []byte(a.String()), nil
+}
+
+func (a *AccessType) MarshalJSONPB(_ *jsonpb.Marshaler) ([]byte, error) {
+	return json.Marshal(a)
+}
+
+func (a *AccessType) UnmarshalJSONPB(_ *jsonpb.Unmarshaler, data []byte) error {
+	return json.Unmarshal(data, a)
+}
+
+func (a AccessConfig) Equals(o AccessConfig) bool {
+	return a.Permission == o.Permission && a.Address == o.Address
+}

x/wasm/migrations/v2/params_legacy_test.go

@@ -0,0 +1,89 @@
+package v2
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/cosmos/cosmos-sdk/codec"
+)
+
+func TestAccessTypeMarshalJson(t *testing.T) {
+	specs := map[string]struct {
+		src AccessType
+		exp string
+	}{
+		"Unspecified":              {src: AccessTypeUnspecified, exp: `"Unspecified"`},
+		"Nobody":                   {src: AccessTypeNobody, exp: `"Nobody"`},
+		"OnlyAddress":              {src: AccessTypeOnlyAddress, exp: `"OnlyAddress"`},
+		"AccessTypeAnyOfAddresses": {src: AccessTypeAnyOfAddresses, exp: `"AnyOfAddresses"`},
+		"Everybody":                {src: AccessTypeEverybody, exp: `"Everybody"`},
+		"unknown":                  {src: 999, exp: `"Unspecified"`},
+	}
+	for msg, spec := range specs {
+		t.Run(msg, func(t *testing.T) {
+			got, err := json.Marshal(spec.src)
+			require.NoError(t, err)
+			assert.Equal(t, []byte(spec.exp), got)
+		})
+	}
+}
+
+func TestAccessTypeUnmarshalJson(t *testing.T) {
+	specs := map[string]struct {
+		src string
+		exp AccessType
+	}{
+		"Unspecified":    {src: `"Unspecified"`, exp: AccessTypeUnspecified},
+		"Nobody":         {src: `"Nobody"`, exp: AccessTypeNobody},
+		"OnlyAddress":    {src: `"OnlyAddress"`, exp: AccessTypeOnlyAddress},
+		"AnyOfAddresses": {src: `"AnyOfAddresses"`, exp: AccessTypeAnyOfAddresses},
+		"Everybody":      {src: `"Everybody"`, exp: AccessTypeEverybody},
+		"unknown":        {src: `""`, exp: AccessTypeUnspecified},
+	}
+	for msg, spec := range specs {
+		t.Run(msg, func(t *testing.T) {
+			var got AccessType
+			err := json.Unmarshal([]byte(spec.src), &got)
+			require.NoError(t, err)
+			assert.Equal(t, spec.exp, got)
+		})
+	}
+}
+
+func TestParamsUnmarshalJson(t *testing.T) {
+	specs := map[string]struct {
+		src string
+		exp Params
+	}{
+		"defaults": {
+			src: `{"code_upload_access": {"permission": "Everybody"},
+				"instantiate_default_permission": "Everybody"}`,
+			exp: Params{
+				CodeUploadAccess:             AccessConfig{Permission: AccessTypeEverybody},
+				InstantiateDefaultPermission: AccessTypeEverybody,
+			},
+		},
+		"legacy type": {
+			src: `{"code_upload_access": {"permission": "OnlyAddress", "address": "wasm1lq3q55r9sqwqyrfmlp6xy8ufhayt96lmcttthz", "addresses": [] },
+					"instantiate_default_permission": "Nobody"}`,
+			exp: Params{
+				CodeUploadAccess: AccessConfig{
+					Permission: AccessTypeOnlyAddress, Address: "wasm1lq3q55r9sqwqyrfmlp6xy8ufhayt96lmcttthz", Addresses: nil,
+				},
+				InstantiateDefaultPermission: AccessTypeNobody,
+			},
+		},
+	}
+	for msg, spec := range specs {
+		t.Run(msg, func(t *testing.T) {
+			var val Params
+			marshaler := codec.NewLegacyAmino()
+			err := marshaler.UnmarshalJSON([]byte(spec.src), &val)
+			require.NoError(t, err)
+			assert.Equal(t, spec.exp, val)
+		})
+	}
+}

x/wasm/migrations/v2/store_test.go

@@ -1,6 +1,8 @@
 package v2_test
 
 import (
+	"github.com/cosmos/cosmos-sdk/runtime"
+	"github.com/cosmos/cosmos-sdk/testutil"
 	"testing"
 
 	"github.com/cometbft/cometbft/libs/rand"
@@ -9,51 +11,91 @@ import (
 
 	storetypes "cosmossdk.io/store/types"
 
-	"github.com/cosmos/cosmos-sdk/runtime"
-	"github.com/cosmos/cosmos-sdk/testutil"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/address"
 	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
+	paramskeeper "github.com/cosmos/cosmos-sdk/x/params/keeper"
+	paramstypes "github.com/cosmos/cosmos-sdk/x/params/types"
 
 	"github.com/CosmWasm/wasmd/x/wasm"
-	"github.com/CosmWasm/wasmd/x/wasm/exported"
 	v2 "github.com/CosmWasm/wasmd/x/wasm/migrations/v2"
 	"github.com/CosmWasm/wasmd/x/wasm/types"
 )
 
-type mockSubspace struct {
-	ps v2.Params
-}
+func TestMigrate(t *testing.T) {
+	cfg := moduletestutil.MakeTestEncodingConfig(wasm.AppModuleBasic{})
+	cdc := cfg.Codec
+	var (
+		wasmStoreKey    = storetypes.NewKVStoreKey(types.StoreKey)
+		paramsStoreKey  = storetypes.NewKVStoreKey(paramstypes.StoreKey)
+		paramsTStoreKey = storetypes.NewTransientStoreKey(paramstypes.TStoreKey)
+		myAddress       = sdk.AccAddress(rand.Bytes(address.Len))
+	)
+	specs := map[string]struct {
+		src v2.Params
+	}{
+		"one address": {
+			src: v2.Params{
+				CodeUploadAccess: v2.AccessConfig{
+					Permission: v2.AccessTypeOnlyAddress,
+					Address:    myAddress.String(),
+				},
+				InstantiateDefaultPermission: v2.AccessTypeNobody,
+			},
+		},
+		"multiple addresses": {
+			src: v2.Params{
+				CodeUploadAccess: v2.AccessConfig{
+					Permission: v2.AccessTypeAnyOfAddresses,
+					Addresses:  []string{myAddress.String(), sdk.AccAddress(rand.Bytes(address.Len)).String()},
+				},
+				InstantiateDefaultPermission: v2.AccessTypeEverybody,
+			},
+		},
+		"everybody": {
+			src: v2.Params{
+				CodeUploadAccess: v2.AccessConfig{
+					Permission: v2.AccessTypeEverybody,
+				},
+				InstantiateDefaultPermission: v2.AccessTypeEverybody,
+			},
+		},
+		"nobody": {
+			src: v2.Params{
+				CodeUploadAccess: v2.AccessConfig{
+					Permission: v2.AccessTypeNobody,
+				},
+				InstantiateDefaultPermission: v2.AccessTypeNobody,
+			},
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			paramsKeeper := paramskeeper.NewKeeper(cdc, cfg.Amino, paramsStoreKey, paramsTStoreKey)
+			ctx := testutil.DefaultContextWithKeys(
+				map[string]*storetypes.KVStoreKey{
+					paramstypes.StoreKey: paramsStoreKey,
+					types.StoreKey:       wasmStoreKey,
+				},
+				map[string]*storetypes.TransientStoreKey{
+					paramstypes.TStoreKey: paramsTStoreKey,
+				},
+				nil,
+			)
 
-func newMockSubspace(ps v2.Params) mockSubspace {
-	return mockSubspace{ps: ps}
-}
+			// register legacy parameters
+			params := spec.src
+			subspace := paramsKeeper.Subspace(types.ModuleName)
+			subspace.WithKeyTable(v2.ParamKeyTable())
+			subspace.SetParamSet(ctx, &params)
 
-func (ms mockSubspace) GetParamSet(ctx sdk.Context, ps exported.ParamSet) {
-	*ps.(*v2.Params) = ms.ps
-}
+			// when
+			require.NoError(t, v2.MigrateStore(ctx, runtime.NewKVStoreService(wasmStoreKey), subspace, cdc))
 
-func TestMigrate(t *testing.T) {
-	cdc := moduletestutil.MakeTestEncodingConfig(wasm.AppModuleBasic{}).Codec
-	storeKey := storetypes.NewKVStoreKey(types.StoreKey)
-	tKey := storetypes.NewTransientStoreKey("transient_test")
-	ctx := testutil.DefaultContext(storeKey, tKey)
-	store := ctx.KVStore(storeKey)
-
-	myAddress := sdk.AccAddress(rand.Bytes(address.Len))
-	params := v2.Params{
-		CodeUploadAccess: v2.AccessConfig{
-			Permission: v2.AccessTypeOnlyAddress,
-			Address:    myAddress.String(),
-		},
-		InstantiateDefaultPermission: v2.AccessTypeNobody,
+			var res v2.Params
+			bz := ctx.KVStore(wasmStoreKey).Get(types.ParamsKey)
+			require.NoError(t, cdc.Unmarshal(bz, &res))
+			assert.Equal(t, params, res)
+		})
 	}
-	legacySubspace := newMockSubspace(params)
-	// when
-	require.NoError(t, v2.MigrateStore(ctx, runtime.NewKVStoreService(storeKey), legacySubspace, cdc))
-
-	var res v2.Params
-	bz := store.Get(types.ParamsKey)
-	require.NoError(t, cdc.Unmarshal(bz, &res))
-	assert.Equal(t, params, res)
 }