commit 31fb7196ddc2aaa056e5f7fdc1e88a39ce959f97 · bretton.dev/coves

+62 -69

tests/integration/community_e2e_test.go

···

       1
       1
        
       package integration

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"Coves/internal/api/middleware"

     

       4
       5
        
       	"Coves/internal/api/routes"

     

       5
       6
        
       	"Coves/internal/atproto/identity"

     

       6
       7
        
       	"Coves/internal/atproto/jetstream"

     
···

       106
       107
        
       

     

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

     

       108
       109
        
       

     

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

     

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

     

       112
       112
       +
       

     

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

     

       110
       114
        
       	var instanceDomain string

     

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

     
···

       141
       145
        
       

     

       142
       146
        
       	// Setup HTTP server with XRPC routes

     

       143
       147
        
       	r := chi.NewRouter()

     

       144
       144
       -
       	routes.RegisterCommunityRoutes(r, communityService)

     

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

     

       145
       149
        
       	httpServer := httptest.NewServer(r)

     

       146
       150
        
       	defer httpServer.Close()

     

       147
       151
        
       

     
···

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       357
       364
        
       				"displayName":            "XRPC E2E Test",

     

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

     

       359
       366
        
       				"visibility":             "public",

     

       360
       360
       -
       				"createdByDid":           instanceDID,

     

       361
       361
       -
       				"hostedByDid":            instanceDID,

     

       362
       367
        
       				"allowExternalDiscovery": true,

     

       363
       368
        
       			}

     

       364
       369
        
       

     
···

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

     

       368
       373
        
       			}

     

       369
       374
        
       

     

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

     

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

     

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

     

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

     

       373
       373
       -
       			resp, err := http.Post(

     

       378
       378
       +
       

     

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

     

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

     

       375
       375
       -
       				"application/json",

     

       376
       376
       -
       				bytes.NewBuffer(reqBody),

     

       377
       377
       -
       			)

     

       381
       381
       +
       				bytes.NewBuffer(reqBody))

     

       382
       382
       +
       			if err != nil {

     

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

     

       384
       384
       +
       			}

     

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

     

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

     

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

     

       388
       388
       +
       

     

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

     

       378
       390
        
       			if err != nil {

     

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

     

       380
       392
        
       			}

     
···

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

     

       409
       421
        
       

     

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

     

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

     

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

     

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

     

       412
       426
        
       			rkey := extractRKeyFromURI(createResp.URI)

     

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

     

       413
       428
        
       			event := jetstream.JetstreamEvent{

     

       414
       414
       -
       				Did:    instanceDID,

     

       429
       429
       +
       				Did:    createResp.DID,

     

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

     

       416
       431
        
       				Kind:   "commit",

     

       417
       432
        
       				Commit: &jetstream.CommitEvent{

     
···

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

     

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

     

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

     

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

     

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

     

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

     

       445
       445
       +
       						"createdBy": instanceDID,

     

       446
       446
       +
       						"hostedBy":  instanceDID,

     

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

     

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

     

       433
       449
        
       						},

     
···

       464
       480
        
       

     

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

     

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

     

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

     

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

     

       468
       484
        
       

     

       469
       485
        
       			// GET via HTTP endpoint

     

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

     
···

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

     

       500
       516
        
       			// Create and index multiple communities

     

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

     

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

     

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

     

       503
       519
        
       			}

     

       504
       520
        
       

     

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

     
···

       535
       551
        
       

     

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

     

       537
       553
        
       			// Create a community to subscribe to

     

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

     

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

     

       539
       555
        
       

     

       540
       556
        
       			// Subscribe to the community

     

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

     
···

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

     

       559
       575
        
       			}

     

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

     

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

     

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

     

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

     

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

     

       563
       579
        
       

     

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

     

       565
       581
        
       			if err != nil {

     
···

       639
       655
        
       

     

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

     

       641
       657
        
       			// Create a community and subscribe to it first

     

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

     

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

     

       643
       659
        
       

     

       644
       644
       -
       			// Subscribe first

     

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

     

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

     

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

     

       646
       662
        
       			if err != nil {

     

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

     

       648
       664
        
       			}

     
···

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

     

       693
       709
        
       			}

     

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

     

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

     

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

     

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

     

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

     

       697
       713
        
       

     

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

     

       699
       715
        
       			if err != nil {

     
···

       759
       775
        
       

     

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

     

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

     

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

     

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

     

       763
       779
        
       

     

       764
       780
        
       			// Update the community

     

       765
       781
        
       			newDisplayName := "Updated E2E Test Community"

     

       766
       782
        
       			newDescription := "This community has been updated"

     

       767
       783
        
       			newVisibility := "unlisted"

     

       768
       784
        
       

     

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

     

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

     

       770
       787
        
       				"communityDid": community.DID,

     

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

     

       772
       788
        
       				"displayName":  newDisplayName,

     

       773
       789
        
       				"description":  newDescription,

     

       774
       790
        
       				"visibility":   newVisibility,

     
···

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

     

       780
       796
        
       			}

     

       781
       797
        
       

     

       782
       782
       -
       			// POST update request

     

       798
       798
       +
       			// POST update request with JWT authentication

     

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

     

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

     

       785
       785
       -
       			resp, err := http.Post(

     

       801
       801
       +
       

     

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

     

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

     

       787
       787
       -
       				"application/json",

     

       788
       788
       -
       				bytes.NewBuffer(reqBody),

     

       789
       789
       -
       			)

     

       804
       804
       +
       				bytes.NewBuffer(reqBody))

     

       805
       805
       +
       			if err != nil {

     

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

     

       807
       807
       +
       			}

     

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

     

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

     

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

     

       811
       811
       +
       

     

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

     

       790
       813
        
       			if err != nil {

     

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

     

       792
       815
        
       			}

     
···

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

     

       929
       952
        
       }

     

       930
       953
        
       

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     
···

       949
       974
        
       	}

     

       950
       975
        
       

     

       951
       976
        
       	// Fetch from PDS to get full record

     

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

     

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

     

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

     

       954
       979
        
       	rkey := extractRKeyFromURI(community.RecordURI)

     

       955
       980
        
       

     

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

     

       957
       957
       -
       		pdsURL, instanceDID, collection, rkey))

     

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

     

       958
       983
        
       	if pdsErr != nil {

     

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

     

       960
       985
        
       	}

     
···

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

     

       973
       998
        
       	}

     

       974
       999
        
       

     

       975
       975
       -
       	// Simulate firehose event

     

       1000
       1000
       +
       	// Simulate firehose event for fast indexing

     

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

     

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

     

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

     

       976
       1004
        
       	event := jetstream.JetstreamEvent{

     

       977
       977
       -
       		Did:    instanceDID,

     

       1005
       1005
       +
       		Did:    community.DID,

     

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

     

       979
       1007
        
       		Kind:   "commit",

     

       980
       1008
        
       		Commit: &jetstream.CommitEvent{

     
···

       1043
       1071
        
       	}

     

       1044
       1072
        
       

     

       1045
       1073
        
       	return sessionResp.AccessJwt, sessionResp.DID, nil

     

       1046
       1046
       -
       }

     

       1047
       1047
       -
       

     

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

     

       1049
       1049
       -
       type communityTestIdentityResolver struct{}

     

       1050
       1050
       -
       

     

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

     

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

     

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

     

       1054
       1054
       -
       }

     

       1055
       1055
       -
       

     

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

     

       1057
       1057
       -
       	// Simple mock - return minimal DID document

     

       1058
       1058
       -
       	return &identity.DIDDocument{

     

       1059
       1059
       -
       		DID: did,

     

       1060
       1060
       -
       		Service: []identity.Service{

     

       1061
       1061
       -
       			{

     

       1062
       1062
       -
       				ID:              "#atproto_pds",

     

       1063
       1063
       -
       				Type:            "AtprotoPersonalDataServer",

     

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

     

       1065
       1065
       -
       			},

     

       1066
       1066
       -
       		},

     

       1067
       1067
       -
       	}, nil

     

       1068
       1068
       -
       }

     

       1069
       1069
       -
       

     

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

     

       1071
       1071
       -
       	return &identity.Identity{

     

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

     

       1073
       1073
       -
       		Handle: identifier,

     

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

     

       1075
       1075
       -
       	}, nil

     

       1076
       1076
       -
       }

     

       1077
       1077
       -
       

     

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

     

       1079
       1079
       -
       	// No-op for mock

     

       1080
       1080
       -
       	return nil

     

       1081
       1074
        
       }

     

       1082
       1075
        
       

     

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

+5 -10

tests/integration/community_service_integration_test.go

···

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

     

       81
       81
        
       			AllowExternalDiscovery: true,

     

       82
       82
        
       		})

     

       83
       83
       -
       

     

       84
       83
        
       		if err != nil {

     

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

     

       86
       85
        
       		}

     
···

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

     

       326
       325
        
       			AllowExternalDiscovery: true,

     

       327
       326
        
       		})

     

       328
       328
       -
       

     

       329
       327
        
       		if err != nil {

     

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

     

       331
       329
        
       		}

     
···

       339
       337
        
       

     

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

     

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

     

       342
       342
       -
       			CommunityDID:      community.DID,

     

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

     

       344
       344
       -
       			DisplayName:       &newDisplayName,

     

       345
       345
       -
       			Description:       &newDescription,

     

       346
       346
       -
       			Visibility:        &newVisibility,

     

       340
       340
       +
       			CommunityDID:           community.DID,

     

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

     

       342
       342
       +
       			DisplayName:            &newDisplayName,

     

       343
       343
       +
       			Description:            &newDescription,

     

       344
       344
       +
       			Visibility:             &newVisibility,

     

       347
       345
        
       			AllowExternalDiscovery: nil, // Don't change

     

       348
       346
        
       		})

     

       349
       349
       -
       

     

       350
       347
        
       		if err != nil {

     

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

     

       352
       349
        
       		}

     
···

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

     

       396
       393
        
       			AllowExternalDiscovery: true,

     

       397
       394
        
       		})

     

       398
       398
       -
       

     

       399
       395
        
       		if err != nil {

     

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

     

       401
       397
        
       		}

     
···

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

     

       518
       514
        
       			AllowExternalDiscovery: true,

     

       519
       515
        
       		})

     

       520
       520
       -
       

     

       521
       516
        
       		if err != nil {

     

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

     

       523
       518
        
       		}