feat: authsession service

2026-04-08 16:23:07 +02:00
parent 28f04916af
commit 86a68ed9d0
174 changed files with 31732 additions and 112 deletions
@@ -0,0 +1,203 @@
+package testkit
+
+import (
+	"context"
+	"errors"
+	"github.com/stretchr/testify/require"
+	"testing"
+
+	"galaxy/authsession/internal/domain/common"
+	"galaxy/authsession/internal/domain/userresolution"
+	"galaxy/authsession/internal/ports"
+)
+
+func TestInMemoryUserDirectoryResolveExistingCreatableAndBlocked(t *testing.T) {
+	t.Parallel()
+
+	directory := &InMemoryUserDirectory{}
+	if err := directory.SeedExisting(common.Email("existing@example.com"), common.UserID("user-existing")); err != nil {
+		require.Failf(t, "test failed", "SeedExisting() returned error: %v", err)
+	}
+	if err := directory.SeedBlockedEmail(common.Email("blocked@example.com"), userresolution.BlockReasonCode("policy_block")); err != nil {
+		require.Failf(t, "test failed", "SeedBlockedEmail() returned error: %v", err)
+	}
+
+	tests := []struct {
+		name     string
+		email    common.Email
+		wantKind userresolution.Kind
+	}{
+		{name: "existing", email: common.Email("existing@example.com"), wantKind: userresolution.KindExisting},
+		{name: "creatable", email: common.Email("new@example.com"), wantKind: userresolution.KindCreatable},
+		{name: "blocked", email: common.Email("blocked@example.com"), wantKind: userresolution.KindBlocked},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := directory.ResolveByEmail(context.Background(), tt.email)
+			if err != nil {
+				require.Failf(t, "test failed", "ResolveByEmail() returned error: %v", err)
+			}
+			if got.Kind != tt.wantKind {
+				require.Failf(t, "test failed", "ResolveByEmail().Kind = %q, want %q", got.Kind, tt.wantKind)
+			}
+		})
+	}
+}
+
+func TestInMemoryUserDirectoryEnsureUserExistingCreatedAndBlocked(t *testing.T) {
+	t.Parallel()
+
+	directory := &InMemoryUserDirectory{}
+	if err := directory.SeedExisting(common.Email("existing@example.com"), common.UserID("user-existing")); err != nil {
+		require.Failf(t, "test failed", "SeedExisting() returned error: %v", err)
+	}
+	if err := directory.SeedBlockedEmail(common.Email("blocked@example.com"), userresolution.BlockReasonCode("policy_block")); err != nil {
+		require.Failf(t, "test failed", "SeedBlockedEmail() returned error: %v", err)
+	}
+	if err := directory.QueueCreatedUserIDs(common.UserID("user-created")); err != nil {
+		require.Failf(t, "test failed", "QueueCreatedUserIDs() returned error: %v", err)
+	}
+
+	tests := []struct {
+		name        string
+		email       common.Email
+		wantOutcome ports.EnsureUserOutcome
+		wantUserID  common.UserID
+	}{
+		{
+			name:        "existing",
+			email:       common.Email("existing@example.com"),
+			wantOutcome: ports.EnsureUserOutcomeExisting,
+			wantUserID:  common.UserID("user-existing"),
+		},
+		{
+			name:        "created",
+			email:       common.Email("created@example.com"),
+			wantOutcome: ports.EnsureUserOutcomeCreated,
+			wantUserID:  common.UserID("user-created"),
+		},
+		{
+			name:        "blocked",
+			email:       common.Email("blocked@example.com"),
+			wantOutcome: ports.EnsureUserOutcomeBlocked,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := directory.EnsureUserByEmail(context.Background(), tt.email)
+			if err != nil {
+				require.Failf(t, "test failed", "EnsureUserByEmail() returned error: %v", err)
+			}
+			if got.Outcome != tt.wantOutcome {
+				require.Failf(t, "test failed", "EnsureUserByEmail().Outcome = %q, want %q", got.Outcome, tt.wantOutcome)
+			}
+			if got.UserID != tt.wantUserID {
+				require.Failf(t, "test failed", "EnsureUserByEmail().UserID = %q, want %q", got.UserID, tt.wantUserID)
+			}
+		})
+	}
+}
+
+func TestInMemoryUserDirectoryExistsByUserID(t *testing.T) {
+	t.Parallel()
+
+	directory := &InMemoryUserDirectory{}
+	if err := directory.SeedExisting(common.Email("existing@example.com"), common.UserID("user-existing")); err != nil {
+		require.Failf(t, "test failed", "SeedExisting() returned error: %v", err)
+	}
+
+	exists, err := directory.ExistsByUserID(context.Background(), common.UserID("user-existing"))
+	if err != nil {
+		require.Failf(t, "test failed", "ExistsByUserID() returned error: %v", err)
+	}
+	if !exists {
+		require.FailNow(t, "ExistsByUserID() = false, want true")
+	}
+
+	exists, err = directory.ExistsByUserID(context.Background(), common.UserID("missing"))
+	if err != nil {
+		require.Failf(t, "test failed", "ExistsByUserID() returned error: %v", err)
+	}
+	if exists {
+		require.FailNow(t, "ExistsByUserID() = true, want false")
+	}
+}
+
+func TestInMemoryUserDirectoryBlockByEmail(t *testing.T) {
+	t.Parallel()
+
+	directory := &InMemoryUserDirectory{}
+	result, err := directory.BlockByEmail(context.Background(), ports.BlockUserByEmailInput{
+		Email:      common.Email("blocked@example.com"),
+		ReasonCode: userresolution.BlockReasonCode("policy_block"),
+	})
+	if err != nil {
+		require.Failf(t, "test failed", "BlockByEmail() returned error: %v", err)
+	}
+	if result.Outcome != ports.BlockUserOutcomeBlocked {
+		require.Failf(t, "test failed", "BlockByEmail().Outcome = %q, want %q", result.Outcome, ports.BlockUserOutcomeBlocked)
+	}
+
+	resolution, err := directory.ResolveByEmail(context.Background(), common.Email("blocked@example.com"))
+	if err != nil {
+		require.Failf(t, "test failed", "ResolveByEmail() returned error: %v", err)
+	}
+	if resolution.Kind != userresolution.KindBlocked {
+		require.Failf(t, "test failed", "ResolveByEmail().Kind = %q, want %q", resolution.Kind, userresolution.KindBlocked)
+	}
+}
+
+func TestInMemoryUserDirectoryBlockByUserID(t *testing.T) {
+	t.Parallel()
+
+	directory := &InMemoryUserDirectory{}
+	if err := directory.SeedExisting(common.Email("pilot@example.com"), common.UserID("user-1")); err != nil {
+		require.Failf(t, "test failed", "SeedExisting() returned error: %v", err)
+	}
+
+	result, err := directory.BlockByUserID(context.Background(), ports.BlockUserByIDInput{
+		UserID:     common.UserID("user-1"),
+		ReasonCode: userresolution.BlockReasonCode("policy_block"),
+	})
+	if err != nil {
+		require.Failf(t, "test failed", "BlockByUserID() returned error: %v", err)
+	}
+	if result.Outcome != ports.BlockUserOutcomeBlocked {
+		require.Failf(t, "test failed", "BlockByUserID().Outcome = %q, want %q", result.Outcome, ports.BlockUserOutcomeBlocked)
+	}
+
+	second, err := directory.BlockByUserID(context.Background(), ports.BlockUserByIDInput{
+		UserID:     common.UserID("user-1"),
+		ReasonCode: userresolution.BlockReasonCode("policy_block"),
+	})
+	if err != nil {
+		require.Failf(t, "test failed", "second BlockByUserID() returned error: %v", err)
+	}
+	if second.Outcome != ports.BlockUserOutcomeAlreadyBlocked {
+		require.Failf(t, "test failed", "second BlockByUserID().Outcome = %q, want %q", second.Outcome, ports.BlockUserOutcomeAlreadyBlocked)
+	}
+}
+
+func TestInMemoryUserDirectoryBlockByUserIDNotFound(t *testing.T) {
+	t.Parallel()
+
+	directory := &InMemoryUserDirectory{}
+
+	_, err := directory.BlockByUserID(context.Background(), ports.BlockUserByIDInput{
+		UserID:     common.UserID("missing"),
+		ReasonCode: userresolution.BlockReasonCode("policy_block"),
+	})
+	if !errors.Is(err, ports.ErrNotFound) {
+		require.Failf(t, "test failed", "BlockByUserID() error = %v, want ErrNotFound", err)
+	}
+}