explicit test_symbol and test_order in tests

data/redisrepo/create_user.go

@@ -16,14 +16,16 @@ var orderId = uuid.MustParse("00000000-0000-0000-0000-000000000001")
 var clientOId = uuid.MustParse("00000000-0000-0000-0000-000000000002")
 var userId = uuid.MustParse("00000000-0000-0000-0000-000000000003")
 var size, _ = decimal.NewFromString("10000324.123456789")
-var symbol, _ = models.StrToSymbol("MATIC-USDC")
+
+// for tests
+var test_symbol, _ = models.StrToSymbol("MATIC-USDC")
 var price = decimal.NewFromFloat(10.0)
 
-var order = models.Order{
+var test_order = models.Order{
 	Id:     orderId,
 	Price:  price,
 	Size:   size,
-	Symbol: symbol,
+	Symbol: test_symbol,
 	Side:   models.BUY,
 }
 

data/redisrepo/pub_sub_test.go

@@ -7,7 +7,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-var orderJson, _ = order.ToJson()
+var orderJson, _ = test_order.ToJson()
 
 func TestRedisRepository_PublishEvent(t *testing.T) {
 
@@ -18,9 +18,9 @@ func TestRedisRepository_PublishEvent(t *testing.T) {
 			client: db,
 		}
 
-		mock.ExpectPublish(order.Id.String(), orderJson).SetVal(1)
+		mock.ExpectPublish(test_order.Id.String(), orderJson).SetVal(1)
 
-		err := repo.PublishEvent(ctx, order.Id.String(), orderJson)
+		err := repo.PublishEvent(ctx, test_order.Id.String(), orderJson)
 
 		assert.NoError(t, err)
 	})
@@ -32,9 +32,9 @@ func TestRedisRepository_PublishEvent(t *testing.T) {
 			client: db,
 		}
 
-		mock.ExpectPublish(order.Id.String(), orderJson).SetErr(assert.AnError)
+		mock.ExpectPublish(test_order.Id.String(), orderJson).SetErr(assert.AnError)
 
-		err := repo.PublishEvent(ctx, order.Id.String(), orderJson)
+		err := repo.PublishEvent(ctx, test_order.Id.String(), orderJson)
 
 		assert.ErrorContains(t, err, "failed to publish redis event")
 	})

data/redisrepo/store_filled_orders.go

@@ -35,7 +35,7 @@ func (r *redisRepository) StoreFilledOrders(ctx context.Context, orders []models
 
 func storeFilledOrderTx(ctx context.Context, transaction redis.Pipeliner, order *models.Order) error {
 	// 1. Remove the order from the user's open orders set
-	userOrdersKey := CreateUserOpenOrdersKey(order.UserId, symbol)
+	userOrdersKey := CreateUserOpenOrdersKey(order.UserId, order.Symbol)
 	transaction.ZRem(ctx, userOrdersKey, order.Id.String())
 	// 2. Remove the order from the buy/sell prices set for that pair
 	if order.Side == models.BUY {

data/redisrepo/store_filled_orders_test.go

@@ -19,7 +19,7 @@ func TestRedisRepository_StoreFilledOrders(t *testing.T) {
 			ClientOId:   clientOId,
 			Price:       price,
 			Size:        size,
-			Symbol:      symbol,
+			Symbol:      test_symbol,
 			Side:        models.BUY,
 			Timestamp:   timestamp,
 			SizePending: decimal.Zero,
@@ -34,7 +34,7 @@ func TestRedisRepository_StoreFilledOrders(t *testing.T) {
 		}
 
 		mock.ExpectTxPipeline()
-		mock.ExpectZRem(CreateUserOpenOrdersKey(buyOrder.UserId, symbol), buyOrder.Id.String()).SetVal(1)
+		mock.ExpectZRem(CreateUserOpenOrdersKey(buyOrder.UserId, buyOrder.Symbol), buyOrder.Id.String()).SetVal(1)
 		mock.ExpectZRem(CreateBuySidePricesKey(buyOrder.Symbol), buyOrder.Id.String()).SetVal(1)
 		mock.ExpectHSet(CreateOrderIDKey(buyOrder.Id), buyOrder.OrderToMap()).SetVal(1)
 		mock.ExpectTxPipelineExec()
@@ -50,7 +50,7 @@ func TestRedisRepository_StoreFilledOrders(t *testing.T) {
 			ClientOId:   clientOId,
 			Price:       price,
 			Size:        size,
-			Symbol:      symbol,
+			Symbol:      test_symbol,
 			Side:        models.SELL,
 			Timestamp:   timestamp,
 			SizePending: decimal.Zero,
@@ -65,7 +65,7 @@ func TestRedisRepository_StoreFilledOrders(t *testing.T) {
 		}
 
 		mock.ExpectTxPipeline()
-		mock.ExpectZRem(CreateUserOpenOrdersKey(sellOrder.UserId, symbol), sellOrder.Id.String()).SetVal(1)
+		mock.ExpectZRem(CreateUserOpenOrdersKey(sellOrder.UserId, sellOrder.Symbol), sellOrder.Id.String()).SetVal(1)
 		mock.ExpectZRem(CreateSellSidePricesKey(sellOrder.Symbol), sellOrder.Id.String()).SetVal(1)
 		mock.ExpectHSet(CreateOrderIDKey(sellOrder.Id), sellOrder.OrderToMap()).SetVal(1)
 		mock.ExpectTxPipelineExec()
@@ -87,7 +87,7 @@ func TestRedisRepository_StoreFilledOrders(t *testing.T) {
 		}
 
 		mock.ExpectTxPipeline()
-		mock.ExpectZRem(CreateUserOpenOrdersKey(sellOrder.UserId, symbol), sellOrder.Id.String()).SetErr(assert.AnError)
+		mock.ExpectZRem(CreateUserOpenOrdersKey(sellOrder.UserId, sellOrder.Symbol), sellOrder.Id.String()).SetErr(assert.AnError)
 
 		err := repo.StoreFilledOrders(ctx, []models.Order{sellOrder})
 

data/redisrepo/store_open_order_test.go

@@ -20,7 +20,7 @@ func TestRedisRepository_StoreOpenOrder(t *testing.T) {
 			ClientOId: clientOId,
 			Price:     price,
 			Size:      size,
-			Symbol:    symbol,
+			Symbol:    test_symbol,
 			Side:      models.BUY,
 			Timestamp: timestamp,
 		}
@@ -38,11 +38,11 @@ func TestRedisRepository_StoreOpenOrder(t *testing.T) {
 			Score:  10.0016969392,
 			Member: buyOrder.Id.String(),
 		}).SetVal(1)
-		mock.ExpectZAdd(CreateUserOpenOrdersKey(buyOrder.UserId, symbol), redis.Z{
+		mock.ExpectZAdd(CreateUserOpenOrdersKey(buyOrder.UserId, buyOrder.Symbol), redis.Z{
 			Score:  float64(timestamp.UnixNano()),
 			Member: buyOrder.Id.String(),
 		}).SetVal(1)
-		mock.ExpectSetNX(Order2MakerTokenTrackKey(order), -1, 0).SetVal(true)
+		mock.ExpectSetNX(Order2MakerTokenTrackKey(buyOrder), -1, 0).SetVal(true)
 		mock.ExpectTxPipelineExec()
 
 		err := repo.StoreOpenOrder(ctx, buyOrder)
@@ -56,7 +56,7 @@ func TestRedisRepository_StoreOpenOrder(t *testing.T) {
 			ClientOId: clientOId,
 			Price:     price,
 			Size:      size,
-			Symbol:    symbol,
+			Symbol:    test_symbol,
 			Side:      models.SELL,
 			Timestamp: timestamp,
 		}
@@ -75,11 +75,11 @@ func TestRedisRepository_StoreOpenOrder(t *testing.T) {
 			Score:  10.0016969392,
 			Member: sellOrder.Id.String(),
 		}).SetVal(1)
-		mock.ExpectZAdd(CreateUserOpenOrdersKey(sellOrder.UserId, symbol), redis.Z{
+		mock.ExpectZAdd(CreateUserOpenOrdersKey(sellOrder.UserId, sellOrder.Symbol), redis.Z{
 			Score:  float64(timestamp.UnixNano()),
 			Member: sellOrder.Id.String(),
 		}).SetVal(1)
-		mock.ExpectSetNX(Order2MakerTokenTrackKey(order), -1, 0).SetVal(true)
+		mock.ExpectSetNX(Order2MakerTokenTrackKey(sellOrder), -1, 0).SetVal(true)
 		mock.ExpectTxPipelineExec()
 
 		err := repo.StoreOpenOrder(ctx, sellOrder)
@@ -96,20 +96,20 @@ func TestRedisRepository_StoreOpenOrder(t *testing.T) {
 		}
 
 		mock.ExpectTxPipeline()
-		mock.ExpectHSet(CreateOrderIDKey(order.Id), order.OrderToMap()).SetErr(assert.AnError)
-		mock.ExpectSet(CreateClientOIDKey(order.ClientOId), order.Id.String(), 0).SetVal("OK")
-		mock.ExpectZAdd(CreateSellSidePricesKey(order.Symbol), redis.Z{
+		mock.ExpectHSet(CreateOrderIDKey(test_order.Id), test_order.OrderToMap()).SetErr(assert.AnError)
+		mock.ExpectSet(CreateClientOIDKey(test_order.ClientOId), test_order.Id.String(), 0).SetVal("OK")
+		mock.ExpectZAdd(CreateSellSidePricesKey(test_order.Symbol), redis.Z{
 			Score:  10.0016969392,
-			Member: order.Id.String(),
+			Member: test_order.Id.String(),
 		}).SetVal(1)
-		mock.ExpectZAdd(CreateUserOpenOrdersKey(order.UserId, symbol), redis.Z{
-			Score:  float64(order.Timestamp.UnixNano()),
-			Member: order.Id.String(),
+		mock.ExpectZAdd(CreateUserOpenOrdersKey(test_order.UserId, test_order.Symbol), redis.Z{
+			Score:  float64(test_order.Timestamp.UnixNano()),
+			Member: test_order.Id.String(),
 		}).SetErr(assert.AnError)
-		mock.ExpectExists(Order2MakerTokenTrackKey(order)).SetVal(0)
-		mock.ExpectSetNX(Order2MakerTokenTrackKey(order), -1, 0).SetVal(true)
+		mock.ExpectExists(Order2MakerTokenTrackKey(test_order)).SetVal(0)
+		mock.ExpectSetNX(Order2MakerTokenTrackKey(test_order), -1, 0).SetVal(true)
 
-		err := repo.StoreOpenOrder(ctx, order)
+		err := repo.StoreOpenOrder(ctx, test_order)
 
 		assert.ErrorContains(t, err, "PerformTx txEnd commit failed", "should return error")
 	})

data/redisrepo/tk_order_test.go

@@ -157,7 +157,7 @@ func TestRedisRepository_TxModifyPrices(t *testing.T) {
 			ClientOId: clientOId,
 			Price:     price,
 			Size:      size,
-			Symbol:    symbol,
+			Symbol:    test_symbol,
 			Side:      models.BUY,
 			Timestamp: timestamp,
 		}
@@ -184,7 +184,7 @@ func TestRedisRepository_TxModifyPrices(t *testing.T) {
 			ClientOId: clientOId,
 			Price:     price,
 			Size:      size,
-			Symbol:    symbol,
+			Symbol:    test_symbol,
 			Side:      models.SELL,
 			Timestamp: timestamp,
 		}
@@ -276,12 +276,13 @@ func TestRedisRepository_TxModifyUserOpenOrders(t *testing.T) {
 	timestamp := time.Date(2023, 10, 10, 12, 0, 0, 0, time.UTC)
 	order := models.Order{
 		Timestamp: timestamp,
+		Symbol:    test_symbol,
 	}
 
 	t.Run("successfully adds user open order", func(t *testing.T) {
 
 		mock.ExpectTxPipeline()
-		mock.ExpectZAdd(CreateUserOpenOrdersKey(order.UserId, symbol), redis.Z{
+		mock.ExpectZAdd(CreateUserOpenOrdersKey(order.UserId, order.Symbol), redis.Z{
 			Score:  float64(timestamp.UnixNano()),
 			Member: order.Id.String(),
 		}).SetVal(1)
@@ -298,11 +299,11 @@ func TestRedisRepository_TxModifyUserOpenOrders(t *testing.T) {
 	t.Run("successfully removes user open order", func(t *testing.T) {
 
 		mock.ExpectTxPipeline()
-		mock.ExpectZRem(CreateUserOpenOrdersKey(order.UserId, symbol), order.Id.String()).SetVal(1)
+		mock.ExpectZRem(CreateUserOpenOrdersKey(test_order.UserId, test_symbol), test_order.Id.String()).SetVal(1)
 		mock.ExpectTxPipelineExec()
 
 		err := repo.PerformTx(ctx, func(txid uint) error {
-			return repo.TxModifyUserOpenOrders(ctx, txid, models.Remove, order)
+			return repo.TxModifyUserOpenOrders(ctx, txid, models.Remove, test_order)
 		})
 
 		assert.NoError(t, err)

data/redisrepo/tx_order.go

@@ -157,10 +157,9 @@ func (r *redisRepository) TxModifyUserOpenOrders(ctx context.Context, txid uint,
 		return models.ErrNotFound
 	}
 
-	userOrdersKey := CreateUserOpenOrdersKey(order.UserId, symbol)
+	userOrdersKey := CreateUserOpenOrdersKey(order.UserId, order.Symbol)
 	switch operation {
 	case models.Add:
-
 		userOrdersScore := float64(order.Timestamp.UTC().UnixNano())
 		tx.ZAdd(ctx, userOrdersKey, redis.Z{
 			Score:  userOrdersScore,