commit b1dd9891dbc7d147730deba4ac96939fab9e61ca · bretton.dev/coves

+2 -1

tests/integration/community_blocking_test.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"Coves/internal/atproto/jetstream"

     

       5
       5
        
       	"Coves/internal/core/communities"

     

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

     

       7
       6
        
       	"context"

     

       8
       7
        
       	"database/sql"

     

       9
       8
        
       	"fmt"

     

       10
       9
        
       	"testing"

     

       11
       10
        
       	"time"

     

       11
       11
       +
       

     

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

     

       12
       13
        
       )

     

       13
       14
        
       

     

       14
       15
        
       // TestCommunityBlocking_Indexing tests Jetstream indexing of block events

-42

tests/integration/community_e2e_test.go

···

       1506
       1506
        
       	return community

     

       1507
       1507
        
       }

     

       1508
       1508
        
       

     

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

     

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

     

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

     

       1512
       1512
       -
       	sessionReq := map[string]string{

     

       1513
       1513
       -
       		"identifier": handle,

     

       1514
       1514
       -
       		"password":   password,

     

       1515
       1515
       -
       	}

     

       1516
       1516
       -
       

     

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

     

       1518
       1518
       -
       	if marshalErr != nil {

     

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

     

       1520
       1520
       -
       	}

     

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

     

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

     

       1523
       1523
       -
       		"application/json",

     

       1524
       1524
       -
       		bytes.NewBuffer(reqBody),

     

       1525
       1525
       -
       	)

     

       1526
       1526
       -
       	if err != nil {

     

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

     

       1528
       1528
       -
       	}

     

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

     

       1530
       1530
       -
       

     

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

     

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

     

       1533
       1533
       -
       		if readErr != nil {

     

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

     

       1535
       1535
       -
       		}

     

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

     

       1537
       1537
       -
       	}

     

       1538
       1538
       -
       

     

       1539
       1539
       -
       	var sessionResp struct {

     

       1540
       1540
       -
       		AccessJwt string `json:"accessJwt"`

     

       1541
       1541
       -
       		DID       string `json:"did"`

     

       1542
       1542
       -
       	}

     

       1543
       1543
       -
       

     

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

     

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

     

       1546
       1546
       -
       	}

     

       1547
       1547
       -
       

     

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

     

       1549
       1549
       -
       }

     

       1550
       1550
       -
       

     

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

     

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

     

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

+8 -4

tests/integration/community_hostedby_security_test.go

···

       27
       27
        
       

     

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

     

       29
       29
        
       		communityDID := generateTestDID(uniqueSuffix)

     

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

     

       30
       31
        
       

     

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

     

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

     
···

       41
       42
        
       				RKey:       "self",

     

       42
       43
        
       				CID:        "bafy123abc",

     

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

     

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

     

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

     

       45
       46
        
       					"name":        "gaming",

     

       46
       47
        
       					"displayName": "Nintendo Gaming",

     

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

     
···

       84
       85
        
       

     

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

     

       86
       87
        
       		communityDID := generateTestDID(uniqueSuffix)

     

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

     

       87
       89
        
       

     

       88
       90
        
       		// Create community with matching hostedBy and handle domains

     

       89
       91
        
       		event := &jetstream.JetstreamEvent{

     
···

       97
       99
        
       				RKey:       "self",

     

       98
       100
        
       				CID:        "bafy123abc",

     

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

     

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

     

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

     

       101
       103
        
       					"name":        "gaming",

     

       102
       104
        
       					"displayName": "Gaming Community",

     

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

     
···

       136
       138
        
       

     

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

     

       138
       140
        
       		communityDID := generateTestDID(uniqueSuffix)

     

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

     

       139
       142
        
       

     

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

     

       141
       144
        
       		event := &jetstream.JetstreamEvent{

     
···

       149
       152
        
       				RKey:       "self",

     

       150
       153
        
       				CID:        "bafy123abc",

     

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

     

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

     

       155
       155
       +
       					"handle":      uniqueHandle,

     

       153
       156
        
       					"name":        "gaming",

     

       154
       157
        
       					"displayName": "Test Community",

     

       155
       158
        
       					"description": "Test",

     
···

       180
       183
        
       

     

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

     

       182
       185
        
       		communityDID := generateTestDID(uniqueSuffix)

     

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

     

       183
       187
        
       

     

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

     

       185
       189
        
       		event := &jetstream.JetstreamEvent{

     
···

       193
       197
        
       				RKey:       "self",

     

       194
       198
        
       				CID:        "bafy123abc",

     

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

     

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

     

       200
       200
       +
       					"handle":      uniqueHandle,

     

       197
       201
        
       					"name":        "gaming",

     

       198
       202
        
       					"displayName": "Test",

     

       199
       203
        
       					"description": "Test",

+1 -1

tests/integration/community_identifier_resolution_test.go

···

       371
       371
        
       		}{

     

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

     

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

     

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

     

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

     

       375
       375
        
       		}

     

       376
       376
        
       

     

       377
       377
        
       		for _, tc := range testCases {

+12 -6

tests/integration/community_v2_validation_test.go

···

       5
       5
        
       	"Coves/internal/core/communities"

     

       6
       6
        
       	"Coves/internal/db/postgres"

     

       7
       7
        
       	"context"

     

       8
       8
       +
       	"fmt"

     

       8
       9
        
       	"testing"

     

       9
       10
        
       	"time"

     

       10
       11
        
       )

     
···

       24
       25
        
       	ctx := context.Background()

     

       25
       26
        
       

     

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

     

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

     

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

     

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

     

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

     

       32
       32
       +
       

     

       27
       33
        
       		event := &jetstream.JetstreamEvent{

     

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

     

       34
       34
       +
       			Did:  testDID,

     

       29
       35
        
       			Kind: "commit",

     

       30
       36
        
       			Commit: &jetstream.CommitEvent{

     

       31
       37
        
       				Operation:  "create",

     
···

       34
       40
        
       				CID:        "bafyreigaming123",

     

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

     

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

     

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

     

       38
       38
       -
       					"name":       "gaming",

     

       43
       43
       +
       					"handle":     testHandle,

     

       44
       44
       +
       					"name":       "testv2rkey",

     

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

     

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

     

       41
       47
        
       					"visibility": "public",

     
···

       55
       61
        
       		}

     

       56
       62
        
       

     

       57
       63
        
       		// Verify community was indexed

     

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

     

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

     

       59
       65
        
       		if err != nil {

     

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

     

       61
       67
        
       		}

     
···

       66
       72
        
       		}

     

       67
       73
        
       

     

       68
       74
        
       		// Verify record URI uses "self"

     

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

     

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

     

       70
       76
        
       		if community.RecordURI != expectedURI {

     

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

     

       72
       78
        
       		}

     
···

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       265
       271
        
       					"visibility": "public",

+1 -13

tests/integration/jetstream_consumer_test.go

···

       367
       367
        
       	})

     

       368
       368
        
       }

     

       369
       369
        
       

     

       370
       370
       -
       // Helper function

     

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

     

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

     

       373
       373
       -
       }

     

       374
       374
       -
       

     

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

     

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

     

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

     

       378
       378
       -
       			return true

     

       379
       379
       -
       		}

     

       380
       380
       -
       	}

     

       381
       381
       -
       	return false

     

       382
       382
       -
       }

     

       370
       370
       +
       // Helper functions moved to helpers.go

+2 -1

tests/integration/subscription_indexing_test.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"Coves/internal/atproto/jetstream"

     

       5
       5
        
       	"Coves/internal/core/communities"

     

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

     

       7
       6
        
       	"context"

     

       8
       7
        
       	"database/sql"

     

       9
       8
        
       	"fmt"

     

       10
       9
        
       	"testing"

     

       11
       10
        
       	"time"

     

       11
       11
       +
       

     

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

     

       12
       13
        
       )

     

       13
       14
        
       

     

       14
       15
        
       // TestSubscriptionIndexing_ContentVisibility tests that contentVisibility is properly indexed