code.vegaprotocol.io/vega@v0.79.0/datanode/entities/marketdata_test.go

// Copyright (C) 2023 Gobalsky Labs Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package entities_test

import (
	"testing"
	"time"

	"code.vegaprotocol.io/vega/datanode/entities"
	types "code.vegaprotocol.io/vega/protos/vega"

	"github.com/shopspring/decimal"
	"github.com/stretchr/testify/assert"
)

func TestMarketDataFromProto(t *testing.T) {
	t.Run("should parse all valid prices", testParseAllValidPrices)
	t.Run("should return zero for prices if string is empty", testParseEmptyPrices)
	t.Run("should return error if an invalid price string is provided", testParseInvalidPriceString)
	t.Run("should parse valid market data records successfully", testParseMarketDataSuccessfully)
}

func testParseAllValidPrices(t *testing.T) {
	marketdata := types.MarketData{
		MarkPrice:            "1",
		BestBidPrice:         "1",
		BestOfferPrice:       "1",
		BestStaticBidPrice:   "1",
		BestStaticOfferPrice: "1",
		MidPrice:             "1",
		StaticMidPrice:       "1",
		IndicativePrice:      "1",
		TargetStake:          "1",
		SuppliedStake:        "1",
	}

	md, err := entities.MarketDataFromProto(&marketdata, generateTxHash())
	assert.NoError(t, err)
	assert.NotNil(t, md.MarkPrice)
	assert.NotNil(t, md.BestBidPrice)
	assert.NotNil(t, md.BestOfferPrice)
	assert.NotNil(t, md.BestStaticBidPrice)
	assert.NotNil(t, md.BestStaticOfferVolume)
	assert.NotNil(t, md.MidPrice)
	assert.NotNil(t, md.StaticMidPrice)
	assert.NotNil(t, md.IndicativePrice)
	assert.NotNil(t, md.TargetStake)
	assert.NotNil(t, md.SuppliedStake)

	want := decimal.NewFromInt(1)
	assert.True(t, want.Equal(md.MarkPrice))
	assert.True(t, want.Equal(md.BestBidPrice))
	assert.True(t, want.Equal(md.BestOfferPrice))
	assert.True(t, want.Equal(md.BestStaticBidPrice))
	assert.True(t, want.Equal(md.BestStaticOfferPrice))
	assert.True(t, want.Equal(md.MidPrice))
	assert.True(t, want.Equal(md.StaticMidPrice))
	assert.True(t, want.Equal(md.IndicativePrice))
	assert.True(t, want.Equal(md.TargetStake))
	assert.True(t, want.Equal(md.SuppliedStake))
}

func testParseEmptyPrices(t *testing.T) {
	marketdata := types.MarketData{}
	md, err := entities.MarketDataFromProto(&marketdata, generateTxHash())
	assert.NoError(t, err)
	assert.True(t, decimal.Zero.Equals(md.MarkPrice))
	assert.True(t, decimal.Zero.Equals(md.BestBidPrice))
	assert.True(t, decimal.Zero.Equals(md.BestOfferPrice))
	assert.True(t, decimal.Zero.Equals(md.BestStaticBidPrice))
	assert.True(t, decimal.Zero.Equals(md.BestStaticOfferPrice))
	assert.True(t, decimal.Zero.Equals(md.MidPrice))
	assert.True(t, decimal.Zero.Equals(md.StaticMidPrice))
	assert.True(t, decimal.Zero.Equals(md.IndicativePrice))
	assert.True(t, decimal.Zero.Equals(md.TargetStake))
	assert.True(t, decimal.Zero.Equals(md.SuppliedStake))
}

func testParseInvalidPriceString(t *testing.T) {
	type args struct {
		marketdata types.MarketData
	}
	testCases := []struct {
		name string
		args args
	}{
		{
			name: "Invalid Mark Price",
			args: args{
				marketdata: types.MarketData{
					MarkPrice: "Test",
				},
			},
		},
		{
			name: "Invalid Best Bid Price",
			args: args{
				marketdata: types.MarketData{
					BestBidPrice: "Test",
				},
			},
		},
		{
			name: "Invalid Best Offer Price",
			args: args{
				marketdata: types.MarketData{
					BestOfferPrice: "Test",
				},
			},
		},
		{
			name: "Invalid Best Static Bid Price",
			args: args{
				marketdata: types.MarketData{
					BestStaticBidPrice: "Test",
				},
			},
		},
		{
			name: "Invalid Best Static Offer Price",
			args: args{
				marketdata: types.MarketData{
					BestStaticOfferPrice: "Test",
				},
			},
		},
		{
			name: "Invalid Mid Price",
			args: args{
				marketdata: types.MarketData{
					MidPrice: "Test",
				},
			},
		},
		{
			name: "Invalid Static Mid Price",
			args: args{
				marketdata: types.MarketData{
					StaticMidPrice: "Test",
				},
			},
		},
		{
			name: "Invalid Indicative Price",
			args: args{
				marketdata: types.MarketData{
					IndicativePrice: "Test",
				},
			},
		},
		{
			name: "Invalid Target Stake",
			args: args{
				marketdata: types.MarketData{
					TargetStake: "Test",
				},
			},
		},
		{
			name: "Invalid Supplied Stake",
			args: args{
				marketdata: types.MarketData{
					SuppliedStake: "Test",
				},
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(tt *testing.T) {
			md, err := entities.MarketDataFromProto(&tc.args.marketdata, generateTxHash())
			assert.Error(tt, err)
			assert.Nil(tt, md)
		})
	}
}

func testParseMarketDataSuccessfully(t *testing.T) {
	type args struct {
		marketdata types.MarketData
	}

	nextMTM := time.Now()
	nextNC := time.Now()
	zeroTime := time.Unix(0, 0)

	testCases := []struct {
		name string
		args args
		want *entities.MarketData
	}{
		{
			name: "Empty market data",
			args: args{
				marketdata: types.MarketData{},
			},
			want: &entities.MarketData{
				AuctionTrigger:      "AUCTION_TRIGGER_UNSPECIFIED",
				MarketState:         "STATE_UNSPECIFIED",
				MarketTradingMode:   "TRADING_MODE_UNSPECIFIED",
				ExtensionTrigger:    "AUCTION_TRIGGER_UNSPECIFIED",
				TxHash:              generateTxHash(),
				NextMarkToMarket:    zeroTime,
				NextNetworkCloseout: zeroTime,
				MarkPriceType:       "COMPOSITE_PRICE_TYPE_UNSPECIFIED",
			},
		},
		{
			name: "Market data with auction trigger specified",
			args: args{
				marketdata: types.MarketData{
					Trigger:             types.AuctionTrigger_AUCTION_TRIGGER_PRICE,
					NextMarkToMarket:    nextMTM.UnixNano(),
					NextNetworkCloseout: nextNC.UnixNano(),
				},
			},
			want: &entities.MarketData{
				AuctionTrigger:      "AUCTION_TRIGGER_PRICE",
				MarketState:         "STATE_UNSPECIFIED",
				MarketTradingMode:   "TRADING_MODE_UNSPECIFIED",
				ExtensionTrigger:    "AUCTION_TRIGGER_UNSPECIFIED",
				MarkPriceType:       "COMPOSITE_PRICE_TYPE_UNSPECIFIED",
				NextMarkToMarket:    nextMTM,
				NextNetworkCloseout: nextNC,
				TxHash:              generateTxHash(),
			},
		},
		{
			name: "Market data with auction trigger and market trading mode specified",
			args: args{
				marketdata: types.MarketData{
					Trigger:             types.AuctionTrigger_AUCTION_TRIGGER_PRICE,
					MarketTradingMode:   types.Market_TRADING_MODE_CONTINUOUS,
					NextMarkToMarket:    nextMTM.UnixNano(),
					NextNetworkCloseout: nextNC.UnixNano(),
				},
			},
			want: &entities.MarketData{
				AuctionTrigger:      "AUCTION_TRIGGER_PRICE",
				MarketTradingMode:   "TRADING_MODE_CONTINUOUS",
				MarketState:         "STATE_UNSPECIFIED",
				ExtensionTrigger:    "AUCTION_TRIGGER_UNSPECIFIED",
				MarkPriceType:       "COMPOSITE_PRICE_TYPE_UNSPECIFIED",
				NextMarkToMarket:    nextMTM,
				NextNetworkCloseout: nextNC,
				TxHash:              generateTxHash(),
			},
		},
		{
			name: "Market data with best bid and best offer specified",
			args: args{
				marketdata: types.MarketData{
					BestBidPrice:        "100.0",
					BestOfferPrice:      "110.0",
					Trigger:             types.AuctionTrigger_AUCTION_TRIGGER_PRICE,
					MarketTradingMode:   types.Market_TRADING_MODE_CONTINUOUS,
					MarketState:         types.Market_STATE_ACTIVE,
					NextMarkToMarket:    nextMTM.UnixNano(),
					NextNetworkCloseout: nextNC.UnixNano(),
				},
			},
			want: &entities.MarketData{
				BestBidPrice:        decimal.NewFromFloat(100.0),
				BestOfferPrice:      decimal.NewFromFloat(110.0),
				AuctionTrigger:      "AUCTION_TRIGGER_PRICE",
				MarketState:         "STATE_ACTIVE",
				MarketTradingMode:   "TRADING_MODE_CONTINUOUS",
				ExtensionTrigger:    "AUCTION_TRIGGER_UNSPECIFIED",
				MarkPriceType:       "COMPOSITE_PRICE_TYPE_UNSPECIFIED",
				TxHash:              generateTxHash(),
				NextMarkToMarket:    nextMTM,
				NextNetworkCloseout: nextNC,
			},
		},
		{
			name: "Market data with best bid and best offer specified and price monitoring bounds",
			args: args{
				marketdata: types.MarketData{
					BestBidPrice:      "100.0",
					BestOfferPrice:    "110.0",
					Trigger:           types.AuctionTrigger_AUCTION_TRIGGER_PRICE,
					MarketTradingMode: types.Market_TRADING_MODE_CONTINUOUS,
					PriceMonitoringBounds: []*types.PriceMonitoringBounds{
						{
							MinValidPrice: "100",
							MaxValidPrice: "200",
						},
					},
					NextMarkToMarket:    nextMTM.UnixNano(),
					NextNetworkCloseout: nextNC.UnixNano(),
				},
			},
			want: &entities.MarketData{
				BestBidPrice:      decimal.NewFromFloat(100.0),
				BestOfferPrice:    decimal.NewFromFloat(110.0),
				AuctionTrigger:    "AUCTION_TRIGGER_PRICE",
				MarketTradingMode: "TRADING_MODE_CONTINUOUS",
				MarketState:       "STATE_UNSPECIFIED",
				ExtensionTrigger:  "AUCTION_TRIGGER_UNSPECIFIED",
				MarkPriceType:     "COMPOSITE_PRICE_TYPE_UNSPECIFIED",
				PriceMonitoringBounds: []*types.PriceMonitoringBounds{
					{
						MinValidPrice:  "100",
						MaxValidPrice:  "200",
						ReferencePrice: "",
					},
				},
				TxHash:              generateTxHash(),
				NextMarkToMarket:    nextMTM,
				NextNetworkCloseout: nextNC,
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(tt *testing.T) {
			got, err := entities.MarketDataFromProto(&tc.args.marketdata, tc.want.TxHash)
			assert.NoError(tt, err)
			assert.True(tt, tc.want.Equal(*got))
		})
	}
}