diff --git a/currency/pairs.go b/currency/pairs.go index 887b46fcbc9..a68edfa9eb8 100644 --- a/currency/pairs.go +++ b/currency/pairs.go @@ -52,6 +52,19 @@ func (p Pairs) Strings() []string { return list } +// String is a convenience method returning a comma-separated string of uppercase currencies using / as delimiter +func (p Pairs) String() string { + f := PairFormat{ + Delimiter: "/", + Uppercase: true, + } + l := make([]string, len(p)) + for i, pair := range p { + l[i] = f.Format(pair) + } + return strings.Join(l, ",") +} + // Join returns a comma separated list of currency pairs func (p Pairs) Join() string { return strings.Join(p.Strings(), ",") diff --git a/exchanges/subscription/list_test.go b/exchanges/subscription/list_test.go new file mode 100644 index 00000000000..e2293e7ea9d --- /dev/null +++ b/exchanges/subscription/list_test.go @@ -0,0 +1,25 @@ +package subscription + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/thrasher-corp/gocryptotrader/currency" + "github.com/thrasher-corp/gocryptotrader/exchanges/asset" +) + +func TestListStrings(t *testing.T) { + l := List{ + &Subscription{ + Channel: TickerChannel, + Asset: asset.Spot, + Pairs: currency.Pairs{ethusdcPair, btcusdtPair}, + }, + &Subscription{ + Channel: OrderbookChannel, + Pairs: currency.Pairs{ethusdcPair}, + }, + } + exp := []string{"orderbook ETH/USDC", "ticker spot ETH/USDC,BTC/USDT"} + assert.ElementsMatch(t, exp, l.Strings(), "String must return correct sorted list") +} diff --git a/exchanges/subscription/store_test.go b/exchanges/subscription/store_test.go new file mode 100644 index 00000000000..7f8a34d249a --- /dev/null +++ b/exchanges/subscription/store_test.go @@ -0,0 +1,34 @@ +package subscription + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// TestNewStore exercises NewStore +func TestNewStore(t *testing.T) { + s := NewStore() + require.IsType(t, &Store{}, s, "Must return a store ref") + require.NotNil(t, s.m, "storage map must be initialised") +} + +// TestNewStoreFromList exercises NewStoreFromList +func TestNewStoreFromList(t *testing.T) { + s, err := NewStoreFromList(List{}) + assert.NoError(t, err, "Should not error on empty list") + require.IsType(t, &Store{}, s, "Must return a store ref") + l := List{ + {Channel: OrderbookChannel}, + {Channel: TickerChannel}, + } + s, err = NewStoreFromList(l) + assert.NoError(t, err, "Should not error on empty list") + assert.Len(t, s.m, 2, "Map should have 2 values") + assert.NotNil(t, s.get(l[0]), "Should be able to get a list element") + + l = append(l, &Subscription{Channel: OrderbookChannel}) + s, err = NewStoreFromList(l) + assert.ErrorIs(t, err, ErrDuplicate, "Should error correctly on duplicates") +} diff --git a/exchanges/subscription/subscription.go b/exchanges/subscription/subscription.go index 3e340ebbc1c..32e799ad44c 100644 --- a/exchanges/subscription/subscription.go +++ b/exchanges/subscription/subscription.go @@ -88,8 +88,8 @@ func (s *Subscription) SetState(state State) error { return nil } -// EnsureKeyed sets the default key on a channel if it doesn't have one -// Returns key for convenience +// EnsureKeyed returns the subscription key +// If no key exists then a pointer to the subscription itself will be used, since Subscriptions implement MatchableKey func (s *Subscription) EnsureKeyed() any { if s.Key == nil { s.Key = s @@ -103,17 +103,25 @@ func (s *Subscription) EnsureKeyed() any { // 2) >=1 pairs then Subscriptions which contain all the pairs match // Such that a subscription for all enabled pairs will be matched when seaching for any one pair func (s *Subscription) Match(key any) bool { - b, ok := key.(*Subscription) + var b *Subscription + switch v := key.(type) { + case *Subscription: + b = v + case Subscription: + b = &v + default: + return false + } + switch { - case !ok, - s.Channel != b.Channel, - s.Asset != b.Asset, - len(b.Pairs) == 0 && len(s.Pairs) != 0, + case b.Channel != s.Channel, + b.Asset != s.Asset, // len(b.Pairs) == 0 && len(s.Pairs) == 0: Okay; continue to next non-pairs check + len(b.Pairs) == 0 && len(s.Pairs) != 0, len(b.Pairs) != 0 && len(s.Pairs) == 0, len(b.Pairs) != 0 && s.Pairs.ContainsAll(b.Pairs, true) != nil, - s.Levels != b.Levels, - s.Interval != b.Interval: + b.Levels != s.Levels, + b.Interval != s.Interval: return false } diff --git a/exchanges/subscription/subscription_test.go b/exchanges/subscription/subscription_test.go index 38cabb8694a..b9a71b4ae6a 100644 --- a/exchanges/subscription/subscription_test.go +++ b/exchanges/subscription/subscription_test.go @@ -11,36 +11,67 @@ import ( "github.com/thrasher-corp/gocryptotrader/exchanges/kline" ) -// TestEnsureKeyed logic test -func TestEnsureKeyed(t *testing.T) { - t.Parallel() +var ( + btcusdtPair = currency.NewPair(currency.BTC, currency.USDT) + ethusdcPair = currency.NewPair(currency.ETH, currency.USDC) + ltcusdcPair = currency.NewPair(currency.LTC, currency.USDC) +) + +// TestSubscriptionString exercises the String method +func TestSubscriptionString(t *testing.T) { s := &Subscription{ Channel: "candles", Asset: asset.Spot, - Pairs: []currency.Pair{currency.NewPair(currency.BTC, currency.USDT)}, + Pairs: currency.Pairs{btcusdtPair, ethusdcPair.Format(currency.PairFormat{Delimiter: "/"})}, + } + assert.Equal(t, "candles spot BTC/USDT,ETH/USDC", s.String(), "Subscription String should return correct value") +} + +// TestState exercises the state getter +func TestState(t *testing.T) { + t.Parallel() + s := &Subscription{} + assert.Equal(t, InactiveState, s.State(), "State should return initial state") + s.state = SubscribedState + assert.Equal(t, SubscribedState, s.State(), "State should return correct state") +} + +// TestSetState exercises the state setter +func TestSetState(t *testing.T) { + t.Parallel() + + s := &Subscription{state: UnsubscribingState} + + for i := InactiveState; i <= UnsubscribingState; i++ { + assert.NoErrorf(t, s.SetState(i), "State should not error setting state %s", i) } + assert.ErrorIs(t, s.SetState(UnsubscribingState), ErrInStateAlready, "SetState should error on same state") + assert.ErrorIs(t, s.SetState(UnsubscribingState+1), ErrInvalidState, "Setting an invalid state should error") +} + +// TestEnsureKeyed exercises the key getter and ensures it sets a self-pointer key for non +func TestEnsureKeyed(t *testing.T) { + t.Parallel() + s := &Subscription{} k1, ok := s.EnsureKeyed().(*Subscription) if assert.True(t, ok, "EnsureKeyed should return a *Subscription") { - assert.Same(t, k1, s, "Key should point to the same struct") + assert.Same(t, s, k1, "Key should point to the same struct") } type platypus string s = &Subscription{ Key: platypus("Gerald"), Channel: "orderbook", - Asset: asset.Margin, - Pairs: []currency.Pair{currency.NewPair(currency.ETH, currency.USDC)}, - } - k2, ok := s.EnsureKeyed().(platypus) - if assert.True(t, ok, "EnsureKeyed should return a platypus") { - assert.Exactly(t, k2, s.Key, "ensureKeyed should set the same key") - assert.EqualValues(t, "Gerald", k2, "key should have the correct value") } + k2 := s.EnsureKeyed() + assert.IsType(t, platypus(""), k2, "EnsureKeyed should return a platypus") + assert.Equal(t, s.Key, k2, "Key should be the key provided") } -// TestMarshalling logic test -func TestMarshaling(t *testing.T) { +// TestSubscriptionMarshalling ensures json Marshalling is clean and concise +// Since there is no UnmarshalJSON, this just exercises the json field tags of Subscription, and regressions in conciseness +func TestSubscriptionMarshaling(t *testing.T) { t.Parallel() - j, err := json.Marshal(&Subscription{Channel: CandlesChannel}) + j, err := json.Marshal(&Subscription{Key: 42, Channel: CandlesChannel}) assert.NoError(t, err, "Marshalling should not error") assert.Equal(t, `{"enabled":false,"channel":"candles"}`, string(j), "Marshalling should be clean and concise") @@ -57,16 +88,44 @@ func TestMarshaling(t *testing.T) { assert.Equal(t, `{"enabled":true,"channel":"myTrades","authenticated":true}`, string(j), "Marshalling should be clean and concise") } -// TestSetState tests Subscription state changes -func TestSetState(t *testing.T) { +// TestSubscriptionMatch exercises the Subscription MatchableKey interface implementation +func TestSubscriptionMatch(t *testing.T) { t.Parallel() + require.Implements(t, (*MatchableKey)(nil), new(Subscription), "Must implement MatchableKey") + s := &Subscription{Channel: TickerChannel} + assert.NotNil(t, s.EnsureKeyed(), "EnsureKeyed should work") + assert.False(t, s.Match(42), "Match should reject an invalid key type") + try := &Subscription{Channel: OrderbookChannel} + require.False(t, s.Match(try), "Gate 1: Match must reject a bad Channel") + try = &Subscription{Channel: TickerChannel} + require.True(t, s.Match(Subscription{Channel: TickerChannel}), "Match must accept a pass-by-value subscription") + require.True(t, s.Match(try), "Gate 1: Match must accept a good Channel") + s.Asset = asset.Spot + require.False(t, s.Match(try), "Gate 2: Match must reject a bad Asset") + try.Asset = asset.Spot + require.True(t, s.Match(try), "Gate 2: Match must accept a good Asset") - s := &Subscription{Key: 42, Channel: "Gophers"} - assert.Equal(t, InactiveState, s.State(), "State should start as unknown") - require.NoError(t, s.SetState(SubscribingState), "SetState should not error") - assert.Equal(t, SubscribingState, s.State(), "State should be set correctly") - assert.ErrorIs(t, s.SetState(SubscribingState), ErrInStateAlready, "SetState should error on same state") - assert.ErrorIs(t, s.SetState(UnsubscribingState+1), ErrInvalidState, "Setting an invalid state should error") - require.NoError(t, s.SetState(UnsubscribingState), "SetState should not error") - assert.Equal(t, UnsubscribingState, s.State(), "State should be set correctly") + s.Pairs = currency.Pairs{btcusdtPair} + require.False(t, s.Match(try), "Gate 3: Match must reject a pair list when searching for no pairs") + try.Pairs = s.Pairs + s.Pairs = nil + require.False(t, s.Match(try), "Gate 4: Match must reject empty Pairs when searching for a list") + s.Pairs = try.Pairs + require.True(t, s.Match(try), "Gate 5: Match must accept matching pairs") + s.Pairs = currency.Pairs{ethusdcPair} + require.False(t, s.Match(try), "Gate 5: Match must reject mismatched pairs") + s.Pairs = currency.Pairs{btcusdtPair, ethusdcPair} + require.True(t, s.Match(try), "Gate 5: Match must accept one of the key pairs matching in sub pairs") + try.Pairs = currency.Pairs{btcusdtPair, ltcusdcPair} + require.False(t, s.Match(try), "Gate 5: Match must reject when sub pair list doesn't contain all key pairs") + s.Pairs = currency.Pairs{btcusdtPair, ethusdcPair, ltcusdcPair} + require.True(t, s.Match(try), "Gate 5: Match must accept all of the key pairs are contained in sub pairs") + s.Levels = 4 + require.False(t, s.Match(try), "Gate 6: Match must reject a bad Level") + try.Levels = 4 + require.True(t, s.Match(try), "Gate 6: Match must accept a good Level") + s.Interval = kline.FiveMin + require.False(t, s.Match(try), "Gate 7: Match must reject a bad Interval") + try.Interval = kline.FiveMin + require.True(t, s.Match(try), "Gate 7: Match must accept a good Inteval") }