test(communities): Add comprehensive integration and E2E tests

+340

tests/integration/community_consumer_test.go

··· 1 + package integration 2 + 3 + import ( 4 + "context" 5 + "fmt" 6 + "testing" 7 + "time" 8 + 9 + "Coves/internal/atproto/did" 10 + "Coves/internal/atproto/jetstream" 11 + "Coves/internal/core/communities" 12 + "Coves/internal/db/postgres" 13 + ) 14 + 15 + func TestCommunityConsumer_HandleCommunityProfile(t *testing.T) { 16 + db := setupTestDB(t) 17 + defer db.Close() 18 + 19 + repo := postgres.NewCommunityRepository(db) 20 + consumer := jetstream.NewCommunityEventConsumer(repo) 21 + didGen := did.NewGenerator(true, "https://plc.directory") 22 + ctx := context.Background() 23 + 24 + t.Run("creates community from firehose event", func(t *testing.T) { 25 + communityDID, _ := didGen.GenerateCommunityDID() 26 + uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano()) 27 + 28 + // Simulate a Jetstream commit event 29 + event := &jetstream.JetstreamEvent{ 30 + Did: communityDID, 31 + TimeUS: time.Now().UnixMicro(), 32 + Kind: "commit", 33 + Commit: &jetstream.CommitEvent{ 34 + Rev: "rev123", 35 + Operation: "create", 36 + Collection: "social.coves.community.profile", 37 + RKey: "self", 38 + CID: "bafy123abc", 39 + Record: map[string]interface{}{ 40 + "did": communityDID, // Community's unique DID 41 + "handle": fmt.Sprintf("!test-community-%s@coves.local", uniqueSuffix), 42 + "name": "test-community", 43 + "displayName": "Test Community", 44 + "description": "A test community", 45 + "owner": "did:web:coves.local", 46 + "createdBy": "did:plc:user123", 47 + "hostedBy": "did:web:coves.local", 48 + "visibility": "public", 49 + "federation": map[string]interface{}{ 50 + "allowExternalDiscovery": true, 51 + }, 52 + "memberCount": 0, 53 + "subscriberCount": 0, 54 + "createdAt": time.Now().Format(time.RFC3339), 55 + }, 56 + }, 57 + } 58 + 59 + // Handle the event 60 + err := consumer.HandleEvent(ctx, event) 61 + if err != nil { 62 + t.Fatalf("Failed to handle event: %v", err) 63 + } 64 + 65 + // Verify community was indexed 66 + community, err := repo.GetByDID(ctx, communityDID) 67 + if err != nil { 68 + t.Fatalf("Failed to get indexed community: %v", err) 69 + } 70 + 71 + if community.DID != communityDID { 72 + t.Errorf("Expected DID %s, got %s", communityDID, community.DID) 73 + } 74 + if community.DisplayName != "Test Community" { 75 + t.Errorf("Expected DisplayName 'Test Community', got %s", community.DisplayName) 76 + } 77 + if community.Visibility != "public" { 78 + t.Errorf("Expected Visibility 'public', got %s", community.Visibility) 79 + } 80 + }) 81 + 82 + t.Run("updates existing community", func(t *testing.T) { 83 + communityDID, _ := didGen.GenerateCommunityDID() 84 + uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano()) 85 + handle := fmt.Sprintf("!update-test-%s@coves.local", uniqueSuffix) 86 + 87 + // Create initial community 88 + initialCommunity := &communities.Community{ 89 + DID: communityDID, 90 + Handle: handle, 91 + Name: "update-test", 92 + DisplayName: "Original Name", 93 + Description: "Original description", 94 + OwnerDID: "did:web:coves.local", 95 + CreatedByDID: "did:plc:user123", 96 + HostedByDID: "did:web:coves.local", 97 + Visibility: "public", 98 + AllowExternalDiscovery: true, 99 + CreatedAt: time.Now(), 100 + UpdatedAt: time.Now(), 101 + } 102 + 103 + _, err := repo.Create(ctx, initialCommunity) 104 + if err != nil { 105 + t.Fatalf("Failed to create initial community: %v", err) 106 + } 107 + 108 + // Simulate update event 109 + updateEvent := &jetstream.JetstreamEvent{ 110 + Did: communityDID, 111 + TimeUS: time.Now().UnixMicro(), 112 + Kind: "commit", 113 + Commit: &jetstream.CommitEvent{ 114 + Rev: "rev124", 115 + Operation: "update", 116 + Collection: "social.coves.community.profile", 117 + RKey: "self", 118 + CID: "bafy456def", 119 + Record: map[string]interface{}{ 120 + "did": communityDID, // Community's unique DID 121 + "handle": handle, 122 + "name": "update-test", 123 + "displayName": "Updated Name", 124 + "description": "Updated description", 125 + "owner": "did:web:coves.local", 126 + "createdBy": "did:plc:user123", 127 + "hostedBy": "did:web:coves.local", 128 + "visibility": "unlisted", 129 + "federation": map[string]interface{}{ 130 + "allowExternalDiscovery": false, 131 + }, 132 + "memberCount": 5, 133 + "subscriberCount": 10, 134 + "createdAt": time.Now().Format(time.RFC3339), 135 + }, 136 + }, 137 + } 138 + 139 + // Handle the update 140 + err = consumer.HandleEvent(ctx, updateEvent) 141 + if err != nil { 142 + t.Fatalf("Failed to handle update event: %v", err) 143 + } 144 + 145 + // Verify community was updated 146 + updated, err := repo.GetByDID(ctx, communityDID) 147 + if err != nil { 148 + t.Fatalf("Failed to get updated community: %v", err) 149 + } 150 + 151 + if updated.DisplayName != "Updated Name" { 152 + t.Errorf("Expected DisplayName 'Updated Name', got %s", updated.DisplayName) 153 + } 154 + if updated.Description != "Updated description" { 155 + t.Errorf("Expected Description 'Updated description', got %s", updated.Description) 156 + } 157 + if updated.Visibility != "unlisted" { 158 + t.Errorf("Expected Visibility 'unlisted', got %s", updated.Visibility) 159 + } 160 + if updated.AllowExternalDiscovery { 161 + t.Error("Expected AllowExternalDiscovery to be false") 162 + } 163 + }) 164 + 165 + t.Run("deletes community", func(t *testing.T) { 166 + communityDID, _ := didGen.GenerateCommunityDID() 167 + uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano()) 168 + 169 + // Create community to delete 170 + community := &communities.Community{ 171 + DID: communityDID, 172 + Handle: fmt.Sprintf("!delete-test-%s@coves.local", uniqueSuffix), 173 + Name: "delete-test", 174 + OwnerDID: "did:web:coves.local", 175 + CreatedByDID: "did:plc:user123", 176 + HostedByDID: "did:web:coves.local", 177 + Visibility: "public", 178 + CreatedAt: time.Now(), 179 + UpdatedAt: time.Now(), 180 + } 181 + 182 + _, err := repo.Create(ctx, community) 183 + if err != nil { 184 + t.Fatalf("Failed to create community: %v", err) 185 + } 186 + 187 + // Simulate delete event 188 + deleteEvent := &jetstream.JetstreamEvent{ 189 + Did: communityDID, 190 + TimeUS: time.Now().UnixMicro(), 191 + Kind: "commit", 192 + Commit: &jetstream.CommitEvent{ 193 + Rev: "rev125", 194 + Operation: "delete", 195 + Collection: "social.coves.community.profile", 196 + RKey: "self", 197 + }, 198 + } 199 + 200 + // Handle the delete 201 + err = consumer.HandleEvent(ctx, deleteEvent) 202 + if err != nil { 203 + t.Fatalf("Failed to handle delete event: %v", err) 204 + } 205 + 206 + // Verify community was deleted 207 + _, err = repo.GetByDID(ctx, communityDID) 208 + if err != communities.ErrCommunityNotFound { 209 + t.Errorf("Expected ErrCommunityNotFound, got: %v", err) 210 + } 211 + }) 212 + } 213 + 214 + func TestCommunityConsumer_HandleSubscription(t *testing.T) { 215 + db := setupTestDB(t) 216 + defer db.Close() 217 + 218 + repo := postgres.NewCommunityRepository(db) 219 + consumer := jetstream.NewCommunityEventConsumer(repo) 220 + didGen := did.NewGenerator(true, "https://plc.directory") 221 + ctx := context.Background() 222 + 223 + t.Run("creates subscription from event", func(t *testing.T) { 224 + // Create a community first 225 + communityDID, _ := didGen.GenerateCommunityDID() 226 + uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano()) 227 + 228 + community := &communities.Community{ 229 + DID: communityDID, 230 + Handle: fmt.Sprintf("!sub-test-%s@coves.local", uniqueSuffix), 231 + Name: "sub-test", 232 + OwnerDID: "did:web:coves.local", 233 + CreatedByDID: "did:plc:user123", 234 + HostedByDID: "did:web:coves.local", 235 + Visibility: "public", 236 + CreatedAt: time.Now(), 237 + UpdatedAt: time.Now(), 238 + } 239 + 240 + _, err := repo.Create(ctx, community) 241 + if err != nil { 242 + t.Fatalf("Failed to create community: %v", err) 243 + } 244 + 245 + // Simulate subscription event 246 + userDID := "did:plc:subscriber123" 247 + subEvent := &jetstream.JetstreamEvent{ 248 + Did: userDID, 249 + TimeUS: time.Now().UnixMicro(), 250 + Kind: "commit", 251 + Commit: &jetstream.CommitEvent{ 252 + Rev: "rev200", 253 + Operation: "create", 254 + Collection: "social.coves.community.subscribe", 255 + RKey: "sub123", 256 + CID: "bafy789ghi", 257 + Record: map[string]interface{}{ 258 + "community": communityDID, 259 + }, 260 + }, 261 + } 262 + 263 + // Handle the subscription 264 + err = consumer.HandleEvent(ctx, subEvent) 265 + if err != nil { 266 + t.Fatalf("Failed to handle subscription event: %v", err) 267 + } 268 + 269 + // Verify subscription was created 270 + subscription, err := repo.GetSubscription(ctx, userDID, communityDID) 271 + if err != nil { 272 + t.Fatalf("Failed to get subscription: %v", err) 273 + } 274 + 275 + if subscription.UserDID != userDID { 276 + t.Errorf("Expected UserDID %s, got %s", userDID, subscription.UserDID) 277 + } 278 + if subscription.CommunityDID != communityDID { 279 + t.Errorf("Expected CommunityDID %s, got %s", communityDID, subscription.CommunityDID) 280 + } 281 + 282 + // Verify subscriber count was incremented 283 + updated, err := repo.GetByDID(ctx, communityDID) 284 + if err != nil { 285 + t.Fatalf("Failed to get community: %v", err) 286 + } 287 + 288 + if updated.SubscriberCount != 1 { 289 + t.Errorf("Expected SubscriberCount 1, got %d", updated.SubscriberCount) 290 + } 291 + }) 292 + } 293 + 294 + func TestCommunityConsumer_IgnoresNonCommunityEvents(t *testing.T) { 295 + db := setupTestDB(t) 296 + defer db.Close() 297 + 298 + repo := postgres.NewCommunityRepository(db) 299 + consumer := jetstream.NewCommunityEventConsumer(repo) 300 + ctx := context.Background() 301 + 302 + t.Run("ignores identity events", func(t *testing.T) { 303 + event := &jetstream.JetstreamEvent{ 304 + Did: "did:plc:user123", 305 + TimeUS: time.Now().UnixMicro(), 306 + Kind: "identity", 307 + Identity: &jetstream.IdentityEvent{ 308 + Did: "did:plc:user123", 309 + Handle: "alice.bsky.social", 310 + }, 311 + } 312 + 313 + err := consumer.HandleEvent(ctx, event) 314 + if err != nil { 315 + t.Errorf("Expected no error for identity event, got: %v", err) 316 + } 317 + }) 318 + 319 + t.Run("ignores non-community collections", func(t *testing.T) { 320 + event := &jetstream.JetstreamEvent{ 321 + Did: "did:plc:user123", 322 + TimeUS: time.Now().UnixMicro(), 323 + Kind: "commit", 324 + Commit: &jetstream.CommitEvent{ 325 + Rev: "rev300", 326 + Operation: "create", 327 + Collection: "app.bsky.feed.post", 328 + RKey: "post123", 329 + Record: map[string]interface{}{ 330 + "text": "Hello world", 331 + }, 332 + }, 333 + } 334 + 335 + err := consumer.HandleEvent(ctx, event) 336 + if err != nil { 337 + t.Errorf("Expected no error for non-community event, got: %v", err) 338 + } 339 + }) 340 + }

+508

tests/integration/community_e2e_test.go

··· 1 + package integration 2 + 3 + import ( 4 + "bytes" 5 + "context" 6 + "database/sql" 7 + "encoding/json" 8 + "fmt" 9 + "io" 10 + "net/http" 11 + "net/http/httptest" 12 + "os" 13 + "strings" 14 + "testing" 15 + "time" 16 + 17 + "github.com/go-chi/chi/v5" 18 + _ "github.com/lib/pq" 19 + "github.com/pressly/goose/v3" 20 + 21 + "Coves/internal/api/routes" 22 + "Coves/internal/atproto/did" 23 + "Coves/internal/atproto/jetstream" 24 + "Coves/internal/core/communities" 25 + "Coves/internal/db/postgres" 26 + ) 27 + 28 + // TestCommunity_E2E is a comprehensive end-to-end test covering: 29 + // 1. Write-forward to PDS (service layer) 30 + // 2. Firehose consumer indexing 31 + // 3. XRPC HTTP endpoints (create, get, list) 32 + func TestCommunity_E2E(t *testing.T) { 33 + // Skip in short mode since this requires real PDS 34 + if testing.Short() { 35 + t.Skip("Skipping E2E test in short mode") 36 + } 37 + 38 + // Setup test database 39 + dbURL := os.Getenv("TEST_DATABASE_URL") 40 + if dbURL == "" { 41 + dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" 42 + } 43 + 44 + db, err := sql.Open("postgres", dbURL) 45 + if err != nil { 46 + t.Fatalf("Failed to connect to test database: %v", err) 47 + } 48 + defer db.Close() 49 + 50 + // Run migrations 51 + if err := goose.SetDialect("postgres"); err != nil { 52 + t.Fatalf("Failed to set goose dialect: %v", err) 53 + } 54 + if err := goose.Up(db, "../../internal/db/migrations"); err != nil { 55 + t.Fatalf("Failed to run migrations: %v", err) 56 + } 57 + 58 + // Check if PDS is running 59 + pdsURL := os.Getenv("PDS_URL") 60 + if pdsURL == "" { 61 + pdsURL = "http://localhost:3001" 62 + } 63 + 64 + healthResp, err := http.Get(pdsURL + "/xrpc/_health") 65 + if err != nil { 66 + t.Skipf("PDS not running at %s: %v", pdsURL, err) 67 + } 68 + healthResp.Body.Close() 69 + 70 + // Setup dependencies 71 + communityRepo := postgres.NewCommunityRepository(db) 72 + didGen := did.NewGenerator(true, "https://plc.directory") 73 + 74 + // Get instance credentials 75 + instanceHandle := os.Getenv("PDS_INSTANCE_HANDLE") 76 + instancePassword := os.Getenv("PDS_INSTANCE_PASSWORD") 77 + if instanceHandle == "" { 78 + instanceHandle = "testuser123.local.coves.dev" 79 + } 80 + if instancePassword == "" { 81 + instancePassword = "test-password-123" 82 + } 83 + 84 + t.Logf("🔐 Authenticating with PDS as: %s", instanceHandle) 85 + 86 + // Authenticate to get instance DID 87 + accessToken, instanceDID, err := authenticateWithPDS(pdsURL, instanceHandle, instancePassword) 88 + if err != nil { 89 + t.Fatalf("Failed to authenticate with PDS: %v", err) 90 + } 91 + 92 + t.Logf("✅ Authenticated - Instance DID: %s", instanceDID) 93 + 94 + // Create service and consumer 95 + communityService := communities.NewCommunityService(communityRepo, didGen, pdsURL, instanceDID) 96 + if svc, ok := communityService.(interface{ SetPDSAccessToken(string) }); ok { 97 + svc.SetPDSAccessToken(accessToken) 98 + } 99 + 100 + consumer := jetstream.NewCommunityEventConsumer(communityRepo) 101 + 102 + // Setup HTTP server with XRPC routes 103 + r := chi.NewRouter() 104 + routes.RegisterCommunityRoutes(r, communityService) 105 + httpServer := httptest.NewServer(r) 106 + defer httpServer.Close() 107 + 108 + ctx := context.Background() 109 + 110 + // ==================================================================================== 111 + // Part 1: Write-Forward to PDS (Service Layer) 112 + // ==================================================================================== 113 + t.Run("1. Write-Forward to PDS", func(t *testing.T) { 114 + communityName := fmt.Sprintf("e2e-test-%d", time.Now().UnixNano()) 115 + 116 + createReq := communities.CreateCommunityRequest{ 117 + Name: communityName, 118 + DisplayName: "E2E Test Community", 119 + Description: "Testing full E2E flow", 120 + Visibility: "public", 121 + CreatedByDID: instanceDID, 122 + HostedByDID: instanceDID, 123 + AllowExternalDiscovery: true, 124 + } 125 + 126 + t.Logf("\n📝 Creating community via service: %s", communityName) 127 + community, err := communityService.CreateCommunity(ctx, createReq) 128 + if err != nil { 129 + t.Fatalf("Failed to create community: %v", err) 130 + } 131 + 132 + t.Logf("✅ Service returned:") 133 + t.Logf(" DID: %s", community.DID) 134 + t.Logf(" Handle: %s", community.Handle) 135 + t.Logf(" RecordURI: %s", community.RecordURI) 136 + t.Logf(" RecordCID: %s", community.RecordCID) 137 + 138 + // Verify DID format 139 + if community.DID[:8] != "did:plc:" { 140 + t.Errorf("Expected did:plc DID, got: %s", community.DID) 141 + } 142 + 143 + // Verify record exists in PDS 144 + t.Logf("\n📡 Querying PDS for the record...") 145 + 146 + collection := "social.coves.community.profile" 147 + rkey := extractRKeyFromURI(community.RecordURI) 148 + 149 + getRecordURL := fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s", 150 + pdsURL, instanceDID, collection, rkey) 151 + 152 + pdsResp, err := http.Get(getRecordURL) 153 + if err != nil { 154 + t.Fatalf("Failed to query PDS: %v", err) 155 + } 156 + defer pdsResp.Body.Close() 157 + 158 + if pdsResp.StatusCode != http.StatusOK { 159 + body, _ := io.ReadAll(pdsResp.Body) 160 + t.Fatalf("PDS returned status %d: %s", pdsResp.StatusCode, string(body)) 161 + } 162 + 163 + var pdsRecord struct { 164 + URI string `json:"uri"` 165 + CID string `json:"cid"` 166 + Value map[string]interface{} `json:"value"` 167 + } 168 + 169 + if err := json.NewDecoder(pdsResp.Body).Decode(&pdsRecord); err != nil { 170 + t.Fatalf("Failed to decode PDS response: %v", err) 171 + } 172 + 173 + t.Logf("✅ Record found in PDS!") 174 + t.Logf(" URI: %s", pdsRecord.URI) 175 + t.Logf(" CID: %s", pdsRecord.CID) 176 + 177 + // Verify record has correct DIDs 178 + if pdsRecord.Value["did"] != community.DID { 179 + t.Errorf("Community DID mismatch in PDS record: expected %s, got %v", 180 + community.DID, pdsRecord.Value["did"]) 181 + } 182 + 183 + // ==================================================================================== 184 + // Part 2: Firehose Consumer Indexing 185 + // ==================================================================================== 186 + t.Run("2. Firehose Consumer Indexing", func(t *testing.T) { 187 + t.Logf("\n🔄 Simulating Jetstream firehose event...") 188 + 189 + // Simulate firehose event (in production, this comes from Jetstream) 190 + firehoseEvent := jetstream.JetstreamEvent{ 191 + Did: instanceDID, // Repository owner (instance DID, not community DID!) 192 + TimeUS: time.Now().UnixMicro(), 193 + Kind: "commit", 194 + Commit: &jetstream.CommitEvent{ 195 + Rev: "test-rev", 196 + Operation: "create", 197 + Collection: collection, 198 + RKey: rkey, 199 + CID: pdsRecord.CID, 200 + Record: pdsRecord.Value, 201 + }, 202 + } 203 + 204 + err := consumer.HandleEvent(ctx, &firehoseEvent) 205 + if err != nil { 206 + t.Fatalf("Failed to process firehose event: %v", err) 207 + } 208 + 209 + t.Logf("✅ Consumer processed event") 210 + 211 + // Verify indexed in AppView database 212 + t.Logf("\n🔍 Querying AppView database...") 213 + 214 + indexed, err := communityRepo.GetByDID(ctx, community.DID) 215 + if err != nil { 216 + t.Fatalf("Community not indexed in AppView: %v", err) 217 + } 218 + 219 + t.Logf("✅ Community indexed in AppView:") 220 + t.Logf(" DID: %s", indexed.DID) 221 + t.Logf(" Handle: %s", indexed.Handle) 222 + t.Logf(" DisplayName: %s", indexed.DisplayName) 223 + t.Logf(" RecordURI: %s", indexed.RecordURI) 224 + 225 + // Verify record_uri points to instance repo (not community repo) 226 + if indexed.RecordURI[:len("at://"+instanceDID)] != "at://"+instanceDID { 227 + t.Errorf("record_uri should point to instance repo, got: %s", indexed.RecordURI) 228 + } 229 + 230 + t.Logf("\n✅ Part 1 & 2 Complete: Write-Forward → PDS → Firehose → AppView ✓") 231 + }) 232 + }) 233 + 234 + // ==================================================================================== 235 + // Part 3: XRPC HTTP Endpoints 236 + // ==================================================================================== 237 + t.Run("3. XRPC HTTP Endpoints", func(t *testing.T) { 238 + 239 + t.Run("Create via XRPC endpoint", func(t *testing.T) { 240 + createReq := map[string]interface{}{ 241 + "name": fmt.Sprintf("xrpc-%d", time.Now().UnixNano()), 242 + "displayName": "XRPC E2E Test", 243 + "description": "Testing true end-to-end flow", 244 + "visibility": "public", 245 + "createdByDid": instanceDID, 246 + "hostedByDid": instanceDID, 247 + "allowExternalDiscovery": true, 248 + } 249 + 250 + reqBody, _ := json.Marshal(createReq) 251 + 252 + // Step 1: Client POSTs to XRPC endpoint 253 + t.Logf("📡 Client → POST /xrpc/social.coves.community.create") 254 + resp, err := http.Post( 255 + httpServer.URL+"/xrpc/social.coves.community.create", 256 + "application/json", 257 + bytes.NewBuffer(reqBody), 258 + ) 259 + if err != nil { 260 + t.Fatalf("Failed to POST: %v", err) 261 + } 262 + defer resp.Body.Close() 263 + 264 + if resp.StatusCode != http.StatusOK { 265 + body, _ := io.ReadAll(resp.Body) 266 + t.Fatalf("Expected 200, got %d: %s", resp.StatusCode, string(body)) 267 + } 268 + 269 + var createResp struct { 270 + URI string `json:"uri"` 271 + CID string `json:"cid"` 272 + DID string `json:"did"` 273 + Handle string `json:"handle"` 274 + } 275 + 276 + json.NewDecoder(resp.Body).Decode(&createResp) 277 + 278 + t.Logf("✅ XRPC response received:") 279 + t.Logf(" DID: %s", createResp.DID) 280 + t.Logf(" Handle: %s", createResp.Handle) 281 + t.Logf(" URI: %s", createResp.URI) 282 + 283 + // Step 2: Simulate firehose consumer picking up the event 284 + t.Logf("🔄 Simulating Jetstream consumer indexing...") 285 + rkey := extractRKeyFromURI(createResp.URI) 286 + event := jetstream.JetstreamEvent{ 287 + Did: instanceDID, 288 + TimeUS: time.Now().UnixMicro(), 289 + Kind: "commit", 290 + Commit: &jetstream.CommitEvent{ 291 + Rev: "test-rev", 292 + Operation: "create", 293 + Collection: "social.coves.community.profile", 294 + RKey: rkey, 295 + Record: map[string]interface{}{ 296 + "did": createResp.DID, // Community's DID from response 297 + "handle": createResp.Handle, // Community's handle from response 298 + "name": createReq["name"], 299 + "displayName": createReq["displayName"], 300 + "description": createReq["description"], 301 + "visibility": createReq["visibility"], 302 + "createdBy": createReq["createdByDid"], 303 + "hostedBy": createReq["hostedByDid"], 304 + "federation": map[string]interface{}{ 305 + "allowExternalDiscovery": createReq["allowExternalDiscovery"], 306 + }, 307 + "createdAt": time.Now().Format(time.RFC3339), 308 + }, 309 + CID: createResp.CID, 310 + }, 311 + } 312 + consumer.HandleEvent(context.Background(), &event) 313 + 314 + // Step 3: Verify it's indexed in AppView 315 + t.Logf("🔍 Querying AppView to verify indexing...") 316 + var indexedCommunity communities.Community 317 + err = db.QueryRow(` 318 + SELECT did, handle, display_name, description 319 + FROM communities 320 + WHERE did = $1 321 + `, createResp.DID).Scan( 322 + &indexedCommunity.DID, 323 + &indexedCommunity.Handle, 324 + &indexedCommunity.DisplayName, 325 + &indexedCommunity.Description, 326 + ) 327 + if err != nil { 328 + t.Fatalf("Community not indexed in AppView: %v", err) 329 + } 330 + 331 + t.Logf("✅ TRUE E2E FLOW COMPLETE:") 332 + t.Logf(" Client → XRPC → PDS → Firehose → AppView ✓") 333 + t.Logf(" Indexed community: %s (%s)", indexedCommunity.Handle, indexedCommunity.DisplayName) 334 + }) 335 + 336 + t.Run("Get via XRPC endpoint", func(t *testing.T) { 337 + // Create a community first (via service, so it's indexed) 338 + community := createAndIndexCommunity(t, communityService, consumer, instanceDID) 339 + 340 + // GET via HTTP endpoint 341 + resp, err := http.Get(fmt.Sprintf("%s/xrpc/social.coves.community.get?community=%s", 342 + httpServer.URL, community.DID)) 343 + if err != nil { 344 + t.Fatalf("Failed to GET: %v", err) 345 + } 346 + defer resp.Body.Close() 347 + 348 + if resp.StatusCode != http.StatusOK { 349 + body, _ := io.ReadAll(resp.Body) 350 + t.Fatalf("Expected 200, got %d: %s", resp.StatusCode, string(body)) 351 + } 352 + 353 + var getCommunity communities.Community 354 + json.NewDecoder(resp.Body).Decode(&getCommunity) 355 + 356 + t.Logf("✅ Retrieved via XRPC HTTP endpoint:") 357 + t.Logf(" DID: %s", getCommunity.DID) 358 + t.Logf(" DisplayName: %s", getCommunity.DisplayName) 359 + 360 + if getCommunity.DID != community.DID { 361 + t.Errorf("DID mismatch: expected %s, got %s", community.DID, getCommunity.DID) 362 + } 363 + }) 364 + 365 + t.Run("List via XRPC endpoint", func(t *testing.T) { 366 + // Create and index multiple communities 367 + for i := 0; i < 3; i++ { 368 + createAndIndexCommunity(t, communityService, consumer, instanceDID) 369 + } 370 + 371 + resp, err := http.Get(fmt.Sprintf("%s/xrpc/social.coves.community.list?limit=10", 372 + httpServer.URL)) 373 + if err != nil { 374 + t.Fatalf("Failed to GET list: %v", err) 375 + } 376 + defer resp.Body.Close() 377 + 378 + if resp.StatusCode != http.StatusOK { 379 + body, _ := io.ReadAll(resp.Body) 380 + t.Fatalf("Expected 200, got %d: %s", resp.StatusCode, string(body)) 381 + } 382 + 383 + var listResp struct { 384 + Communities []communities.Community `json:"communities"` 385 + Total int `json:"total"` 386 + } 387 + 388 + json.NewDecoder(resp.Body).Decode(&listResp) 389 + 390 + t.Logf("✅ Listed %d communities via XRPC", len(listResp.Communities)) 391 + 392 + if len(listResp.Communities) < 3 { 393 + t.Errorf("Expected at least 3 communities, got %d", len(listResp.Communities)) 394 + } 395 + }) 396 + 397 + t.Logf("\n✅ Part 3 Complete: All XRPC HTTP endpoints working ✓") 398 + }) 399 + 400 + divider := strings.Repeat("=", 70) 401 + t.Logf("\n%s", divider) 402 + t.Logf("✅ COMPREHENSIVE E2E TEST COMPLETE!") 403 + t.Logf("%s", divider) 404 + t.Logf("✓ Write-forward to PDS") 405 + t.Logf("✓ Record stored with correct DIDs (community vs instance)") 406 + t.Logf("✓ Firehose consumer indexes to AppView") 407 + t.Logf("✓ XRPC create endpoint (HTTP)") 408 + t.Logf("✓ XRPC get endpoint (HTTP)") 409 + t.Logf("✓ XRPC list endpoint (HTTP)") 410 + t.Logf("%s", divider) 411 + } 412 + 413 + // Helper: create and index a community (simulates full flow) 414 + func createAndIndexCommunity(t *testing.T, service communities.Service, consumer *jetstream.CommunityEventConsumer, instanceDID string) *communities.Community { 415 + req := communities.CreateCommunityRequest{ 416 + Name: fmt.Sprintf("test-%d", time.Now().UnixNano()), 417 + DisplayName: "Test Community", 418 + Description: "Test", 419 + Visibility: "public", 420 + CreatedByDID: instanceDID, 421 + HostedByDID: instanceDID, 422 + AllowExternalDiscovery: true, 423 + } 424 + 425 + community, err := service.CreateCommunity(context.Background(), req) 426 + if err != nil { 427 + t.Fatalf("Failed to create: %v", err) 428 + } 429 + 430 + // Fetch from PDS to get full record 431 + pdsURL := "http://localhost:3001" 432 + collection := "social.coves.community.profile" 433 + rkey := extractRKeyFromURI(community.RecordURI) 434 + 435 + pdsResp, _ := http.Get(fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s", 436 + pdsURL, instanceDID, collection, rkey)) 437 + defer pdsResp.Body.Close() 438 + 439 + var pdsRecord struct { 440 + CID string `json:"cid"` 441 + Value map[string]interface{} `json:"value"` 442 + } 443 + json.NewDecoder(pdsResp.Body).Decode(&pdsRecord) 444 + 445 + // Simulate firehose event 446 + event := jetstream.JetstreamEvent{ 447 + Did: instanceDID, 448 + TimeUS: time.Now().UnixMicro(), 449 + Kind: "commit", 450 + Commit: &jetstream.CommitEvent{ 451 + Rev: "test", 452 + Operation: "create", 453 + Collection: collection, 454 + RKey: rkey, 455 + CID: pdsRecord.CID, 456 + Record: pdsRecord.Value, 457 + }, 458 + } 459 + 460 + consumer.HandleEvent(context.Background(), &event) 461 + 462 + return community 463 + } 464 + 465 + func extractRKeyFromURI(uri string) string { 466 + // at://did/collection/rkey -> rkey 467 + parts := strings.Split(uri, "/") 468 + if len(parts) >= 4 { 469 + return parts[len(parts)-1] 470 + } 471 + return "" 472 + } 473 + 474 + // authenticateWithPDS authenticates with the PDS and returns access token and DID 475 + func authenticateWithPDS(pdsURL, handle, password string) (string, string, error) { 476 + // Call com.atproto.server.createSession 477 + sessionReq := map[string]string{ 478 + "identifier": handle, 479 + "password": password, 480 + } 481 + 482 + reqBody, _ := json.Marshal(sessionReq) 483 + resp, err := http.Post( 484 + pdsURL+"/xrpc/com.atproto.server.createSession", 485 + "application/json", 486 + bytes.NewBuffer(reqBody), 487 + ) 488 + if err != nil { 489 + return "", "", fmt.Errorf("failed to create session: %w", err) 490 + } 491 + defer resp.Body.Close() 492 + 493 + if resp.StatusCode != http.StatusOK { 494 + body, _ := io.ReadAll(resp.Body) 495 + return "", "", fmt.Errorf("PDS auth failed (status %d): %s", resp.StatusCode, string(body)) 496 + } 497 + 498 + var sessionResp struct { 499 + AccessJwt string `json:"accessJwt"` 500 + DID string `json:"did"` 501 + } 502 + 503 + if err := json.NewDecoder(resp.Body).Decode(&sessionResp); err != nil { 504 + return "", "", fmt.Errorf("failed to decode session response: %w", err) 505 + } 506 + 507 + return sessionResp.AccessJwt, sessionResp.DID, nil 508 + }

+468

tests/integration/community_repo_test.go

··· 1 + package integration 2 + 3 + import ( 4 + "context" 5 + "fmt" 6 + "testing" 7 + "time" 8 + 9 + "Coves/internal/atproto/did" 10 + "Coves/internal/core/communities" 11 + "Coves/internal/db/postgres" 12 + ) 13 + 14 + func TestCommunityRepository_Create(t *testing.T) { 15 + db := setupTestDB(t) 16 + defer db.Close() 17 + 18 + repo := postgres.NewCommunityRepository(db) 19 + didGen := did.NewGenerator(true, "https://plc.directory") 20 + ctx := context.Background() 21 + 22 + t.Run("creates community successfully", func(t *testing.T) { 23 + communityDID, _ := didGen.GenerateCommunityDID() 24 + // Generate unique handle using timestamp to avoid collisions 25 + uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano()) 26 + community := &communities.Community{ 27 + DID: communityDID, 28 + Handle: fmt.Sprintf("!test-gaming-%s@coves.local", uniqueSuffix), 29 + Name: "test-gaming", 30 + DisplayName: "Test Gaming Community", 31 + Description: "A community for testing", 32 + OwnerDID: "did:web:coves.local", 33 + CreatedByDID: "did:plc:user123", 34 + HostedByDID: "did:web:coves.local", 35 + Visibility: "public", 36 + AllowExternalDiscovery: true, 37 + CreatedAt: time.Now(), 38 + UpdatedAt: time.Now(), 39 + } 40 + 41 + created, err := repo.Create(ctx, community) 42 + if err != nil { 43 + t.Fatalf("Failed to create community: %v", err) 44 + } 45 + 46 + if created.ID == 0 { 47 + t.Error("Expected non-zero ID") 48 + } 49 + if created.DID != communityDID { 50 + t.Errorf("Expected DID %s, got %s", communityDID, created.DID) 51 + } 52 + }) 53 + 54 + t.Run("returns error for duplicate DID", func(t *testing.T) { 55 + communityDID, _ := didGen.GenerateCommunityDID() 56 + uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano()) 57 + community := &communities.Community{ 58 + DID: communityDID, 59 + Handle: fmt.Sprintf("!duplicate-test-%s@coves.local", uniqueSuffix), 60 + Name: "duplicate-test", 61 + OwnerDID: "did:web:coves.local", 62 + CreatedByDID: "did:plc:user123", 63 + HostedByDID: "did:web:coves.local", 64 + Visibility: "public", 65 + CreatedAt: time.Now(), 66 + UpdatedAt: time.Now(), 67 + } 68 + 69 + // Create first time 70 + _, err := repo.Create(ctx, community) 71 + if err != nil { 72 + t.Fatalf("First create failed: %v", err) 73 + } 74 + 75 + // Try to create again with same DID 76 + _, err = repo.Create(ctx, community) 77 + if err != communities.ErrCommunityAlreadyExists { 78 + t.Errorf("Expected ErrCommunityAlreadyExists, got: %v", err) 79 + } 80 + }) 81 + 82 + t.Run("returns error for duplicate handle", func(t *testing.T) { 83 + uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano()) 84 + handle := fmt.Sprintf("!unique-handle-%s@coves.local", uniqueSuffix) 85 + 86 + // First community 87 + did1, _ := didGen.GenerateCommunityDID() 88 + community1 := &communities.Community{ 89 + DID: did1, 90 + Handle: handle, 91 + Name: "unique-handle", 92 + OwnerDID: "did:web:coves.local", 93 + CreatedByDID: "did:plc:user123", 94 + HostedByDID: "did:web:coves.local", 95 + Visibility: "public", 96 + CreatedAt: time.Now(), 97 + UpdatedAt: time.Now(), 98 + } 99 + 100 + _, err := repo.Create(ctx, community1) 101 + if err != nil { 102 + t.Fatalf("First create failed: %v", err) 103 + } 104 + 105 + // Second community with different DID but same handle 106 + did2, _ := didGen.GenerateCommunityDID() 107 + community2 := &communities.Community{ 108 + DID: did2, 109 + Handle: handle, // Same handle! 110 + Name: "unique-handle", 111 + OwnerDID: "did:web:coves.local", 112 + CreatedByDID: "did:plc:user456", 113 + HostedByDID: "did:web:coves.local", 114 + Visibility: "public", 115 + CreatedAt: time.Now(), 116 + UpdatedAt: time.Now(), 117 + } 118 + 119 + _, err = repo.Create(ctx, community2) 120 + if err != communities.ErrHandleTaken { 121 + t.Errorf("Expected ErrHandleTaken, got: %v", err) 122 + } 123 + }) 124 + } 125 + 126 + func TestCommunityRepository_GetByDID(t *testing.T) { 127 + db := setupTestDB(t) 128 + defer db.Close() 129 + 130 + repo := postgres.NewCommunityRepository(db) 131 + didGen := did.NewGenerator(true, "https://plc.directory") 132 + ctx := context.Background() 133 + 134 + t.Run("retrieves existing community", func(t *testing.T) { 135 + communityDID, _ := didGen.GenerateCommunityDID() 136 + uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano()) 137 + community := &communities.Community{ 138 + DID: communityDID, 139 + Handle: fmt.Sprintf("!getbyid-test-%s@coves.local", uniqueSuffix), 140 + Name: "getbyid-test", 141 + DisplayName: "Get By ID Test", 142 + Description: "Testing retrieval", 143 + OwnerDID: "did:web:coves.local", 144 + CreatedByDID: "did:plc:user123", 145 + HostedByDID: "did:web:coves.local", 146 + Visibility: "public", 147 + CreatedAt: time.Now(), 148 + UpdatedAt: time.Now(), 149 + } 150 + 151 + created, err := repo.Create(ctx, community) 152 + if err != nil { 153 + t.Fatalf("Failed to create community: %v", err) 154 + } 155 + 156 + retrieved, err := repo.GetByDID(ctx, communityDID) 157 + if err != nil { 158 + t.Fatalf("Failed to get community: %v", err) 159 + } 160 + 161 + if retrieved.DID != created.DID { 162 + t.Errorf("Expected DID %s, got %s", created.DID, retrieved.DID) 163 + } 164 + if retrieved.Handle != created.Handle { 165 + t.Errorf("Expected Handle %s, got %s", created.Handle, retrieved.Handle) 166 + } 167 + if retrieved.DisplayName != created.DisplayName { 168 + t.Errorf("Expected DisplayName %s, got %s", created.DisplayName, retrieved.DisplayName) 169 + } 170 + }) 171 + 172 + t.Run("returns error for non-existent community", func(t *testing.T) { 173 + fakeDID, _ := didGen.GenerateCommunityDID() 174 + _, err := repo.GetByDID(ctx, fakeDID) 175 + if err != communities.ErrCommunityNotFound { 176 + t.Errorf("Expected ErrCommunityNotFound, got: %v", err) 177 + } 178 + }) 179 + } 180 + 181 + func TestCommunityRepository_GetByHandle(t *testing.T) { 182 + db := setupTestDB(t) 183 + defer db.Close() 184 + 185 + repo := postgres.NewCommunityRepository(db) 186 + didGen := did.NewGenerator(true, "https://plc.directory") 187 + ctx := context.Background() 188 + 189 + t.Run("retrieves community by handle", func(t *testing.T) { 190 + communityDID, _ := didGen.GenerateCommunityDID() 191 + uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano()) 192 + handle := fmt.Sprintf("!handle-lookup-%s@coves.local", uniqueSuffix) 193 + 194 + community := &communities.Community{ 195 + DID: communityDID, 196 + Handle: handle, 197 + Name: "handle-lookup", 198 + OwnerDID: "did:web:coves.local", 199 + CreatedByDID: "did:plc:user123", 200 + HostedByDID: "did:web:coves.local", 201 + Visibility: "public", 202 + CreatedAt: time.Now(), 203 + UpdatedAt: time.Now(), 204 + } 205 + 206 + _, err := repo.Create(ctx, community) 207 + if err != nil { 208 + t.Fatalf("Failed to create community: %v", err) 209 + } 210 + 211 + retrieved, err := repo.GetByHandle(ctx, handle) 212 + if err != nil { 213 + t.Fatalf("Failed to get community by handle: %v", err) 214 + } 215 + 216 + if retrieved.Handle != handle { 217 + t.Errorf("Expected handle %s, got %s", handle, retrieved.Handle) 218 + } 219 + if retrieved.DID != communityDID { 220 + t.Errorf("Expected DID %s, got %s", communityDID, retrieved.DID) 221 + } 222 + }) 223 + } 224 + 225 + func TestCommunityRepository_Subscriptions(t *testing.T) { 226 + db := setupTestDB(t) 227 + defer db.Close() 228 + 229 + repo := postgres.NewCommunityRepository(db) 230 + didGen := did.NewGenerator(true, "https://plc.directory") 231 + ctx := context.Background() 232 + 233 + // Create a community for subscription tests 234 + communityDID, _ := didGen.GenerateCommunityDID() 235 + uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano()) 236 + community := &communities.Community{ 237 + DID: communityDID, 238 + Handle: fmt.Sprintf("!subscription-test-%s@coves.local", uniqueSuffix), 239 + Name: "subscription-test", 240 + OwnerDID: "did:web:coves.local", 241 + CreatedByDID: "did:plc:user123", 242 + HostedByDID: "did:web:coves.local", 243 + Visibility: "public", 244 + CreatedAt: time.Now(), 245 + UpdatedAt: time.Now(), 246 + } 247 + 248 + _, err := repo.Create(ctx, community) 249 + if err != nil { 250 + t.Fatalf("Failed to create community: %v", err) 251 + } 252 + 253 + t.Run("creates subscription successfully", func(t *testing.T) { 254 + sub := &communities.Subscription{ 255 + UserDID: "did:plc:subscriber1", 256 + CommunityDID: communityDID, 257 + SubscribedAt: time.Now(), 258 + } 259 + 260 + created, err := repo.Subscribe(ctx, sub) 261 + if err != nil { 262 + t.Fatalf("Failed to subscribe: %v", err) 263 + } 264 + 265 + if created.ID == 0 { 266 + t.Error("Expected non-zero subscription ID") 267 + } 268 + }) 269 + 270 + t.Run("prevents duplicate subscriptions", func(t *testing.T) { 271 + sub := &communities.Subscription{ 272 + UserDID: "did:plc:duplicate-sub", 273 + CommunityDID: communityDID, 274 + SubscribedAt: time.Now(), 275 + } 276 + 277 + _, err := repo.Subscribe(ctx, sub) 278 + if err != nil { 279 + t.Fatalf("First subscription failed: %v", err) 280 + } 281 + 282 + // Try to subscribe again 283 + _, err = repo.Subscribe(ctx, sub) 284 + if err != communities.ErrSubscriptionAlreadyExists { 285 + t.Errorf("Expected ErrSubscriptionAlreadyExists, got: %v", err) 286 + } 287 + }) 288 + 289 + t.Run("unsubscribes successfully", func(t *testing.T) { 290 + userDID := "did:plc:unsub-user" 291 + sub := &communities.Subscription{ 292 + UserDID: userDID, 293 + CommunityDID: communityDID, 294 + SubscribedAt: time.Now(), 295 + } 296 + 297 + _, err := repo.Subscribe(ctx, sub) 298 + if err != nil { 299 + t.Fatalf("Failed to subscribe: %v", err) 300 + } 301 + 302 + err = repo.Unsubscribe(ctx, userDID, communityDID) 303 + if err != nil { 304 + t.Fatalf("Failed to unsubscribe: %v", err) 305 + } 306 + 307 + // Verify subscription is gone 308 + _, err = repo.GetSubscription(ctx, userDID, communityDID) 309 + if err != communities.ErrSubscriptionNotFound { 310 + t.Errorf("Expected ErrSubscriptionNotFound after unsubscribe, got: %v", err) 311 + } 312 + }) 313 + } 314 + 315 + func TestCommunityRepository_List(t *testing.T) { 316 + db := setupTestDB(t) 317 + defer db.Close() 318 + 319 + repo := postgres.NewCommunityRepository(db) 320 + didGen := did.NewGenerator(true, "https://plc.directory") 321 + ctx := context.Background() 322 + 323 + t.Run("lists communities with pagination", func(t *testing.T) { 324 + // Create multiple communities 325 + baseSuffix := time.Now().UnixNano() 326 + for i := 0; i < 5; i++ { 327 + communityDID, _ := didGen.GenerateCommunityDID() 328 + community := &communities.Community{ 329 + DID: communityDID, 330 + Handle: fmt.Sprintf("!list-test-%d-%d@coves.local", baseSuffix, i), 331 + Name: fmt.Sprintf("list-test-%d", i), 332 + OwnerDID: "did:web:coves.local", 333 + CreatedByDID: "did:plc:user123", 334 + HostedByDID: "did:web:coves.local", 335 + Visibility: "public", 336 + CreatedAt: time.Now(), 337 + UpdatedAt: time.Now(), 338 + } 339 + _, err := repo.Create(ctx, community) 340 + if err != nil { 341 + t.Fatalf("Failed to create community %d: %v", i, err) 342 + } 343 + time.Sleep(10 * time.Millisecond) // Ensure different timestamps 344 + } 345 + 346 + // List with limit 347 + req := communities.ListCommunitiesRequest{ 348 + Limit: 3, 349 + Offset: 0, 350 + } 351 + 352 + results, total, err := repo.List(ctx, req) 353 + if err != nil { 354 + t.Fatalf("Failed to list communities: %v", err) 355 + } 356 + 357 + if len(results) != 3 { 358 + t.Errorf("Expected 3 communities, got %d", len(results)) 359 + } 360 + 361 + if total < 5 { 362 + t.Errorf("Expected total >= 5, got %d", total) 363 + } 364 + }) 365 + 366 + t.Run("filters by visibility", func(t *testing.T) { 367 + // Create an unlisted community 368 + communityDID, _ := didGen.GenerateCommunityDID() 369 + uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano()) 370 + community := &communities.Community{ 371 + DID: communityDID, 372 + Handle: fmt.Sprintf("!unlisted-test-%s@coves.local", uniqueSuffix), 373 + Name: "unlisted-test", 374 + OwnerDID: "did:web:coves.local", 375 + CreatedByDID: "did:plc:user123", 376 + HostedByDID: "did:web:coves.local", 377 + Visibility: "unlisted", 378 + CreatedAt: time.Now(), 379 + UpdatedAt: time.Now(), 380 + } 381 + 382 + _, err := repo.Create(ctx, community) 383 + if err != nil { 384 + t.Fatalf("Failed to create unlisted community: %v", err) 385 + } 386 + 387 + // List only public communities 388 + req := communities.ListCommunitiesRequest{ 389 + Limit: 100, 390 + Offset: 0, 391 + Visibility: "public", 392 + } 393 + 394 + results, _, err := repo.List(ctx, req) 395 + if err != nil { 396 + t.Fatalf("Failed to list public communities: %v", err) 397 + } 398 + 399 + // Verify no unlisted communities in results 400 + for _, c := range results { 401 + if c.Visibility != "public" { 402 + t.Errorf("Found non-public community in public-only results: %s", c.Handle) 403 + } 404 + } 405 + }) 406 + } 407 + 408 + func TestCommunityRepository_Search(t *testing.T) { 409 + db := setupTestDB(t) 410 + defer db.Close() 411 + 412 + repo := postgres.NewCommunityRepository(db) 413 + didGen := did.NewGenerator(true, "https://plc.directory") 414 + ctx := context.Background() 415 + 416 + t.Run("searches communities by name", func(t *testing.T) { 417 + // Create a community with searchable name 418 + communityDID, _ := didGen.GenerateCommunityDID() 419 + uniqueSuffix := fmt.Sprintf("%d", time.Now().UnixNano()) 420 + community := &communities.Community{ 421 + DID: communityDID, 422 + Handle: fmt.Sprintf("!golang-search-%s@coves.local", uniqueSuffix), 423 + Name: "golang-search", 424 + DisplayName: "Go Programming", 425 + Description: "A community for Go developers", 426 + OwnerDID: "did:web:coves.local", 427 + CreatedByDID: "did:plc:user123", 428 + HostedByDID: "did:web:coves.local", 429 + Visibility: "public", 430 + CreatedAt: time.Now(), 431 + UpdatedAt: time.Now(), 432 + } 433 + 434 + _, err := repo.Create(ctx, community) 435 + if err != nil { 436 + t.Fatalf("Failed to create community: %v", err) 437 + } 438 + 439 + // Search for it 440 + req := communities.SearchCommunitiesRequest{ 441 + Query: "golang", 442 + Limit: 10, 443 + Offset: 0, 444 + } 445 + 446 + results, total, err := repo.Search(ctx, req) 447 + if err != nil { 448 + t.Fatalf("Failed to search communities: %v", err) 449 + } 450 + 451 + if total == 0 { 452 + t.Error("Expected to find at least one result") 453 + } 454 + 455 + // Verify our community is in results 456 + found := false 457 + for _, c := range results { 458 + if c.DID == communityDID { 459 + found = true 460 + break 461 + } 462 + } 463 + 464 + if !found { 465 + t.Error("Expected to find created community in search results") 466 + } 467 + }) 468 + }