cloudinit-bot
c97e18fc1f
---ci--- project: oy phase: 1 milestone: v0.5 status: complete requirements: covered: [REQ-033] partial: [] ---/ci---
516 lines
18 KiB
Go
516 lines
18 KiB
Go
package keeper_test
|
|
|
|
// msg_server_simtest_test.go is the x/exit keeper simtest (P1-06-01).
|
|
//
|
|
// D-054: simtest-grade — in-memory sdk.Context + dbm in-memory store, no
|
|
// real IBC light clients. The simtest wires the expected-keeper shim
|
|
// (BridgeKeeper) to an in-test stub (G-003 test exemption: the test imports
|
|
// x/exit/keeper + defines a stub BridgeKeeper that satisfies the interface;
|
|
// no production struct imports across x/<module>/types).
|
|
//
|
|
// Coverage (A-513, G-021):
|
|
// - ExitStatus lifecycle: Proposed → InProgress → Settled; Failed → Refunded.
|
|
// - Cross-chain exit via BridgeKeeper shim (G-003 test exemption — wired to
|
|
// a stub that returns Active status; the simtest asserts the shim is called).
|
|
// - Fee Covenant clamp event (exit-fee-bps clamped to [1, 10] bps).
|
|
// - Replay rejection (duplicate MsgExecuteDEXSwap on a Settled route is an
|
|
// error — the route is terminal).
|
|
|
|
import (
|
|
"encoding/json"
|
|
"testing"
|
|
|
|
"cosmossdk.io/log"
|
|
"cosmossdk.io/store"
|
|
storetypes "cosmossdk.io/store/types"
|
|
cmtproto "github.com/cometbft/cometbft/proto/tendermint/types"
|
|
dbm "github.com/cosmos/cosmos-db"
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
|
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
|
|
"github.com/oy/openyield/x/exit/keeper"
|
|
exittypes "github.com/oy/openyield/x/exit/types"
|
|
)
|
|
|
|
// --- Stub expected-keeper (G-003 test exemption) -----------------------------
|
|
|
|
// stubBridgeKeeper satisfies exittypes.BridgeKeeper for the simtest. It
|
|
// records GetBridgeRoute calls and returns the configured status/bridge-type.
|
|
type stubBridgeKeeper struct {
|
|
// routes maps bridge-id → (status, bridgeType).
|
|
routes map[string]stubBridgeRoute
|
|
calls int
|
|
}
|
|
|
|
type stubBridgeRoute struct {
|
|
status string
|
|
bridgeType string
|
|
}
|
|
|
|
func (s *stubBridgeKeeper) GetBridgeRoute(routeID string) (status string, bridgeType string, err error) {
|
|
s.calls++
|
|
r, ok := s.routes[routeID]
|
|
if !ok {
|
|
return "", "", nil // not found: status "" → handler fails the exit
|
|
}
|
|
return r.status, r.bridgeType, nil
|
|
}
|
|
|
|
// --- Simtest context helper --------------------------------------------------
|
|
|
|
// newSimtestContext constructs an in-memory sdk.Context with a KVStore mounted
|
|
// at the exit store key. D-054: in-memory, no real IBC light clients.
|
|
func newSimtestContext(t *testing.T) (sdk.Context, *stubBridgeKeeper, keeper.Keeper) {
|
|
t.Helper()
|
|
db := dbm.NewMemDB()
|
|
cdc := newTestCodec()
|
|
storeKey := storetypes.NewKVStoreKey(exittypes.StoreKey)
|
|
cms := store.NewCommitMultiStore(db, log.NewNopLogger(), nil)
|
|
cms.MountStoreWithDB(storeKey, storetypes.StoreTypeDB, nil)
|
|
if err := cms.LoadLatestVersion(); err != nil {
|
|
t.Fatalf("load latest version: %v", err)
|
|
}
|
|
ctx := sdk.NewContext(cms, cmtproto.Header{}, false, log.NewNopLogger())
|
|
|
|
bk := &stubBridgeKeeper{routes: map[string]stubBridgeRoute{}}
|
|
k := keeper.NewKeeper(cdc, storeKey, bk)
|
|
return ctx, bk, k
|
|
}
|
|
|
|
// newTestCodec constructs a minimal codec for the simtest.
|
|
func newTestCodec() codec.Codec {
|
|
registry := codectypes.NewInterfaceRegistry()
|
|
return codec.NewProtoCodec(registry)
|
|
}
|
|
|
|
// hasEvent reports whether ctx emitted an event of the given type.
|
|
func hasEvent(ctx sdk.Context, eventType string) bool {
|
|
for _, ev := range ctx.EventManager().Events() {
|
|
if ev.Type == eventType {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// eventAttr returns the value of an attribute on the last event of the given
|
|
// type, or "" if not found.
|
|
func eventAttr(ctx sdk.Context, eventType, attrKey string) string {
|
|
for _, ev := range ctx.EventManager().Events() {
|
|
if ev.Type == eventType {
|
|
for _, a := range ev.Attributes {
|
|
if string(a.Key) == attrKey {
|
|
return string(a.Value)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// --- ExitStatus lifecycle: Proposed → InProgress → Settled -------------------
|
|
|
|
// TestExitStatusLifecycleProposedToSettled asserts the full success lifecycle:
|
|
// SubmitExitRoute (Proposed) → ExecuteDEXSwap (InProgress → Settled). The
|
|
// DEXSwap record is produced. The Fee Covenant clamp event is emitted.
|
|
func TestExitStatusLifecycleProposedToSettled(t *testing.T) {
|
|
ctx, _, k := newSimtestContext(t)
|
|
srv := keeper.NewMsgServerImpl(k)
|
|
|
|
// SubmitExitRoute → Proposed.
|
|
if _, err := srv.SubmitExitRoute(ctx, &exittypes.MsgSubmitExitRoute{
|
|
RouteID: "route-1", HolderReachID: "holder-1",
|
|
SourceAsset: "ubread", DestAsset: "uatom", Amount: 500, Signer: "holder-1",
|
|
}); err != nil {
|
|
t.Fatalf("SubmitExitRoute: %v", err)
|
|
}
|
|
r, ok := k.GetExitRoute(ctx, "route-1")
|
|
if !ok {
|
|
t.Fatal("route not found after submit")
|
|
}
|
|
if r.Status != exittypes.ExitProposed {
|
|
t.Errorf("status = %q, want Proposed", r.Status)
|
|
}
|
|
if !hasEvent(ctx, "exit.submit_route") {
|
|
t.Error("submit_route event not emitted")
|
|
}
|
|
|
|
// ExecuteDEXSwap → InProgress → Settled (same-chain exit, no bridge-route-id).
|
|
if _, err := srv.ExecuteDEXSwap(ctx, &exittypes.MsgExecuteDEXSwap{
|
|
RouteID: "route-1", Venue: "uniswap-v3:5", Signer: "holder-1",
|
|
}); err != nil {
|
|
t.Fatalf("ExecuteDEXSwap: %v", err)
|
|
}
|
|
r, _ = k.GetExitRoute(ctx, "route-1")
|
|
if r.Status != exittypes.ExitSettled {
|
|
t.Errorf("status = %q, want Settled", r.Status)
|
|
}
|
|
|
|
// DEXSwap record produced.
|
|
swap, ok := k.GetDEXSwap(ctx, "route-1-swap")
|
|
if !ok {
|
|
t.Fatal("DEXSwap record not produced")
|
|
}
|
|
if swap.Status != exittypes.ExitSettled {
|
|
t.Errorf("swap status = %q, want Settled", swap.Status)
|
|
}
|
|
|
|
// Fee Covenant clamp event emitted (5 bps → within [1,10], no clamp).
|
|
if !hasEvent(ctx, "exit.fee_covenant_clamp") {
|
|
t.Error("fee_covenant_clamp event not emitted")
|
|
}
|
|
if !hasEvent(ctx, "exit.settled") {
|
|
t.Error("settled event not emitted")
|
|
}
|
|
}
|
|
|
|
// TestFeeCovenantClampHighFee asserts a fee above the ceiling (10 bps) is
|
|
// clamped to the ceiling (10 bps) — the Fee Covenant auto-decline-only rule.
|
|
func TestFeeCovenantClampHighFee(t *testing.T) {
|
|
ctx, _, k := newSimtestContext(t)
|
|
srv := keeper.NewMsgServerImpl(k)
|
|
|
|
srv.SubmitExitRoute(ctx, &exittypes.MsgSubmitExitRoute{
|
|
RouteID: "route-clamp-hi", HolderReachID: "h",
|
|
SourceAsset: "ubread", DestAsset: "uatom", Amount: 100, Signer: "h",
|
|
})
|
|
srv.ExecuteDEXSwap(ctx, &exittypes.MsgExecuteDEXSwap{
|
|
RouteID: "route-clamp-hi", Venue: "venue:99", Signer: "h", // 99 bps → clamped to 10
|
|
})
|
|
|
|
clamped := eventAttr(ctx, "exit.fee_covenant_clamp", "fee_bps_clamped")
|
|
if clamped != "10" {
|
|
t.Errorf("fee should be clamped to 10 (ceiling); got %q", clamped)
|
|
}
|
|
requested := eventAttr(ctx, "exit.fee_covenant_clamp", "fee_bps_requested")
|
|
if requested != "99" {
|
|
t.Errorf("fee requested = %q, want 99", requested)
|
|
}
|
|
}
|
|
|
|
// TestFeeCovenantClampLowFee asserts a fee below the floor (1 bps) is clamped
|
|
// up to the floor (1 bps) — the Fee Covenant never-below-floor rule.
|
|
func TestFeeCovenantClampLowFee(t *testing.T) {
|
|
ctx, _, k := newSimtestContext(t)
|
|
srv := keeper.NewMsgServerImpl(k)
|
|
|
|
srv.SubmitExitRoute(ctx, &exittypes.MsgSubmitExitRoute{
|
|
RouteID: "route-clamp-lo", HolderReachID: "h",
|
|
SourceAsset: "ubread", DestAsset: "uatom", Amount: 100, Signer: "h",
|
|
})
|
|
srv.ExecuteDEXSwap(ctx, &exittypes.MsgExecuteDEXSwap{
|
|
RouteID: "route-clamp-lo", Venue: "venue:0", Signer: "h", // 0 bps → clamped to 1
|
|
})
|
|
|
|
clamped := eventAttr(ctx, "exit.fee_covenant_clamp", "fee_bps_clamped")
|
|
if clamped != "1" {
|
|
t.Errorf("fee should be clamped to 1 (floor); got %q", clamped)
|
|
}
|
|
}
|
|
|
|
// TestFeeCovenantClampInBand asserts a fee within [1, 10] bps is unchanged.
|
|
func TestFeeCovenantClampInBand(t *testing.T) {
|
|
ctx, _, k := newSimtestContext(t)
|
|
srv := keeper.NewMsgServerImpl(k)
|
|
|
|
srv.SubmitExitRoute(ctx, &exittypes.MsgSubmitExitRoute{
|
|
RouteID: "route-band", HolderReachID: "h",
|
|
SourceAsset: "ubread", DestAsset: "uatom", Amount: 100, Signer: "h",
|
|
})
|
|
srv.ExecuteDEXSwap(ctx, &exittypes.MsgExecuteDEXSwap{
|
|
RouteID: "route-band", Venue: "venue:5", Signer: "h", // 5 bps → in-band, unchanged
|
|
})
|
|
|
|
clamped := eventAttr(ctx, "exit.fee_covenant_clamp", "fee_bps_clamped")
|
|
if clamped != "5" {
|
|
t.Errorf("fee in-band should be unchanged at 5; got %q", clamped)
|
|
}
|
|
}
|
|
|
|
// --- ExitStatus lifecycle: Failed → Refunded ---------------------------------
|
|
|
|
// TestExitStatusLifecycleFailedToRefunded asserts the failure/refund path:
|
|
// SubmitExitRoute (Proposed) → cross-chain ExecuteDEXSwap with a non-Active
|
|
// bridge route → Failed → RefundExit → Refunded.
|
|
func TestExitStatusLifecycleFailedToRefunded(t *testing.T) {
|
|
ctx, bk, k := newSimtestContext(t)
|
|
srv := keeper.NewMsgServerImpl(k)
|
|
|
|
// Submit a cross-chain exit route (with a bridge-route-id).
|
|
srv.SubmitExitRoute(ctx, &exittypes.MsgSubmitExitRoute{
|
|
RouteID: "route-fail", HolderReachID: "h",
|
|
SourceAsset: "ubread", DestAsset: "uatom", Amount: 200, Signer: "h",
|
|
})
|
|
// Set the bridge-route-id on the route (simtest sets it directly; the real
|
|
// handler sets it at submit time from the route params).
|
|
r, _ := k.GetExitRoute(ctx, "route-fail")
|
|
r.BridgeRouteID = "bridge-fail-1"
|
|
k.SetExitRoute(ctx, r)
|
|
|
|
// Stub bridge returns a non-Active status (Closed) → exit fails.
|
|
bk.routes["bridge-fail-1"] = stubBridgeRoute{status: "Closed", bridgeType: "evm-ibc"}
|
|
|
|
srv.ExecuteDEXSwap(ctx, &exittypes.MsgExecuteDEXSwap{
|
|
RouteID: "route-fail", Venue: "venue:3", Signer: "h",
|
|
})
|
|
r, _ = k.GetExitRoute(ctx, "route-fail")
|
|
if r.Status != exittypes.ExitFailed {
|
|
t.Errorf("status = %q, want Failed", r.Status)
|
|
}
|
|
if !hasEvent(ctx, "exit.failed") {
|
|
t.Error("failed event not emitted")
|
|
}
|
|
|
|
// RefundExit → Refunded.
|
|
if _, err := srv.RefundExit(ctx, &exittypes.MsgRefundExit{
|
|
RouteID: "route-fail", Signer: "h",
|
|
}); err != nil {
|
|
t.Fatalf("RefundExit: %v", err)
|
|
}
|
|
r, _ = k.GetExitRoute(ctx, "route-fail")
|
|
if r.Status != exittypes.ExitRefunded {
|
|
t.Errorf("status = %q, want Refunded", r.Status)
|
|
}
|
|
if !hasEvent(ctx, "exit.refunded") {
|
|
t.Error("refunded event not emitted")
|
|
}
|
|
}
|
|
|
|
// TestCrossChainExitActiveBridge asserts a cross-chain exit with an Active
|
|
// bridge route succeeds (Settled), invoking the BridgeKeeper shim.
|
|
func TestCrossChainExitActiveBridge(t *testing.T) {
|
|
ctx, bk, k := newSimtestContext(t)
|
|
srv := keeper.NewMsgServerImpl(k)
|
|
|
|
srv.SubmitExitRoute(ctx, &exittypes.MsgSubmitExitRoute{
|
|
RouteID: "route-xchain", HolderReachID: "h",
|
|
SourceAsset: "ubread", DestAsset: "uatom", Amount: 300, Signer: "h",
|
|
})
|
|
r, _ := k.GetExitRoute(ctx, "route-xchain")
|
|
r.BridgeRouteID = "bridge-active-1"
|
|
k.SetExitRoute(ctx, r)
|
|
bk.routes["bridge-active-1"] = stubBridgeRoute{status: "Active", bridgeType: "evm-ibc"}
|
|
|
|
srv.ExecuteDEXSwap(ctx, &exittypes.MsgExecuteDEXSwap{
|
|
RouteID: "route-xchain", Venue: "venue:5", Signer: "h",
|
|
})
|
|
r, _ = k.GetExitRoute(ctx, "route-xchain")
|
|
if r.Status != exittypes.ExitSettled {
|
|
t.Errorf("cross-chain exit with Active bridge should Settle; got %q", r.Status)
|
|
}
|
|
if bk.calls == 0 {
|
|
t.Error("BridgeKeeper.GetBridgeRoute was not called (G-003 shim not invoked)")
|
|
}
|
|
}
|
|
|
|
// --- Replay rejection --------------------------------------------------------
|
|
|
|
// TestReplayRejectedOnSettledRoute asserts a duplicate ExecuteDEXSwap on a
|
|
// Settled route returns an error (the route is terminal — replay rejection).
|
|
func TestReplayRejectedOnSettledRoute(t *testing.T) {
|
|
ctx, _, k := newSimtestContext(t)
|
|
srv := keeper.NewMsgServerImpl(k)
|
|
|
|
srv.SubmitExitRoute(ctx, &exittypes.MsgSubmitExitRoute{
|
|
RouteID: "route-replay", HolderReachID: "h",
|
|
SourceAsset: "ubread", DestAsset: "uatom", Amount: 100, Signer: "h",
|
|
})
|
|
srv.ExecuteDEXSwap(ctx, &exittypes.MsgExecuteDEXSwap{
|
|
RouteID: "route-replay", Venue: "venue:5", Signer: "h",
|
|
})
|
|
// Second ExecuteDEXSwap on Settled route → error (replay rejection).
|
|
_, err := srv.ExecuteDEXSwap(ctx, &exittypes.MsgExecuteDEXSwap{
|
|
RouteID: "route-replay", Venue: "venue:5", Signer: "h",
|
|
})
|
|
if err == nil {
|
|
t.Error("duplicate ExecuteDEXSwap on Settled route should return error (replay rejection)")
|
|
}
|
|
}
|
|
|
|
// TestRefundExitRejectsNonFailed asserts RefundExit rejects a route that is
|
|
// not Failed.
|
|
func TestRefundExitRejectsNonFailed(t *testing.T) {
|
|
ctx, _, k := newSimtestContext(t)
|
|
srv := keeper.NewMsgServerImpl(k)
|
|
|
|
srv.SubmitExitRoute(ctx, &exittypes.MsgSubmitExitRoute{
|
|
RouteID: "route-refund-bad", HolderReachID: "h",
|
|
SourceAsset: "ubread", DestAsset: "uatom", Amount: 100, Signer: "h",
|
|
})
|
|
_, err := srv.RefundExit(ctx, &exittypes.MsgRefundExit{
|
|
RouteID: "route-refund-bad", Signer: "h",
|
|
})
|
|
if err == nil {
|
|
t.Error("RefundExit should reject a Proposed route (must be Failed)")
|
|
}
|
|
}
|
|
|
|
// --- SubmitExitRoute validation ----------------------------------------------
|
|
|
|
func TestSubmitExitRouteRejectsDuplicate(t *testing.T) {
|
|
ctx, _, k := newSimtestContext(t)
|
|
srv := keeper.NewMsgServerImpl(k)
|
|
srv.SubmitExitRoute(ctx, &exittypes.MsgSubmitExitRoute{
|
|
RouteID: "dup", HolderReachID: "h", SourceAsset: "a", DestAsset: "b", Amount: 1, Signer: "h",
|
|
})
|
|
_, err := srv.SubmitExitRoute(ctx, &exittypes.MsgSubmitExitRoute{
|
|
RouteID: "dup", HolderReachID: "h", SourceAsset: "a", DestAsset: "b", Amount: 1, Signer: "h",
|
|
})
|
|
if err == nil {
|
|
t.Error("SubmitExitRoute should reject a duplicate route-id")
|
|
}
|
|
}
|
|
|
|
// --- ValidateBasic (Msg types) -----------------------------------------------
|
|
|
|
func TestMsgSubmitExitRouteValidateBasic(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
msg exittypes.MsgSubmitExitRoute
|
|
ok bool
|
|
}{
|
|
{"valid", exittypes.MsgSubmitExitRoute{"r1", "h", "a", "b", 100, "s"}, true},
|
|
{"empty holder", exittypes.MsgSubmitExitRoute{"r1", "", "a", "b", 100, "s"}, false},
|
|
{"empty source", exittypes.MsgSubmitExitRoute{"r1", "h", "", "b", 100, "s"}, false},
|
|
{"empty dest", exittypes.MsgSubmitExitRoute{"r1", "h", "a", "", 100, "s"}, false},
|
|
{"zero amount", exittypes.MsgSubmitExitRoute{"r1", "h", "a", "b", 0, "s"}, false},
|
|
{"neg amount", exittypes.MsgSubmitExitRoute{"r1", "h", "a", "b", -1, "s"}, false},
|
|
{"empty signer", exittypes.MsgSubmitExitRoute{"r1", "h", "a", "b", 100, ""}, false},
|
|
}
|
|
for _, c := range cases {
|
|
err := c.msg.ValidateBasic()
|
|
if c.ok && err != nil {
|
|
t.Errorf("%s: expected ok, got %v", c.name, err)
|
|
}
|
|
if !c.ok && err == nil {
|
|
t.Errorf("%s: expected error, got nil", c.name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMsgExecuteDEXSwapValidateBasic(t *testing.T) {
|
|
if err := (&exittypes.MsgExecuteDEXSwap{RouteID: "r1", Signer: "s"}).ValidateBasic(); err != nil {
|
|
t.Errorf("valid: %v", err)
|
|
}
|
|
if err := (&exittypes.MsgExecuteDEXSwap{RouteID: "", Signer: "s"}).ValidateBasic(); err == nil {
|
|
t.Error("empty route-id should fail")
|
|
}
|
|
if err := (&exittypes.MsgExecuteDEXSwap{RouteID: "r1", Signer: ""}).ValidateBasic(); err == nil {
|
|
t.Error("empty signer should fail")
|
|
}
|
|
}
|
|
|
|
func TestMsgRefundExitValidateBasic(t *testing.T) {
|
|
if err := (&exittypes.MsgRefundExit{RouteID: "r1", Signer: "s"}).ValidateBasic(); err != nil {
|
|
t.Errorf("valid: %v", err)
|
|
}
|
|
if err := (&exittypes.MsgRefundExit{RouteID: "", Signer: "s"}).ValidateBasic(); err == nil {
|
|
t.Error("empty route-id should fail")
|
|
}
|
|
}
|
|
|
|
func TestExitMsgGetSigners(t *testing.T) {
|
|
m := &exittypes.MsgSubmitExitRoute{Signer: "holder-reach"}
|
|
addrs := m.GetSigners()
|
|
if len(addrs) != 1 || string(addrs[0]) != "holder-reach" {
|
|
t.Errorf("GetSigners = %v, want [holder-reach]", addrs)
|
|
}
|
|
}
|
|
|
|
// --- Keeper store helpers ----------------------------------------------------
|
|
|
|
func TestSetGetExitRoute(t *testing.T) {
|
|
ctx, _, k := newSimtestContext(t)
|
|
r := exittypes.ExitRoute{RouteID: "r9", Status: exittypes.ExitProposed}
|
|
k.SetExitRoute(ctx, r)
|
|
got, ok := k.GetExitRoute(ctx, "r9")
|
|
if !ok {
|
|
t.Fatal("GetExitRoute: not found")
|
|
}
|
|
if got.Status != exittypes.ExitProposed {
|
|
t.Errorf("status = %q", got.Status)
|
|
}
|
|
if _, ok := k.GetExitRoute(ctx, "missing"); ok {
|
|
t.Error("GetExitRoute should return false for missing route")
|
|
}
|
|
}
|
|
|
|
func TestSetGetDEXSwap(t *testing.T) {
|
|
ctx, _, k := newSimtestContext(t)
|
|
s := exittypes.DEXSwap{SwapID: "s9", Venue: "oy-dex", Status: exittypes.ExitSettled}
|
|
k.SetDEXSwap(ctx, s)
|
|
got, ok := k.GetDEXSwap(ctx, "s9")
|
|
if !ok {
|
|
t.Fatal("GetDEXSwap: not found")
|
|
}
|
|
if got.Venue != "oy-dex" {
|
|
t.Errorf("venue = %q", got.Venue)
|
|
}
|
|
}
|
|
|
|
func TestAllExitRoutesAndSwaps(t *testing.T) {
|
|
ctx, _, k := newSimtestContext(t)
|
|
k.SetExitRoute(ctx, exittypes.ExitRoute{RouteID: "r1", Status: exittypes.ExitProposed})
|
|
k.SetExitRoute(ctx, exittypes.ExitRoute{RouteID: "r2", Status: exittypes.ExitSettled})
|
|
k.SetDEXSwap(ctx, exittypes.DEXSwap{SwapID: "s1", Venue: "v"})
|
|
if len(k.AllExitRoutes(ctx)) != 2 {
|
|
t.Errorf("expected 2 routes")
|
|
}
|
|
if len(k.AllDEXSwaps(ctx)) != 1 {
|
|
t.Errorf("expected 1 swap")
|
|
}
|
|
}
|
|
|
|
// --- Cross-chain exit: nil shim handling -------------------------------------
|
|
|
|
// TestCrossChainExitNilBridgeShimFails asserts a cross-chain exit with a nil
|
|
// BridgeKeeper shim fails the route (not a panic).
|
|
func TestCrossChainExitNilBridgeShimFails(t *testing.T) {
|
|
ctx, _, k := newSimtestContext(t)
|
|
srv := keeper.NewMsgServerImpl(k)
|
|
// Clear the bridge shim to simulate unwired.
|
|
k.SetBridgeKeeper(nil)
|
|
|
|
srv.SubmitExitRoute(ctx, &exittypes.MsgSubmitExitRoute{
|
|
RouteID: "route-noshim", HolderReachID: "h",
|
|
SourceAsset: "ubread", DestAsset: "uatom", Amount: 100, Signer: "h",
|
|
})
|
|
r, _ := k.GetExitRoute(ctx, "route-noshim")
|
|
r.BridgeRouteID = "bridge-x"
|
|
k.SetExitRoute(ctx, r)
|
|
|
|
_, err := srv.ExecuteDEXSwap(ctx, &exittypes.MsgExecuteDEXSwap{
|
|
RouteID: "route-noshim", Venue: "venue:5", Signer: "h",
|
|
})
|
|
if err != nil {
|
|
t.Errorf("ExecuteDEXSwap with nil shim should not return error (route fails to Failed); got %v", err)
|
|
}
|
|
r, _ = k.GetExitRoute(ctx, "route-noshim")
|
|
if r.Status != exittypes.ExitFailed {
|
|
t.Errorf("cross-chain exit with nil shim should fail; got %q", r.Status)
|
|
}
|
|
}
|
|
|
|
// --- JSON marshal/unmarshal for the InflightPacket (bridge) sanity -----------
|
|
|
|
// TestInflightPacketJSON asserts the InflightPacket JSON round-trips (the
|
|
// keeper uses json.Marshal/Unmarshal).
|
|
func TestInflightPacketJSON(t *testing.T) {
|
|
p := struct {
|
|
SourcePort string
|
|
Amount int64
|
|
}{"transfer", 100}
|
|
bz, _ := json.Marshal(p)
|
|
var got struct {
|
|
SourcePort string
|
|
Amount int64
|
|
}
|
|
if err := json.Unmarshal(bz, &got); err != nil {
|
|
t.Fatalf("unmarshal: %v", err)
|
|
}
|
|
if got.SourcePort != "transfer" || got.Amount != 100 {
|
|
t.Errorf("round-trip mismatch: %+v", got)
|
|
}
|
|
}
|