···

       
3
       
 
       
import (

     

       
4
       
 
       
	"Coves/internal/atproto/jetstream"

     

       
5
       
 
       
	"Coves/internal/core/communities"

     

       
6
       
-
       
	postgresRepo "Coves/internal/db/postgres"

     

       
7
       
 
       
	"context"

     

       
8
       
 
       
	"database/sql"

     

       
9
       
 
       
	"fmt"

     

       
10
       
 
       
	"testing"

     

       
11
       
 
       
	"time"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
12
       
 
       
)

     

       
13
       
 
       


     

       
14
       
 
       
// TestCommunityBlocking_Indexing tests Jetstream indexing of block events

     

···

       
3
       
 
       
import (

     

       
4
       
 
       
	"Coves/internal/atproto/jetstream"

     

       
5
       
 
       
	"Coves/internal/core/communities"

     

       
0
       
 
       

     

       
6
       
 
       
	"context"

     

       
7
       
 
       
	"database/sql"

     

       
8
       
 
       
	"fmt"

     

       
9
       
 
       
	"testing"

     

       
10
       
 
       
	"time"

     

       
11
       
+
       


     

       
12
       
+
       
	postgresRepo "Coves/internal/db/postgres"

     

       
13
       
 
       
)

     

       
14
       
 
       


     

       
15
       
 
       
// TestCommunityBlocking_Indexing tests Jetstream indexing of block events

     

···

       
1506
       
 
       
	return community

     

       
1507
       
 
       
}

     

       
1508
       
 
       


     

       
1509
       
-
       
// authenticateWithPDS authenticates with the PDS and returns access token and DID

     

       
1510
       
-
       
func authenticateWithPDS(pdsURL, handle, password string) (string, string, error) {

     

       
1511
       
-
       
	// Call com.atproto.server.createSession

     

       
1512
       
-
       
	sessionReq := map[string]string{

     

       
1513
       
-
       
		"identifier": handle,

     

       
1514
       
-
       
		"password":   password,

     

       
1515
       
-
       
	}

     

       
1516
       
-
       


     

       
1517
       
-
       
	reqBody, marshalErr := json.Marshal(sessionReq)

     

       
1518
       
-
       
	if marshalErr != nil {

     

       
1519
       
-
       
		return "", "", fmt.Errorf("failed to marshal session request: %w", marshalErr)

     

       
1520
       
-
       
	}

     

       
1521
       
-
       
	resp, err := http.Post(

     

       
1522
       
-
       
		pdsURL+"/xrpc/com.atproto.server.createSession",

     

       
1523
       
-
       
		"application/json",

     

       
1524
       
-
       
		bytes.NewBuffer(reqBody),

     

       
1525
       
-
       
	)

     

       
1526
       
-
       
	if err != nil {

     

       
1527
       
-
       
		return "", "", fmt.Errorf("failed to create session: %w", err)

     

       
1528
       
-
       
	}

     

       
1529
       
-
       
	defer func() { _ = resp.Body.Close() }()

     

       
1530
       
-
       


     

       
1531
       
-
       
	if resp.StatusCode != http.StatusOK {

     

       
1532
       
-
       
		body, readErr := io.ReadAll(resp.Body)

     

       
1533
       
-
       
		if readErr != nil {

     

       
1534
       
-
       
			return "", "", fmt.Errorf("PDS auth failed (status %d, failed to read body: %w)", resp.StatusCode, readErr)

     

       
1535
       
-
       
		}

     

       
1536
       
-
       
		return "", "", fmt.Errorf("PDS auth failed (status %d): %s", resp.StatusCode, string(body))

     

       
1537
       
-
       
	}

     

       
1538
       
-
       


     

       
1539
       
-
       
	var sessionResp struct {

     

       
1540
       
-
       
		AccessJwt string `json:"accessJwt"`

     

       
1541
       
-
       
		DID       string `json:"did"`

     

       
1542
       
-
       
	}

     

       
1543
       
-
       


     

       
1544
       
-
       
	if err := json.NewDecoder(resp.Body).Decode(&sessionResp); err != nil {

     

       
1545
       
-
       
		return "", "", fmt.Errorf("failed to decode session response: %w", err)

     

       
1546
       
-
       
	}

     

       
1547
       
-
       


     

       
1548
       
-
       
	return sessionResp.AccessJwt, sessionResp.DID, nil

     

       
1549
       
-
       
}

     

       
1550
       
-
       


     

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

     

       
1552
       
 
       
// Returns the account's DID and handle if found

     

       
1553
       
 
       
func queryPDSAccount(pdsURL, handle string) (string, string, error) {

     

···

       
1506
       
 
       
	return community

     

       
1507
       
 
       
}

     

       
1508
       
 
       


     

       
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
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

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

     

       
1510
       
 
       
// Returns the account's DID and handle if found

     

       
1511
       
 
       
func queryPDSAccount(pdsURL, handle string) (string, string, error) {

     

···

       
27
       
 
       


     

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

     

       
29
       
 
       
		communityDID := generateTestDID(uniqueSuffix)

     

       
0
       
 
       

     

       
30
       
 
       


     

       
31
       
 
       
		// Attempt to create community claiming to be hosted by nintendo.com

     

       
32
       
 
       
		// but with a coves.social handle (ATTACK!)

     
···

       
41
       
 
       
				RKey:       "self",

     

       
42
       
 
       
				CID:        "bafy123abc",

     

       
43
       
 
       
				Record: map[string]interface{}{

     

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

     

       
45
       
 
       
					"name":        "gaming",

     

       
46
       
 
       
					"displayName": "Nintendo Gaming",

     

       
47
       
 
       
					"description": "Fake Nintendo community",

     
···

       
84
       
 
       


     

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

     

       
86
       
 
       
		communityDID := generateTestDID(uniqueSuffix)

     

       
0
       
 
       

     

       
87
       
 
       


     

       
88
       
 
       
		// Create community with matching hostedBy and handle domains

     

       
89
       
 
       
		event := &jetstream.JetstreamEvent{

     
···

       
97
       
 
       
				RKey:       "self",

     

       
98
       
 
       
				CID:        "bafy123abc",

     

       
99
       
 
       
				Record: map[string]interface{}{

     

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

     

       
101
       
 
       
					"name":        "gaming",

     

       
102
       
 
       
					"displayName": "Gaming Community",

     

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

     
···

       
136
       
 
       


     

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

     

       
138
       
 
       
		communityDID := generateTestDID(uniqueSuffix)

     

       
0
       
 
       

     

       
139
       
 
       


     

       
140
       
 
       
		// Attempt to use did:plc for hostedBy (not allowed)

     

       
141
       
 
       
		event := &jetstream.JetstreamEvent{

     
···

       
149
       
 
       
				RKey:       "self",

     

       
150
       
 
       
				CID:        "bafy123abc",

     

       
151
       
 
       
				Record: map[string]interface{}{

     

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

     

       
153
       
 
       
					"name":        "gaming",

     

       
154
       
 
       
					"displayName": "Test Community",

     

       
155
       
 
       
					"description": "Test",

     
···

       
180
       
 
       


     

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

     

       
182
       
 
       
		communityDID := generateTestDID(uniqueSuffix)

     

       
0
       
 
       

     

       
183
       
 
       


     

       
184
       
 
       
		// Even with mismatched domain, this should succeed with skipVerification=true

     

       
185
       
 
       
		event := &jetstream.JetstreamEvent{

     
···

       
193
       
 
       
				RKey:       "self",

     

       
194
       
 
       
				CID:        "bafy123abc",

     

       
195
       
 
       
				Record: map[string]interface{}{

     

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

     

       
197
       
 
       
					"name":        "gaming",

     

       
198
       
 
       
					"displayName": "Test",

     

       
199
       
 
       
					"description": "Test",

     

···

       
27
       
 
       


     

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

     

       
29
       
 
       
		communityDID := generateTestDID(uniqueSuffix)

     

       
30
       
+
       
		uniqueHandle := fmt.Sprintf("gaming%s.community.coves.social", uniqueSuffix)

     

       
31
       
 
       


     

       
32
       
 
       
		// Attempt to create community claiming to be hosted by nintendo.com

     

       
33
       
 
       
		// but with a coves.social handle (ATTACK!)

     
···

       
42
       
 
       
				RKey:       "self",

     

       
43
       
 
       
				CID:        "bafy123abc",

     

       
44
       
 
       
				Record: map[string]interface{}{

     

       
45
       
+
       
					"handle":      uniqueHandle, // coves.social handle

     

       
46
       
 
       
					"name":        "gaming",

     

       
47
       
 
       
					"displayName": "Nintendo Gaming",

     

       
48
       
 
       
					"description": "Fake Nintendo community",

     
···

       
85
       
 
       


     

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

     

       
87
       
 
       
		communityDID := generateTestDID(uniqueSuffix)

     

       
88
       
+
       
		uniqueHandle := fmt.Sprintf("gaming%s.community.coves.social", uniqueSuffix)

     

       
89
       
 
       


     

       
90
       
 
       
		// Create community with matching hostedBy and handle domains

     

       
91
       
 
       
		event := &jetstream.JetstreamEvent{

     
···

       
99
       
 
       
				RKey:       "self",

     

       
100
       
 
       
				CID:        "bafy123abc",

     

       
101
       
 
       
				Record: map[string]interface{}{

     

       
102
       
+
       
					"handle":      uniqueHandle, // coves.social handle

     

       
103
       
 
       
					"name":        "gaming",

     

       
104
       
 
       
					"displayName": "Gaming Community",

     

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

     
···

       
138
       
 
       


     

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

     

       
140
       
 
       
		communityDID := generateTestDID(uniqueSuffix)

     

       
141
       
+
       
		uniqueHandle := fmt.Sprintf("gaming%s.community.coves.social", uniqueSuffix)

     

       
142
       
 
       


     

       
143
       
 
       
		// Attempt to use did:plc for hostedBy (not allowed)

     

       
144
       
 
       
		event := &jetstream.JetstreamEvent{

     
···

       
152
       
 
       
				RKey:       "self",

     

       
153
       
 
       
				CID:        "bafy123abc",

     

       
154
       
 
       
				Record: map[string]interface{}{

     

       
155
       
+
       
					"handle":      uniqueHandle,

     

       
156
       
 
       
					"name":        "gaming",

     

       
157
       
 
       
					"displayName": "Test Community",

     

       
158
       
 
       
					"description": "Test",

     
···

       
183
       
 
       


     

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

     

       
185
       
 
       
		communityDID := generateTestDID(uniqueSuffix)

     

       
186
       
+
       
		uniqueHandle := fmt.Sprintf("gaming%s.community.example.com", uniqueSuffix)

     

       
187
       
 
       


     

       
188
       
 
       
		// Even with mismatched domain, this should succeed with skipVerification=true

     

       
189
       
 
       
		event := &jetstream.JetstreamEvent{

     
···

       
197
       
 
       
				RKey:       "self",

     

       
198
       
 
       
				CID:        "bafy123abc",

     

       
199
       
 
       
				Record: map[string]interface{}{

     

       
200
       
+
       
					"handle":      uniqueHandle,

     

       
201
       
 
       
					"name":        "gaming",

     

       
202
       
 
       
					"displayName": "Test",

     

       
203
       
 
       
					"description": "Test",

     

···

       
371
       
 
       
		}{

     

       
372
       
 
       
			{"nodots", "nodots"},         // No dots - should return as-is

     

       
373
       
 
       
			{"single.dot", "single.dot"}, // Single dot - should return as-is

     

       
374
       
-
       
			{"", ""},                      // Empty - should return as-is

     

       
375
       
 
       
		}

     

       
376
       
 
       


     

       
377
       
 
       
		for _, tc := range testCases {

     

···

       
371
       
 
       
		}{

     

       
372
       
 
       
			{"nodots", "nodots"},         // No dots - should return as-is

     

       
373
       
 
       
			{"single.dot", "single.dot"}, // Single dot - should return as-is

     

       
374
       
+
       
			{"", ""},                     // Empty - should return as-is

     

       
375
       
 
       
		}

     

       
376
       
 
       


     

       
377
       
 
       
		for _, tc := range testCases {

     

···

       
5
       
 
       
	"Coves/internal/core/communities"

     

       
6
       
 
       
	"Coves/internal/db/postgres"

     

       
7
       
 
       
	"context"

     

       
0
       
 
       

     

       
8
       
 
       
	"testing"

     

       
9
       
 
       
	"time"

     

       
10
       
 
       
)

     
···

       
24
       
 
       
	ctx := context.Background()

     

       
25
       
 
       


     

       
26
       
 
       
	t.Run("accepts V2 community with rkey=self", func(t *testing.T) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
27
       
 
       
		event := &jetstream.JetstreamEvent{

     

       
28
       
-
       
			Did:  "did:plc:community123",

     

       
29
       
 
       
			Kind: "commit",

     

       
30
       
 
       
			Commit: &jetstream.CommitEvent{

     

       
31
       
 
       
				Operation:  "create",

     
···

       
34
       
 
       
				CID:        "bafyreigaming123",

     

       
35
       
 
       
				Record: map[string]interface{}{

     

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

     

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

     

       
38
       
-
       
					"name":       "gaming",

     

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

     

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

     

       
41
       
 
       
					"visibility": "public",

     
···

       
55
       
 
       
		}

     

       
56
       
 
       


     

       
57
       
 
       
		// Verify community was indexed

     

       
58
       
-
       
		community, err := repo.GetByDID(ctx, "did:plc:community123")

     

       
59
       
 
       
		if err != nil {

     

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

     

       
61
       
 
       
		}

     
···

       
66
       
 
       
		}

     

       
67
       
 
       


     

       
68
       
 
       
		// Verify record URI uses "self"

     

       
69
       
-
       
		expectedURI := "at://did:plc:community123/social.coves.community.profile/self"

     

       
70
       
 
       
		if community.RecordURI != expectedURI {

     

       
71
       
 
       
			t.Errorf("Expected RecordURI %s, got %s", expectedURI, community.RecordURI)

     

       
72
       
 
       
		}

     
···

       
259
       
 
       
				Record: map[string]interface{}{

     

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

     

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

     

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

     

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

     

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

     

       
265
       
 
       
					"visibility": "public",

     

···

       
5
       
 
       
	"Coves/internal/core/communities"

     

       
6
       
 
       
	"Coves/internal/db/postgres"

     

       
7
       
 
       
	"context"

     

       
8
       
+
       
	"fmt"

     

       
9
       
 
       
	"testing"

     

       
10
       
 
       
	"time"

     

       
11
       
 
       
)

     
···

       
25
       
 
       
	ctx := context.Background()

     

       
26
       
 
       


     

       
27
       
 
       
	t.Run("accepts V2 community with rkey=self", func(t *testing.T) {

     

       
28
       
+
       
		// Use unique DID and handle to avoid conflicts with other test runs

     

       
29
       
+
       
		timestamp := time.Now().UnixNano()

     

       
30
       
+
       
		testDID := fmt.Sprintf("did:plc:testv2rkey%d", timestamp)

     

       
31
       
+
       
		testHandle := fmt.Sprintf("testv2rkey%d.community.coves.social", timestamp)

     

       
32
       
+
       


     

       
33
       
 
       
		event := &jetstream.JetstreamEvent{

     

       
34
       
+
       
			Did:  testDID,

     

       
35
       
 
       
			Kind: "commit",

     

       
36
       
 
       
			Commit: &jetstream.CommitEvent{

     

       
37
       
 
       
				Operation:  "create",

     
···

       
40
       
 
       
				CID:        "bafyreigaming123",

     

       
41
       
 
       
				Record: map[string]interface{}{

     

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

     

       
43
       
+
       
					"handle":     testHandle,

     

       
44
       
+
       
					"name":       "testv2rkey",

     

       
45
       
 
       
					"createdBy":  "did:plc:user123",

     

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

     

       
47
       
 
       
					"visibility": "public",

     
···

       
61
       
 
       
		}

     

       
62
       
 
       


     

       
63
       
 
       
		// Verify community was indexed

     

       
64
       
+
       
		community, err := repo.GetByDID(ctx, testDID)

     

       
65
       
 
       
		if err != nil {

     

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

     

       
67
       
 
       
		}

     
···

       
72
       
 
       
		}

     

       
73
       
 
       


     

       
74
       
 
       
		// Verify record URI uses "self"

     

       
75
       
+
       
		expectedURI := fmt.Sprintf("at://%s/social.coves.community.profile/self", testDID)

     

       
76
       
 
       
		if community.RecordURI != expectedURI {

     

       
77
       
 
       
			t.Errorf("Expected RecordURI %s, got %s", expectedURI, community.RecordURI)

     

       
78
       
 
       
		}

     
···

       
265
       
 
       
				Record: map[string]interface{}{

     

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

     

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

     

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

     

       
269
       
 
       
					"createdBy":  "did:plc:user123",

     

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

     

       
271
       
 
       
					"visibility": "public",

     

···

       
367
       
 
       
	})

     

       
368
       
 
       
}

     

       
369
       
 
       


     

       
370
       
-
       
// Helper function

     

       
371
       
-
       
func contains(s, substr string) bool {

     

       
372
       
-
       
	return len(s) >= len(substr) && anySubstring(s, substr)

     

       
373
       
-
       
}

     

       
374
       
-
       


     

       
375
       
-
       
func anySubstring(s, substr string) bool {

     

       
376
       
-
       
	for i := 0; i <= len(s)-len(substr); i++ {

     

       
377
       
-
       
		if s[i:i+len(substr)] == substr {

     

       
378
       
-
       
			return true

     

       
379
       
-
       
		}

     

       
380
       
-
       
	}

     

       
381
       
-
       
	return false

     

       
382
       
-
       
}

     

···

       
367
       
 
       
	})

     

       
368
       
 
       
}

     

       
369
       
 
       


     

       
370
       
+
       
// Helper functions moved to helpers.go

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
3
       
 
       
import (

     

       
4
       
 
       
	"Coves/internal/atproto/jetstream"

     

       
5
       
 
       
	"Coves/internal/core/communities"

     

       
6
       
-
       
	postgresRepo "Coves/internal/db/postgres"

     

       
7
       
 
       
	"context"

     

       
8
       
 
       
	"database/sql"

     

       
9
       
 
       
	"fmt"

     

       
10
       
 
       
	"testing"

     

       
11
       
 
       
	"time"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
12
       
 
       
)

     

       
13
       
 
       


     

       
14
       
 
       
// TestSubscriptionIndexing_ContentVisibility tests that contentVisibility is properly indexed

     

···

       
3
       
 
       
import (

     

       
4
       
 
       
	"Coves/internal/atproto/jetstream"

     

       
5
       
 
       
	"Coves/internal/core/communities"

     

       
0
       
 
       

     

       
6
       
 
       
	"context"

     

       
7
       
 
       
	"database/sql"

     

       
8
       
 
       
	"fmt"

     

       
9
       
 
       
	"testing"

     

       
10
       
 
       
	"time"

     

       
11
       
+
       


     

       
12
       
+
       
	postgresRepo "Coves/internal/db/postgres"

     

       
13
       
 
       
)

     

       
14
       
 
       


     

       
15
       
 
       
// TestSubscriptionIndexing_ContentVisibility tests that contentVisibility is properly indexed