commit 61b48c78a138be677592e39e886d759ab83c7a10 · bretton.dev/coves

+9 -9

tests/integration/community_credentials_test.go

···

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

     

       26
       26
        
       

     

       27
       27
        
       		community := &communities.Community{

     

       28
       28
       -
       			DID:             communityDID,

     

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

     

       30
       30
       -
       			Name:            "cred-test",

     

       31
       31
       -
       			OwnerDID:        communityDID, // V2: self-owned

     

       32
       32
       -
       			CreatedByDID:    "did:plc:user123",

     

       33
       33
       -
       			HostedByDID:     "did:web:coves.local",

     

       34
       34
       -
       			Visibility:      "public",

     

       28
       28
       +
       			DID:          communityDID,

     

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

     

       30
       30
       +
       			Name:         "cred-test",

     

       31
       31
       +
       			OwnerDID:     communityDID, // V2: self-owned

     

       32
       32
       +
       			CreatedByDID: "did:plc:user123",

     

       33
       33
       +
       			HostedByDID:  "did:web:coves.local",

     

       34
       34
       +
       			Visibility:   "public",

     

       35
       35
        
       			// V2: PDS credentials

     

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

     

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

     
···

       88
       88
        
       			HostedByDID:  "did:web:coves.local",

     

       89
       89
        
       			Visibility:   "public",

     

       90
       90
        
       			// No PDS credentials

     

       91
       91
       -
       			CreatedAt:    time.Now(),

     

       92
       92
       -
       			UpdatedAt:    time.Now(),

     

       91
       91
       +
       			CreatedAt: time.Now(),

     

       92
       92
       +
       			UpdatedAt: time.Now(),

     

       93
       93
        
       		}

     

       94
       94
        
       

     

       95
       95
        
       		created, err := repo.Create(ctx, community)

+27 -8

tests/integration/community_e2e_test.go

···

       229
       229
        
       		t.Logf("   URI: %s", pdsRecord.URI)

     

       230
       230
        
       		t.Logf("   CID: %s", pdsRecord.CID)

     

       231
       231
        
       

     

       232
       232
       -
       		// Verify record has correct DIDs

     

       233
       233
       -
       		if pdsRecord.Value["did"] != community.DID {

     

       234
       234
       -
       			t.Errorf("Community DID mismatch in PDS record: expected %s, got %v",

     

       235
       235
       -
       				community.DID, pdsRecord.Value["did"])

     

       232
       232
       +
       		// Print full record for inspection

     

       233
       233
       +
       		recordJSON, _ := json.MarshalIndent(pdsRecord.Value, "   ", "  ")

     

       234
       234
       +
       		t.Logf("   Record value:\n   %s", string(recordJSON))

     

       235
       235
       +
       

     

       236
       236
       +
       		// V2: DID is NOT in the record - it's in the repository URI

     

       237
       237
       +
       		// The record should have handle, name, etc. but no 'did' field

     

       238
       238
       +
       		// This matches Bluesky's app.bsky.actor.profile pattern

     

       239
       239
       +
       		if pdsRecord.Value["handle"] != community.Handle {

     

       240
       240
       +
       			t.Errorf("Community handle mismatch in PDS record: expected %s, got %v",

     

       241
       241
       +
       				community.Handle, pdsRecord.Value["handle"])

     

       236
       242
        
       		}

     

       237
       243
        
       

     

       238
       244
        
       		// ====================================================================================

     
···

       326
       332
        
       	t.Run("3. XRPC HTTP Endpoints", func(t *testing.T) {

     

       327
       333
        
       

     

       328
       334
        
       		t.Run("Create via XRPC endpoint", func(t *testing.T) {

     

       335
       335
       +
       			// Use Unix timestamp (seconds) instead of UnixNano to keep handle short

     

       329
       336
        
       			createReq := map[string]interface{}{

     

       330
       330
       -
       				"name":                   fmt.Sprintf("xrpc-%d", time.Now().UnixNano()),

     

       337
       337
       +
       				"name":                   fmt.Sprintf("xrpc-%d", time.Now().Unix()),

     

       331
       338
        
       				"displayName":            "XRPC E2E Test",

     

       332
       339
        
       				"description":            "Testing true end-to-end flow",

     

       333
       340
        
       				"visibility":             "public",

     
···

       340
       347
        
       

     

       341
       348
        
       			// Step 1: Client POSTs to XRPC endpoint

     

       342
       349
        
       			t.Logf("📡 Client → POST /xrpc/social.coves.community.create")

     

       350
       350
       +
       			t.Logf("   Request: %s", string(reqBody))

     

       343
       351
        
       			resp, err := http.Post(

     

       344
       352
        
       				httpServer.URL+"/xrpc/social.coves.community.create",

     

       345
       353
        
       				"application/json",

     
···

       352
       360
        
       

     

       353
       361
        
       			if resp.StatusCode != http.StatusOK {

     

       354
       362
        
       				body, _ := io.ReadAll(resp.Body)

     

       363
       363
       +
       				t.Logf("❌ XRPC Create Failed")

     

       364
       364
       +
       				t.Logf("   Status: %d", resp.StatusCode)

     

       365
       365
       +
       				t.Logf("   Response: %s", string(body))

     

       355
       366
        
       				t.Fatalf("Expected 200, got %d: %s", resp.StatusCode, string(body))

     

       356
       367
        
       			}

     

       357
       368
        
       

     
···

       513
       524
        
       

     

       514
       525
        
       // Helper: create and index a community (simulates full flow)

     

       515
       526
        
       func createAndIndexCommunity(t *testing.T, service communities.Service, consumer *jetstream.CommunityEventConsumer, instanceDID string) *communities.Community {

     

       527
       527
       +
       	// Use nanoseconds % 1 billion to get unique but short names

     

       528
       528
       +
       	// This avoids handle collisions when creating multiple communities quickly

     

       529
       529
       +
       	uniqueID := time.Now().UnixNano() % 1000000000

     

       516
       530
        
       	req := communities.CreateCommunityRequest{

     

       517
       517
       -
       		Name:                   fmt.Sprintf("test-%d", time.Now().Unix()),

     

       531
       531
       +
       		Name:                   fmt.Sprintf("test-%d", uniqueID),

     

       518
       532
        
       		DisplayName:            "Test Community",

     

       519
       533
        
       		Description:            "Test",

     

       520
       534
        
       		Visibility:             "public",

     
···

       709
       723
        
       				if netErr, ok := err.(net.Error); ok && netErr.Timeout() {

     

       710
       724
        
       					continue // Timeout is expected, keep listening

     

       711
       725
        
       				}

     

       726
       726
       +
       				// For other errors, don't retry reading from a broken connection

     

       712
       727
        
       				return fmt.Errorf("failed to read Jetstream message: %w", err)

     

       713
       728
        
       			}

     

       714
       729
        
       

     
···

       720
       735
        
       				}

     

       721
       736
        
       

     

       722
       737
        
       				// Send to channel so test can verify

     

       723
       723
       -
       				eventChan <- &event

     

       724
       724
       -
       				return nil

     

       738
       738
       +
       				select {

     

       739
       739
       +
       				case eventChan <- &event:

     

       740
       740
       +
       					return nil

     

       741
       741
       +
       				case <-time.After(1 * time.Second):

     

       742
       742
       +
       					return fmt.Errorf("timeout sending event to channel")

     

       743
       743
       +
       				}

     

       725
       744
        
       			}

     

       726
       745
        
       		}

     

       727
       746
        
       	}

+25 -29

tests/integration/community_v2_validation_test.go

···

       30
       30
        
       				CID:        "bafyreigaming123",

     

       31
       31
        
       				Record: map[string]interface{}{

     

       32
       32
        
       					"$type":      "social.coves.community.profile",

     

       33
       33
       -
       					"handle":     "!gaming@coves.social",

     

       34
       34
       -
       					"atprotoHandle": "gaming.communities.coves.social",

     

       33
       33
       +
       					"handle":     "gaming.communities.coves.social",

     

       35
       34
        
       					"name":       "gaming",

     

       36
       35
        
       					"createdBy":  "did:plc:user123",

     

       37
       36
        
       					"hostedBy":   "did:web:coves.social",

     
···

       80
       79
        
       				CID:        "bafyreiv1community",

     

       81
       80
        
       				Record: map[string]interface{}{

     

       82
       81
        
       					"$type":      "social.coves.community.profile",

     

       83
       83
       -
       					"handle":     "!v1community@coves.social",

     

       82
       82
       +
       					"handle":     "v1community.communities.coves.social",

     

       84
       83
        
       					"name":       "v1community",

     

       85
       84
        
       					"createdBy":  "did:plc:user456",

     

       86
       85
        
       					"hostedBy":   "did:web:coves.social",

     
···

       126
       125
        
       				CID:        "bafyreicustom",

     

       127
       126
        
       				Record: map[string]interface{}{

     

       128
       127
        
       					"$type":      "social.coves.community.profile",

     

       129
       129
       -
       					"handle":     "!custom@coves.social",

     

       128
       128
       +
       					"handle":     "custom.communities.coves.social",

     

       130
       129
        
       					"name":       "custom",

     

       131
       130
        
       					"createdBy":  "did:plc:user789",

     

       132
       131
        
       					"hostedBy":   "did:web:coves.social",

     
···

       165
       164
        
       				CID:        "bafyreiupdate1",

     

       166
       165
        
       				Record: map[string]interface{}{

     

       167
       166
        
       					"$type":      "social.coves.community.profile",

     

       168
       168
       -
       					"handle":     "!updatetest@coves.social",

     

       169
       169
       -
       					"atprotoHandle": "updatetest.communities.coves.social",

     

       167
       167
       +
       					"handle":     "updatetest.communities.coves.social",

     

       170
       168
        
       					"name":       "updatetest",

     

       171
       169
        
       					"createdBy":  "did:plc:userUpdate",

     

       172
       170
        
       					"hostedBy":   "did:web:coves.social",

     
···

       196
       194
        
       				RKey:       "wrong-rkey", // INVALID!

     

       197
       195
        
       				CID:        "bafyreiupdate2",

     

       198
       196
        
       				Record: map[string]interface{}{

     

       199
       199
       -
       					"$type":      "social.coves.community.profile",

     

       200
       200
       -
       					"handle":     "!updatetest@coves.social",

     

       201
       201
       -
       					"atprotoHandle": "updatetest.communities.coves.social",

     

       202
       202
       -
       					"name":       "updatetest",

     

       197
       197
       +
       					"$type":       "social.coves.community.profile",

     

       198
       198
       +
       					"handle":      "updatetest.communities.coves.social",

     

       199
       199
       +
       					"name":        "updatetest",

     

       203
       200
        
       					"displayName": "Updated Name",

     

       204
       204
       -
       					"createdBy":  "did:plc:userUpdate",

     

       205
       205
       -
       					"hostedBy":   "did:web:coves.social",

     

       206
       206
       -
       					"visibility": "public",

     

       201
       201
       +
       					"createdBy":   "did:plc:userUpdate",

     

       202
       202
       +
       					"hostedBy":    "did:web:coves.social",

     

       203
       203
       +
       					"visibility":  "public",

     

       207
       204
        
       					"federation": map[string]interface{}{

     

       208
       205
        
       						"allowExternalDiscovery": true,

     

       209
       206
        
       					},

     
···

       231
       228
        
       	})

     

       232
       229
        
       }

     

       233
       230
        
       

     

       234
       234
       -
       // TestCommunityConsumer_AtprotoHandleField tests the V2 atprotoHandle field

     

       235
       235
       -
       func TestCommunityConsumer_AtprotoHandleField(t *testing.T) {

     

       231
       231
       +
       // TestCommunityConsumer_HandleField tests the V2 handle field

     

       232
       232
       +
       func TestCommunityConsumer_HandleField(t *testing.T) {

     

       236
       233
        
       	db := setupTestDB(t)

     

       237
       234
        
       	defer db.Close()

     

       238
       235
        
       

     
···

       240
       237
        
       	consumer := jetstream.NewCommunityEventConsumer(repo)

     

       241
       238
        
       	ctx := context.Background()

     

       242
       239
        
       

     

       243
       243
       -
       	t.Run("indexes community with atprotoHandle field", func(t *testing.T) {

     

       240
       240
       +
       	t.Run("indexes community with atProto handle", func(t *testing.T) {

     

       244
       241
        
       		uniqueDID := "did:plc:handletestunique987"

     

       245
       242
        
       		event := &jetstream.JetstreamEvent{

     

       246
       243
        
       			Did:  uniqueDID,

     
···

       251
       248
        
       				RKey:       "self",

     

       252
       249
        
       				CID:        "bafyreihandle",

     

       253
       250
        
       				Record: map[string]interface{}{

     

       254
       254
       -
       					"$type":         "social.coves.community.profile",

     

       255
       255
       -
       					"handle":        "!gamingtest@coves.social",       // Scoped handle

     

       256
       256
       -
       					"atprotoHandle": "gamingtest.communities.coves.social", // Real atProto handle

     

       257
       257
       -
       					"name":          "gamingtest",

     

       258
       258
       -
       					"createdBy":     "did:plc:user123",

     

       259
       259
       -
       					"hostedBy":      "did:web:coves.social",

     

       260
       260
       -
       					"visibility":    "public",

     

       251
       251
       +
       					"$type":      "social.coves.community.profile",

     

       252
       252
       +
       					"handle":     "gamingtest.communities.coves.social", // atProto handle (DNS-resolvable)

     

       253
       253
       +
       					"name":       "gamingtest",                          // Short name for !mentions

     

       254
       254
       +
       					"createdBy":  "did:plc:user123",

     

       255
       255
       +
       					"hostedBy":   "did:web:coves.social",

     

       256
       256
       +
       					"visibility": "public",

     

       261
       257
        
       					"federation": map[string]interface{}{

     

       262
       258
        
       						"allowExternalDiscovery": true,

     

       263
       259
        
       					},

     
···

       270
       266
        
       

     

       271
       267
        
       		err := consumer.HandleEvent(ctx, event)

     

       272
       268
        
       		if err != nil {

     

       273
       273
       -
       			t.Errorf("Failed to index community with atprotoHandle: %v", err)

     

       269
       269
       +
       			t.Errorf("Failed to index community with handle: %v", err)

     

       274
       270
        
       		}

     

       275
       271
        
       

     

       276
       272
        
       		community, err := repo.GetByDID(ctx, uniqueDID)

     
···

       278
       274
        
       			t.Fatalf("Community should have been indexed: %v", err)

     

       279
       275
        
       		}

     

       280
       276
        
       

     

       281
       281
       -
       		// Verify the scoped handle is stored (this is the primary handle field)

     

       282
       282
       -
       		if community.Handle != "!gamingtest@coves.social" {

     

       283
       283
       -
       			t.Errorf("Expected handle !gamingtest@coves.social, got %s", community.Handle)

     

       277
       277
       +
       		// Verify the atProto handle is stored

     

       278
       278
       +
       		if community.Handle != "gamingtest.communities.coves.social" {

     

       279
       279
       +
       			t.Errorf("Expected handle gamingtest.communities.coves.social, got %s", community.Handle)

     

       284
       280
        
       		}

     

       285
       281
        
       

     

       286
       286
       -
       		// Note: atprotoHandle is informational in the record but not stored separately

     

       287
       287
       -
       		// The DID is the authoritative identifier for atProto resolution

     

       282
       282
       +
       		// Note: The DID is the authoritative identifier for atProto resolution

     

       283
       283
       +
       		// The handle is DNS-resolvable via .well-known/atproto-did

     

       288
       284
        
       	})

     

       289
       285
        
       }

+9 -3

tests/unit/community_service_test.go

···

       161
       161
        
       		}))

     

       162
       162
        
       		defer slowPDS.Close()

     

       163
       163
        
       

     

       164
       164
       -
       		repo := newMockCommunityRepo()

     

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

     

       164
       164
       +
       		_ = newMockCommunityRepo()

     

       165
       165
       +
       		_ = did.NewGenerator(true, "https://plc.directory")

     

       166
       166
        
       

     

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

     

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

     
···

       188
       188
        
       		mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       189
       189
        
       			// Capture the authorization header

     

       190
       190
        
       			usedToken = r.Header.Get("Authorization")

     

       191
       191
       +
       			// Mark as used to avoid compiler error

     

       192
       192
       +
       			_ = usedToken

     

       191
       193
        
       

     

       192
       194
        
       			// Capture the repo DID from request body

     

       193
       195
        
       			var payload map[string]interface{}

     

       196
       196
       +
       			// Mark as used to avoid compiler error

     

       197
       197
       +
       			_ = payload

     

       198
       198
       +
       			_ = usedRepoDID

     

       199
       199
       +
       

     

       194
       200
        
       			// We'd need to parse the body here, but for this unit test

     

       195
       201
        
       			// we're just verifying the concept

     

       196
       202
        
       

     
···

       249
       255
        
       			UpdatedAt:       time.Now(),

     

       250
       256
        
       		}

     

       251
       257
        
       

     

       252
       252
       -
       		created, err := repo.Create(context.Background(), community)

     

       258
       258
       +
       		_, err := repo.Create(context.Background(), community)

     

       253
       259
        
       		if err != nil {

     

       254
       260
        
       			t.Fatalf("Failed to persist community: %v", err)

     

       255
       261
        
       		}