test: add comprehensive unit tests for session registry operations

Introduced extensive test coverage for `Registry` methods, including `ReadSessions` and `WriteSessions`. Added scenarios for session reading, writing, cookie management, error handling, and integration flows to improve reliability and maintainability.

Author: iagapie

session/registry_test.go

@@ -1,9 +1,13 @@
 package session
 
 import (
+	"net/http"
+	"net/http/httptest"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 )
 
 func TestNewRegistry(t *testing.T) {
@@ -251,6 +255,299 @@ func TestRegistry_SpecialCookieNames(t *testing.T) {
 	}
 }
 
+func TestRegistry_ReadSessions(t *testing.T) {
+	session1 := createTestSession("session1")
+	session2 := createTestSession("session2")
+	session3 := createTestSession("session3")
+
+	tests := []struct {
+		name        string
+		sessions    []*Session
+		setup       func(*testing.T, *http.Request)
+		expectError bool
+		errorMsg    string
+		cookieCount int
+	}{
+		{
+			name:     "read all sessions successfully",
+			sessions: []*Session{session1, session2, session3},
+			setup: func(t *testing.T, req *http.Request) {
+				req.AddCookie(&http.Cookie{Name: "session1", Value: "token1"})
+				req.AddCookie(&http.Cookie{Name: "session2", Value: "token2"})
+				req.AddCookie(&http.Cookie{Name: "session3", Value: "token3"})
+			},
+			cookieCount: 3,
+		},
+		{
+			name:     "read with partial cookies",
+			sessions: []*Session{session1, session2, session3},
+			setup: func(t *testing.T, req *http.Request) {
+				req.AddCookie(&http.Cookie{Name: "session2", Value: "token2"})
+			},
+			cookieCount: 1,
+		},
+		{
+			name:        "read with no cookies",
+			sessions:    []*Session{session1, session2, session3},
+			setup:       func(t *testing.T, req *http.Request) {},
+			cookieCount: 0,
+		},
+		{
+			name:        "empty registry reads successfully",
+			sessions:    []*Session{},
+			setup:       func(t *testing.T, req *http.Request) {},
+			cookieCount: 0,
+		},
+		{
+			name:     "single session",
+			sessions: []*Session{session1},
+			setup: func(t *testing.T, req *http.Request) {
+				req.AddCookie(&http.Cookie{Name: "session1", Value: "token1"})
+			},
+			cookieCount: 1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockStore := new(MockStore)
+			mockStore.On("Find", mock.Anything, mock.Anything).Return([]byte{}, false, nil)
+
+			registry := NewRegistry(tt.sessions...)
+
+			for _, s := range registry.All() {
+				s.store = mockStore
+			}
+
+			req := httptest.NewRequest(http.MethodGet, "/", nil)
+			tt.setup(t, req)
+
+			got, err := registry.ReadSessions(req)
+
+			if tt.expectError {
+				assert.Error(t, err)
+				assert.Contains(t, err.Error(), tt.errorMsg)
+			} else {
+				assert.NoError(t, err)
+				assert.NotNil(t, got)
+			}
+
+			if len(tt.sessions) > 0 {
+				mockStore.AssertNumberOfCalls(t, "Find", tt.cookieCount)
+			}
+		})
+	}
+}
+
+func TestRegistry_WriteSessions(t *testing.T) {
+	tests := []struct {
+		name          string
+		sessions      []*Session
+		modifySession func(*testing.T, *http.Request, *Registry)
+		expectError   bool
+		verifyCookies func(*testing.T, *http.Response)
+	}{
+		{
+			name:     "write modified session",
+			sessions: []*Session{createTestSession("session1")},
+			modifySession: func(t *testing.T, req *http.Request, registry *Registry) {
+				registry.All()[0].Put(req.Context(), "key", "value")
+			},
+			verifyCookies: func(t *testing.T, resp *http.Response) {
+				cookies := resp.Cookies()
+				assert.Len(t, cookies, 1)
+				assert.Equal(t, "session1", cookies[0].Name)
+			},
+		},
+		{
+			name:     "write destroyed session",
+			sessions: []*Session{createTestSession("session1")},
+			modifySession: func(t *testing.T, req *http.Request, registry *Registry) {
+				err := registry.All()[0].Destroy(req.Context())
+				assert.NoError(t, err)
+			},
+			verifyCookies: func(t *testing.T, resp *http.Response) {
+				cookies := resp.Cookies()
+				assert.Len(t, cookies, 1)
+				assert.Equal(t, "session1", cookies[0].Name)
+				assert.Equal(t, -1, cookies[0].MaxAge)
+			},
+		},
+		{
+			name:          "unmodified session - default case",
+			sessions:      []*Session{createTestSession("session1")},
+			modifySession: func(t *testing.T, req *http.Request, registry *Registry) {},
+			verifyCookies: func(t *testing.T, resp *http.Response) {
+				cookies := resp.Cookies()
+				assert.Len(t, cookies, 0)
+			},
+		},
+		{
+			name:     "multiple sessions with mixed statuses",
+			sessions: []*Session{createTestSession("session1"), createTestSession("session2"), createTestSession("session3")},
+			modifySession: func(t *testing.T, req *http.Request, registry *Registry) {
+				sessions := registry.All()
+				sessions[0].Put(req.Context(), "key1", "value1")
+				err := sessions[1].Destroy(req.Context())
+				assert.NoError(t, err)
+			},
+			verifyCookies: func(t *testing.T, resp *http.Response) {
+				cookies := resp.Cookies()
+				assert.Len(t, cookies, 2)
+			},
+		},
+		{
+			name:          "empty registry writes successfully",
+			sessions:      []*Session{},
+			modifySession: func(t *testing.T, req *http.Request, registry *Registry) {},
+			verifyCookies: func(t *testing.T, resp *http.Response) {
+				cookies := resp.Cookies()
+				assert.Len(t, cookies, 0)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockStore := new(MockStore)
+			mockStore.On("Find", mock.Anything, mock.Anything).Return([]byte{}, false, nil)
+			mockStore.On("Commit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
+			mockStore.On("Delete", mock.Anything, mock.Anything).Return(nil)
+
+			registry := NewRegistry(tt.sessions...)
+
+			req := httptest.NewRequest(http.MethodGet, "/", nil)
+			w := httptest.NewRecorder()
+
+			for _, s := range registry.All() {
+				s.store = mockStore
+			}
+
+			req, err := registry.ReadSessions(req)
+			assert.NoError(t, err)
+
+			tt.modifySession(t, req, registry)
+
+			err = registry.WriteSessions(w, req)
+
+			if tt.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+
+			tt.verifyCookies(t, w.Result())
+		})
+	}
+}
+
+func TestRegistry_WriteSessions_ErrorHandling(t *testing.T) {
+	tests := []struct {
+		name          string
+		modifySession func(*testing.T, *http.Request, *Registry)
+		errorContains string
+	}{
+		{
+			name: "commit error is joined and returned",
+			modifySession: func(t *testing.T, req *http.Request, registry *Registry) {
+				registry.All()[0].Put(req.Context(), "key", "value")
+			},
+			errorContains: "session session1",
+		},
+		{
+			name: "multiple commit errors are joined",
+			modifySession: func(t *testing.T, req *http.Request, registry *Registry) {
+				sessions := registry.All()
+				sessions[0].Put(req.Context(), "key1", "value1")
+				sessions[1].Put(req.Context(), "key2", "value2")
+			},
+			errorContains: "session session1",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockStore := new(MockStore)
+			mockStore.On("Find", mock.Anything, mock.Anything).Return([]byte{}, false, nil)
+			mockStore.On("Commit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(assert.AnError)
+
+			registry := NewRegistry(createTestSession("session1"), createTestSession("session2"))
+
+			req := httptest.NewRequest(http.MethodGet, "/", nil)
+			w := httptest.NewRecorder()
+
+			for _, s := range registry.All() {
+				s.store = mockStore
+			}
+
+			req, err := registry.ReadSessions(req)
+			assert.NoError(t, err)
+
+			tt.modifySession(t, req, registry)
+
+			err = registry.WriteSessions(w, req)
+			assert.Error(t, err)
+			assert.Contains(t, err.Error(), tt.errorContains)
+		})
+	}
+}
+
+func TestRegistry_Integration_ReadWriteSessions(t *testing.T) {
+	mockStore := new(MockStore)
+	mockStore.On("Find", mock.Anything, mock.Anything).Return([]byte{}, false, nil)
+	mockStore.On("Commit", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
+
+	sessions := []*Session{createTestSession("session1"), createTestSession("session2")}
+	registry := NewRegistry(sessions...)
+
+	for _, s := range registry.All() {
+		s.store = mockStore
+	}
+
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	w := httptest.NewRecorder()
+
+	req, err := registry.ReadSessions(req)
+	assert.NoError(t, err)
+
+	sessions[0].Put(req.Context(), "key1", "value1")
+
+	err = registry.WriteSessions(w, req)
+	assert.NoError(t, err)
+
+	cookies := w.Result().Cookies()
+	assert.Len(t, cookies, 1)
+	assert.Equal(t, "session1", cookies[0].Name)
+}
+
+func TestRegistry_WriteSessions_DestroyedExpiry(t *testing.T) {
+	mockStore := new(MockStore)
+	mockStore.On("Find", mock.Anything, mock.Anything).Return([]byte{}, false, nil)
+	mockStore.On("Delete", mock.Anything, mock.Anything).Return(nil)
+
+	session := createTestSession("session1")
+	session.store = mockStore
+
+	registry := NewRegistry(session)
+
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	w := httptest.NewRecorder()
+
+	req, err := registry.ReadSessions(req)
+	assert.NoError(t, err)
+
+	err = session.Destroy(req.Context())
+	assert.NoError(t, err)
+
+	err = registry.WriteSessions(w, req)
+	assert.NoError(t, err)
+
+	cookies := w.Result().Cookies()
+	assert.Len(t, cookies, 1)
+	assert.Equal(t, -1, cookies[0].MaxAge)
+	assert.True(t, cookies[0].Expires.Equal(time.Unix(1, 0).UTC()))
+}
+
 func createTestSession(cookieName string) *Session {
 	config := Config{
 		Cookie: Cookie{