From debff298b997d3def035122eed0d9da5d0897f12 Mon Sep 17 00:00:00 2001 From: Daniel Wedul Date: Tue, 26 Sep 2023 12:25:20 -0600 Subject: [PATCH] [1658]: Unit tests on GetAsset/PriceTransfer. --- x/exchange/fulfillment_test.go | 485 ++++++++++++++++++++++++++++++++- x/exchange/orders_test.go | 10 +- 2 files changed, 484 insertions(+), 11 deletions(-) diff --git a/x/exchange/fulfillment_test.go b/x/exchange/fulfillment_test.go index 71ebaee48a..aa7bbbc27b 100644 --- a/x/exchange/fulfillment_test.go +++ b/x/exchange/fulfillment_test.go @@ -1455,6 +1455,487 @@ func TestIndexedAddrAmts_GetAsOutputs(t *testing.T) { // TODO[1658]: func TestBuildSettlementTransfers(t *testing.T) -// TODO[1658]: func TestGetAssetTransfer(t *testing.T) +func transferString(t *Transfer) string { + if t == nil { + return "nil" + } + inputs := "nil" + if t.Inputs != nil { + inputVals := make([]string, len(t.Inputs)) + for i, input := range t.Inputs { + inputVals[i] = bankInputString(input) + } + inputs = strings.Join(inputVals, ", ") + } + outputs := "nil" + if t.Outputs != nil { + outputVals := make([]string, len(t.Outputs)) + for i, output := range t.Outputs { + outputVals[i] = bankOutputString(output) + } + outputs = strings.Join(outputVals, ", ") + } + return fmt.Sprintf("{Inputs:%s, Outputs: %s}", inputs, outputs) +} + +// bankInputString is similar to %v except with easier to understand Coin entries. +func bankInputString(i banktypes.Input) string { + return fmt.Sprintf("I{Address:%q,Coins:%q}", i.Address, i.Coins) +} + +// bankOutputString is similar to %v except with easier to understand Coin entries. +func bankOutputString(o banktypes.Output) string { + return fmt.Sprintf("O{Address:%q,Coins:%q}", o.Address, o.Coins) +} + +func TestGetAssetTransfer(t *testing.T) { + coin := func(amt int64, denom string) sdk.Coin { + return sdk.Coin{Denom: denom, Amount: sdkmath.NewInt(amt)} + } + igc := coin(2468, "ignorable") // igc => "ignorable coin" + askOrder := func(orderID uint64, seller string, assets sdk.Coin) *Order { + return NewOrder(orderID).WithAsk(&AskOrder{ + Seller: seller, + Assets: assets, + }) + } + bidOrder := func(orderID uint64, buyer string, assets sdk.Coin) *Order { + return NewOrder(orderID).WithBid(&BidOrder{ + Buyer: buyer, + Assets: assets, + }) + } + orderSplit := func(order *Order, assets sdk.Coin) *OrderSplit { + return &OrderSplit{ + Order: &OrderFulfillment{Order: order}, + Assets: assets, + Price: igc, + } + } + input := func(addr string, coins ...sdk.Coin) banktypes.Input { + return banktypes.Input{Address: addr, Coins: coins} + } + output := func(addr string, coins ...sdk.Coin) banktypes.Output { + return banktypes.Output{Address: addr, Coins: coins} + } + + tests := []struct { + name string + f *OrderFulfillment + exp *Transfer + expPanic string + }{ + { + name: "ask, one split", + f: &OrderFulfillment{ + Order: askOrder(1, "seller", coin(25, "carrot")), + AssetsFilledAmt: sdkmath.NewInt(33), + Splits: []*OrderSplit{orderSplit(bidOrder(2, "buyer", igc), coin(88, "banana"))}, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("seller", coin(33, "carrot"))}, + Outputs: []banktypes.Output{output("buyer", coin(88, "banana"))}, + }, + }, + { + name: "ask, two splits diff addrs", + f: &OrderFulfillment{ + Order: askOrder(3, "SELLER", coin(26, "carrot")), + AssetsFilledAmt: sdkmath.NewInt(4321), + Splits: []*OrderSplit{ + orderSplit(bidOrder(4, "buyer 1", igc), coin(89, "banana")), + orderSplit(bidOrder(5, "second buyer", igc), coin(45, "apple")), + }, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("SELLER", coin(4321, "carrot"))}, + Outputs: []banktypes.Output{ + output("buyer 1", coin(89, "banana")), + output("second buyer", coin(45, "apple")), + }, + }, + }, + { + name: "ask, two splits same addr, two denoms", + f: &OrderFulfillment{ + Order: askOrder(6, "SeLleR", coin(27, "carrot")), + AssetsFilledAmt: sdkmath.NewInt(5511), + Splits: []*OrderSplit{ + orderSplit(bidOrder(7, "buyer", igc), coin(90, "banana")), + orderSplit(bidOrder(8, "buyer", igc), coin(46, "apple")), + }, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("SeLleR", coin(5511, "carrot"))}, + Outputs: []banktypes.Output{output("buyer", coin(46, "apple"), coin(90, "banana"))}, + }, + }, + { + name: "ask, two splits same addr, one denom", + f: &OrderFulfillment{ + Order: askOrder(9, "sellsell", coin(28, "carrot")), + AssetsFilledAmt: sdkmath.NewInt(42), + Splits: []*OrderSplit{ + orderSplit(bidOrder(10, "buybuy", igc), coin(55, "apple")), + orderSplit(bidOrder(11, "buybuy", igc), coin(34, "apple")), + }, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("sellsell", coin(42, "carrot"))}, + Outputs: []banktypes.Output{output("buybuy", coin(89, "apple"))}, + }, + }, + { + name: "ask, negative price in split", + f: &OrderFulfillment{ + Order: askOrder(12, "goodsell", coin(29, "carrot")), + AssetsFilledAmt: sdkmath.NewInt(91), + Splits: []*OrderSplit{orderSplit(bidOrder(13, "buygood", igc), coin(-4, "banana"))}, + }, + expPanic: "cannot index and add invalid coin amount \"-4banana\"", + }, + { + name: "ask, negative price applied", + f: &OrderFulfillment{ + Order: askOrder(14, "solong", coin(30, "carrot")), + AssetsFilledAmt: sdkmath.NewInt(-5), + Splits: []*OrderSplit{orderSplit(bidOrder(15, "hello", igc), coin(66, "banana"))}, + }, + expPanic: "invalid coin set -5carrot: coin -5carrot amount is not positive", + }, + + { + name: "bid, one split", + f: &OrderFulfillment{ + Order: bidOrder(1, "buyer", coin(25, "carrot")), + AssetsFilledAmt: sdkmath.NewInt(33), + Splits: []*OrderSplit{orderSplit(askOrder(2, "seller", igc), coin(88, "banana"))}, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("seller", coin(88, "banana"))}, + Outputs: []banktypes.Output{output("buyer", coin(33, "carrot"))}, + }, + }, + { + name: "bid, two splits diff addrs", + f: &OrderFulfillment{ + Order: bidOrder(3, "BUYER", coin(26, "carrot")), + AssetsFilledAmt: sdkmath.NewInt(4321), + Splits: []*OrderSplit{ + orderSplit(askOrder(4, "seller 1", igc), coin(89, "banana")), + orderSplit(askOrder(5, "second seller", igc), coin(45, "apple")), + }, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{ + input("seller 1", coin(89, "banana")), + input("second seller", coin(45, "apple")), + }, + Outputs: []banktypes.Output{output("BUYER", coin(4321, "carrot"))}, + }, + }, + { + name: "bid, two splits same addr, two denoms", + f: &OrderFulfillment{ + Order: bidOrder(6, "BuYeR", coin(27, "carrot")), + AssetsFilledAmt: sdkmath.NewInt(5511), + Splits: []*OrderSplit{ + orderSplit(askOrder(7, "seller", igc), coin(90, "banana")), + orderSplit(askOrder(8, "seller", igc), coin(46, "apple")), + }, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("seller", coin(46, "apple"), coin(90, "banana"))}, + Outputs: []banktypes.Output{output("BuYeR", coin(5511, "carrot"))}, + }, + }, + { + name: "bid, two splits same addr, one denom", + f: &OrderFulfillment{ + Order: bidOrder(9, "buybuy", coin(28, "carrot")), + AssetsFilledAmt: sdkmath.NewInt(42), + Splits: []*OrderSplit{ + orderSplit(bidOrder(10, "sellsell", igc), coin(55, "apple")), + orderSplit(bidOrder(11, "sellsell", igc), coin(34, "apple")), + }, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("sellsell", coin(89, "apple"))}, + Outputs: []banktypes.Output{output("buybuy", coin(42, "carrot"))}, + }, + }, + { + name: "bid, negative price in split", + f: &OrderFulfillment{ + Order: bidOrder(12, "goodbuy", coin(29, "carrot")), + AssetsFilledAmt: sdkmath.NewInt(91), + Splits: []*OrderSplit{orderSplit(askOrder(13, "sellgood", igc), coin(-4, "banana"))}, + }, + expPanic: "cannot index and add invalid coin amount \"-4banana\"", + }, + { + name: "bid, negative price applied", + f: &OrderFulfillment{ + Order: bidOrder(14, "heythere", coin(30, "carrot")), + AssetsFilledAmt: sdkmath.NewInt(-5), + Splits: []*OrderSplit{orderSplit(askOrder(15, "afterwhile", igc), coin(66, "banana"))}, + }, + expPanic: "invalid coin set -5carrot: coin -5carrot amount is not positive", + }, + + { + name: "nil inside order", + f: &OrderFulfillment{Order: NewOrder(20)}, + expPanic: "unknown order type ", + }, + { + name: "unknown inside order", + f: &OrderFulfillment{Order: &Order{OrderId: 21, Order: &unknownOrderType{}}}, + expPanic: "unknown order type *exchange.unknownOrderType", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + var actual *Transfer + defer func() { + if t.Failed() { + t.Logf(" Actual: %s", transferString(actual)) + t.Logf("Expected: %s", transferString(tc.exp)) + t.Logf("OrderFulfillment: %s", orderFulfillmentString(tc.f)) + } + }() + testFunc := func() { + actual = GetAssetTransfer(tc.f) + } + assertions.RequirePanicEquals(t, testFunc, tc.expPanic, "GetAssetTransfer") + assert.Equal(t, tc.exp, actual, "GetAssetTransfer") + }) + } +} -// TODO[1658]: func TestGetPriceTransfer(t *testing.T) +func TestGetPriceTransfer(t *testing.T) { + coin := func(amt int64, denom string) sdk.Coin { + return sdk.Coin{Denom: denom, Amount: sdkmath.NewInt(amt)} + } + igc := coin(2468, "ignorable") // igc => "ignorable coin" + askOrder := func(orderID uint64, seller string, price sdk.Coin) *Order { + return NewOrder(orderID).WithAsk(&AskOrder{ + Seller: seller, + Price: price, + }) + } + bidOrder := func(orderID uint64, buyer string, price sdk.Coin) *Order { + return NewOrder(orderID).WithBid(&BidOrder{ + Buyer: buyer, + Price: price, + }) + } + orderSplit := func(order *Order, price sdk.Coin) *OrderSplit { + return &OrderSplit{ + Order: &OrderFulfillment{Order: order}, + Price: price, + Assets: igc, + } + } + input := func(addr string, coins ...sdk.Coin) banktypes.Input { + return banktypes.Input{Address: addr, Coins: coins} + } + output := func(addr string, coins ...sdk.Coin) banktypes.Output { + return banktypes.Output{Address: addr, Coins: coins} + } + + tests := []struct { + name string + f *OrderFulfillment + exp *Transfer + expPanic string + }{ + { + name: "ask, one split", + f: &OrderFulfillment{ + Order: askOrder(1, "seller", coin(25, "carrot")), + PriceAppliedAmt: sdkmath.NewInt(33), + Splits: []*OrderSplit{orderSplit(bidOrder(2, "buyer", igc), coin(88, "banana"))}, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("buyer", coin(88, "banana"))}, + Outputs: []banktypes.Output{output("seller", coin(33, "carrot"))}, + }, + }, + { + name: "ask, two splits diff addrs", + f: &OrderFulfillment{ + Order: askOrder(3, "SELLER", coin(26, "carrot")), + PriceAppliedAmt: sdkmath.NewInt(4321), + Splits: []*OrderSplit{ + orderSplit(bidOrder(4, "buyer 1", igc), coin(89, "banana")), + orderSplit(bidOrder(5, "second buyer", igc), coin(45, "apple")), + }, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{ + input("buyer 1", coin(89, "banana")), + input("second buyer", coin(45, "apple")), + }, + Outputs: []banktypes.Output{output("SELLER", coin(4321, "carrot"))}, + }, + }, + { + name: "ask, two splits same addr, two denoms", + f: &OrderFulfillment{ + Order: askOrder(6, "SeLleR", coin(27, "carrot")), + PriceAppliedAmt: sdkmath.NewInt(5511), + Splits: []*OrderSplit{ + orderSplit(bidOrder(7, "buyer", igc), coin(90, "banana")), + orderSplit(bidOrder(8, "buyer", igc), coin(46, "apple")), + }, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("buyer", coin(46, "apple"), coin(90, "banana"))}, + Outputs: []banktypes.Output{output("SeLleR", coin(5511, "carrot"))}, + }, + }, + { + name: "ask, two splits same addr, one denom", + f: &OrderFulfillment{ + Order: askOrder(9, "sellsell", coin(28, "carrot")), + PriceAppliedAmt: sdkmath.NewInt(42), + Splits: []*OrderSplit{ + orderSplit(bidOrder(10, "buybuy", igc), coin(55, "apple")), + orderSplit(bidOrder(11, "buybuy", igc), coin(34, "apple")), + }, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("buybuy", coin(89, "apple"))}, + Outputs: []banktypes.Output{output("sellsell", coin(42, "carrot"))}, + }, + }, + { + name: "ask, negative price in split", + f: &OrderFulfillment{ + Order: askOrder(12, "goodsell", coin(29, "carrot")), + PriceAppliedAmt: sdkmath.NewInt(91), + Splits: []*OrderSplit{orderSplit(bidOrder(13, "buygood", igc), coin(-4, "banana"))}, + }, + expPanic: "cannot index and add invalid coin amount \"-4banana\"", + }, + { + name: "ask, negative price applied", + f: &OrderFulfillment{ + Order: askOrder(14, "solong", coin(30, "carrot")), + PriceAppliedAmt: sdkmath.NewInt(-5), + Splits: []*OrderSplit{orderSplit(bidOrder(15, "hello", igc), coin(66, "banana"))}, + }, + expPanic: "invalid coin set -5carrot: coin -5carrot amount is not positive", + }, + + { + name: "bid, one split", + f: &OrderFulfillment{ + Order: bidOrder(1, "buyer", coin(25, "carrot")), + PriceAppliedAmt: sdkmath.NewInt(33), + Splits: []*OrderSplit{orderSplit(askOrder(2, "seller", igc), coin(88, "banana"))}, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("buyer", coin(33, "carrot"))}, + Outputs: []banktypes.Output{output("seller", coin(88, "banana"))}, + }, + }, + { + name: "bid, two splits diff addrs", + f: &OrderFulfillment{ + Order: bidOrder(3, "BUYER", coin(26, "carrot")), + PriceAppliedAmt: sdkmath.NewInt(4321), + Splits: []*OrderSplit{ + orderSplit(askOrder(4, "seller 1", igc), coin(89, "banana")), + orderSplit(askOrder(5, "second seller", igc), coin(45, "apple")), + }, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("BUYER", coin(4321, "carrot"))}, + Outputs: []banktypes.Output{ + output("seller 1", coin(89, "banana")), + output("second seller", coin(45, "apple")), + }, + }, + }, + { + name: "bid, two splits same addr, two denoms", + f: &OrderFulfillment{ + Order: bidOrder(6, "BuYeR", coin(27, "carrot")), + PriceAppliedAmt: sdkmath.NewInt(5511), + Splits: []*OrderSplit{ + orderSplit(askOrder(7, "seller", igc), coin(90, "banana")), + orderSplit(askOrder(8, "seller", igc), coin(46, "apple")), + }, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("BuYeR", coin(5511, "carrot"))}, + Outputs: []banktypes.Output{output("seller", coin(46, "apple"), coin(90, "banana"))}, + }, + }, + { + name: "bid, two splits same addr, one denom", + f: &OrderFulfillment{ + Order: bidOrder(9, "buybuy", coin(28, "carrot")), + PriceAppliedAmt: sdkmath.NewInt(42), + Splits: []*OrderSplit{ + orderSplit(bidOrder(10, "sellsell", igc), coin(55, "apple")), + orderSplit(bidOrder(11, "sellsell", igc), coin(34, "apple")), + }, + }, + exp: &Transfer{ + Inputs: []banktypes.Input{input("buybuy", coin(42, "carrot"))}, + Outputs: []banktypes.Output{output("sellsell", coin(89, "apple"))}, + }, + }, + { + name: "bid, negative price in split", + f: &OrderFulfillment{ + Order: bidOrder(12, "goodbuy", coin(29, "carrot")), + PriceAppliedAmt: sdkmath.NewInt(91), + Splits: []*OrderSplit{orderSplit(askOrder(13, "sellgood", igc), coin(-4, "banana"))}, + }, + expPanic: "cannot index and add invalid coin amount \"-4banana\"", + }, + { + name: "bid, negative price applied", + f: &OrderFulfillment{ + Order: bidOrder(14, "heythere", coin(30, "carrot")), + PriceAppliedAmt: sdkmath.NewInt(-5), + Splits: []*OrderSplit{orderSplit(askOrder(15, "afterwhile", igc), coin(66, "banana"))}, + }, + expPanic: "invalid coin set -5carrot: coin -5carrot amount is not positive", + }, + + { + name: "nil inside order", + f: &OrderFulfillment{Order: NewOrder(20)}, + expPanic: "unknown order type ", + }, + { + name: "unknown inside order", + f: &OrderFulfillment{Order: &Order{OrderId: 21, Order: &unknownOrderType{}}}, + expPanic: "unknown order type *exchange.unknownOrderType", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + var actual *Transfer + defer func() { + if t.Failed() { + t.Logf(" Actual: %s", transferString(actual)) + t.Logf("Expected: %s", transferString(tc.exp)) + t.Logf("OrderFulfillment: %s", orderFulfillmentString(tc.f)) + } + }() + testFunc := func() { + actual = GetPriceTransfer(tc.f) + } + assertions.RequirePanicEquals(t, testFunc, tc.expPanic, "GetPriceTransfer") + assert.Equal(t, tc.exp, actual, "GetPriceTransfer") + }) + } +} diff --git a/x/exchange/orders_test.go b/x/exchange/orders_test.go index c7b2f41f0a..7bf29d7a00 100644 --- a/x/exchange/orders_test.go +++ b/x/exchange/orders_test.go @@ -72,15 +72,7 @@ func orderString(order *Order) string { fields = append(fields, fmt.Sprintf("BidOrder:%s", bidOrderString(order.GetBidOrder()))) default: if order.GetOrder() != nil { - fields = append(fields, - fmt.Sprintf("orderType:%q", order.GetOrderType()), - fmt.Sprintf("MarketId:%d", order.GetMarketID()), - fmt.Sprintf("owner:%s", order.GetOwner()), - fmt.Sprintf("Assets:%q", order.GetAssets()), - fmt.Sprintf("Price:%q", order.GetPrice()), - fmt.Sprintf("fees:%s", coinsString(order.GetSettlementFees())), - fmt.Sprintf("AllowPartial:%t", order.PartialFillAllowed()), - ) + fields = append(fields, fmt.Sprintf("orderType:%q", order.GetOrderType())) } else { fields = append(fields, "Order:nil") }