commit e63838db12b54e713a85d699fd2654978e6785df · bretton.dev/coves

+4 -19

tests/integration/community_consumer_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"Coves/internal/atproto/did"

     

       5
       4
        
       	"Coves/internal/atproto/jetstream"

     

       6
       5
        
       	"Coves/internal/core/communities"

     

       7
       6
        
       	"Coves/internal/db/postgres"

     
···

       21
       20
        
       

     

       22
       21
        
       	repo := postgres.NewCommunityRepository(db)

     

       23
       22
        
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     

       24
       24
       -
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       25
       23
        
       	ctx := context.Background()

     

       26
       24
        
       

     

       27
       25
        
       	t.Run("creates community from firehose event", func(t *testing.T) {

     

       28
       28
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       29
       29
       -
       		if err != nil {

     

       30
       30
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       31
       31
       -
       		}

     

       32
       26
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       27
       27
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       33
       28
        
       

     

       34
       29
        
       		// Simulate a Jetstream commit event

     

       35
       30
        
       		event := &jetstream.JetstreamEvent{

     
···

       85
       80
        
       	})

     

       86
       81
        
       

     

       87
       82
        
       	t.Run("updates existing community", func(t *testing.T) {

     

       88
       88
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       89
       89
       -
       		if err != nil {

     

       90
       90
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       91
       91
       -
       		}

     

       92
       83
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       84
       84
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       93
       85
        
       		handle := fmt.Sprintf("!update-test-%s@coves.local", uniqueSuffix)

     

       94
       86
        
       

     

       95
       87
        
       		// Create initial community

     
···

       169
       161
        
       	})

     

       170
       162
        
       

     

       171
       163
        
       	t.Run("deletes community", func(t *testing.T) {

     

       172
       172
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       173
       173
       -
       		if err != nil {

     

       174
       174
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       175
       175
       -
       		}

     

       176
       164
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       165
       165
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       177
       166
        
       

     

       178
       167
        
       		// Create community to delete

     

       179
       168
        
       		community := &communities.Community{

     
···

       227
       216
        
       

     

       228
       217
        
       	repo := postgres.NewCommunityRepository(db)

     

       229
       218
        
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     

       230
       230
       -
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       231
       219
        
       	ctx := context.Background()

     

       232
       220
        
       

     

       233
       221
        
       	t.Run("creates subscription from event", func(t *testing.T) {

     

       234
       222
        
       		// Create a community first

     

       235
       235
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       236
       236
       -
       		if err != nil {

     

       237
       237
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       238
       238
       -
       		}

     

       239
       223
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       224
       224
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       240
       225
        
       

     

       241
       226
        
       		community := &communities.Community{

     

       242
       227
        
       			DID:          communityDID,

+9 -28

tests/integration/community_credentials_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"Coves/internal/atproto/did"

     

       5
       4
        
       	"Coves/internal/core/communities"

     

       6
       5
        
       	"Coves/internal/db/postgres"

     

       7
       6
        
       	"context"

     
···

       20
       19
        
       	}()

     

       21
       20
        
       

     

       22
       21
        
       	repo := postgres.NewCommunityRepository(db)

     

       23
       23
       -
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       24
       22
        
       	ctx := context.Background()

     

       25
       23
        
       

     

       26
       24
        
       	t.Run("persists PDS credentials on create", func(t *testing.T) {

     

       27
       27
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       28
       28
       -
       		if err != nil {

     

       29
       29
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       30
       30
       -
       		}

     

       31
       25
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       26
       26
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       32
       27
        
       

     

       33
       28
        
       		community := &communities.Community{

     

       34
       29
        
       			DID:          communityDID,

     
···

       40
       35
        
       			Visibility:   "public",

     

       41
       36
        
       			// V2: PDS credentials

     

       42
       37
        
       			PDSEmail:        "community-test@communities.coves.local",

     

       43
       43
       -
       			PDSPasswordHash: "$2a$10$abcdefghijklmnopqrstuv", // Mock bcrypt hash

     

       38
       38
       +
       			PDSPassword:     "cleartext-password-encrypted-by-repo", // V2: Cleartext (encrypted by repository)

     

       44
       39
        
       			PDSAccessToken:  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.test.token",

     

       45
       40
        
       			PDSRefreshToken: "refresh_token_xyz123",

     

       46
       41
        
       			PDSURL:          "http://localhost:2583",

     
···

       66
       61
        
       		if retrieved.PDSEmail != community.PDSEmail {

     

       67
       62
        
       			t.Errorf("Expected PDSEmail %s, got %s", community.PDSEmail, retrieved.PDSEmail)

     

       68
       63
        
       		}

     

       69
       69
       -
       		if retrieved.PDSPasswordHash != community.PDSPasswordHash {

     

       70
       70
       -
       			t.Errorf("Expected PDSPasswordHash to be persisted")

     

       64
       64
       +
       		if retrieved.PDSPassword != community.PDSPassword {

     

       65
       65
       +
       			t.Errorf("Expected PDSPassword to be persisted and encrypted/decrypted")

     

       71
       66
        
       		}

     

       72
       67
        
       		if retrieved.PDSAccessToken != community.PDSAccessToken {

     

       73
       68
        
       			t.Errorf("Expected PDSAccessToken to be persisted and decrypted correctly")

     
···

       81
       76
        
       	})

     

       82
       77
        
       

     

       83
       78
        
       	t.Run("handles empty credentials gracefully", func(t *testing.T) {

     

       84
       84
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       85
       85
       -
       		if err != nil {

     

       86
       86
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       87
       87
       -
       		}

     

       88
       79
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       80
       80
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       89
       81
        
       

     

       90
       82
        
       		// Community without PDS credentials (e.g., from Jetstream consumer)

     

       91
       83
        
       		community := &communities.Community{

     
···

       138
       130
        
       	}()

     

       139
       131
        
       

     

       140
       132
        
       	repo := postgres.NewCommunityRepository(db)

     

       141
       141
       -
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       142
       133
        
       	ctx := context.Background()

     

       143
       134
        
       

     

       144
       135
        
       	t.Run("credentials are encrypted in database", func(t *testing.T) {

     

       145
       145
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       146
       146
       -
       		if err != nil {

     

       147
       147
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       148
       148
       -
       		}

     

       149
       136
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       137
       137
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       150
       138
        
       

     

       151
       139
        
       		accessToken := "sensitive_access_token_xyz123"

     

       152
       140
        
       		refreshToken := "sensitive_refresh_token_abc456"

     
···

       160
       148
        
       			HostedByDID:     "did:web:coves.local",

     

       161
       149
        
       			Visibility:      "public",

     

       162
       150
        
       			PDSEmail:        "encrypted@communities.coves.local",

     

       163
       163
       -
       			PDSPasswordHash: "$2a$10$encrypted",

     

       151
       151
       +
       			PDSPassword:     "cleartext-password-for-encryption", // V2: Cleartext (encrypted by repository)

     

       164
       152
        
       			PDSAccessToken:  accessToken,

     

       165
       153
        
       			PDSRefreshToken: refreshToken,

     

       166
       154
        
       			PDSURL:          "http://localhost:2583",

     
···

       214
       202
        
       	})

     

       215
       203
        
       

     

       216
       204
        
       	t.Run("encryption handles special characters", func(t *testing.T) {

     

       217
       217
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       218
       218
       -
       		if err != nil {

     

       219
       219
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       220
       220
       -
       		}

     

       221
       205
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       206
       206
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       222
       207
        
       

     

       223
       208
        
       		// Token with special characters

     

       224
       209
        
       		specialToken := "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJodHRwczovL2NvdmVzLnNvY2lhbCIsInN1YiI6ImRpZDpwbGM6YWJjMTIzIiwiaWF0IjoxNzA5MjQwMDAwfQ.special/chars+here=="

     
···

       262
       247
        
       	}()

     

       263
       248
        
       

     

       264
       249
        
       	repo := postgres.NewCommunityRepository(db)

     

       265
       265
       -
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       266
       250
        
       	ctx := context.Background()

     

       267
       251
        
       

     

       268
       252
        
       	t.Run("V2 communities are self-owned", func(t *testing.T) {

     

       269
       269
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       270
       270
       -
       		if err != nil {

     

       271
       271
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       272
       272
       -
       		}

     

       273
       253
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       254
       254
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       274
       255
        
       

     

       275
       256
        
       		community := &communities.Community{

     

       276
       257
        
       			DID:          communityDID,

+16 -10

tests/integration/community_e2e_test.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"Coves/internal/api/routes"

     

       5
       5
       -
       	"Coves/internal/atproto/did"

     

       6
       5
        
       	"Coves/internal/atproto/identity"

     

       7
       6
        
       	"Coves/internal/atproto/jetstream"

     

       8
       7
        
       	"Coves/internal/core/communities"

     
···

       86
       85
        
       

     

       87
       86
        
       	// Setup dependencies

     

       88
       87
        
       	communityRepo := postgres.NewCommunityRepository(db)

     

       89
       89
       -
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       90
       88
        
       

     

       91
       89
        
       	// Get instance credentials

     

       92
       90
        
       	instanceHandle := os.Getenv("PDS_INSTANCE_HANDLE")

     
···

       108
       106
        
       

     

       109
       107
        
       	t.Logf("✅ Authenticated - Instance DID: %s", instanceDID)

     

       110
       108
        
       

     

       111
       111
       -
       	// V2: Extract instance domain for community provisioning

     

       109
       109
       +
       	// V2.0: Extract instance domain for community provisioning

     

       112
       110
        
       	var instanceDomain string

     

       113
       111
        
       	if strings.HasPrefix(instanceDID, "did:web:") {

     

       114
       112
        
       		instanceDomain = strings.TrimPrefix(instanceDID, "did:web:")

     
···

       117
       115
        
       		instanceDomain = "coves.social"

     

       118
       116
        
       	}

     

       119
       117
        
       

     

       120
       120
       -
       	// V2: Create user service for PDS account provisioning

     

       118
       118
       +
       	// V2.0: Create user service with REAL identity resolution using local PLC

     

       119
       119
       +
       	plcURL := os.Getenv("PLC_DIRECTORY_URL")

     

       120
       120
       +
       	if plcURL == "" {

     

       121
       121
       +
       		plcURL = "http://localhost:3002" // Local PLC directory

     

       122
       122
       +
       	}

     

       121
       123
        
       	userRepo := postgres.NewUserRepository(db)

     

       122
       122
       -
       	identityResolver := &communityTestIdentityResolver{} // Simple mock for test

     

       123
       123
       -
       	userService := users.NewUserService(userRepo, identityResolver, pdsURL)

     

       124
       124
       +
       	identityConfig := identity.DefaultConfig()

     

       125
       125
       +
       	identityConfig.PLCURL = plcURL // Use local PLC for identity resolution

     

       126
       126
       +
       	identityResolver := identity.NewResolver(db, identityConfig)

     

       127
       127
       +
       	_ = users.NewUserService(userRepo, identityResolver, pdsURL) // Keep for potential future use

     

       128
       128
       +
       	t.Logf("✅ Identity resolver configured with local PLC: %s", plcURL)

     

       124
       129
        
       

     

       125
       125
       -
       	// V2: Initialize PDS account provisioner

     

       126
       126
       -
       	provisioner := communities.NewPDSAccountProvisioner(userService, instanceDomain, pdsURL)

     

       130
       130
       +
       	// V2.0: Initialize PDS account provisioner (simplified - no DID generator needed!)

     

       131
       131
       +
       	// PDS handles all DID generation and registration automatically

     

       132
       132
       +
       	provisioner := communities.NewPDSAccountProvisioner(instanceDomain, pdsURL)

     

       127
       133
        
       

     

       128
       128
       -
       	// Create service and consumer

     

       129
       129
       -
       	communityService := communities.NewCommunityService(communityRepo, didGen, pdsURL, instanceDID, instanceDomain, provisioner)

     

       134
       134
       +
       	// Create service (no longer needs didGen directly - provisioner owns it)

     

       135
       135
       +
       	communityService := communities.NewCommunityService(communityRepo, pdsURL, instanceDID, instanceDomain, provisioner)

     

       130
       136
        
       	if svc, ok := communityService.(interface{ SetPDSAccessToken(string) }); ok {

     

       131
       137
        
       		svc.SetPDSAccessToken(accessToken)

     

       132
       138
        
       	}

+17 -55

tests/integration/community_repo_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"Coves/internal/atproto/did"

     

       5
       4
        
       	"Coves/internal/core/communities"

     

       6
       5
        
       	"Coves/internal/db/postgres"

     

       7
       6
        
       	"context"

     
···

       19
       18
        
       	}()

     

       20
       19
        
       

     

       21
       20
        
       	repo := postgres.NewCommunityRepository(db)

     

       22
       22
       -
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       23
       21
        
       	ctx := context.Background()

     

       24
       22
        
       

     

       25
       23
        
       	t.Run("creates community successfully", func(t *testing.T) {

     

       26
       26
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       27
       27
       -
       		if err != nil {

     

       28
       28
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       29
       29
       -
       		}

     

       30
       30
       -
       		// Generate unique handle using timestamp to avoid collisions

     

       24
       24
       +
       		// Generate unique handle and DID using timestamp to avoid collisions

     

       31
       25
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       26
       26
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       32
       27
        
       		community := &communities.Community{

     

       33
       28
        
       			DID:                    communityDID,

     

       34
       29
        
       			Handle:                 fmt.Sprintf("!test-gaming-%s@coves.local", uniqueSuffix),

     
···

       58
       53
        
       	})

     

       59
       54
        
       

     

       60
       55
        
       	t.Run("returns error for duplicate DID", func(t *testing.T) {

     

       61
       61
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       62
       62
       -
       		if err != nil {

     

       63
       63
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       64
       64
       -
       		}

     

       65
       56
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       57
       57
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       66
       58
        
       		community := &communities.Community{

     

       67
       59
        
       			DID:          communityDID,

     

       68
       60
        
       			Handle:       fmt.Sprintf("!duplicate-test-%s@coves.local", uniqueSuffix),

     
···

       81
       73
        
       		}

     

       82
       74
        
       

     

       83
       75
        
       		// Try to create again with same DID

     

       84
       84
       -
       		if _, err = repo.Create(ctx, community); err != communities.ErrCommunityAlreadyExists {

     

       76
       76
       +
       		if _, err := repo.Create(ctx, community); err != communities.ErrCommunityAlreadyExists {

     

       85
       77
        
       			t.Errorf("Expected ErrCommunityAlreadyExists, got: %v", err)

     

       86
       78
        
       		}

     

       87
       79
        
       	})

     
···

       91
       83
        
       		handle := fmt.Sprintf("!unique-handle-%s@coves.local", uniqueSuffix)

     

       92
       84
        
       

     

       93
       85
        
       		// First community

     

       94
       94
       -
       		did1, err := didGen.GenerateCommunityDID()

     

       95
       95
       -
       		if err != nil {

     

       96
       96
       -
       			t.Fatalf("Failed to generate first community DID: %v", err)

     

       97
       97
       -
       		}

     

       86
       86
       +
       		did1 := generateTestDID(uniqueSuffix + "1")

     

       98
       87
        
       		community1 := &communities.Community{

     

       99
       88
        
       			DID:          did1,

     

       100
       89
        
       			Handle:       handle,

     
···

       112
       101
        
       		}

     

       113
       102
        
       

     

       114
       103
        
       		// Second community with different DID but same handle

     

       115
       115
       -
       		did2, err := didGen.GenerateCommunityDID()

     

       116
       116
       -
       		if err != nil {

     

       117
       117
       -
       			t.Fatalf("Failed to generate second community DID: %v", err)

     

       118
       118
       -
       		}

     

       104
       104
       +
       		did2 := generateTestDID(uniqueSuffix + "2")

     

       119
       105
        
       		community2 := &communities.Community{

     

       120
       106
        
       			DID:          did2,

     

       121
       107
        
       			Handle:       handle, // Same handle!

     
···

       128
       114
        
       			UpdatedAt:    time.Now(),

     

       129
       115
        
       		}

     

       130
       116
        
       

     

       131
       131
       -
       		if _, err = repo.Create(ctx, community2); err != communities.ErrHandleTaken {

     

       117
       117
       +
       		if _, err := repo.Create(ctx, community2); err != communities.ErrHandleTaken {

     

       132
       118
        
       			t.Errorf("Expected ErrHandleTaken, got: %v", err)

     

       133
       119
        
       		}

     

       134
       120
        
       	})

     
···

       143
       129
        
       	}()

     

       144
       130
        
       

     

       145
       131
        
       	repo := postgres.NewCommunityRepository(db)

     

       146
       146
       -
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       147
       132
        
       	ctx := context.Background()

     

       148
       133
        
       

     

       149
       134
        
       	t.Run("retrieves existing community", func(t *testing.T) {

     

       150
       150
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       151
       151
       -
       		if err != nil {

     

       152
       152
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       153
       153
       -
       		}

     

       154
       135
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       136
       136
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       155
       137
        
       		community := &communities.Community{

     

       156
       138
        
       			DID:          communityDID,

     

       157
       139
        
       			Handle:       fmt.Sprintf("!getbyid-test-%s@coves.local", uniqueSuffix),

     
···

       188
       170
        
       	})

     

       189
       171
        
       

     

       190
       172
        
       	t.Run("returns error for non-existent community", func(t *testing.T) {

     

       191
       191
       -
       		fakeDID, err := didGen.GenerateCommunityDID()

     

       192
       192
       -
       		if err != nil {

     

       193
       193
       -
       			t.Fatalf("Failed to generate fake DID: %v", err)

     

       194
       194
       -
       		}

     

       173
       173
       +
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       174
       174
       +
       		fakeDID := generateTestDID(uniqueSuffix)

     

       195
       175
        
       		if _, err := repo.GetByDID(ctx, fakeDID); err != communities.ErrCommunityNotFound {

     

       196
       176
        
       			t.Errorf("Expected ErrCommunityNotFound, got: %v", err)

     

       197
       177
        
       		}

     
···

       207
       187
        
       	}()

     

       208
       188
        
       

     

       209
       189
        
       	repo := postgres.NewCommunityRepository(db)

     

       210
       210
       -
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       211
       190
        
       	ctx := context.Background()

     

       212
       191
        
       

     

       213
       192
        
       	t.Run("retrieves community by handle", func(t *testing.T) {

     

       214
       214
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       215
       215
       -
       		if err != nil {

     

       216
       216
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       217
       217
       -
       		}

     

       218
       193
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       194
       194
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       219
       195
        
       		handle := fmt.Sprintf("!handle-lookup-%s@coves.local", uniqueSuffix)

     

       220
       196
        
       

     

       221
       197
        
       		community := &communities.Community{

     
···

       257
       233
        
       	}()

     

       258
       234
        
       

     

       259
       235
        
       	repo := postgres.NewCommunityRepository(db)

     

       260
       260
       -
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       261
       236
        
       	ctx := context.Background()

     

       262
       237
        
       

     

       263
       238
        
       	// Create a community for subscription tests

     

       264
       264
       -
       	communityDID, err := didGen.GenerateCommunityDID()

     

       265
       265
       -
       	if err != nil {

     

       266
       266
       -
       		t.Fatalf("Failed to generate community DID: %v", err)

     

       267
       267
       -
       	}

     

       268
       239
        
       	uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       240
       240
       +
       	communityDID := generateTestDID(uniqueSuffix)

     

       269
       241
        
       	community := &communities.Community{

     

       270
       242
        
       		DID:          communityDID,

     

       271
       243
        
       		Handle:       fmt.Sprintf("!subscription-test-%s@coves.local", uniqueSuffix),

     
···

       311
       283
        
       		}

     

       312
       284
        
       

     

       313
       285
        
       		// Try to subscribe again

     

       314
       314
       -
       		_, err = repo.Subscribe(ctx, sub)

     

       286
       286
       +
       		_, err := repo.Subscribe(ctx, sub)

     

       315
       287
        
       		if err != communities.ErrSubscriptionAlreadyExists {

     

       316
       288
        
       			t.Errorf("Expected ErrSubscriptionAlreadyExists, got: %v", err)

     

       317
       289
        
       		}

     
···

       352
       324
        
       	}()

     

       353
       325
        
       

     

       354
       326
        
       	repo := postgres.NewCommunityRepository(db)

     

       355
       355
       -
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       356
       327
        
       	ctx := context.Background()

     

       357
       328
        
       

     

       358
       329
        
       	t.Run("lists communities with pagination", func(t *testing.T) {

     

       359
       330
        
       		// Create multiple communities

     

       360
       331
        
       		baseSuffix := time.Now().UnixNano()

     

       361
       332
        
       		for i := 0; i < 5; i++ {

     

       362
       362
       -
       			communityDID, err := didGen.GenerateCommunityDID()

     

       363
       363
       -
       			if err != nil {

     

       364
       364
       -
       				t.Fatalf("Failed to generate community DID: %v", err)

     

       365
       365
       -
       			}

     

       333
       333
       +
       			uniqueSuffix := fmt.Sprintf("%d%d", baseSuffix, i)

     

       334
       334
       +
       			communityDID := generateTestDID(uniqueSuffix)

     

       366
       335
        
       			community := &communities.Community{

     

       367
       336
        
       				DID:          communityDID,

     

       368
       337
        
       				Handle:       fmt.Sprintf("!list-test-%d-%d@coves.local", baseSuffix, i),

     
···

       402
       371
        
       

     

       403
       372
        
       	t.Run("filters by visibility", func(t *testing.T) {

     

       404
       373
        
       		// Create an unlisted community

     

       405
       405
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       406
       406
       -
       		if err != nil {

     

       407
       407
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       408
       408
       -
       		}

     

       409
       374
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       375
       375
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       410
       376
        
       		community := &communities.Community{

     

       411
       377
        
       			DID:          communityDID,

     

       412
       378
        
       			Handle:       fmt.Sprintf("!unlisted-test-%s@coves.local", uniqueSuffix),

     
···

       453
       419
        
       	}()

     

       454
       420
        
       

     

       455
       421
        
       	repo := postgres.NewCommunityRepository(db)

     

       456
       456
       -
       	didGen := did.NewGenerator(true, "https://plc.directory")

     

       457
       422
        
       	ctx := context.Background()

     

       458
       423
        
       

     

       459
       424
        
       	t.Run("searches communities by name", func(t *testing.T) {

     

       460
       425
        
       		// Create a community with searchable name

     

       461
       461
       -
       		communityDID, err := didGen.GenerateCommunityDID()

     

       462
       462
       -
       		if err != nil {

     

       463
       463
       -
       			t.Fatalf("Failed to generate community DID: %v", err)

     

       464
       464
       -
       		}

     

       465
       426
        
       		uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano())

     

       427
       427
       +
       		communityDID := generateTestDID(uniqueSuffix)

     

       466
       428
        
       		community := &communities.Community{

     

       467
       429
        
       			DID:          communityDID,

     

       468
       430
        
       			Handle:       fmt.Sprintf("!golang-search-%s@coves.local", uniqueSuffix),

tests/integration/user_test.go

···

       70
       70
        
       	return db

     

       71
       71
        
       }

     

       72
       72
        
       

     

       73
       73
       +
       // generateTestDID generates a unique test DID for integration tests

     

       74
       74
       +
       // V2.0: No longer uses DID generator - just creates valid did:plc strings

     

       75
       75
       +
       func generateTestDID(suffix string) string {

     

       76
       76
       +
       	// Use a deterministic base + suffix for reproducible test DIDs

     

       77
       77
       +
       	// Format matches did:plc but doesn't need PLC registration for unit/repo tests

     

       78
       78
       +
       	return fmt.Sprintf("did:plc:test%s", suffix)

     

       79
       79
       +
       }

     

       80
       80
       +
       

     

       73
       81
        
       func TestUserCreationAndRetrieval(t *testing.T) {

     

       74
       82
        
       	db := setupTestDB(t)

     

       75
       83
        
       	defer func() {

+2 -3

tests/unit/community_service_test.go

···

       1
       1
        
       package unit

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"Coves/internal/atproto/did"

     

       5
       4
        
       	"Coves/internal/core/communities"

     

       6
       5
        
       	"context"

     

       7
       6
        
       	"fmt"

     
···

       163
       162
        
       		defer slowPDS.Close()

     

       164
       163
        
       

     

       165
       164
        
       		_ = newMockCommunityRepo()

     

       166
       166
       -
       		_ = did.NewGenerator(true, "https://plc.directory")

     

       165
       165
       +
       		// V2.0: DID generator no longer needed - PDS generates DIDs

     

       167
       166
        
       

     

       168
       167
        
       		// Note: We can't easily test the actual service without mocking more dependencies

     

       169
       168
        
       		// This test verifies the concept - in practice, a 15s operation should NOT timeout

     
···

       249
       248
        
       			CreatedByDID:    "did:plc:creator",

     

       250
       249
        
       			HostedByDID:     "did:web:coves.social",

     

       251
       250
        
       			PDSEmail:        "community-test@communities.coves.social",

     

       252
       252
       -
       			PDSPasswordHash: "$2a$10$hash",

     

       251
       251
       +
       			PDSPassword:     "cleartext-password-will-be-encrypted", // V2: Cleartext (encrypted by repository)

     

       253
       252
        
       			PDSAccessToken:  "test_access_token",

     

       254
       253
        
       			PDSRefreshToken: "test_refresh_token",

     

       255
       254
        
       			PDSURL:          "http://localhost:2583",