feat: authsession service

authsession/internal/service/shared/projection_publish_test.go

@@ -0,0 +1,119 @@
+package shared
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"galaxy/authsession/internal/domain/devicesession"
+	"galaxy/authsession/internal/domain/gatewayprojection"
+	"galaxy/authsession/internal/testkit"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPublishSessionProjectionRetriesUntilSuccess(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name         string
+		errors       []error
+		wantAttempts int
+	}{
+		{
+			name:         "success on second attempt",
+			errors:       []error{errors.New("transient publish failure"), nil},
+			wantAttempts: 2,
+		},
+		{
+			name:         "success on third attempt",
+			errors:       []error{errors.New("transient publish failure"), errors.New("transient publish failure"), nil},
+			wantAttempts: 3,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			publisher := &testkit.RecordingProjectionPublisher{Errors: tt.errors}
+
+			err := PublishSessionProjection(context.Background(), publisher, revokedSessionFixture())
+			require.NoError(t, err)
+			require.Len(t, publisher.PublishedSnapshots(), tt.wantAttempts)
+		})
+	}
+}
+
+func TestPublishSessionProjectionReturnsServiceUnavailableAfterExhaustedRetries(t *testing.T) {
+	t.Parallel()
+
+	publisher := &testkit.RecordingProjectionPublisher{Err: errors.New("publish failed")}
+
+	err := PublishSessionProjection(context.Background(), publisher, revokedSessionFixture())
+	require.Error(t, err)
+	assert.Equal(t, ErrorCodeServiceUnavailable, CodeOf(err))
+	require.Len(t, publisher.PublishedSnapshots(), MaxProjectionPublishAttempts)
+}
+
+func TestPublishProjectionSnapshotStopsRetriesWhenContextIsCanceled(t *testing.T) {
+	t.Parallel()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	publisher := &cancelingProjectionPublisher{
+		cancel: cancel,
+		err:    errors.New("publish failed"),
+	}
+
+	err := PublishProjectionSnapshot(ctx, publisher, mustProjectionSnapshot(t))
+	require.Error(t, err)
+	assert.Equal(t, ErrorCodeServiceUnavailable, CodeOf(err))
+	assert.Equal(t, 1, publisher.attempts)
+}
+
+func TestPublishSessionProjectionReturnsInternalErrorForInvalidLocalRecord(t *testing.T) {
+	t.Parallel()
+
+	publisher := &testkit.RecordingProjectionPublisher{}
+
+	err := PublishSessionProjection(context.Background(), publisher, invalidSessionFixture())
+	require.Error(t, err)
+	assert.Equal(t, ErrorCodeInternalError, CodeOf(err))
+	assert.Empty(t, publisher.PublishedSnapshots())
+}
+
+type cancelingProjectionPublisher struct {
+	attempts int
+	cancel   context.CancelFunc
+	err      error
+}
+
+func (p *cancelingProjectionPublisher) PublishSession(_ context.Context, snapshot gatewayprojection.Snapshot) error {
+	if err := snapshot.Validate(); err != nil {
+		return err
+	}
+
+	p.attempts++
+	if p.cancel != nil {
+		p.cancel()
+		p.cancel = nil
+	}
+
+	return p.err
+}
+
+func mustProjectionSnapshot(t *testing.T) gatewayprojection.Snapshot {
+	t.Helper()
+
+	snapshot, err := ToGatewayProjectionSnapshot(revokedSessionFixture())
+	require.NoError(t, err)
+
+	return snapshot
+}
+
+func invalidSessionFixture() devicesession.Session {
+	return devicesession.Session{}
+}