exchanges/wrappers: shift bespoke fetch ticker, orderbook and accountinfo

backtester/eventhandlers/exchange/exchange_test.go

@@ -268,7 +268,7 @@ func TestExecuteOrder(t *testing.T) {
 
 	p := currency.NewPair(currency.BTC, currency.USDT)
 	a := asset.Spot
-	_, err = exch.FetchOrderbook(context.Background(), p, a)
+	_, err = exch.UpdateOrderbook(context.Background(), p, a)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -403,7 +403,7 @@ func TestExecuteOrderBuySellSizeLimit(t *testing.T) {
 	}
 	p := currency.NewPair(currency.BTC, currency.AUD)
 	a := asset.Spot
-	_, err = exch.FetchOrderbook(context.Background(), p, a)
+	_, err = exch.UpdateOrderbook(context.Background(), p, a)
 	if err != nil {
 		t.Fatal(err)
 	}

backtester/eventhandlers/exchange/slippage/slippage_test.go

@@ -28,7 +28,7 @@ func TestCalculateSlippageByOrderbook(t *testing.T) {
 		t.Fatal(err)
 	}
 	cp := currency.NewPair(currency.BTC, currency.USD)
-	ob, err := b.FetchOrderbook(context.Background(), cp, asset.Spot)
+	ob, err := b.UpdateOrderbook(context.Background(), cp, asset.Spot)
 	if err != nil {
 		t.Error(err)
 	}

cmd/exchange_template/wrapper_file.tmpl

@@ -304,24 +304,6 @@ func ({{.Variable}} *{{.CapitalName}}) UpdateTickers(ctx context.Context, assetT
     return nil
 }
 
-// FetchTicker returns the ticker for a currency pair
-func ({{.Variable}} *{{.CapitalName}}) FetchTicker(ctx context.Context, p currency.Pair, assetType asset.Item) (*ticker.Price, error) {
-	tickerNew, err := ticker.GetTicker({{.Variable}}.Name, p, assetType)
-	if err != nil {
-		return {{.Variable}}.UpdateTicker(ctx, p, assetType)
-	}
-	return tickerNew, nil
-}
-
-// FetchOrderbook returns orderbook base on the currency pair
-func ({{.Variable}} *{{.CapitalName}}) FetchOrderbook(ctx context.Context, pair currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
-	ob, err := orderbook.Get({{.Variable}}.Name, pair, assetType)
-	if err != nil {
-		return {{.Variable}}.UpdateOrderbook(ctx, pair, assetType)
-	}
-	return ob, nil
-}
-
 // UpdateOrderbook updates and returns the orderbook for a currency pair
 func ({{.Variable}} *{{.CapitalName}}) UpdateOrderbook(ctx context.Context, pair currency.Pair, assetType asset.Item) (*orderbook.Base, error) {
 	book := &orderbook.Base{
@@ -370,21 +352,6 @@ func ({{.Variable}} *{{.CapitalName}}) UpdateAccountInfo(ctx context.Context, as
 	return account.Holdings{}, common.ErrNotYetImplemented
 }
 
-// FetchAccountInfo retrieves balances for all enabled currencies
-func ({{.Variable}} *{{.CapitalName}}) FetchAccountInfo(ctx context.Context, assetType asset.Item) (account.Holdings, error) {
-	// Example implementation below:
-	// 	creds, err := {{.Variable}}.GetCredentials(ctx)
-	// 	if err != nil {
-	// 		return account.Holdings{}, err
-	// 	}
-	// 	acc, err := account.GetHoldings({{.Variable}}.Name, creds, assetType)
-	// 	if err != nil {
-	// 		return {{.Variable}}.UpdateAccountInfo(ctx, assetType)
-	// 	}
-	// 	return acc, nil
-	return account.Holdings{}, common.ErrNotYetImplemented
-}
-
 // GetFundingHistory returns funding history, deposits and
 // withdrawals
 func ({{.Variable}} *{{.CapitalName}}) GetAccountFundingHistory(ctx context.Context) ([]exchange.FundingHistory, error) {

cmd/exchange_wrapper_issues/main.go

@@ -347,60 +347,60 @@ func testWrappers(e exchange.IBotExchange, base *exchange.Base, config *Config)
 		log.Printf("Executing wrappers for %v %v %v", base.GetName(), assetTypes[i], p)
 
 		if !authenticatedOnly {
-			var fetchTickerResponse *ticker.Price
-			fetchTickerResponse, err = e.FetchTicker(context.TODO(), p, assetTypes[i])
+			var updateTickerResponse *ticker.Price
+			updateTickerResponse, err = e.UpdateTicker(context.TODO(), p, assetTypes[i])
 			msg = ""
 			if err != nil {
 				msg = err.Error()
 				responseContainer.ErrorCount++
 			}
 			responseContainer.EndpointResponses = append(responseContainer.EndpointResponses, EndpointResponse{
 				SentParams: jsonifyInterface([]interface{}{p, assetTypes[i]}),
-				Function:   "FetchTicker",
+				Function:   "UpdateTicker",
 				Error:      msg,
-				Response:   jsonifyInterface([]interface{}{fetchTickerResponse}),
+				Response:   jsonifyInterface([]interface{}{updateTickerResponse}),
 			})
 
-			var updateTickerResponse *ticker.Price
-			updateTickerResponse, err = e.UpdateTicker(context.TODO(), p, assetTypes[i])
+			var fetchTickerResponse *ticker.Price
+			fetchTickerResponse, err = e.FetchTicker(context.TODO(), p, assetTypes[i])
 			msg = ""
 			if err != nil {
 				msg = err.Error()
 				responseContainer.ErrorCount++
 			}
 			responseContainer.EndpointResponses = append(responseContainer.EndpointResponses, EndpointResponse{
 				SentParams: jsonifyInterface([]interface{}{p, assetTypes[i]}),
-				Function:   "UpdateTicker",
+				Function:   "FetchTicker",
 				Error:      msg,
-				Response:   jsonifyInterface([]interface{}{updateTickerResponse}),
+				Response:   jsonifyInterface([]interface{}{fetchTickerResponse}),
 			})
 
-			var fetchOrderbookResponse *orderbook.Base
-			fetchOrderbookResponse, err = e.FetchOrderbook(context.TODO(), p, assetTypes[i])
+			var updateOrderbookResponse *orderbook.Base
+			updateOrderbookResponse, err = e.UpdateOrderbook(context.TODO(), p, assetTypes[i])
 			msg = ""
 			if err != nil {
 				msg = err.Error()
 				responseContainer.ErrorCount++
 			}
 			responseContainer.EndpointResponses = append(responseContainer.EndpointResponses, EndpointResponse{
 				SentParams: jsonifyInterface([]interface{}{p, assetTypes[i]}),
-				Function:   "FetchOrderbook",
+				Function:   "UpdateOrderbook",
 				Error:      msg,
-				Response:   jsonifyInterface([]interface{}{fetchOrderbookResponse}),
+				Response:   jsonifyInterface([]interface{}{updateOrderbookResponse}),
 			})
 
-			var updateOrderbookResponse *orderbook.Base
-			updateOrderbookResponse, err = e.UpdateOrderbook(context.TODO(), p, assetTypes[i])
+			var fetchOrderbookResponse *orderbook.Base
+			fetchOrderbookResponse, err = e.FetchOrderbook(context.TODO(), p, assetTypes[i])
 			msg = ""
 			if err != nil {
 				msg = err.Error()
 				responseContainer.ErrorCount++
 			}
 			responseContainer.EndpointResponses = append(responseContainer.EndpointResponses, EndpointResponse{
 				SentParams: jsonifyInterface([]interface{}{p, assetTypes[i]}),
-				Function:   "UpdateOrderbook",
+				Function:   "FetchOrderbook",
 				Error:      msg,
-				Response:   jsonifyInterface([]interface{}{updateOrderbookResponse}),
+				Response:   jsonifyInterface([]interface{}{fetchOrderbookResponse}),
 			})
 
 			var fetchTradablePairsResponse []currency.Pair

cmd/exchange_wrapper_standards/exchange_wrapper_standards_test.go

@@ -175,59 +175,83 @@ func executeExchangeWrapperTests(ctx context.Context, t *testing.T, exch exchang
 	t.Helper()
 	iExchange := reflect.TypeOf(&exch).Elem()
 	actualExchange := reflect.ValueOf(exch)
+
+	var firstPriority []string
+	var secondPriority []string
+
 	for x := 0; x < iExchange.NumMethod(); x++ {
 		methodName := iExchange.Method(x).Name
 		if _, ok := excludedMethodNames[methodName]; ok {
 			continue
 		}
-		method := actualExchange.MethodByName(methodName)
-
-		var assetLen int
-		for y := 0; y < method.Type().NumIn(); y++ {
-			input := method.Type().In(y)
-			if input.AssignableTo(assetParam) ||
-				input.AssignableTo(orderSubmitParam) ||
-				input.AssignableTo(orderModifyParam) ||
-				input.AssignableTo(orderCancelParam) ||
-				input.AssignableTo(orderCancelsParam) ||
-				input.AssignableTo(pairKeySliceParam) ||
-				input.AssignableTo(getOrdersRequestParam) ||
-				input.AssignableTo(pairKeySliceParam) {
-				// this allows wrapper functions that support assets types
-				// to be tested with all supported assets
-				assetLen = len(assetParams) - 1
-			}
-		}
-		tt := time.Now()
-		e := time.Date(tt.Year(), tt.Month(), tt.Day()-1, 0, 0, 0, 0, time.UTC)
-		s := e.Add(-time.Hour * 24 * 2)
-		if methodName == "GetHistoricTrades" {
-			// limit trade history
-			e = time.Now()
-			s = e.Add(-time.Minute * 3)
+
+		if strings.Contains(methodName, "Update") {
+			// Update functions are tested first as they are required for other
+			// functions to work.
+			firstPriority = append(firstPriority, methodName)
+		} else {
+			secondPriority = append(secondPriority, methodName)
 		}
-		for y := 0; y <= assetLen; y++ {
-			inputs := make([]reflect.Value, method.Type().NumIn())
-			argGenerator := &MethodArgumentGenerator{
-				Exchange:    exch,
-				AssetParams: assetParams[y],
-				MethodName:  methodName,
-				Start:       s,
-				End:         e,
+	}
+	handleExchangeWrapperTests(ctx, t, actualExchange, firstPriority, exch, assetParams, "PRIORITY GROUP")
+	handleExchangeWrapperTests(ctx, t, actualExchange, secondPriority, exch, assetParams, "SECONDARY GROUP")
+}
+
+func handleExchangeWrapperTests(ctx context.Context, t *testing.T, actualExchange reflect.Value, methodNames []string, exch exchange.IBotExchange, assetParams []assetPair, groupTestID string) {
+	t.Helper()
+	t.Run(groupTestID, func(t *testing.T) {
+		for x := range methodNames {
+			method := actualExchange.MethodByName(methodNames[x])
+
+			var assetLen int
+			for y := 0; y < method.Type().NumIn(); y++ {
+				input := method.Type().In(y)
+				if input.AssignableTo(assetParam) ||
+					input.AssignableTo(orderSubmitParam) ||
+					input.AssignableTo(orderModifyParam) ||
+					input.AssignableTo(orderCancelParam) ||
+					input.AssignableTo(orderCancelsParam) ||
+					input.AssignableTo(pairKeySliceParam) ||
+					input.AssignableTo(getOrdersRequestParam) ||
+					input.AssignableTo(pairKeySliceParam) {
+					// this allows wrapper functions that support assets types
+					// to be tested with all supported assets
+					assetLen = len(assetParams) - 1
+				}
 			}
-			for z := 0; z < method.Type().NumIn(); z++ {
-				argGenerator.MethodInputType = method.Type().In(z)
-				generatedArg := generateMethodArg(ctx, t, argGenerator)
-				inputs[z] = *generatedArg
+			tt := time.Now()
+			e := time.Date(tt.Year(), tt.Month(), tt.Day()-1, 0, 0, 0, 0, time.UTC)
+			s := e.Add(-time.Hour * 24 * 2)
+			if methodNames[x] == "GetHistoricTrades" {
+				// limit trade history
+				e = time.Now()
+				s = e.Add(-time.Minute * 3)
+			}
+			for y := 0; y <= assetLen; y++ {
+				inputs := make([]reflect.Value, method.Type().NumIn())
+				argGenerator := &MethodArgumentGenerator{
+					Exchange:    exch,
+					AssetParams: assetParams[y],
+					MethodName:  methodNames[x],
+					Start:       s,
+					End:         e,
+				}
+				for z := 0; z < method.Type().NumIn(); z++ {
+					argGenerator.MethodInputType = method.Type().In(z)
+					generatedArg := generateMethodArg(ctx, t, argGenerator)
+					inputs[z] = *generatedArg
+				}
+				assetY := assetParams[y].Asset.String()
+				pairY := assetParams[y].Pair.String()
+
+				methodNameBro := methodNames[x]
+				t.Run(methodNames[x]+"-"+assetY+"-"+pairY, func(t *testing.T) {
+					t.Parallel()
+					CallExchangeMethod(t, method, inputs, methodNameBro, exch)
+				})
 			}
-			assetY := assetParams[y].Asset.String()
-			pairY := assetParams[y].Pair.String()
-			t.Run(methodName+"-"+assetY+"-"+pairY, func(t *testing.T) {
-				t.Parallel()
-				CallExchangeMethod(t, method, inputs, methodName, exch)
-			})
 		}
-	}
+	})
 }
 
 // CallExchangeMethod will call an exchange's method using generated arguments
@@ -584,6 +608,7 @@ var excludedMethodNames = map[string]struct{}{
 	"GetLeverage":                      {},
 	"SetMarginType":                    {},
 	"ChangePositionMargin":             {},
+	"FetchAccountInfo":                 {}, // Cannot be set correctly with UpdateAccountInfo
 }
 
 // blockedCIExchanges are exchanges that are not able to be tested on CI

engine/event_manager_test.go

@@ -306,8 +306,7 @@ func TestCheckEventCondition(t *testing.T) {
 		t.Error("expected error")
 	}
 	m.m.Unlock()
-	_, err = exch.FetchTicker(context.Background(),
-		currency.NewPair(currency.BTC, currency.USD), asset.Spot)
+	_, err = exch.UpdateTicker(context.Background(), currency.NewPair(currency.BTC, currency.USD), asset.Spot)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}
@@ -331,8 +330,7 @@ func TestCheckEventCondition(t *testing.T) {
 	}
 	m.m.Unlock()
 
-	_, err = exch.FetchOrderbook(context.Background(),
-		currency.NewPair(currency.BTC, currency.USD), asset.Spot)
+	_, err = exch.UpdateOrderbook(context.Background(), currency.NewPair(currency.BTC, currency.USD), asset.Spot)
 	if !errors.Is(err, nil) {
 		t.Errorf("error '%v', expected '%v'", err, nil)
 	}

engine/helpers.go

@@ -577,22 +577,22 @@ func GetRelatableCurrencies(p currency.Pair, incOrig, incUSDT bool) currency.Pai
 
 // GetSpecificOrderbook returns a specific orderbook given the currency,
 // exchangeName and assetType
-func (bot *Engine) GetSpecificOrderbook(ctx context.Context, p currency.Pair, exchangeName string, assetType asset.Item) (*orderbook.Base, error) {
+func (bot *Engine) GetSpecificOrderbook(p currency.Pair, exchangeName string, assetType asset.Item) (*orderbook.Base, error) {
 	exch, err := bot.GetExchangeByName(exchangeName)
 	if err != nil {
 		return nil, err
 	}
-	return exch.FetchOrderbook(ctx, p, assetType)
+	return exch.FetchOrderbook(context.TODO(), p, assetType)
 }
 
 // GetSpecificTicker returns a specific ticker given the currency,
 // exchangeName and assetType
-func (bot *Engine) GetSpecificTicker(ctx context.Context, p currency.Pair, exchangeName string, assetType asset.Item) (*ticker.Price, error) {
+func (bot *Engine) GetSpecificTicker(p currency.Pair, exchangeName string, assetType asset.Item) (*ticker.Price, error) {
 	exch, err := bot.GetExchangeByName(exchangeName)
 	if err != nil {
 		return nil, err
 	}
-	return exch.FetchTicker(ctx, p, assetType)
+	return exch.FetchTicker(context.TODO(), p, assetType)
 }
 
 // GetCollatedExchangeAccountInfoByCoin collates individual exchange account
@@ -831,7 +831,7 @@ func (bot *Engine) GetExchangeNames(enabledOnly bool) []string {
 }
 
 // GetAllActiveTickers returns all enabled exchange tickers
-func (bot *Engine) GetAllActiveTickers(ctx context.Context) []EnabledExchangeCurrencies {
+func (bot *Engine) GetAllActiveTickers() []EnabledExchangeCurrencies {
 	var tickerData []EnabledExchangeCurrencies
 	exchanges := bot.GetExchanges()
 	for x := range exchanges {
@@ -850,7 +850,7 @@ func (bot *Engine) GetAllActiveTickers(ctx context.Context) []EnabledExchangeCur
 				continue
 			}
 			for z := range currencies {
-				tp, err := exchanges[x].FetchTicker(ctx, currencies[z], assets[y])
+				tp, err := exchanges[x].FetchTicker(context.TODO(), currencies[z], assets[y])
 				if err != nil {
 					log.Errorf(log.ExchangeSys, "Exchange %s failed to retrieve %s ticker. Err: %s\n", exchName,
 						currencies[z].String(),

engine/helpers_test.go

@@ -774,8 +774,7 @@ func TestGetSpecificOrderbook(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	ob, err := e.GetSpecificOrderbook(context.Background(),
-		btsusd, testExchange, asset.Spot)
+	ob, err := e.GetSpecificOrderbook(btsusd, testExchange, asset.Spot)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -789,8 +788,7 @@ func TestGetSpecificOrderbook(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, err = e.GetSpecificOrderbook(context.Background(),
-		ethltc, testExchange, asset.Spot)
+	_, err = e.GetSpecificOrderbook(ethltc, testExchange, asset.Spot)
 	if err == nil {
 		t.Fatal("Unexpected result")
 	}
@@ -818,8 +816,7 @@ func TestGetSpecificTicker(t *testing.T) {
 		t.Fatal("ProcessTicker error", err)
 	}
 
-	tick, err := e.GetSpecificTicker(context.Background(),
-		p, testExchange, asset.Spot)
+	tick, err := e.GetSpecificTicker(p, testExchange, asset.Spot)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -833,8 +830,7 @@ func TestGetSpecificTicker(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, err = e.GetSpecificTicker(context.Background(),
-		ethltc, testExchange, asset.Spot)
+	_, err = e.GetSpecificTicker(ethltc, testExchange, asset.Spot)
 	if err == nil {
 		t.Fatal("Unexpected result")
 	}