commit 0cffb091c30b20e343c23df166af4ae2ba390942 · bretton.dev/coves

+3 -3

tests/integration/community_e2e_test.go

···

       158
       158
        
       	// ====================================================================================

     

       159
       159
        
       	t.Run("1. Write-Forward to PDS", func(t *testing.T) {

     

       160
       160
        
       		// Use shorter names to avoid "Handle too long" errors

     

       161
       161
       -
       		// atProto handles max: 63 chars, format: name.communities.coves.social

     

       161
       161
       +
       		// atProto handles max: 63 chars, format: name.community.coves.social

     

       162
       162
        
       		communityName := fmt.Sprintf("e2e-%d", time.Now().Unix())

     

       163
       163
        
       

     

       164
       164
        
       		createReq := communities.CreateCommunityRequest{

     
···

       190
       190
        
       

     

       191
       191
        
       		// V2: Verify PDS account was created for the community

     

       192
       192
        
       		t.Logf("\n🔍 V2: Verifying community PDS account exists...")

     

       193
       193
       -
       		expectedHandle := fmt.Sprintf("%s.communities.%s", communityName, instanceDomain)

     

       193
       193
       +
       		expectedHandle := fmt.Sprintf("%s.community.%s", communityName, instanceDomain)

     

       194
       194
        
       		t.Logf("   Expected handle: %s", expectedHandle)

     

       195
       195
       -
       		t.Logf("   (Using subdomain: *.communities.%s)", instanceDomain)

     

       195
       195
       +
       		t.Logf("   (Using subdomain: *.community.%s)", instanceDomain)

     

       196
       196
        
       

     

       197
       197
        
       		accountDID, accountHandle, err := queryPDSAccount(pdsURL, expectedHandle)

     

       198
       198
        
       		if err != nil {

+12 -12

tests/integration/community_hostedby_security_test.go

···

       41
       41
        
       				RKey:       "self",

     

       42
       42
        
       				CID:        "bafy123abc",

     

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

     

       44
       44
       -
       					"handle":      "gaming.communities.coves.social", // coves.social handle

     

       44
       44
       +
       					"handle":      "gaming.community.coves.social", // coves.social handle

     

       45
       45
        
       					"name":        "gaming",

     

       46
       46
        
       					"displayName": "Nintendo Gaming",

     

       47
       47
        
       					"description": "Fake Nintendo community",

     
···

       97
       97
        
       				RKey:       "self",

     

       98
       98
        
       				CID:        "bafy123abc",

     

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

     

       100
       100
       -
       					"handle":      "gaming.communities.coves.social", // coves.social handle

     

       100
       100
       +
       					"handle":      "gaming.community.coves.social", // coves.social handle

     

       101
       101
        
       					"name":        "gaming",

     

       102
       102
        
       					"displayName": "Gaming Community",

     

       103
       103
        
       					"description": "Legitimate coves.social community",

     
···

       149
       149
        
       				RKey:       "self",

     

       150
       150
        
       				CID:        "bafy123abc",

     

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

     

       152
       152
       -
       					"handle":      "gaming.communities.coves.social",

     

       152
       152
       +
       					"handle":      "gaming.community.coves.social",

     

       153
       153
        
       					"name":        "gaming",

     

       154
       154
        
       					"displayName": "Test Community",

     

       155
       155
        
       					"description": "Test",

     
···

       193
       193
        
       				RKey:       "self",

     

       194
       194
        
       				CID:        "bafy123abc",

     

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

     

       196
       196
       -
       					"handle":      "gaming.communities.example.com",

     

       196
       196
       +
       					"handle":      "gaming.community.example.com",

     

       197
       197
        
       					"name":        "gaming",

     

       198
       198
        
       					"displayName": "Test",

     

       199
       199
        
       					"description": "Test",

     
···

       245
       245
        
       	}{

     

       246
       246
        
       		{

     

       247
       247
        
       			name:          "DNS-style handle with subdomain",

     

       248
       248
       -
       			handle:        "gaming.communities.coves.social",

     

       248
       248
       +
       			handle:        "gaming.community.coves.social",

     

       249
       249
        
       			hostedByDID:   "did:web:coves.social",

     

       250
       250
        
       			shouldSucceed: true,

     

       251
       251
        
       		},

     
···

       257
       257
        
       		},

     

       258
       258
        
       		{

     

       259
       259
        
       			name:          "Multi-part subdomain",

     

       260
       260
       -
       			handle:        "gaming.test.communities.example.com",

     

       260
       260
       +
       			handle:        "gaming.test.community.example.com",

     

       261
       261
        
       			hostedByDID:   "did:web:example.com",

     

       262
       262
        
       			shouldSucceed: true,

     

       263
       263
        
       		},

     

       264
       264
        
       		{

     

       265
       265
        
       			name:          "Mismatched domain",

     

       266
       266
       -
       			handle:        "gaming.communities.coves.social",

     

       266
       266
       +
       			handle:        "gaming.community.coves.social",

     

       267
       267
        
       			hostedByDID:   "did:web:example.com",

     

       268
       268
        
       			shouldSucceed: false,

     

       269
       269
        
       		},

     

       270
       270
        
       		// CRITICAL: Multi-part TLD tests (PR review feedback)

     

       271
       271
        
       		{

     

       272
       272
        
       			name:          "Multi-part TLD: .co.uk",

     

       273
       273
       -
       			handle:        "gaming.communities.coves.co.uk",

     

       273
       273
       +
       			handle:        "gaming.community.coves.co.uk",

     

       274
       274
        
       			hostedByDID:   "did:web:coves.co.uk",

     

       275
       275
        
       			shouldSucceed: true,

     

       276
       276
        
       		},

     

       277
       277
        
       		{

     

       278
       278
        
       			name:          "Multi-part TLD: .com.au",

     

       279
       279
       -
       			handle:        "gaming.communities.example.com.au",

     

       279
       279
       +
       			handle:        "gaming.community.example.com.au",

     

       280
       280
        
       			hostedByDID:   "did:web:example.com.au",

     

       281
       281
        
       			shouldSucceed: true,

     

       282
       282
        
       		},

     

       283
       283
        
       		{

     

       284
       284
        
       			name:          "Multi-part TLD: Reject incorrect .co.uk extraction",

     

       285
       285
       -
       			handle:        "gaming.communities.coves.co.uk",

     

       285
       285
       +
       			handle:        "gaming.community.coves.co.uk",

     

       286
       286
        
       			hostedByDID:   "did:web:co.uk", // Wrong! Should be coves.co.uk

     

       287
       287
        
       			shouldSucceed: false,

     

       288
       288
        
       		},

     

       289
       289
        
       		{

     

       290
       290
        
       			name:          "Multi-part TLD: .org.uk",

     

       291
       291
       -
       			handle:        "gaming.communities.myinstance.org.uk",

     

       291
       291
       +
       			handle:        "gaming.community.myinstance.org.uk",

     

       292
       292
        
       			hostedByDID:   "did:web:myinstance.org.uk",

     

       293
       293
        
       			shouldSucceed: true,

     

       294
       294
        
       		},

     

       295
       295
        
       		{

     

       296
       296
        
       			name:          "Multi-part TLD: .ac.uk",

     

       297
       297
       -
       			handle:        "gaming.communities.university.ac.uk",

     

       297
       297
       +
       			handle:        "gaming.community.university.ac.uk",

     

       298
       298
        
       			hostedByDID:   "did:web:university.ac.uk",

     

       299
       299
        
       			shouldSucceed: true,

     

       300
       300
        
       		},

+9 -9

tests/integration/community_provisioning_test.go

···

       29
       29
        
       

     

       30
       30
        
       		community := &communities.Community{

     

       31
       31
        
       			DID:                    generateTestDID(uniqueSuffix),

     

       32
       32
       -
       			Handle:                 fmt.Sprintf("test-encryption-%s.communities.test.local", uniqueSuffix),

     

       32
       32
       +
       			Handle:                 fmt.Sprintf("test-encryption-%s.community.test.local", uniqueSuffix),

     

       33
       33
        
       			Name:                   "test-encryption",

     

       34
       34
        
       			DisplayName:            "Test Encryption",

     

       35
       35
        
       			Description:            "Testing password encryption",

     
···

       100
       100
        
       

     

       101
       101
        
       		community := &communities.Community{

     

       102
       102
        
       			DID:                    generateTestDID(uniqueSuffix),

     

       103
       103
       -
       			Handle:                 fmt.Sprintf("test-empty-pass-%s.communities.test.local", uniqueSuffix),

     

       103
       103
       +
       			Handle:                 fmt.Sprintf("test-empty-pass-%s.community.test.local", uniqueSuffix),

     

       104
       104
        
       			Name:                   "test-empty-pass",

     

       105
       105
        
       			DisplayName:            "Test Empty Password",

     

       106
       106
        
       			Description:            "Testing empty password handling",

     
···

       332
       332
        
       

     

       333
       333
        
       			community := &communities.Community{

     

       334
       334
        
       				DID:                    generateTestDID(uniqueSuffix),

     

       335
       335
       -
       				Handle:                 fmt.Sprintf("pwd-unique-%s.communities.test.local", uniqueSuffix),

     

       335
       335
       +
       				Handle:                 fmt.Sprintf("pwd-unique-%s.community.test.local", uniqueSuffix),

     

       336
       336
        
       				Name:                   fmt.Sprintf("pwd-unique-%s", uniqueSuffix),

     

       337
       337
        
       				DisplayName:            fmt.Sprintf("Password Unique Test %d", i),

     

       338
       338
        
       				Description:            "Testing password uniqueness",

     
···

       402
       402
        
       

     

       403
       403
        
       		community := &communities.Community{

     

       404
       404
        
       			DID:                    generateTestDID(uniqueSuffix),

     

       405
       405
       -
       			Handle:                 fmt.Sprintf("test-pwd-len-%s.communities.test.local", uniqueSuffix),

     

       405
       405
       +
       			Handle:                 fmt.Sprintf("test-pwd-len-%s.community.test.local", uniqueSuffix),

     

       406
       406
        
       			Name:                   "test-pwd-len",

     

       407
       407
        
       			DisplayName:            "Test Password Length",

     

       408
       408
        
       			Description:            "Testing password length requirements",

     
···

       470
       470
        
       				uniqueSuffix := fmt.Sprintf("%d-%d", time.Now().UnixNano(), idx)

     

       471
       471
        
       				community := &communities.Community{

     

       472
       472
        
       					DID:                    generateTestDID(uniqueSuffix),

     

       473
       473
       -
       					Handle:                 fmt.Sprintf("%s.communities.test.local", sameName),

     

       473
       473
       +
       					Handle:                 fmt.Sprintf("%s.community.test.local", sameName),

     

       474
       474
        
       					Name:                   sameName,

     

       475
       475
        
       					DisplayName:            "Concurrent Test",

     

       476
       476
        
       					Description:            "Testing concurrent creation",

     
···

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

     

       531
       531
        
       		community := &communities.Community{

     

       532
       532
        
       			DID:                    generateTestDID(uniqueSuffix),

     

       533
       533
       -
       			Handle:                 fmt.Sprintf("read-test-%s.communities.test.local", uniqueSuffix),

     

       533
       533
       +
       			Handle:                 fmt.Sprintf("read-test-%s.community.test.local", uniqueSuffix),

     

       534
       534
        
       			Name:                   "read-test",

     

       535
       535
        
       			DisplayName:            "Read Test",

     

       536
       536
        
       			Description:            "Testing concurrent reads",

     
···

       719
       719
        
       

     

       720
       720
        
       		community := &communities.Community{

     

       721
       721
        
       			DID:                    generateTestDID(uniqueSuffix),

     

       722
       722
       -
       			Handle:                 fmt.Sprintf("token-test-%s.communities.test.local", uniqueSuffix),

     

       722
       722
       +
       			Handle:                 fmt.Sprintf("token-test-%s.community.test.local", uniqueSuffix),

     

       723
       723
        
       			Name:                   "token-test",

     

       724
       724
        
       			DisplayName:            "Token Test",

     

       725
       725
        
       			Description:            "Testing token storage",

     
···

       784
       784
        
       

     

       785
       785
        
       		community := &communities.Community{

     

       786
       786
        
       			DID:                    generateTestDID(uniqueSuffix),

     

       787
       787
       -
       			Handle:                 fmt.Sprintf("empty-token-%s.communities.test.local", uniqueSuffix),

     

       787
       787
       +
       			Handle:                 fmt.Sprintf("empty-token-%s.community.test.local", uniqueSuffix),

     

       788
       788
        
       			Name:                   "empty-token",

     

       789
       789
        
       			DisplayName:            "Empty Token Test",

     

       790
       790
        
       			Description:            "Testing empty token handling",

     
···

       832
       832
        
       

     

       833
       833
        
       		community := &communities.Community{

     

       834
       834
        
       			DID:                    generateTestDID(uniqueSuffix),

     

       835
       835
       -
       			Handle:                 fmt.Sprintf("encrypted-token-%s.communities.test.local", uniqueSuffix),

     

       835
       835
       +
       			Handle:                 fmt.Sprintf("encrypted-token-%s.community.test.local", uniqueSuffix),

     

       836
       836
        
       			Name:                   "encrypted-token",

     

       837
       837
        
       			DisplayName:            "Encrypted Token Test",

     

       838
       838
        
       			Description:            "Testing token encryption",

+2 -2

tests/integration/community_service_integration_test.go

···

       55
       55
        
       

     

       56
       56
        
       	t.Run("creates community with real PDS provisioning", func(t *testing.T) {

     

       57
       57
        
       		// Create provisioner and service (production code path)

     

       58
       58
       -
       		// Use coves.social domain (configured in PDS_SERVICE_HANDLE_DOMAINS as .communities.coves.social)

     

       58
       58
       +
       		// Use coves.social domain (configured in PDS_SERVICE_HANDLE_DOMAINS as .community.coves.social)

     

       59
       59
        
       		provisioner := communities.NewPDSAccountProvisioner("coves.social", pdsURL)

     

       60
       60
        
       		service := communities.NewCommunityService(

     

       61
       61
        
       			repo,

     
···

       114
       114
        
       		t.Logf("✅ Real DID generated: %s", community.DID)

     

       115
       115
        
       

     

       116
       116
        
       		// Verify handle format

     

       117
       117
       -
       		expectedHandle := fmt.Sprintf("%s.communities.coves.social", uniqueName)

     

       117
       117
       +
       		expectedHandle := fmt.Sprintf("%s.community.coves.social", uniqueName)

     

       118
       118
        
       		if community.Handle != expectedHandle {

     

       119
       119
        
       			t.Errorf("Expected handle %s, got %s", expectedHandle, community.Handle)

     

       120
       120
        
       		}

+8 -8

tests/integration/community_v2_validation_test.go

···

       34
       34
        
       				CID:        "bafyreigaming123",

     

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

     

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

     

       37
       37
       -
       					"handle":     "gaming.communities.coves.social",

     

       37
       37
       +
       					"handle":     "gaming.community.coves.social",

     

       38
       38
        
       					"name":       "gaming",

     

       39
       39
        
       					"createdBy":  "did:plc:user123",

     

       40
       40
        
       					"hostedBy":   "did:web:coves.social",

     
···

       83
       83
        
       				CID:        "bafyreiv1community",

     

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

     

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

     

       86
       86
       -
       					"handle":     "v1community.communities.coves.social",

     

       86
       86
       +
       					"handle":     "v1community.community.coves.social",

     

       87
       87
        
       					"name":       "v1community",

     

       88
       88
        
       					"createdBy":  "did:plc:user456",

     

       89
       89
        
       					"hostedBy":   "did:web:coves.social",

     
···

       129
       129
        
       				CID:        "bafyreicustom",

     

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

     

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

     

       132
       132
       -
       					"handle":     "custom.communities.coves.social",

     

       132
       132
       +
       					"handle":     "custom.community.coves.social",

     

       133
       133
        
       					"name":       "custom",

     

       134
       134
        
       					"createdBy":  "did:plc:user789",

     

       135
       135
        
       					"hostedBy":   "did:web:coves.social",

     
···

       168
       168
        
       				CID:        "bafyreiupdate1",

     

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

     

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

     

       171
       171
       -
       					"handle":     "updatetest.communities.coves.social",

     

       171
       171
       +
       					"handle":     "updatetest.community.coves.social",

     

       172
       172
        
       					"name":       "updatetest",

     

       173
       173
        
       					"createdBy":  "did:plc:userUpdate",

     

       174
       174
        
       					"hostedBy":   "did:web:coves.social",

     
···

       199
       199
        
       				CID:        "bafyreiupdate2",

     

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

     

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

     

       202
       202
       -
       					"handle":      "updatetest.communities.coves.social",

     

       202
       202
       +
       					"handle":      "updatetest.community.coves.social",

     

       203
       203
        
       					"name":        "updatetest",

     

       204
       204
        
       					"displayName": "Updated Name",

     

       205
       205
        
       					"createdBy":   "did:plc:userUpdate",

     
···

       258
       258
        
       				CID:        "bafyreihandle",

     

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

     

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

     

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

     

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

     

       262
       262
        
       					"name":       "gamingtest",                          // Short name for !mentions

     

       263
       263
        
       					"createdBy":  "did:plc:user123",

     

       264
       264
        
       					"hostedBy":   "did:web:coves.social",

     
···

       284
       284
        
       		}

     

       285
       285
        
       

     

       286
       286
        
       		// Verify the atProto handle is stored

     

       287
       287
       -
       		if community.Handle != "gamingtest.communities.coves.social" {

     

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

     

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

     

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

     

       289
       289
        
       		}

     

       290
       290
        
       

     

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

+2 -2

tests/integration/token_refresh_test.go

···

       110
       110
        
       	// Create a test community first

     

       111
       111
        
       	community := &communities.Community{

     

       112
       112
        
       		DID:             "did:plc:test123",

     

       113
       113
       -
       		Handle:          "test.communities.coves.social",

     

       113
       113
       +
       		Handle:          "test.community.coves.social",

     

       114
       114
        
       		Name:            "test",

     

       115
       115
        
       		OwnerDID:        "did:plc:test123",

     

       116
       116
        
       		CreatedByDID:    "did:plc:creator",

     
···

       186
       186
        
       

     

       187
       187
        
       	community := &communities.Community{

     

       188
       188
        
       		DID:             "did:plc:expiring123",

     

       189
       189
       -
       		Handle:          "expiring.communities.coves.social",

     

       189
       189
       +
       		Handle:          "expiring.community.coves.social",

     

       190
       190
        
       		Name:            "expiring",

     

       191
       191
        
       		OwnerDID:        "did:plc:expiring123",

     

       192
       192
        
       		CreatedByDID:    "did:plc:creator",