chore: Update tests

BaseServer now receives a pointer since it owns a mutex.

+ adding more tests for the lifecycle flows

Author: alexjba

pkg/messaging/waku/api_test.go

@@ -63,6 +63,54 @@ func TestRunPausedPollingLoopSkipsWhenPausedAndResumes(t *testing.T) {
 		case tickerCh <- time.Now():
 		default:
 		}
+		return ticks.Load() >= 1
+	}, time.Second, 20*time.Millisecond)
+
+	stopCh <- nil
+	require.Eventually(t, func() bool {
+		return len(stopped) == 1
+	}, time.Second, 20*time.Millisecond)
+}
+
+func TestRunPausedPollingLoopStopsWhenLifecycleChannelCloses(t *testing.T) {
+	lifecycleCh := make(chan bool)
+	tickerCh := make(chan time.Time, 1)
+	stopCh := make(chan error, 1)
+
+	stopped := make(chan struct{}, 1)
+	go runPausedPollingLoop(
+		false,
+		lifecycleCh,
+		tickerCh,
+		stopCh,
+		func() {},
+		func() { stopped <- struct{}{} },
+	)
+
+	close(lifecycleCh)
+	require.Eventually(t, func() bool {
+		return len(stopped) == 1
+	}, time.Second, 20*time.Millisecond)
+}
+
+func TestRunPausedPollingLoopStopsOnStopSignal(t *testing.T) {
+	lifecycleCh := make(chan bool, 1)
+	tickerCh := make(chan time.Time, 1)
+	stopCh := make(chan error, 1)
+
+	var ticks atomic.Int32
+	stopped := make(chan struct{}, 1)
+	go runPausedPollingLoop(
+		false,
+		lifecycleCh,
+		tickerCh,
+		stopCh,
+		func() { ticks.Add(1) },
+		func() { stopped <- struct{}{} },
+	)
+
+	tickerCh <- time.Now()
+	require.Eventually(t, func() bool {
 		return ticks.Load() == 1
 	}, time.Second, 20*time.Millisecond)
 

protocol/communities/manager_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/status-im/status-go/internal/testutils/fake"
 	"github.com/status-im/status-go/params"
 	"github.com/status-im/status-go/pkg/messaging"
+	messaginglifecycle "github.com/status-im/status-go/pkg/messaging/lifecycle"
 	"github.com/status-im/status-go/pkg/messaging/types"
 	community_token "github.com/status-im/status-go/protocol/communities/token"
 	"github.com/status-im/status-go/protocol/protobuf"
@@ -519,6 +520,33 @@ func (s *ManagerSuite) TestStartHistoryArchiveTasksInterval() {
 	s.Require().Equal(count, 0)
 }
 
+func (s *ManagerSuite) TestStartHistoryArchiveTasksInterval_RespectsPausedLifecycle() {
+	err := s.archiveManager.StartTorrentClient()
+	s.Require().NoError(err)
+	defer s.archiveManager.Stop() //nolint: errcheck
+
+	messaginglifecycle.SetPausedBackground(true)
+	defer messaginglifecycle.SetPausedBackground(false)
+
+	community, _, err := s.buildCommunityWithChat()
+	s.Require().NoError(err)
+
+	interval := 300 * time.Millisecond
+	go s.archiveManager.StartHistoryArchiveTasksInterval(community, interval)
+
+	time.Sleep(200 * time.Millisecond)
+	s.Require().Equal(1, s.getHistoryTasksCount())
+
+	// Unpause to exercise lifecycle transition handling in the running loop.
+	messaginglifecycle.SetPausedBackground(false)
+	time.Sleep(200 * time.Millisecond)
+	s.Require().Equal(1, s.getHistoryTasksCount())
+
+	s.archiveManager.StopHistoryArchiveTasksInterval(community.ID())
+	s.archiveManager.historyArchiveTasksWaitGroup.Wait()
+	s.Require().Equal(0, s.getHistoryTasksCount())
+}
+
 func (s *ManagerSuite) TestStopHistoryArchiveTasksIntervals() {
 	err := s.archiveManager.StartTorrentClient()
 	s.Require().NoError(err)

protocol/local_notifications_test.go

@@ -76,6 +76,66 @@ func TestApplyMessagePreview(t *testing.T) {
 	})
 }
 
+func TestGetMessagePreviewTextNilMessage(t *testing.T) {
+	require.Equal(t, "", getMessagePreviewText(nil, nil))
+}
+
+func TestGetMessagePreviewTextTrimsMessageText(t *testing.T) {
+	msg := &common.Message{
+		ChatMessage: &protobuf.ChatMessage{
+			Text: "  hello world  ",
+		},
+	}
+	require.Equal(t, "hello world", getMessagePreviewText(msg, nil))
+}
+
+func TestTimestampOrZero(t *testing.T) {
+	require.Equal(t, uint64(0), timestampOrZero(nil))
+
+	msg := &common.Message{WhisperTimestamp: 42}
+	require.Equal(t, uint64(42), timestampOrZero(msg))
+}
+
+func TestToContactRequestNotificationFallbackMessageAndZeroTimestamp(t *testing.T) {
+	body := NotificationBody{
+		Contact: &contacts.Contact{
+			ID:          "0xabc",
+			DisplayName: "Alice",
+		},
+		Chat: &Chat{
+			ID:       "chat-1",
+			ChatType: ChatTypeOneToOne,
+		},
+	}
+
+	notif, err := body.toContactRequestNotification("0x1", 0, messagePreviewNameAndMessage)
+	require.NoError(t, err)
+	require.Equal(t, "Alice sent you a contact request", notif.Message)
+	require.Equal(t, uint64(0), notif.Timestamp)
+}
+
+func TestToPrivateGroupInviteNotificationUsesMessagePreviewWhenPresent(t *testing.T) {
+	body := NotificationBody{
+		Contact: &contacts.Contact{
+			ID:          "0xabc",
+			DisplayName: "Alice",
+		},
+		Chat: &Chat{
+			ID:       "group-1",
+			Name:     "Secret Group",
+			ChatType: ChatTypePrivateGroupChat,
+		},
+		Message: &common.Message{
+			ChatMessage: &protobuf.ChatMessage{
+				Text: "  please join us  ",
+			},
+		},
+	}
+
+	notif := body.toPrivateGroupInviteNotification("0x2", 0, messagePreviewNameAndMessage)
+	require.Equal(t, "please join us", notif.Message)
+}
+
 func TestShowMessageNotification_OneToOneChats(t *testing.T) {
 	key, _ := crypto.GenerateKey()
 	pkHex := types.EncodeHex(crypto.FromECDSAPub(&key.PublicKey))

server/lifecycle_test.go

@@ -0,0 +1,46 @@
+package server
+
+import (
+	"net/netip"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+)
+
+func TestGetBindAddrPortUsesCachedPortForEphemeralConfig(t *testing.T) {
+	s := NewServer(zap.NewNop(), &Config{
+		AddrPort: netip.MustParseAddrPort("127.0.0.1:0"),
+	})
+	s.cachedPort = 45678
+
+	require.Equal(t, netip.MustParseAddrPort("127.0.0.1:45678"), s.getBindAddrPort())
+}
+
+func TestServerToBackgroundToForegroundReusesEphemeralPort(t *testing.T) {
+	s := NewServer(zap.NewNop(), &Config{
+		AddrPort: netip.MustParseAddrPort("127.0.0.1:0"),
+	})
+
+	require.NoError(t, s.Start())
+	require.Eventually(t, func() bool {
+		return s.GetPort() != 0
+	}, time.Second, 10*time.Millisecond)
+
+	firstPort := s.GetPort()
+	require.NotZero(t, firstPort)
+
+	s.ToBackground()
+	require.Eventually(t, func() bool {
+		return !s.IsRunning()
+	}, time.Second, 10*time.Millisecond)
+
+	s.ToForeground()
+	require.Eventually(t, func() bool {
+		return s.IsRunning() && s.GetPort() != 0
+	}, time.Second, 10*time.Millisecond)
+
+	require.Equal(t, firstPort, s.GetPort())
+	require.NoError(t, s.Stop())
+}

server/pairing/connection_test.go

@@ -73,7 +73,7 @@ func (s *ConnectionParamsSuite) SetupSuite() {
 	s.Require().NoError(err)
 
 	s.server = &BaseServer{
-		Server: bs,
+		Server: &bs,
 		config: sc,
 	}
 }

server/pairing/server.go

@@ -29,7 +29,7 @@ import (
 */
 
 type BaseServer struct {
-	server.Server
+	*server.Server
 	challengeGiver *ChallengeGiver
 
 	config ServerConfig
@@ -47,14 +47,15 @@ func NewBaseServer(logger *zap.Logger, e *PayloadEncryptor, config *ServerConfig
 		return nil, errorspkg.New("invalid listen IP")
 	}
 
+	srv := server.NewServer(
+		logger,
+		&server.Config{
+			Cert:     config.Cert,
+			AddrPort: netip.AddrPortFrom(addr, 0),
+		},
+	)
 	bs := &BaseServer{
-		Server: server.NewServer(
-			logger,
-			&server.Config{
-				Cert:     config.Cert,
-				AddrPort: netip.AddrPortFrom(addr, 0),
-			},
-		),
+		Server:         &srv,
 		challengeGiver: cg,
 		config:         *config,
 	}

server/server.go

@@ -10,6 +10,8 @@ import (
 	"net/url"
 	"strconv"
 	"sync"
+	"syscall"
+	"time"
 
 	"go.uber.org/zap"
 
@@ -153,15 +155,22 @@ func (s *Server) listen() error {
 	return nil
 }
 
-func (s *Server) serve() {
+func (s *Server) serve(currentServer *http.Server, currentListener net.Listener) {
 	defer common.LogOnPanic()
 
 	defer func() {
-		s.isRunning = false
-		s.address = nil
+		s.lifecycleMu.Lock()
+		defer s.lifecycleMu.Unlock()
+
+		// If a newer Start() already replaced server/listener, do not clobber
+		// the latest running instance state.
+		if s.server == currentServer && s.listener == currentListener {
+			s.isRunning = false
+			s.address = nil
+		}
 	}()
 
-	err := s.server.Serve(s.listener)
+	err := currentServer.Serve(currentListener)
 	if errors.Is(err, http.ErrServerClosed) {
 		return
 	}
@@ -209,23 +218,26 @@ func (s *Server) Start() error {
 	// Mark running synchronously to avoid pause/play races where ToBackground
 	// can run before serve() goroutine has a chance to set the state.
 	s.isRunning = true
-	go s.serve()
+	go s.serve(s.server, s.listener)
 	return nil
 }
 
 func (s *Server) Stop() error {
 	s.lifecycleMu.Lock()
-	defer s.lifecycleMu.Unlock()
-
 	s.StopTimeout()
 	if !s.isRunning || s.server == nil {
+		s.lifecycleMu.Unlock()
 		return nil
 	}
 
-	// Flip state before shutdown so rapid foreground/background transitions
-	// don't attempt a concurrent second bind to a cached port.
+	// Capture the current instance and release the lock before Shutdown.
+	// Shutdown waits for Serve() to return, and Serve() may update state in
+	// its defer path under the same mutex.
+	currentServer := s.server
 	s.isRunning = false
-	return s.server.Shutdown(context.Background())
+	s.lifecycleMu.Unlock()
+
+	return currentServer.Shutdown(context.Background())
 }
 
 func (s *Server) IsRunning() bool {
@@ -234,9 +246,26 @@ func (s *Server) IsRunning() bool {
 
 func (s *Server) ToForeground() {
 	err := s.Start()
-	if err != nil {
-		s.logger.Error("server start failed during foreground transition", zap.Error(err))
+	if err == nil {
+		return
+	}
+
+	// On rapid pause/resume cycles with ephemeral ports, the previous listener
+	// close can lag briefly and return EADDRINUSE for the cached port.
+	// Retry a few times to preserve stable URL reuse semantics.
+	if s.config != nil && s.config.AddrPort.Port() == 0 && s.cachedPort != 0 && errors.Is(err, syscall.EADDRINUSE) {
+		for i := 0; i < 10; i++ {
+			time.Sleep(20 * time.Millisecond)
+			err = s.Start()
+			if err == nil {
+				return
+			}
+			if !errors.Is(err, syscall.EADDRINUSE) {
+				break
+			}
+		}
 	}
+	s.logger.Error("server start failed during foreground transition", zap.Error(err))
 }
 
 func (s *Server) ToBackground() {

services/ext/service_test.go

@@ -0,0 +1,31 @@
+package ext
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	messaginglifecycle "github.com/status-im/status-go/pkg/messaging/lifecycle"
+	"github.com/status-im/status-go/protocol"
+)
+
+func TestServicePauseResumeBackgroundWithNilMessenger(t *testing.T) {
+	svc := &Service{}
+	require.NoError(t, svc.PauseBackground())
+	require.NoError(t, svc.ResumeForeground())
+}
+
+func TestServicePauseResumeBackgroundUpdatesLifecycleState(t *testing.T) {
+	messaginglifecycle.SetPausedBackground(false)
+	defer messaginglifecycle.SetPausedBackground(false)
+
+	svc := &Service{
+		messenger: &protocol.Messenger{},
+	}
+
+	require.NoError(t, svc.PauseBackground())
+	require.True(t, messaginglifecycle.IsPausedBackground())
+
+	require.NoError(t, svc.ResumeForeground())
+	require.False(t, messaginglifecycle.IsPausedBackground())
+}

services/newsfeed/service_test.go

@@ -120,3 +120,17 @@ func (s *MessengerNewsFeedSuite) TestToggleSettings() {
 	s.service.newsFeedManager.StopPolling()
 	s.Require().False(s.service.newsFeedManager.IsPolling())
 }
+
+func (s *MessengerNewsFeedSuite) TestPauseResumeBackground() {
+	err := s.service.Start()
+	s.Require().NoError(err)
+	s.Require().True(s.service.started)
+
+	err = s.service.PauseBackground()
+	s.Require().NoError(err)
+	s.Require().False(s.service.started)
+
+	err = s.service.ResumeForeground()
+	s.Require().NoError(err)
+	s.Require().True(s.service.started)
+}