Bugfix: Submit/Cancel order scripting errors + Ordermanager GetOrder & CancelOrder improvements (#584)

* Fixes Submit and Cancel order functions for scripting. Adds tests to ensure that wrapper functions actually execute as expected. Adds more coverage. Fixes a few other tests

* Fixes issues

* Simplifies tests

* Update cancel order to properly cancel an order. Adds example script. Adds sweet tests.

* Fixes bad test setup for cancelling orders

* Adds new order manager GetOrderInfo function to call the wrapper function and then store it in the order manager

* Addresses order concerns

* LOWERS THE CASE OF ALL EXCHANGE NAMES BECAUSE ORDER MANAGER NEVER CARED ABOUT CASING OR YOUR FAMILY

* Removes asset and currency requirement from cancelling orders via validation test

* Fixes old cancel order assumptions that had requirements for currency and asset

* Moves all the logs and events to the dedicated Cancel function instead of exclusively doing it in CancelAllOrders

* Adds more detail logging. Fixes lbank fee test

* Addresses comms manager issues

* Removes go routine for pushing events. Better to let them fail

gctscript/modules/gct/exchange.go

@@ -330,7 +330,7 @@ func ExchangeOrderQuery(args ...objects.Object) (objects.Object, error) {
 
 // ExchangeOrderCancel cancels order on requested exchange
 func ExchangeOrderCancel(args ...objects.Object) (objects.Object, error) {
-	if len(args) != 2 {
+	if len(args) < 2 || len(args) > 4 {
 		return nil, objects.ErrWrongNumArguments
 	}
 
@@ -338,17 +338,50 @@ func ExchangeOrderCancel(args ...objects.Object) (objects.Object, error) {
 	if !ok {
 		return nil, fmt.Errorf(ErrParameterConvertFailed, exchangeName)
 	}
-	orderID, ok := objects.ToString(args[1])
+	if exchangeName == "" {
+		return nil, fmt.Errorf(ErrEmptyParameter, "exchange name")
+	}
+	var orderID string
+	orderID, ok = objects.ToString(args[1])
 	if !ok {
 		return nil, fmt.Errorf(ErrParameterConvertFailed, orderID)
 	}
+	if orderID == "" {
+		return nil, fmt.Errorf(ErrEmptyParameter, "orderID")
+	}
+	var err error
+	var cp currency.Pair
+	if len(args) > 2 {
+		var currencyPair string
+		currencyPair, ok = objects.ToString(args[2])
+		if !ok {
+			return nil, fmt.Errorf(ErrParameterConvertFailed, currencyPair)
+		}
+		cp, err = currency.NewPairFromString(currencyPair)
+		if err != nil {
+			return nil, err
+		}
+	}
+	var a asset.Item
+	if len(args) > 3 {
+		var assetType string
+		assetType, ok = objects.ToString(args[3])
+		if !ok {
+			return nil, fmt.Errorf(ErrParameterConvertFailed, assetType)
+		}
+		a, err = asset.New(assetType)
+		if err != nil {
+			return nil, err
+		}
+	}
 
-	rtn, err := wrappers.GetWrapper().CancelOrder(exchangeName, orderID)
+	var isCancelled bool
+	isCancelled, err = wrappers.GetWrapper().CancelOrder(exchangeName, orderID, cp, a)
 	if err != nil {
 		return nil, err
 	}
 
-	if rtn {
+	if isCancelled {
 		return objects.TrueValue, nil
 	}
 	return objects.FalseValue, nil
@@ -413,6 +446,7 @@ func ExchangeOrderSubmit(args ...objects.Object) (objects.Object, error) {
 		Amount:    orderAmount,
 		ClientID:  orderClientID,
 		AssetType: a,
+		Exchange:  exchangeName,
 	}
 
 	rtn, err := wrappers.GetWrapper().SubmitOrder(tempSubmit)

gctscript/modules/gct/gct_test.go

@@ -32,6 +32,9 @@ var (
 	orderID = &objects.String{
 		Value: "1235",
 	}
+	blank = &objects.String{
+		Value: "",
+	}
 
 	tv            = objects.TrueValue
 	fv            = objects.FalseValue
@@ -47,17 +50,17 @@ func TestExchangeOrderbook(t *testing.T) {
 	t.Parallel()
 	_, err := ExchangeOrderbook(exch, currencyPair, delimiter, assetType)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeOrderbook(exchError, currencyPair, delimiter, assetType)
 	if err != nil && errors.Is(err, errTestFailed) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeOrderbook()
 	if !errors.Is(err, objects.ErrWrongNumArguments) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 }
 
@@ -65,17 +68,17 @@ func TestExchangeTicker(t *testing.T) {
 	t.Parallel()
 	_, err := ExchangeTicker(exch, currencyPair, delimiter, assetType)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeTicker(exchError, currencyPair, delimiter, assetType)
 	if err != nil && errors.Is(err, errTestFailed) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeTicker()
 	if !errors.Is(err, objects.ErrWrongNumArguments) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 }
 
@@ -84,22 +87,22 @@ func TestExchangeExchanges(t *testing.T) {
 
 	_, err := ExchangeExchanges(tv)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeExchanges(exch)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeExchanges(fv)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeExchanges()
 	if !errors.Is(err, objects.ErrWrongNumArguments) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 }
 
@@ -108,17 +111,17 @@ func TestExchangePairs(t *testing.T) {
 
 	_, err := ExchangePairs(exch, tv, assetType)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangePairs(exchError, tv, assetType)
 	if err != nil && errors.Is(err, errTestFailed) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangePairs()
 	if !errors.Is(err, objects.ErrWrongNumArguments) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 }
 
@@ -127,17 +130,17 @@ func TestAccountInfo(t *testing.T) {
 
 	_, err := ExchangeAccountInfo()
 	if !errors.Is(err, objects.ErrWrongNumArguments) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeAccountInfo(exch)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeAccountInfo(exchError)
 	if err != nil && !errors.Is(err, errTestFailed) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 }
 
@@ -146,46 +149,58 @@ func TestExchangeOrderQuery(t *testing.T) {
 
 	_, err := ExchangeOrderQuery()
 	if !errors.Is(err, objects.ErrWrongNumArguments) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeOrderQuery(exch, orderID)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeOrderQuery(exchError, orderID)
 	if err != nil && !errors.Is(err, errTestFailed) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 }
 
 func TestExchangeOrderCancel(t *testing.T) {
+	t.Parallel()
 	_, err := ExchangeOrderCancel()
 	if !errors.Is(err, objects.ErrWrongNumArguments) {
-		t.Fatal(err)
+		t.Error(err)
+	}
+
+	_, err = ExchangeOrderCancel(blank, orderID, currencyPair, assetType)
+	if err == nil {
+		t.Error("expecting error")
+	}
+
+	_, err = ExchangeOrderCancel(exch, blank, currencyPair, assetType)
+	if err == nil {
+		t.Error("expecting error")
 	}
 
 	_, err = ExchangeOrderCancel(exch, orderID)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
-	_, err = ExchangeOrderCancel(exch, objects.FalseValue)
+	_, err = ExchangeOrderCancel(exch, orderID, currencyPair)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
-	_, err = ExchangeOrderCancel(exchError, orderID)
-	if err != nil && !errors.Is(err, errTestFailed) {
-		t.Fatal(err)
+	_, err = ExchangeOrderCancel(exch, orderID, currencyPair, assetType)
+	if err != nil {
+		t.Error(err)
 	}
 }
 
 func TestExchangeOrderSubmit(t *testing.T) {
+	t.Parallel()
 	_, err := ExchangeOrderSubmit()
 	if !errors.Is(err, objects.ErrWrongNumArguments) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	orderSide := &objects.String{Value: "ASK"}
@@ -197,52 +212,55 @@ func TestExchangeOrderSubmit(t *testing.T) {
 	_, err = ExchangeOrderSubmit(exch, currencyPair, delimiter,
 		orderType, orderSide, orderPrice, orderAmount, orderID, orderAsset)
 	if err != nil && !errors.Is(err, errTestFailed) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeOrderSubmit(exch, currencyPair, delimiter,
 		orderType, orderSide, orderPrice, orderAmount, orderID, orderAsset)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeOrderSubmit(objects.TrueValue, currencyPair, delimiter,
 		orderType, orderSide, orderPrice, orderAmount, orderID, orderAsset)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 }
 
 func TestAllModuleNames(t *testing.T) {
+	t.Parallel()
 	x := AllModuleNames()
 	xType := reflect.TypeOf(x).Kind()
 	if xType != reflect.Slice {
-		t.Fatalf("AllModuleNames() should return slice instead received: %v", x)
+		t.Errorf("AllModuleNames() should return slice instead received: %v", x)
 	}
 }
 
 func TestExchangeDepositAddress(t *testing.T) {
+	t.Parallel()
 	_, err := ExchangeDepositAddress()
 	if !errors.Is(err, objects.ErrWrongNumArguments) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	currCode := &objects.String{Value: "BTC"}
 	_, err = ExchangeDepositAddress(exch, currCode)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	_, err = ExchangeDepositAddress(exchError, currCode)
 	if err != nil && !errors.Is(err, errTestFailed) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 }
 
 func TestExchangeWithdrawCrypto(t *testing.T) {
+	t.Parallel()
 	_, err := ExchangeWithdrawCrypto()
 	if !errors.Is(err, objects.ErrWrongNumArguments) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	currCode := &objects.String{Value: "BTC"}
@@ -252,14 +270,15 @@ func TestExchangeWithdrawCrypto(t *testing.T) {
 
 	_, err = ExchangeWithdrawCrypto(exch, currCode, address, address, amount, amount, desc)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 }
 
 func TestExchangeWithdrawFiat(t *testing.T) {
+	t.Parallel()
 	_, err := ExchangeWithdrawFiat()
 	if !errors.Is(err, objects.ErrWrongNumArguments) {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
 	currCode := &objects.String{Value: "AUD"}
@@ -268,14 +287,15 @@ func TestExchangeWithdrawFiat(t *testing.T) {
 	bankID := &objects.String{Value: "test-bank-01"}
 	_, err = ExchangeWithdrawFiat(exch, currCode, desc, amount, bankID)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 }
 
 func TestParseInterval(t *testing.T) {
+	t.Parallel()
 	v, err := parseInterval("1h")
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 	if v != time.Hour {
 		t.Fatalf("unexpected value return expected %v received %v", time.Hour, v)
@@ -283,32 +303,32 @@ func TestParseInterval(t *testing.T) {
 
 	v, err = parseInterval("1d")
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 	if v != time.Hour*24 {
-		t.Fatalf("unexpected value return expected %v received %v", time.Hour*24, v)
+		t.Errorf("unexpected value return expected %v received %v", time.Hour*24, v)
 	}
 
 	v, err = parseInterval("3d")
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 	if v != time.Hour*72 {
-		t.Fatalf("unexpected value return expected %v received %v", time.Hour*72, v)
+		t.Errorf("unexpected value return expected %v received %v", time.Hour*72, v)
 	}
 
 	v, err = parseInterval("1w")
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 	if v != time.Hour*168 {
-		t.Fatalf("unexpected value return expected %v received %v", time.Hour*168, v)
+		t.Errorf("unexpected value return expected %v received %v", time.Hour*168, v)
 	}
 
 	_, err = parseInterval("6m")
 	if err != nil {
 		if !errors.Is(err, errInvalidInterval) {
-			t.Fatal(err)
+			t.Error(err)
 		}
 	}
 }

gctscript/modules/gct/gct_types.go

@@ -9,6 +9,7 @@ import (
 const (
 	// ErrParameterConvertFailed error to return when type conversion fails
 	ErrParameterConvertFailed = "%v failed conversion"
+	ErrEmptyParameter         = "received empty parameter for %v"
 )
 
 var errInvalidInterval = errors.New("invalid interval")

gctscript/modules/wrapper_types.go

@@ -37,7 +37,7 @@ type Exchange interface {
 	Pairs(exch string, enabledOnly bool, item asset.Item) (*currency.Pairs, error)
 	QueryOrder(exch, orderid string, pair currency.Pair, assetType asset.Item) (*order.Detail, error)
 	SubmitOrder(submit *order.Submit) (*order.SubmitResponse, error)
-	CancelOrder(exch, orderid string) (bool, error)
+	CancelOrder(exch, orderid string, pair currency.Pair, item asset.Item) (bool, error)
 	AccountInformation(exch string) (account.Holdings, error)
 	DepositAddress(exch string, currencyCode currency.Code) (string, error)
 	WithdrawalFiatFunds(bankAccountID string, request *withdraw.Request) (out string, err error)