From 48d9f595362365b58234151f10fe725f2b08e41e Mon Sep 17 00:00:00 2001 From: Gareth Kirwan Date: Thu, 22 Feb 2024 09:57:57 +0700 Subject: [PATCH] Websocket: Add suffix to state consts --- exchanges/stream/websocket.go | 18 +++++++------- exchanges/stream/websocket_test.go | 38 ++++++++++++++--------------- exchanges/stream/websocket_types.go | 8 +++--- 3 files changed, 32 insertions(+), 32 deletions(-) diff --git a/exchanges/stream/websocket.go b/exchanges/stream/websocket.go index dc701881dcc..7f41f53335e 100644 --- a/exchanges/stream/websocket.go +++ b/exchanges/stream/websocket.go @@ -190,7 +190,7 @@ func (w *Websocket) Setup(s *WebsocketSetup) error { return fmt.Errorf("%s %w", w.exchangeName, errInvalidMaxSubscriptions) } w.MaxSubscriptionsPerConnection = s.MaxWebsocketSubscriptionsPerConnection - w.setState(disconnected) + w.setState(disconnectedState) return nil } @@ -279,14 +279,14 @@ func (w *Websocket) Connect() error { w.dataMonitor() w.trafficMonitor() - w.setState(connecting) + w.setState(connectingState) err := w.connector() if err != nil { - w.setState(disconnected) + w.setState(disconnectedState) return fmt.Errorf("%v Error connecting %w", w.exchangeName, err) } - w.setState(connected) + w.setState(connectedState) if !w.IsConnectionMonitorRunning() { err = w.connectionMonitor() @@ -406,7 +406,7 @@ func (w *Websocket) connectionMonitor() error { case err := <-w.ReadMessageErrors: if IsDisconnectionError(err) { log.Warnf(log.WebsocketMgr, "%v websocket has been disconnected. Reason: %v", w.exchangeName, err) - w.setState(disconnected) + w.setState(disconnectedState) } w.DataHandler <- err @@ -466,7 +466,7 @@ func (w *Websocket) Shutdown() error { // flush any subscriptions from last connection if needed w.subscriptions.Clear() - w.setState(disconnected) + w.setState(disconnectedState) close(w.ShutdownC) w.Wg.Wait() @@ -597,17 +597,17 @@ func (w *Websocket) setState(s uint32) { // IsInitialised returns whether the websocket has been Setup() already func (w *Websocket) IsInitialised() bool { - return w.state.Load() != uninitialised + return w.state.Load() != uninitialisedState } // IsConnected returns whether the websocket is connected func (w *Websocket) IsConnected() bool { - return w.state.Load() == connected + return w.state.Load() == connectedState } // IsConnecting returns whether the websocket is connecting func (w *Websocket) IsConnecting() bool { - return w.state.Load() == connecting + return w.state.Load() == connectingState } func (w *Websocket) setEnabled(b bool) { diff --git a/exchanges/stream/websocket_test.go b/exchanges/stream/websocket_test.go index bdf92a6f662..e2f25056bb0 100644 --- a/exchanges/stream/websocket_test.go +++ b/exchanges/stream/websocket_test.go @@ -193,13 +193,13 @@ func TestTrafficMonitorTrafficAlerts(t *testing.T) { signal := struct{}{} patience := 10 * time.Millisecond ws.trafficTimeout = 200 * time.Millisecond - ws.state.Store(connected) + ws.state.Store(connectedState) thenish := time.Now() ws.trafficMonitor() assert.True(t, ws.IsTrafficMonitorRunning(), "traffic monitor should be running") - require.Equal(t, connected, ws.state.Load(), "websocket must be connected") + require.Equal(t, connectedState, ws.state.Load(), "websocket must be connected") for i := 0; i < 6; i++ { // Timeout will happen at 200ms so we want 6 * 50ms checks to pass select { @@ -225,7 +225,7 @@ func TestTrafficMonitorTrafficAlerts(t *testing.T) { } require.EventuallyWithT(t, func(c *assert.CollectT) { - assert.Equal(c, disconnected, ws.state.Load(), "websocket must be disconnected") + assert.Equal(c, disconnectedState, ws.state.Load(), "websocket must be disconnected") assert.False(c, ws.IsTrafficMonitorRunning(), "trafficMonitor should be shut down") }, 2*ws.trafficTimeout, patience, "trafficTimeout should trigger a shutdown once we stop feeding trafficAlerts") } @@ -237,16 +237,16 @@ func TestTrafficMonitorConnecting(t *testing.T) { err := ws.Setup(defaultSetup) require.NoError(t, err, "Setup must not error") - ws.state.Store(connecting) + ws.state.Store(connectingState) ws.trafficTimeout = 50 * time.Millisecond ws.trafficMonitor() require.True(t, ws.IsTrafficMonitorRunning(), "traffic monitor should be running") - require.Equal(t, connecting, ws.state.Load(), "websocket must be connecting") + require.Equal(t, connectingState, ws.state.Load(), "websocket must be connecting") <-time.After(4 * ws.trafficTimeout) - require.Equal(t, connecting, ws.state.Load(), "websocket must still be connecting after several checks") - ws.state.Store(connected) + require.Equal(t, connectingState, ws.state.Load(), "websocket must still be connecting after several checks") + ws.state.Store(connectedState) require.EventuallyWithT(t, func(c *assert.CollectT) { - assert.Equal(c, disconnected, ws.state.Load(), "websocket must be disconnected") + assert.Equal(c, disconnectedState, ws.state.Load(), "websocket must be disconnected") assert.False(c, ws.IsTrafficMonitorRunning(), "trafficMonitor should be shut down") }, 4*ws.trafficTimeout, 10*time.Millisecond, "trafficTimeout should trigger a shutdown after connecting status changes") } @@ -258,7 +258,7 @@ func TestTrafficMonitorShutdown(t *testing.T) { err := ws.Setup(defaultSetup) require.NoError(t, err, "Setup must not error") - ws.state.Store(connected) + ws.state.Store(connectedState) ws.trafficTimeout = time.Minute ws.trafficMonitor() assert.True(t, ws.IsTrafficMonitorRunning(), "traffic monitor should be running") @@ -304,16 +304,16 @@ func TestConnectionMessageErrors(t *testing.T) { assert.ErrorIs(t, err, ErrWebsocketNotEnabled, "Connect should error correctly") wsWrong.setEnabled(true) - wsWrong.setState(connecting) + wsWrong.setState(connectingState) err = wsWrong.Connect() assert.ErrorIs(t, err, errAlreadyReconnecting, "Connect should error correctly") - wsWrong.setState(disconnected) + wsWrong.setState(disconnectedState) err = wsWrong.Connect() assert.ErrorIs(t, err, common.ErrNilPointer, "Connect should get a nil pointer error, presumably on subs") wsWrong.subscriptions = subscription.NewStore() - wsWrong.setState(disconnected) + wsWrong.setState(disconnectedState) wsWrong.connector = func() error { return errDastardlyReason } err = wsWrong.Connect() assert.ErrorIs(t, err, errDastardlyReason, "Connect should error correctly") @@ -379,7 +379,7 @@ func TestWebsocket(t *testing.T) { err = ws.SetProxyAddress("https://192.168.0.1:1337") assert.NoError(t, err, "SetProxyAddress should not error when not yet connected") - ws.setState(connected) + ws.setState(connectedState) err = ws.SetProxyAddress("https://192.168.0.1:1336") assert.ErrorIs(t, err, errDastardlyReason, "SetProxyAddress should call Connect and error from there") @@ -402,14 +402,14 @@ func TestWebsocket(t *testing.T) { assert.Equal(t, "wss://testRunningURL", ws.GetWebsocketURL(), "GetWebsocketURL should return correctly") assert.Equal(t, time.Second*5, ws.trafficTimeout, "trafficTimeout should default correctly") - ws.setState(connected) + ws.setState(connectedState) ws.AuthConn = &dodgyConnection{} err = ws.Shutdown() assert.ErrorIs(t, err, errDastardlyReason, "Shutdown should error correctly with a dodgy authConn") assert.ErrorIs(t, err, errCannotShutdown, "Shutdown should error correctly with a dodgy authConn") ws.AuthConn = &WebsocketConnection{} - ws.setState(disconnected) + ws.setState(disconnectedState) err = ws.Connect() assert.NoError(t, err, "Connect should not error") @@ -853,7 +853,7 @@ func TestCanUseAuthenticatedWebsocketForWrapper(t *testing.T) { ws := &Websocket{} assert.False(t, ws.CanUseAuthenticatedWebsocketForWrapper(), "CanUseAuthenticatedWebsocketForWrapper should return false") - ws.setState(connected) + ws.setState(connectedState) require.True(t, ws.IsConnected(), "IsConnected must return true") assert.False(t, ws.CanUseAuthenticatedWebsocketForWrapper(), "CanUseAuthenticatedWebsocketForWrapper should return false") @@ -987,7 +987,7 @@ func TestFlushChannels(t *testing.T) { w.trafficTimeout = time.Second * 30 w.setEnabled(true) - w.setState(connected) + w.setState(connectedState) problemFunc := func() (subscription.List, error) { return nil, errDastardlyReason @@ -1042,7 +1042,7 @@ func TestFlushChannels(t *testing.T) { err = w.FlushChannels() assert.NoError(t, err, "FlushChannels should not error") - w.setState(connected) + w.setState(connectedState) w.features.Unsubscribe = true err = w.FlushChannels() assert.NoError(t, err, "FlushChannels should not error") @@ -1052,7 +1052,7 @@ func TestDisable(t *testing.T) { t.Parallel() w := NewWebsocket() w.setEnabled(true) - w.setState(connected) + w.setState(connectedState) require.NoError(t, w.Disable(), "Disable must not error") assert.ErrorIs(t, w.Disable(), ErrAlreadyDisabled, "Disable should error correctly") } diff --git a/exchanges/stream/websocket_types.go b/exchanges/stream/websocket_types.go index 353003d0a21..707fc7dcb05 100644 --- a/exchanges/stream/websocket_types.go +++ b/exchanges/stream/websocket_types.go @@ -23,10 +23,10 @@ const ( ) const ( - uninitialised uint32 = iota - disconnected - connecting - connected + uninitialisedState uint32 = iota + disconnectedState + connectingState + connectedState ) // Websocket defines a return type for websocket connections via the interface