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/examples/exchange/cancel_order.gct

@@ -0,0 +1,9 @@
+fmt := import("fmt")
+exch := import("exchange")
+
+load := func() {
+  info := exch.ordercancel("binance","13371337", "btc-usdt", "spot")
+  fmt.println(info)
+}
+
+load()

gctscript/examples/exchange/submit_order.gct

@@ -2,7 +2,7 @@ fmt := import("fmt")
 exch := import("exchange")
 
 load := func() {
-  info := exch.ordersubmit("BTC Markets","BTC-AUD","-","LIMIT","SELL",1000000, 1,"", SPOT)
+  info := exch.ordersubmit("BTC Markets","BTC-AUD","-","LIMIT","SELL",1000000, 1,"", "spot")
   fmt.println(info)
 }
 

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)

gctscript/wrappers/gct/exchange/exchange.go

@@ -83,17 +83,12 @@ func (e Exchange) Pairs(exch string, enabledOnly bool, item asset.Item) (*curren
 
 // QueryOrder returns details of a valid exchange order
 func (e Exchange) QueryOrder(exch, orderID string, pair currency.Pair, assetType asset.Item) (*order.Detail, error) {
-	ex, err := e.GetExchange(exch)
+	o, err := engine.Bot.OrderManager.GetOrderInfo(exch, orderID, pair, assetType)
 	if err != nil {
 		return nil, err
 	}
 
-	r, err := ex.GetOrderInfo(orderID, pair, assetType)
-	if err != nil {
-		return nil, err
-	}
-
-	return &r, nil
+	return &o, nil
 }
 
 // SubmitOrder submit new order on exchange
@@ -107,8 +102,8 @@ func (e Exchange) SubmitOrder(submit *order.Submit) (*order.SubmitResponse, erro
 }
 
 // CancelOrder wrapper to cancel order on exchange
-func (e Exchange) CancelOrder(exch, orderID string) (bool, error) {
-	orderDetails, err := e.QueryOrder(exch, orderID, currency.Pair{}, "")
+func (e Exchange) CancelOrder(exch, orderID string, cp currency.Pair, a asset.Item) (bool, error) {
+	orderDetails, err := e.QueryOrder(exch, orderID, cp, a)
 	if err != nil {
 		return false, err
 	}
@@ -119,6 +114,7 @@ func (e Exchange) CancelOrder(exch, orderID string) (bool, error) {
 		Pair:      orderDetails.Pair,
 		Side:      orderDetails.Side,
 		AssetType: orderDetails.AssetType,
+		Exchange:  exch,
 	}
 
 	err = engine.Bot.OrderManager.Cancel(cancel)

gctscript/wrappers/gct/exchange/exchange_test.go

@@ -5,10 +5,12 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+	"time"
 
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/engine"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/order"
 )
 
@@ -137,6 +139,7 @@ func TestExchange_QueryOrder(t *testing.T) {
 	if !configureExchangeKeys() {
 		t.Skip("no exchange configured test skipped")
 	}
+	t.Parallel()
 	_, err := exchangeTest.QueryOrder(exchName, orderID, currency.Pair{}, assetType)
 	if err != nil {
 		t.Fatal(err)
@@ -148,6 +151,7 @@ func TestExchange_SubmitOrder(t *testing.T) {
 		t.Skip("no exchange configured test skipped")
 	}
 
+	t.Parallel()
 	c, err := currency.NewPairDelimiter(pairs, delimiter)
 	if err != nil {
 		t.Fatal(err)
@@ -174,18 +178,35 @@ func TestExchange_CancelOrder(t *testing.T) {
 	if !configureExchangeKeys() {
 		t.Skip("no exchange configured test skipped")
 	}
-	_, err := exchangeTest.CancelOrder(exchName, orderID)
+	t.Parallel()
+	cp := currency.NewPair(currency.BTC, currency.USD)
+	a := asset.Spot
+	_, err := exchangeTest.CancelOrder(exchName, orderID, cp, a)
 	if err != nil {
 		t.Fatal(err)
 	}
 }
 
+func TestOHLCV(t *testing.T) {
+	t.Parallel()
+	cp := currency.NewPair(currency.BTC, currency.AUD)
+	cp.Delimiter = currency.DashDelimiter
+	calvinKline, err := exchangeTest.OHLCV(exchName, cp, assetType, time.Now().Add(-time.Hour*24).UTC(), time.Now().UTC(), kline.OneHour)
+	if err != nil {
+		t.Error(err)
+	}
+	if calvinKline.Exchange != exchName {
+		t.Error("unexpected response")
+	}
+}
+
 func setupEngine() (err error) {
 	engine.Bot, err = engine.NewFromSettings(&settings, nil)
 	if err != nil {
 		return err
 	}
-	return engine.Bot.Start()
+
+	return engine.Bot.LoadExchange(exchName, false, nil)
 }
 
 func cleanup() {

gctscript/wrappers/gct/gctwrapper_test.go

@@ -1,10 +1,42 @@
 package gct
 
 import (
+	"errors"
+	"log"
+	"os"
+	"path/filepath"
 	"reflect"
+	"strings"
 	"testing"
+
+	objects "github.com/d5/tengo/v2"
+	"github.com/thrasher-corp/gocryptotrader/common"
+	"github.com/thrasher-corp/gocryptotrader/engine"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
+	"github.com/thrasher-corp/gocryptotrader/gctscript/modules"
+	"github.com/thrasher-corp/gocryptotrader/gctscript/modules/gct"
 )
 
+func TestMain(m *testing.M) {
+	settings := engine.Settings{
+		ConfigFile:                  filepath.Join("..", "..", "..", "testdata", "configtest.json"),
+		EnableDryRun:                true,
+		DataDir:                     filepath.Join("..", "..", "..", "testdata", "gocryptotrader"),
+		EnableDepositAddressManager: true,
+	}
+	var err error
+	engine.Bot, err = engine.NewFromSettings(&settings, nil)
+	if err != nil {
+		log.Print(err)
+		os.Exit(1)
+	}
+	engine.Bot.LoadExchange(exch.Value, false, nil)
+	engine.Bot.DepositAddressManager = new(engine.DepositAddressManager)
+	go engine.Bot.DepositAddressManager.Sync()
+	modules.SetModuleWrapper(Setup())
+	os.Exit(m.Run())
+}
+
 func TestSetup(t *testing.T) {
 	x := Setup()
 	xType := reflect.TypeOf(x).String()
@@ -12,3 +44,223 @@ func TestSetup(t *testing.T) {
 		t.Fatalf("Setup() should return pointer to Wrapper instead received: %v", x)
 	}
 }
+
+var (
+	exch = &objects.String{
+		Value: "Bitstamp",
+	}
+	exchError = &objects.String{
+		Value: "error",
+	}
+	currencyPair = &objects.String{
+		Value: "BTCUSD",
+	}
+	delimiter = &objects.String{
+		Value: "",
+	}
+	assetType = &objects.String{
+		Value: "spot",
+	}
+	orderID = &objects.String{
+		Value: "1235",
+	}
+
+	tv            = objects.TrueValue
+	fv            = objects.FalseValue
+	errTestFailed = errors.New("test failed")
+)
+
+func TestExchangeOrderbook(t *testing.T) {
+	t.Parallel()
+	_, err := gct.ExchangeOrderbook(exch, currencyPair, delimiter, assetType)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = gct.ExchangeOrderbook(exchError, currencyPair, delimiter, assetType)
+	if err != nil && errors.Is(err, errTestFailed) {
+		t.Fatal(err)
+	}
+
+	_, err = gct.ExchangeOrderbook()
+	if !errors.Is(err, objects.ErrWrongNumArguments) {
+		t.Error(err)
+	}
+}
+
+func TestExchangeTicker(t *testing.T) {
+	t.Parallel()
+	_, err := gct.ExchangeTicker(exch, currencyPair, delimiter, assetType)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = gct.ExchangeTicker(exchError, currencyPair, delimiter, assetType)
+	if err != nil && errors.Is(err, errTestFailed) {
+		t.Fatal(err)
+	}
+
+	_, err = gct.ExchangeTicker()
+	if !errors.Is(err, objects.ErrWrongNumArguments) {
+		t.Error(err)
+	}
+}
+
+func TestExchangeExchanges(t *testing.T) {
+	t.Parallel()
+	_, err := gct.ExchangeExchanges(tv)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = gct.ExchangeExchanges(exch)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = gct.ExchangeExchanges(fv)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = gct.ExchangeExchanges()
+	if !errors.Is(err, objects.ErrWrongNumArguments) {
+		t.Error(err)
+	}
+}
+
+func TestExchangePairs(t *testing.T) {
+	t.Parallel()
+	_, err := gct.ExchangePairs(exch, tv, assetType)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = gct.ExchangePairs(exchError, tv, assetType)
+	if err != nil && errors.Is(err, errTestFailed) {
+		t.Fatal(err)
+	}
+
+	_, err = gct.ExchangePairs()
+	if !errors.Is(err, objects.ErrWrongNumArguments) {
+		t.Error(err)
+	}
+}
+
+func TestAccountInfo(t *testing.T) {
+	t.Parallel()
+	_, err := gct.ExchangeAccountInfo()
+	if !errors.Is(err, objects.ErrWrongNumArguments) {
+		t.Fatal(err)
+	}
+	_, err = gct.ExchangeAccountInfo(exch)
+	if err != nil &&
+		!strings.Contains(err.Error(), "unset/default API keys") {
+		t.Error(err)
+	}
+}
+
+func TestExchangeOrderQuery(t *testing.T) {
+	t.Parallel()
+
+	_, err := gct.ExchangeOrderQuery()
+	if !errors.Is(err, objects.ErrWrongNumArguments) {
+		t.Fatal(err)
+	}
+
+	_, err = gct.ExchangeOrderQuery(exch, orderID)
+	if err != nil && err != common.ErrNotYetImplemented {
+		t.Error(err)
+	}
+}
+
+func TestExchangeOrderCancel(t *testing.T) {
+	t.Parallel()
+	_, err := gct.ExchangeOrderCancel()
+	if !errors.Is(err, objects.ErrWrongNumArguments) {
+		t.Fatal(err)
+	}
+	_, err = gct.ExchangeOrderCancel(exch, orderID, currencyPair, assetType)
+	if err != nil && err != common.ErrNotYetImplemented {
+		t.Error(err)
+	}
+}
+
+func TestExchangeOrderSubmit(t *testing.T) {
+	t.Parallel()
+	_, err := gct.ExchangeOrderSubmit()
+	if !errors.Is(err, objects.ErrWrongNumArguments) {
+		t.Fatal(err)
+	}
+
+	orderSide := &objects.String{Value: "ASK"}
+	orderType := &objects.String{Value: "LIMIT"}
+	orderPrice := &objects.Float{Value: 1}
+	orderAmount := &objects.Float{Value: 1}
+	orderAsset := &objects.String{Value: asset.Spot.String()}
+
+	_, err = gct.ExchangeOrderSubmit(exch, currencyPair, delimiter,
+		orderType, orderSide, orderPrice, orderAmount, orderID, orderAsset)
+	if err != nil &&
+		!strings.Contains(err.Error(), "unset/default API keys") {
+		t.Error(err)
+	}
+}
+
+func TestAllModuleNames(t *testing.T) {
+	t.Parallel()
+	x := gct.AllModuleNames()
+	xType := reflect.TypeOf(x).Kind()
+	if xType != reflect.Slice {
+		t.Errorf("AllModuleNames() should return slice instead received: %v", x)
+	}
+}
+
+func TestExchangeDepositAddress(t *testing.T) {
+	t.Parallel()
+	_, err := gct.ExchangeDepositAddress()
+	if !errors.Is(err, objects.ErrWrongNumArguments) {
+		t.Fatal(err)
+	}
+
+	currCode := &objects.String{Value: "BTC"}
+	_, err = gct.ExchangeDepositAddress(exch, currCode)
+	if err != nil && err.Error() != "deposit address store is nil" {
+		t.Error(err)
+	}
+}
+
+func TestExchangeWithdrawCrypto(t *testing.T) {
+	t.Parallel()
+	_, err := gct.ExchangeWithdrawCrypto()
+	if !errors.Is(err, objects.ErrWrongNumArguments) {
+		t.Fatal(err)
+	}
+
+	currCode := &objects.String{Value: "BTC"}
+	desc := &objects.String{Value: "HELLO"}
+	address := &objects.String{Value: "0xTHISISALEGITBTCADDRESSS"}
+	amount := &objects.Float{Value: 1.0}
+
+	_, err = gct.ExchangeWithdrawCrypto(exch, currCode, address, address, amount, amount, desc)
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func TestExchangeWithdrawFiat(t *testing.T) {
+	t.Parallel()
+	_, err := gct.ExchangeWithdrawFiat()
+	if !errors.Is(err, objects.ErrWrongNumArguments) {
+		t.Fatal(err)
+	}
+
+	currCode := &objects.String{Value: "TEST"}
+	amount := &objects.Float{Value: 1.0}
+	desc := &objects.String{Value: "2"}
+	bankID := &objects.String{Value: "3!"}
+	_, err = gct.ExchangeWithdrawFiat(exch, currCode, desc, amount, bankID)
+	if err != nil && err.Error() != "exchange Bitstamp bank details not found for TEST" {
+		t.Error(err)
+	}
+}

gctscript/wrappers/validator/validator.go

@@ -167,11 +167,20 @@ func (w Wrapper) SubmitOrder(o *order.Submit) (*order.SubmitResponse, error) {
 }
 
 // CancelOrder validator for test execution/scripts
-func (w Wrapper) CancelOrder(exch, orderid string) (bool, error) {
+func (w Wrapper) CancelOrder(exch, orderid string, cp currency.Pair, a asset.Item) (bool, error) {
 	if exch == exchError.String() {
 		return false, errTestFailed
 	}
-	return orderid != "false", nil
+	if orderid == "" {
+		return false, errTestFailed
+	}
+	if !cp.IsEmpty() && cp.IsInvalid() {
+		return false, errTestFailed
+	}
+	if a != "" && !a.IsValid() {
+		return false, errTestFailed
+	}
+	return true, nil
 }
 
 // AccountInformation validator for test execution/scripts

gctscript/wrappers/validator/validator_test.go

@@ -76,15 +76,30 @@ func TestWrapper_AccountInformation(t *testing.T) {
 
 func TestWrapper_CancelOrder(t *testing.T) {
 	t.Parallel()
-
-	_, err := testWrapper.CancelOrder(exchName, orderID)
+	cp := currency.NewPair(currency.BTC, currency.USD)
+	_, err := testWrapper.CancelOrder(exchName, orderID, cp, assetType)
 	if err != nil {
-		t.Fatal(err)
+		t.Error(err)
 	}
 
-	_, err = testWrapper.CancelOrder(exchError.String(), "")
+	_, err = testWrapper.CancelOrder(exchError.String(), orderID, cp, assetType)
 	if err == nil {
-		t.Fatal("expected CancelOrder to return error on invalid name")
+		t.Error("expected CancelOrder to return error on invalid name")
+	}
+
+	_, err = testWrapper.CancelOrder(exchName, "", cp, assetType)
+	if err == nil {
+		t.Error("expected CancelOrder to return error on invalid name")
+	}
+
+	_, err = testWrapper.CancelOrder(exchName, orderID, currency.Pair{}, assetType)
+	if err != nil {
+		t.Error(err)
+	}
+
+	_, err = testWrapper.CancelOrder(exchName, orderID, cp, "")
+	if err != nil {
+		t.Error(err)
 	}
 }
 

gctscript/wrappers/validator/validator_types.go

@@ -12,7 +12,7 @@ var (
 	IsTestExecution atomic.Value
 
 	exchError = &objects.String{
-		Value: "error",
+		Value: "",
 	}
 	errTestFailed = errors.New("test failed")
 )