unflakey unit test (#258)

- i think init timeout test has been failing bc of the addition of
thread spawning step by the sampling set when creating the logger, which
is not being timed
- moved the thread spawning step into the timed init() function
- added ttl set unit test
- edit init timeout test to check that the store and the ttl set are
being initialized in the background
- got a warning that errors should not have capitalization so changed
that and updated unit test
![Screenshot 2025-01-21 at 6 07
49 PM](https://github.com/user-attachments/assets/03192cfb-32ce-45c9-ba3a-7ce73ad5609a)

Author: kat-statsig

client.go

@@ -81,7 +81,7 @@ func newClientImpl(sdkKey string, options *Options) (*Client, *initContext) {
 			diagnostics.initialize().overall().end().success(false).reason("timeout").mark()
 			client.initInBackground()
 			ctx := context.copy() // Goroutines are not terminated upon timeout. Clone context to avoid race condition on setting Error
-			ctx.setError(errors.New("Timed out"))
+			ctx.setError(errors.New("timed out"))
 			return client, ctx
 		}
 	} else {
@@ -96,12 +96,14 @@ func (c *Client) init(context *initContext) {
 	c.evaluator.initialize(context)
 	c.evaluator.store.mu.RLock()
 	defer c.evaluator.store.mu.RUnlock()
+	c.logger.samplingKeySet.StartResetThread()
 	context.setSuccess(c.evaluator.store.source != SourceUninitialized)
 	context.setSource(c.evaluator.store.source)
 }
 
 func (c *Client) initInBackground() {
 	c.evaluator.store.startPolling()
+	c.logger.samplingKeySet.StartResetThread()
 }
 
 // Checks the value of a Feature Gate for the given user

init_details_test.go

@@ -100,7 +100,7 @@ func TestInitDetails(t *testing.T) {
 		if details.Success {
 			t.Errorf("Expected initalize success to be false")
 		}
-		if details.Error.Error() != "Timed out" {
+		if details.Error.Error() != "timed out" {
 			t.Errorf("Expected initalize to have timeout error")
 		}
 		if details.Source != SourceUninitialized {

init_timeout_test.go

@@ -18,7 +18,7 @@ func TestInitTimeout(t *testing.T) {
 	defer testServer.Close()
 
 	user := User{UserID: "some_user_id"}
-	initTimeBuffer := 2 * time.Millisecond // expected runtime buffer for initialize with timeout
+	initTimeBuffer := 5 * time.Millisecond // expected runtime buffer for initialize with timeout
 
 	t.Run("No timeout option", func(t *testing.T) {
 		options := &Options{
@@ -83,6 +83,13 @@ func TestInitTimeout(t *testing.T) {
 		if gate != false {
 			t.Errorf("Expected gate to be default off")
 		}
+		if !instance.evaluator.store.isPolling {
+			t.Errorf("Expected evaluator store background polling to start")
+		}
+		if !instance.logger.samplingKeySet.isBackgroundThreadRunning {
+			t.Errorf("Expected sampling key set background thread to start")
+		}
+
 		ShutdownAndDangerouslyClearInstance()
 	})
 }

ttl_set.go

@@ -7,10 +7,11 @@ import (
 )
 
 type TTLSet struct {
-	store         map[string]struct{}
-	mu            sync.RWMutex
-	resetInterval time.Duration
-	shutdown      bool
+	store                     map[string]struct{}
+	mu                        sync.RWMutex
+	resetInterval             time.Duration
+	shutdown                  bool
+	isBackgroundThreadRunning bool
 }
 
 func NewTTLSet() *TTLSet {
@@ -19,7 +20,6 @@ func NewTTLSet() *TTLSet {
 		resetInterval: time.Minute,
 	}
 
-	go set.startResetThread()
 	return set
 }
 
@@ -36,38 +36,43 @@ func (s *TTLSet) Contains(key string) bool {
 	return exists
 }
 
-func (s *TTLSet) Reset() {
+func (s *TTLSet) Shutdown() {
 	s.mu.Lock()
-	s.store = make(map[string]struct{})
-	s.mu.Unlock()
+	defer s.mu.Unlock()
+	s.shutdown = true
+	s.isBackgroundThreadRunning = false
 }
 
-func (s *TTLSet) Shutdown() {
+func (s *TTLSet) StartResetThread() {
 	s.mu.Lock()
-	s.shutdown = true
+	if s.isBackgroundThreadRunning {
+		s.mu.Unlock()
+		return
+	}
+	s.isBackgroundThreadRunning = true
 	s.mu.Unlock()
-}
 
-func (s *TTLSet) startResetThread() {
-	for {
-		time.Sleep(s.resetInterval)
-		stop := func() bool {
-			s.mu.RLock()
-			defer s.mu.RUnlock()
-			return s.shutdown
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				err := errors.New("panic in TTLSet reset thread")
+				Logger().LogError(err)
+			}
 		}()
-		if stop {
-			break
-		}
-
-		func() {
-			defer func() {
-				if r := recover(); r != nil {
-					err := errors.New("panic in TTLSet reset thread")
-					Logger().LogError(err)
-				}
+		for {
+			time.Sleep(s.resetInterval)
+			stop := func() bool {
+				s.mu.RLock()
+				defer s.mu.RUnlock()
+				return s.shutdown
 			}()
-			s.Reset()
-		}()
-	}
+			if stop {
+				break
+			}
+
+			s.mu.Lock()
+			s.store = make(map[string]struct{})
+			s.mu.Unlock()
+		}
+	}()
 }

ttl_set_test.go

@@ -0,0 +1,59 @@
+package statsig
+
+import (
+	"testing"
+	"time"
+)
+
+func TestTTLSet_AddAndContains(t *testing.T) {
+	set := NewTTLSet()
+	set.Add("key1")
+	if !set.Contains("key1") {
+		t.Errorf("key1 should exist in the set")
+	}
+	if set.Contains("key2") {
+		t.Errorf("key2 should not exist in the set")
+	}
+}
+
+func TestTTLSet_Reset(t *testing.T) {
+	set := NewTTLSet()
+	set.Add("key1")
+	set.Add("key2")
+	set.store = make(map[string]struct{})
+	if set.Contains("key1") {
+		t.Errorf("key1 should not exist after reset")
+	}
+	if set.Contains("key2") {
+		t.Errorf("key2 should not exist after reset")
+	}
+}
+
+func TestTTLSet_StartResetThread(t *testing.T) {
+	set := NewTTLSet()
+	set.resetInterval = 10 * time.Millisecond
+	set.StartResetThread()
+
+	set.Add("key1")
+	time.Sleep(20 * time.Millisecond)
+	if set.Contains("key1") {
+		t.Errorf("key1 should not exist after automatic reset")
+	}
+
+	set.Shutdown()
+}
+
+func TestTTLSet_Shutdown(t *testing.T) {
+	set := NewTTLSet()
+	set.resetInterval = 10 * time.Millisecond
+	set.StartResetThread()
+
+	set.Add("key1")
+	set.Shutdown()
+	time.Sleep(20 * time.Millisecond)
+
+	set.Add("key2")
+	if !set.Contains("key2") {
+		t.Errorf("shutdown should prevent automatic reset")
+	}
+}