commit 31fb7196ddc2aaa056e5f7fdc1e88a39ce959f97 · bretton.dev/coves

+62 -69

tests/integration/community_e2e_test.go

···

       1
        
       package integration

     

       2
        
       

     

       3
        
       import (

     

       0
        
       
     

       4
        
       	"Coves/internal/api/routes"

     

       5
        
       	"Coves/internal/atproto/identity"

     

       6
        
       	"Coves/internal/atproto/jetstream"

     
···

       106
        
       

     

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

     

       108
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       110
        
       	var instanceDomain string

     

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

     
···

       141
        
       

     

       142
        
       	// Setup HTTP server with XRPC routes

     

       143
        
       	r := chi.NewRouter()

     

       144
       -
       	routes.RegisterCommunityRoutes(r, communityService)

     

       145
        
       	httpServer := httptest.NewServer(r)

     

       146
        
       	defer httpServer.Close()

     

       147
        
       

     
···

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

     

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

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       355
        
       			createReq := map[string]interface{}{

     

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

     

       357
        
       				"displayName":            "XRPC E2E Test",

     

       358
        
       				"description":            "Testing true end-to-end flow",

     

       359
        
       				"visibility":             "public",

     

       360
       -
       				"createdByDid":           instanceDID,

     

       361
       -
       				"hostedByDid":            instanceDID,

     

       362
        
       				"allowExternalDiscovery": true,

     

       363
        
       			}

     

       364
        
       

     
···

       367
        
       				t.Fatalf("Failed to marshal request: %v", marshalErr)

     

       368
        
       			}

     

       369
        
       

     

       370
       -
       			// Step 1: Client POSTs to XRPC endpoint

     

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

     

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

     

       373
       -
       			resp, err := http.Post(

     

       0
        
       
     

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

     

       375
       -
       				"application/json",

     

       376
       -
       				bytes.NewBuffer(reqBody),

     

       377
       -
       			)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       378
        
       			if err != nil {

     

       379
        
       				t.Fatalf("Failed to POST: %v", err)

     

       380
        
       			}

     
···

       408
        
       			t.Logf("   URI:    %s", createResp.URI)

     

       409
        
       

     

       410
        
       			// Step 2: Simulate firehose consumer picking up the event

     

       0
        
       
     

       0
        
       
     

       411
        
       			t.Logf("🔄 Simulating Jetstream consumer indexing...")

     

       412
        
       			rkey := extractRKeyFromURI(createResp.URI)

     

       0
        
       
     

       413
        
       			event := jetstream.JetstreamEvent{

     

       414
       -
       				Did:    instanceDID,

     

       415
        
       				TimeUS: time.Now().UnixMicro(),

     

       416
        
       				Kind:   "commit",

     

       417
        
       				Commit: &jetstream.CommitEvent{

     
···

       426
        
       						"displayName": createReq["displayName"],

     

       427
        
       						"description": createReq["description"],

     

       428
        
       						"visibility":  createReq["visibility"],

     

       429
       -
       						"createdBy":   createReq["createdByDid"],

     

       430
       -
       						"hostedBy":    createReq["hostedByDid"],

     

       0
        
       
     

       431
        
       						"federation": map[string]interface{}{

     

       432
        
       							"allowExternalDiscovery": createReq["allowExternalDiscovery"],

     

       433
        
       						},

     
···

       464
        
       

     

       465
        
       		t.Run("Get via XRPC endpoint", func(t *testing.T) {

     

       466
        
       			// Create a community first (via service, so it's indexed)

     

       467
       -
       			community := createAndIndexCommunity(t, communityService, consumer, instanceDID)

     

       468
        
       

     

       469
        
       			// GET via HTTP endpoint

     

       470
        
       			resp, err := http.Get(fmt.Sprintf("%s/xrpc/social.coves.community.get?community=%s",

     
···

       499
        
       		t.Run("List via XRPC endpoint", func(t *testing.T) {

     

       500
        
       			// Create and index multiple communities

     

       501
        
       			for i := 0; i < 3; i++ {

     

       502
       -
       				createAndIndexCommunity(t, communityService, consumer, instanceDID)

     

       503
        
       			}

     

       504
        
       

     

       505
        
       			resp, err := http.Get(fmt.Sprintf("%s/xrpc/social.coves.community.list?limit=10",

     
···

       535
        
       

     

       536
        
       		t.Run("Subscribe via XRPC endpoint", func(t *testing.T) {

     

       537
        
       			// Create a community to subscribe to

     

       538
       -
       			community := createAndIndexCommunity(t, communityService, consumer, instanceDID)

     

       539
        
       

     

       540
        
       			// Subscribe to the community

     

       541
        
       			subscribeReq := map[string]interface{}{

     
···

       558
        
       				t.Fatalf("Failed to create request: %v", err)

     

       559
        
       			}

     

       560
        
       			req.Header.Set("Content-Type", "application/json")

     

       561
       -
       			// TODO(Communities-OAuth): Replace with OAuth session

     

       562
       -
       			req.Header.Set("X-User-DID", instanceDID)

     

       563
        
       

     

       564
        
       			resp, err := http.DefaultClient.Do(req)

     

       565
        
       			if err != nil {

     
···

       639
        
       

     

       640
        
       		t.Run("Unsubscribe via XRPC endpoint", func(t *testing.T) {

     

       641
        
       			// Create a community and subscribe to it first

     

       642
       -
       			community := createAndIndexCommunity(t, communityService, consumer, instanceDID)

     

       643
        
       

     

       644
       -
       			// Subscribe first

     

       645
       -
       			subscription, err := communityService.SubscribeToCommunity(ctx, instanceDID, community.DID)

     

       646
        
       			if err != nil {

     

       647
        
       				t.Fatalf("Failed to subscribe: %v", err)

     

       648
        
       			}

     
···

       692
        
       				t.Fatalf("Failed to create request: %v", err)

     

       693
        
       			}

     

       694
        
       			req.Header.Set("Content-Type", "application/json")

     

       695
       -
       			// TODO(Communities-OAuth): Replace with OAuth session

     

       696
       -
       			req.Header.Set("X-User-DID", instanceDID)

     

       697
        
       

     

       698
        
       			resp, err := http.DefaultClient.Do(req)

     

       699
        
       			if err != nil {

     
···

       759
        
       

     

       760
        
       		t.Run("Update via XRPC endpoint", func(t *testing.T) {

     

       761
        
       			// Create a community first (via service, so it's indexed)

     

       762
       -
       			community := createAndIndexCommunity(t, communityService, consumer, instanceDID)

     

       763
        
       

     

       764
        
       			// Update the community

     

       765
        
       			newDisplayName := "Updated E2E Test Community"

     

       766
        
       			newDescription := "This community has been updated"

     

       767
        
       			newVisibility := "unlisted"

     

       768
        
       

     

       0
        
       
     

       769
        
       			updateReq := map[string]interface{}{

     

       770
        
       				"communityDid": community.DID,

     

       771
       -
       				"updatedByDid": instanceDID, // TODO: Replace with OAuth user DID

     

       772
        
       				"displayName":  newDisplayName,

     

       773
        
       				"description":  newDescription,

     

       774
        
       				"visibility":   newVisibility,

     
···

       779
        
       				t.Fatalf("Failed to marshal update request: %v", marshalErr)

     

       780
        
       			}

     

       781
        
       

     

       782
       -
       			// POST update request

     

       783
        
       			t.Logf("📡 Client → POST /xrpc/social.coves.community.update")

     

       784
        
       			t.Logf("   Updating community: %s", community.DID)

     

       785
       -
       			resp, err := http.Post(

     

       0
        
       
     

       786
        
       				httpServer.URL+"/xrpc/social.coves.community.update",

     

       787
       -
       				"application/json",

     

       788
       -
       				bytes.NewBuffer(reqBody),

     

       789
       -
       			)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       790
        
       			if err != nil {

     

       791
        
       				t.Fatalf("Failed to POST update: %v", err)

     

       792
        
       			}

     
···

       928
        
       	t.Logf("%s\n", divider)

     

       929
        
       }

     

       930
        
       

     

       931
       -
       // Helper: create and index a community (simulates full flow)

     

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

     

       0
        
       
     

       0
        
       
     

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

     

       934
        
       	// This avoids handle collisions when creating multiple communities quickly

     

       935
        
       	uniqueID := time.Now().UnixNano() % 1000000000

     
···

       949
        
       	}

     

       950
        
       

     

       951
        
       	// Fetch from PDS to get full record

     

       952
       -
       	pdsURL := "http://localhost:3001"

     

       953
        
       	collection := "social.coves.community.profile"

     

       954
        
       	rkey := extractRKeyFromURI(community.RecordURI)

     

       955
        
       

     

       956
        
       	pdsResp, pdsErr := http.Get(fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s",

     

       957
       -
       		pdsURL, instanceDID, collection, rkey))

     

       958
        
       	if pdsErr != nil {

     

       959
        
       		t.Fatalf("Failed to fetch PDS record: %v", pdsErr)

     

       960
        
       	}

     
···

       972
        
       		t.Fatalf("Failed to decode PDS record: %v", decodeErr)

     

       973
        
       	}

     

       974
        
       

     

       975
       -
       	// Simulate firehose event

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       976
        
       	event := jetstream.JetstreamEvent{

     

       977
       -
       		Did:    instanceDID,

     

       978
        
       		TimeUS: time.Now().UnixMicro(),

     

       979
        
       		Kind:   "commit",

     

       980
        
       		Commit: &jetstream.CommitEvent{

     
···

       1043
        
       	}

     

       1044
        
       

     

       1045
        
       	return sessionResp.AccessJwt, sessionResp.DID, nil

     

       1046
       -
       }

     

       1047
       -
       

     

       1048
       -
       // communityTestIdentityResolver is a simple mock for testing (renamed to avoid conflict with oauth_test)

     

       1049
       -
       type communityTestIdentityResolver struct{}

     

       1050
       -
       

     

       1051
       -
       func (m *communityTestIdentityResolver) ResolveHandle(ctx context.Context, handle string) (string, string, error) {

     

       1052
       -
       	// Simple mock - not needed for this test

     

       1053
       -
       	return "", "", fmt.Errorf("mock: handle resolution not implemented")

     

       1054
       -
       }

     

       1055
       -
       

     

       1056
       -
       func (m *communityTestIdentityResolver) ResolveDID(ctx context.Context, did string) (*identity.DIDDocument, error) {

     

       1057
       -
       	// Simple mock - return minimal DID document

     

       1058
       -
       	return &identity.DIDDocument{

     

       1059
       -
       		DID: did,

     

       1060
       -
       		Service: []identity.Service{

     

       1061
       -
       			{

     

       1062
       -
       				ID:              "#atproto_pds",

     

       1063
       -
       				Type:            "AtprotoPersonalDataServer",

     

       1064
       -
       				ServiceEndpoint: "http://localhost:3001",

     

       1065
       -
       			},

     

       1066
       -
       		},

     

       1067
       -
       	}, nil

     

       1068
       -
       }

     

       1069
       -
       

     

       1070
       -
       func (m *communityTestIdentityResolver) Resolve(ctx context.Context, identifier string) (*identity.Identity, error) {

     

       1071
       -
       	return &identity.Identity{

     

       1072
       -
       		DID:    "did:plc:test",

     

       1073
       -
       		Handle: identifier,

     

       1074
       -
       		PDSURL: "http://localhost:3001",

     

       1075
       -
       	}, nil

     

       1076
       -
       }

     

       1077
       -
       

     

       1078
       -
       func (m *communityTestIdentityResolver) Purge(ctx context.Context, identifier string) error {

     

       1079
       -
       	// No-op for mock

     

       1080
       -
       	return nil

     

       1081
        
       }

     

       1082
        
       

     

       1083
        
       // queryPDSAccount queries the PDS to verify an account exists

···

       1
        
       package integration

     

       2
        
       

     

       3
        
       import (

     

       4
       +
       	"Coves/internal/api/middleware"

     

       5
        
       	"Coves/internal/api/routes"

     

       6
        
       	"Coves/internal/atproto/identity"

     

       7
        
       	"Coves/internal/atproto/jetstream"

     
···

       107
        
       

     

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

     

       109
        
       

     

       110
       +
       	// Initialize auth middleware (skipVerify=true for E2E tests)

     

       111
       +
       	authMiddleware := middleware.NewAtProtoAuthMiddleware(nil, true)

     

       112
       +
       

     

       113
        
       	// V2.0: Extract instance domain for community provisioning

     

       114
        
       	var instanceDomain string

     

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

     
···

       145
        
       

     

       146
        
       	// Setup HTTP server with XRPC routes

     

       147
        
       	r := chi.NewRouter()

     

       148
       +
       	routes.RegisterCommunityRoutes(r, communityService, authMiddleware)

     

       149
        
       	httpServer := httptest.NewServer(r)

     

       150
        
       	defer httpServer.Close()

     

       151
        
       

     
···

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

     

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

     

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

     

       359
       +
       			// NOTE: Both createdByDid and hostedByDid are derived server-side:

     

       360
       +
       			//   - createdByDid: from JWT token (authenticated user)

     

       361
       +
       			//   - hostedByDid: from instance configuration (security: prevents spoofing)

     

       362
        
       			createReq := map[string]interface{}{

     

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

     

       364
        
       				"displayName":            "XRPC E2E Test",

     

       365
        
       				"description":            "Testing true end-to-end flow",

     

       366
        
       				"visibility":             "public",

     

       0
        
       
     

       0
        
       
     

       367
        
       				"allowExternalDiscovery": true,

     

       368
        
       			}

     

       369
        
       

     
···

       372
        
       				t.Fatalf("Failed to marshal request: %v", marshalErr)

     

       373
        
       			}

     

       374
        
       

     

       375
       +
       			// Step 1: Client POSTs to XRPC endpoint with JWT authentication

     

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

     

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

     

       378
       +
       

     

       379
       +
       			req, err := http.NewRequest(http.MethodPost,

     

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

     

       381
       +
       				bytes.NewBuffer(reqBody))

     

       382
       +
       			if err != nil {

     

       383
       +
       				t.Fatalf("Failed to create request: %v", err)

     

       384
       +
       			}

     

       385
       +
       			req.Header.Set("Content-Type", "application/json")

     

       386
       +
       			// Use real PDS access token for E2E authentication

     

       387
       +
       			req.Header.Set("Authorization", "Bearer "+accessToken)

     

       388
       +
       

     

       389
       +
       			resp, err := http.DefaultClient.Do(req)

     

       390
        
       			if err != nil {

     

       391
        
       				t.Fatalf("Failed to POST: %v", err)

     

       392
        
       			}

     
···

       420
        
       			t.Logf("   URI:    %s", createResp.URI)

     

       421
        
       

     

       422
        
       			// Step 2: Simulate firehose consumer picking up the event

     

       423
       +
       			// NOTE: Using synthetic event for speed. Real Jetstream WebSocket testing

     

       424
       +
       			// happens in "Part 2: Real Jetstream Firehose Consumption" above.

     

       425
        
       			t.Logf("🔄 Simulating Jetstream consumer indexing...")

     

       426
        
       			rkey := extractRKeyFromURI(createResp.URI)

     

       427
       +
       			// V2: Event comes from community's DID (community owns the repo)

     

       428
        
       			event := jetstream.JetstreamEvent{

     

       429
       +
       				Did:    createResp.DID,

     

       430
        
       				TimeUS: time.Now().UnixMicro(),

     

       431
        
       				Kind:   "commit",

     

       432
        
       				Commit: &jetstream.CommitEvent{

     
···

       441
        
       						"displayName": createReq["displayName"],

     

       442
        
       						"description": createReq["description"],

     

       443
        
       						"visibility":  createReq["visibility"],

     

       444
       +
       						// Server-side derives these from JWT auth (instanceDID is the authenticated user)

     

       445
       +
       						"createdBy": instanceDID,

     

       446
       +
       						"hostedBy":  instanceDID,

     

       447
        
       						"federation": map[string]interface{}{

     

       448
        
       							"allowExternalDiscovery": createReq["allowExternalDiscovery"],

     

       449
        
       						},

     
···

       480
        
       

     

       481
        
       		t.Run("Get via XRPC endpoint", func(t *testing.T) {

     

       482
        
       			// Create a community first (via service, so it's indexed)

     

       483
       +
       			community := createAndIndexCommunity(t, communityService, consumer, instanceDID, pdsURL)

     

       484
        
       

     

       485
        
       			// GET via HTTP endpoint

     

       486
        
       			resp, err := http.Get(fmt.Sprintf("%s/xrpc/social.coves.community.get?community=%s",

     
···

       515
        
       		t.Run("List via XRPC endpoint", func(t *testing.T) {

     

       516
        
       			// Create and index multiple communities

     

       517
        
       			for i := 0; i < 3; i++ {

     

       518
       +
       				createAndIndexCommunity(t, communityService, consumer, instanceDID, pdsURL)

     

       519
        
       			}

     

       520
        
       

     

       521
        
       			resp, err := http.Get(fmt.Sprintf("%s/xrpc/social.coves.community.list?limit=10",

     
···

       551
        
       

     

       552
        
       		t.Run("Subscribe via XRPC endpoint", func(t *testing.T) {

     

       553
        
       			// Create a community to subscribe to

     

       554
       +
       			community := createAndIndexCommunity(t, communityService, consumer, instanceDID, pdsURL)

     

       555
        
       

     

       556
        
       			// Subscribe to the community

     

       557
        
       			subscribeReq := map[string]interface{}{

     
···

       574
        
       				t.Fatalf("Failed to create request: %v", err)

     

       575
        
       			}

     

       576
        
       			req.Header.Set("Content-Type", "application/json")

     

       577
       +
       			// Use real PDS access token for E2E authentication

     

       578
       +
       			req.Header.Set("Authorization", "Bearer "+accessToken)

     

       579
        
       

     

       580
        
       			resp, err := http.DefaultClient.Do(req)

     

       581
        
       			if err != nil {

     
···

       655
        
       

     

       656
        
       		t.Run("Unsubscribe via XRPC endpoint", func(t *testing.T) {

     

       657
        
       			// Create a community and subscribe to it first

     

       658
       +
       			community := createAndIndexCommunity(t, communityService, consumer, instanceDID, pdsURL)

     

       659
        
       

     

       660
       +
       			// Subscribe first (using instance access token for instance user)

     

       661
       +
       			subscription, err := communityService.SubscribeToCommunity(ctx, instanceDID, accessToken, community.DID)

     

       662
        
       			if err != nil {

     

       663
        
       				t.Fatalf("Failed to subscribe: %v", err)

     

       664
        
       			}

     
···

       708
        
       				t.Fatalf("Failed to create request: %v", err)

     

       709
        
       			}

     

       710
        
       			req.Header.Set("Content-Type", "application/json")

     

       711
       +
       			// Use real PDS access token for E2E authentication

     

       712
       +
       			req.Header.Set("Authorization", "Bearer "+accessToken)

     

       713
        
       

     

       714
        
       			resp, err := http.DefaultClient.Do(req)

     

       715
        
       			if err != nil {

     
···

       775
        
       

     

       776
        
       		t.Run("Update via XRPC endpoint", func(t *testing.T) {

     

       777
        
       			// Create a community first (via service, so it's indexed)

     

       778
       +
       			community := createAndIndexCommunity(t, communityService, consumer, instanceDID, pdsURL)

     

       779
        
       

     

       780
        
       			// Update the community

     

       781
        
       			newDisplayName := "Updated E2E Test Community"

     

       782
        
       			newDescription := "This community has been updated"

     

       783
        
       			newVisibility := "unlisted"

     

       784
        
       

     

       785
       +
       			// NOTE: updatedByDid is derived from JWT token, not provided in request

     

       786
        
       			updateReq := map[string]interface{}{

     

       787
        
       				"communityDid": community.DID,

     

       0
        
       
     

       788
        
       				"displayName":  newDisplayName,

     

       789
        
       				"description":  newDescription,

     

       790
        
       				"visibility":   newVisibility,

     
···

       795
        
       				t.Fatalf("Failed to marshal update request: %v", marshalErr)

     

       796
        
       			}

     

       797
        
       

     

       798
       +
       			// POST update request with JWT authentication

     

       799
        
       			t.Logf("📡 Client → POST /xrpc/social.coves.community.update")

     

       800
        
       			t.Logf("   Updating community: %s", community.DID)

     

       801
       +
       

     

       802
       +
       			req, err := http.NewRequest(http.MethodPost,

     

       803
        
       				httpServer.URL+"/xrpc/social.coves.community.update",

     

       804
       +
       				bytes.NewBuffer(reqBody))

     

       805
       +
       			if err != nil {

     

       806
       +
       				t.Fatalf("Failed to create request: %v", err)

     

       807
       +
       			}

     

       808
       +
       			req.Header.Set("Content-Type", "application/json")

     

       809
       +
       			// Use real PDS access token for E2E authentication

     

       810
       +
       			req.Header.Set("Authorization", "Bearer "+accessToken)

     

       811
       +
       

     

       812
       +
       			resp, err := http.DefaultClient.Do(req)

     

       813
        
       			if err != nil {

     

       814
        
       				t.Fatalf("Failed to POST update: %v", err)

     

       815
        
       			}

     
···

       951
        
       	t.Logf("%s\n", divider)

     

       952
        
       }

     

       953
        
       

     

       954
       +
       // Helper: create and index a community (simulates consumer indexing for fast test setup)

     

       955
       +
       // NOTE: This simulates the firehose event for speed. For TRUE E2E testing with real

     

       956
       +
       // Jetstream WebSocket subscription, see "Part 2: Real Jetstream Firehose Consumption" above.

     

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

     

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

     

       959
        
       	// This avoids handle collisions when creating multiple communities quickly

     

       960
        
       	uniqueID := time.Now().UnixNano() % 1000000000

     
···

       974
        
       	}

     

       975
        
       

     

       976
        
       	// Fetch from PDS to get full record

     

       977
       +
       	// V2: Record lives in community's own repository (at://community.DID/...)

     

       978
        
       	collection := "social.coves.community.profile"

     

       979
        
       	rkey := extractRKeyFromURI(community.RecordURI)

     

       980
        
       

     

       981
        
       	pdsResp, pdsErr := http.Get(fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s",

     

       982
       +
       		pdsURL, community.DID, collection, rkey))

     

       983
        
       	if pdsErr != nil {

     

       984
        
       		t.Fatalf("Failed to fetch PDS record: %v", pdsErr)

     

       985
        
       	}

     
···

       997
        
       		t.Fatalf("Failed to decode PDS record: %v", decodeErr)

     

       998
        
       	}

     

       999
        
       

     

       1000
       +
       	// Simulate firehose event for fast indexing

     

       1001
       +
       	// V2: Event comes from community's DID (community owns the repo)

     

       1002
       +
       	// NOTE: This bypasses real Jetstream WebSocket for speed. Real firehose testing

     

       1003
       +
       	// happens in "Part 2: Real Jetstream Firehose Consumption" above.

     

       1004
        
       	event := jetstream.JetstreamEvent{

     

       1005
       +
       		Did:    community.DID,

     

       1006
        
       		TimeUS: time.Now().UnixMicro(),

     

       1007
        
       		Kind:   "commit",

     

       1008
        
       		Commit: &jetstream.CommitEvent{

     
···

       1071
        
       	}

     

       1072
        
       

     

       1073
        
       	return sessionResp.AccessJwt, sessionResp.DID, nil

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1074
        
       }

     

       1075
        
       

     

       1076
        
       // queryPDSAccount queries the PDS to verify an account exists

+5 -10

tests/integration/community_service_integration_test.go

···

       80
        
       			HostedByDID:            "did:web:coves.social",

     

       81
        
       			AllowExternalDiscovery: true,

     

       82
        
       		})

     

       83
       -
       

     

       84
        
       		if err != nil {

     

       85
        
       			t.Fatalf("Failed to create community: %v", err)

     

       86
        
       		}

     
···

       325
        
       			HostedByDID:            "did:web:coves.social",

     

       326
        
       			AllowExternalDiscovery: true,

     

       327
        
       		})

     

       328
       -
       

     

       329
        
       		if err != nil {

     

       330
        
       			t.Fatalf("Failed to create community: %v", err)

     

       331
        
       		}

     
···

       339
        
       

     

       340
        
       		t.Logf("Updating community via service.UpdateCommunity()...")

     

       341
        
       		updated, err := service.UpdateCommunity(ctx, communities.UpdateCommunityRequest{

     

       342
       -
       			CommunityDID:      community.DID,

     

       343
       -
       			UpdatedByDID:      creatorDID, // Same as creator - should be authorized

     

       344
       -
       			DisplayName:       &newDisplayName,

     

       345
       -
       			Description:       &newDescription,

     

       346
       -
       			Visibility:        &newVisibility,

     

       347
        
       			AllowExternalDiscovery: nil, // Don't change

     

       348
        
       		})

     

       349
       -
       

     

       350
        
       		if err != nil {

     

       351
        
       			t.Fatalf("Failed to update community: %v", err)

     

       352
        
       		}

     
···

       395
        
       			HostedByDID:            "did:web:coves.social",

     

       396
        
       			AllowExternalDiscovery: true,

     

       397
        
       		})

     

       398
       -
       

     

       399
        
       		if err != nil {

     

       400
        
       			t.Fatalf("Failed to create community: %v", err)

     

       401
        
       		}

     
···

       517
        
       			HostedByDID:            "did:web:coves.social",

     

       518
        
       			AllowExternalDiscovery: true,

     

       519
        
       		})

     

       520
       -
       

     

       521
        
       		if err != nil {

     

       522
        
       			t.Fatalf("Failed to create community: %v", err)

     

       523
        
       		}

···

       80
        
       			HostedByDID:            "did:web:coves.social",

     

       81
        
       			AllowExternalDiscovery: true,

     

       82
        
       		})

     

       0
        
       
     

       83
        
       		if err != nil {

     

       84
        
       			t.Fatalf("Failed to create community: %v", err)

     

       85
        
       		}

     
···

       324
        
       			HostedByDID:            "did:web:coves.social",

     

       325
        
       			AllowExternalDiscovery: true,

     

       326
        
       		})

     

       0
        
       
     

       327
        
       		if err != nil {

     

       328
        
       			t.Fatalf("Failed to create community: %v", err)

     

       329
        
       		}

     
···

       337
        
       

     

       338
        
       		t.Logf("Updating community via service.UpdateCommunity()...")

     

       339
        
       		updated, err := service.UpdateCommunity(ctx, communities.UpdateCommunityRequest{

     

       340
       +
       			CommunityDID:           community.DID,

     

       341
       +
       			UpdatedByDID:           creatorDID, // Same as creator - should be authorized

     

       342
       +
       			DisplayName:            &newDisplayName,

     

       343
       +
       			Description:            &newDescription,

     

       344
       +
       			Visibility:             &newVisibility,

     

       345
        
       			AllowExternalDiscovery: nil, // Don't change

     

       346
        
       		})

     

       0
        
       
     

       347
        
       		if err != nil {

     

       348
        
       			t.Fatalf("Failed to update community: %v", err)

     

       349
        
       		}

     
···

       392
        
       			HostedByDID:            "did:web:coves.social",

     

       393
        
       			AllowExternalDiscovery: true,

     

       394
        
       		})

     

       0
        
       
     

       395
        
       		if err != nil {

     

       396
        
       			t.Fatalf("Failed to create community: %v", err)

     

       397
        
       		}

     
···

       513
        
       			HostedByDID:            "did:web:coves.social",

     

       514
        
       			AllowExternalDiscovery: true,

     

       515
        
       		})

     

       0
        
       
     

       516
        
       		if err != nil {

     

       517
        
       			t.Fatalf("Failed to create community: %v", err)

     

       518
        
       		}