test(posts): add comprehensive integration test suite

+92

tests/integration/helpers.go

··· 1 + package integration 2 + 3 + import ( 4 + "Coves/internal/core/users" 5 + "bytes" 6 + "context" 7 + "database/sql" 8 + "encoding/json" 9 + "fmt" 10 + "io" 11 + "net/http" 12 + "strings" 13 + "testing" 14 + ) 15 + 16 + // createTestUser creates a test user in the database for use in integration tests 17 + // Returns the created user or fails the test 18 + func createTestUser(t *testing.T, db *sql.DB, handle, did string) *users.User { 19 + t.Helper() 20 + 21 + ctx := context.Background() 22 + 23 + // Create user directly in DB for speed 24 + query := ` 25 + INSERT INTO users (did, handle, pds_url, created_at, updated_at) 26 + VALUES ($1, $2, $3, NOW(), NOW()) 27 + RETURNING did, handle, pds_url, created_at, updated_at 28 + ` 29 + 30 + user := &users.User{} 31 + err := db.QueryRowContext(ctx, query, did, handle, "http://localhost:3001").Scan( 32 + &user.DID, 33 + &user.Handle, 34 + &user.PDSURL, 35 + &user.CreatedAt, 36 + &user.UpdatedAt, 37 + ) 38 + if err != nil { 39 + t.Fatalf("Failed to create test user: %v", err) 40 + } 41 + 42 + return user 43 + } 44 + 45 + // contains checks if string s contains substring substr 46 + // Helper for error message assertions 47 + func contains(s, substr string) bool { 48 + return strings.Contains(s, substr) 49 + } 50 + 51 + // authenticateWithPDS authenticates with PDS to get access token and DID 52 + // Used for setting up test environments that need PDS credentials 53 + func authenticateWithPDS(pdsURL, handle, password string) (string, string, error) { 54 + // Call com.atproto.server.createSession 55 + sessionReq := map[string]string{ 56 + "identifier": handle, 57 + "password": password, 58 + } 59 + 60 + reqBody, marshalErr := json.Marshal(sessionReq) 61 + if marshalErr != nil { 62 + return "", "", fmt.Errorf("failed to marshal session request: %w", marshalErr) 63 + } 64 + resp, err := http.Post( 65 + pdsURL+"/xrpc/com.atproto.server.createSession", 66 + "application/json", 67 + bytes.NewBuffer(reqBody), 68 + ) 69 + if err != nil { 70 + return "", "", fmt.Errorf("failed to create session: %w", err) 71 + } 72 + defer func() { _ = resp.Body.Close() }() 73 + 74 + if resp.StatusCode != http.StatusOK { 75 + body, readErr := io.ReadAll(resp.Body) 76 + if readErr != nil { 77 + return "", "", fmt.Errorf("PDS auth failed (status %d, failed to read body: %w)", resp.StatusCode, readErr) 78 + } 79 + return "", "", fmt.Errorf("PDS auth failed (status %d): %s", resp.StatusCode, string(body)) 80 + } 81 + 82 + var sessionResp struct { 83 + AccessJwt string `json:"accessJwt"` 84 + DID string `json:"did"` 85 + } 86 + 87 + if err := json.NewDecoder(resp.Body).Decode(&sessionResp); err != nil { 88 + return "", "", fmt.Errorf("failed to decode session response: %w", err) 89 + } 90 + 91 + return sessionResp.AccessJwt, sessionResp.DID, nil 92 + }

+363

tests/integration/post_creation_test.go

··· 1 + package integration 2 + 3 + import ( 4 + "Coves/internal/atproto/identity" 5 + "Coves/internal/core/communities" 6 + "Coves/internal/core/posts" 7 + "Coves/internal/core/users" 8 + "Coves/internal/db/postgres" 9 + "context" 10 + "fmt" 11 + "strings" 12 + "testing" 13 + 14 + "github.com/stretchr/testify/assert" 15 + "github.com/stretchr/testify/require" 16 + ) 17 + 18 + func TestPostCreation_Basic(t *testing.T) { 19 + if testing.Short() { 20 + t.Skip("Skipping integration test in short mode") 21 + } 22 + 23 + db := setupTestDB(t) 24 + defer func() { 25 + if err := db.Close(); err != nil { 26 + t.Logf("Failed to close database: %v", err) 27 + } 28 + }() 29 + 30 + // Setup: Initialize services 31 + userRepo := postgres.NewUserRepository(db) 32 + resolver := identity.NewResolver(db, identity.DefaultConfig()) 33 + userService := users.NewUserService(userRepo, resolver, "http://localhost:3001") 34 + 35 + communityRepo := postgres.NewCommunityRepository(db) 36 + // Note: Provisioner not needed for this test (we're not actually creating communities) 37 + communityService := communities.NewCommunityService( 38 + communityRepo, 39 + "http://localhost:3001", 40 + "did:web:test.coves.social", 41 + "test.coves.social", 42 + nil, // provisioner 43 + ) 44 + 45 + postRepo := postgres.NewPostRepository(db) 46 + postService := posts.NewPostService(postRepo, communityService, "http://localhost:3001") 47 + 48 + ctx := context.Background() 49 + 50 + // Cleanup: Remove any existing test data 51 + _, _ = db.Exec("DELETE FROM posts WHERE community_did LIKE 'did:plc:test%'") 52 + _, _ = db.Exec("DELETE FROM communities WHERE did LIKE 'did:plc:test%'") 53 + _, _ = db.Exec("DELETE FROM users WHERE did LIKE 'did:plc:test%'") 54 + 55 + // Setup: Create test user 56 + testUserDID := generateTestDID("postauthor") 57 + testUserHandle := "postauthor.test" 58 + 59 + _, err := userService.CreateUser(ctx, users.CreateUserRequest{ 60 + DID: testUserDID, 61 + Handle: testUserHandle, 62 + PDSURL: "http://localhost:3001", 63 + }) 64 + require.NoError(t, err, "Failed to create test user") 65 + 66 + // Setup: Create test community (insert directly to DB for speed) 67 + testCommunity := &communities.Community{ 68 + DID: generateTestDID("testcommunity"), 69 + Handle: "testcommunity.community.test.coves.social", // Canonical atProto handle (no ! prefix, .community. format) 70 + Name: "testcommunity", 71 + DisplayName: "Test Community", 72 + Description: "A community for testing posts", 73 + Visibility: "public", 74 + CreatedByDID: testUserDID, 75 + HostedByDID: "did:web:test.coves.social", 76 + PDSURL: "http://localhost:3001", 77 + PDSAccessToken: "fake_token_for_test", // Won't actually call PDS in unit test 78 + } 79 + 80 + _, err = communityRepo.Create(ctx, testCommunity) 81 + require.NoError(t, err, "Failed to create test community") 82 + 83 + t.Run("Create text post successfully (with DID)", func(t *testing.T) { 84 + // NOTE: This test validates the service layer logic only 85 + // It will fail when trying to write to PDS because we're using a fake token 86 + // For full E2E testing, you'd need a real PDS instance 87 + 88 + content := "This is a test post" 89 + title := "Test Post Title" 90 + 91 + req := posts.CreatePostRequest{ 92 + Community: testCommunity.DID, // Using DID directly 93 + Title: &title, 94 + Content: &content, 95 + AuthorDID: testUserDID, 96 + } 97 + 98 + // This will fail at token refresh step (expected for unit test) 99 + // We're using a fake token that can't be parsed 100 + _, err := postService.CreatePost(ctx, req) 101 + 102 + // For now, we expect an error because token is fake 103 + // In a full E2E test with real PDS, this would succeed 104 + require.Error(t, err) 105 + t.Logf("Expected error (fake token): %v", err) 106 + // Verify the error is from token refresh or PDS, not validation 107 + assert.Contains(t, err.Error(), "failed to refresh community credentials") 108 + }) 109 + 110 + t.Run("Create text post with community handle", func(t *testing.T) { 111 + // Test that we can use community handle instead of DID 112 + // This validates at-identifier resolution per atProto best practices 113 + 114 + content := "Post using handle instead of DID" 115 + title := "Handle Test" 116 + 117 + req := posts.CreatePostRequest{ 118 + Community: testCommunity.Handle, // Using canonical atProto handle 119 + Title: &title, 120 + Content: &content, 121 + AuthorDID: testUserDID, 122 + } 123 + 124 + // Should resolve handle to DID and proceed 125 + // Will still fail at token refresh (expected with fake token) 126 + _, err := postService.CreatePost(ctx, req) 127 + require.Error(t, err) 128 + // Should fail at token refresh, not community resolution 129 + assert.Contains(t, err.Error(), "failed to refresh community credentials") 130 + }) 131 + 132 + t.Run("Create text post with ! prefix handle", func(t *testing.T) { 133 + // Test that we can also use ! prefix with scoped format: !name@instance 134 + // This is Coves-specific UX shorthand for name.community.instance 135 + 136 + content := "Post using !-prefixed handle" 137 + title := "Prefixed Handle Test" 138 + 139 + // Extract name from handle: "gardening.community.coves.social" -> "gardening" 140 + // Scoped format: !gardening@coves.social 141 + handleParts := strings.Split(testCommunity.Handle, ".") 142 + communityName := handleParts[0] 143 + instanceDomain := strings.Join(handleParts[2:], ".") // Skip ".community." 144 + scopedHandle := fmt.Sprintf("!%s@%s", communityName, instanceDomain) 145 + 146 + req := posts.CreatePostRequest{ 147 + Community: scopedHandle, // !gardening@coves.social 148 + Title: &title, 149 + Content: &content, 150 + AuthorDID: testUserDID, 151 + } 152 + 153 + // Should resolve handle to DID and proceed 154 + // Will still fail at token refresh (expected with fake token) 155 + _, err := postService.CreatePost(ctx, req) 156 + require.Error(t, err) 157 + // Should fail at token refresh, not community resolution 158 + assert.Contains(t, err.Error(), "failed to refresh community credentials") 159 + }) 160 + 161 + t.Run("Reject post with missing community", func(t *testing.T) { 162 + content := "Post without community" 163 + 164 + req := posts.CreatePostRequest{ 165 + Community: "", // Missing! 166 + Content: &content, 167 + AuthorDID: testUserDID, 168 + } 169 + 170 + _, err := postService.CreatePost(ctx, req) 171 + require.Error(t, err) 172 + assert.True(t, posts.IsValidationError(err)) 173 + }) 174 + 175 + t.Run("Reject post with non-existent community handle", func(t *testing.T) { 176 + content := "Post with non-existent handle" 177 + 178 + req := posts.CreatePostRequest{ 179 + Community: "nonexistent.community.test.coves.social", // Valid canonical handle format, but doesn't exist 180 + Content: &content, 181 + AuthorDID: testUserDID, 182 + } 183 + 184 + _, err := postService.CreatePost(ctx, req) 185 + require.Error(t, err) 186 + // Should fail with community not found (wrapped in error) 187 + assert.Contains(t, err.Error(), "community not found") 188 + }) 189 + 190 + t.Run("Reject post with missing author DID", func(t *testing.T) { 191 + content := "Post without author" 192 + 193 + req := posts.CreatePostRequest{ 194 + Community: testCommunity.DID, 195 + Content: &content, 196 + AuthorDID: "", // Missing! 197 + } 198 + 199 + _, err := postService.CreatePost(ctx, req) 200 + require.Error(t, err) 201 + assert.True(t, posts.IsValidationError(err)) 202 + assert.Contains(t, err.Error(), "authorDid") 203 + }) 204 + 205 + t.Run("Reject post in non-existent community", func(t *testing.T) { 206 + content := "Post in fake community" 207 + 208 + req := posts.CreatePostRequest{ 209 + Community: "did:plc:nonexistent", 210 + Content: &content, 211 + AuthorDID: testUserDID, 212 + } 213 + 214 + _, err := postService.CreatePost(ctx, req) 215 + require.Error(t, err) 216 + assert.Equal(t, posts.ErrCommunityNotFound, err) 217 + }) 218 + 219 + t.Run("Reject post with too-long content", func(t *testing.T) { 220 + // Create content longer than 50k characters 221 + longContent := string(make([]byte, 50001)) 222 + 223 + req := posts.CreatePostRequest{ 224 + Community: testCommunity.DID, 225 + Content: &longContent, 226 + AuthorDID: testUserDID, 227 + } 228 + 229 + _, err := postService.CreatePost(ctx, req) 230 + require.Error(t, err) 231 + assert.True(t, posts.IsValidationError(err)) 232 + assert.Contains(t, err.Error(), "too long") 233 + }) 234 + 235 + t.Run("Reject post with invalid content label", func(t *testing.T) { 236 + content := "Post with invalid label" 237 + 238 + req := posts.CreatePostRequest{ 239 + Community: testCommunity.DID, 240 + Content: &content, 241 + ContentLabels: []string{"invalid_label"}, // Not in known values! 242 + AuthorDID: testUserDID, 243 + } 244 + 245 + _, err := postService.CreatePost(ctx, req) 246 + require.Error(t, err) 247 + assert.True(t, posts.IsValidationError(err)) 248 + assert.Contains(t, err.Error(), "unknown content label") 249 + }) 250 + 251 + t.Run("Accept post with valid content labels", func(t *testing.T) { 252 + content := "Post with valid labels" 253 + 254 + req := posts.CreatePostRequest{ 255 + Community: testCommunity.DID, 256 + Content: &content, 257 + ContentLabels: []string{"nsfw", "spoiler"}, 258 + AuthorDID: testUserDID, 259 + } 260 + 261 + // Will fail at token refresh (expected with fake token) 262 + _, err := postService.CreatePost(ctx, req) 263 + require.Error(t, err) 264 + // Should fail at token refresh, not validation 265 + assert.Contains(t, err.Error(), "failed to refresh community credentials") 266 + }) 267 + } 268 + 269 + // TestPostRepository_Create tests the repository layer 270 + func TestPostRepository_Create(t *testing.T) { 271 + if testing.Short() { 272 + t.Skip("Skipping integration test in short mode") 273 + } 274 + 275 + db := setupTestDB(t) 276 + defer func() { 277 + if err := db.Close(); err != nil { 278 + t.Logf("Failed to close database: %v", err) 279 + } 280 + }() 281 + 282 + // Cleanup first 283 + _, _ = db.Exec("DELETE FROM posts WHERE community_did LIKE 'did:plc:test%'") 284 + _, _ = db.Exec("DELETE FROM communities WHERE did LIKE 'did:plc:test%'") 285 + _, _ = db.Exec("DELETE FROM users WHERE did LIKE 'did:plc:test%'") 286 + 287 + // Setup: Create test user and community 288 + ctx := context.Background() 289 + userRepo := postgres.NewUserRepository(db) 290 + communityRepo := postgres.NewCommunityRepository(db) 291 + 292 + testUserDID := generateTestDID("postauthor2") 293 + _, err := userRepo.Create(ctx, &users.User{ 294 + DID: testUserDID, 295 + Handle: "postauthor2.test", 296 + PDSURL: "http://localhost:3001", 297 + }) 298 + require.NoError(t, err) 299 + 300 + testCommunityDID := generateTestDID("testcommunity2") 301 + _, err = communityRepo.Create(ctx, &communities.Community{ 302 + DID: testCommunityDID, 303 + Handle: "testcommunity2.community.test.coves.social", // Canonical format (no ! prefix) 304 + Name: "testcommunity2", 305 + Visibility: "public", 306 + CreatedByDID: testUserDID, 307 + HostedByDID: "did:web:test.coves.social", 308 + PDSURL: "http://localhost:3001", 309 + }) 310 + require.NoError(t, err) 311 + 312 + postRepo := postgres.NewPostRepository(db) 313 + 314 + t.Run("Insert post successfully", func(t *testing.T) { 315 + content := "Test post content" 316 + title := "Test Title" 317 + 318 + post := &posts.Post{ 319 + URI: "at://" + testCommunityDID + "/social.coves.post.record/test123", 320 + CID: "bafy2test123", 321 + RKey: "test123", 322 + AuthorDID: testUserDID, 323 + CommunityDID: testCommunityDID, 324 + Title: &title, 325 + Content: &content, 326 + } 327 + 328 + err := postRepo.Create(ctx, post) 329 + require.NoError(t, err) 330 + assert.NotZero(t, post.ID, "Post should have ID after insert") 331 + assert.NotZero(t, post.IndexedAt, "Post should have IndexedAt timestamp") 332 + }) 333 + 334 + t.Run("Reject duplicate post URI", func(t *testing.T) { 335 + content := "Duplicate post" 336 + 337 + post1 := &posts.Post{ 338 + URI: "at://" + testCommunityDID + "/social.coves.post.record/duplicate", 339 + CID: "bafy2duplicate1", 340 + RKey: "duplicate", 341 + AuthorDID: testUserDID, 342 + CommunityDID: testCommunityDID, 343 + Content: &content, 344 + } 345 + 346 + err := postRepo.Create(ctx, post1) 347 + require.NoError(t, err) 348 + 349 + // Try to insert again with same URI 350 + post2 := &posts.Post{ 351 + URI: "at://" + testCommunityDID + "/social.coves.post.record/duplicate", 352 + CID: "bafy2duplicate2", 353 + RKey: "duplicate", 354 + AuthorDID: testUserDID, 355 + CommunityDID: testCommunityDID, 356 + Content: &content, 357 + } 358 + 359 + err = postRepo.Create(ctx, post2) 360 + require.Error(t, err) 361 + assert.Contains(t, err.Error(), "already indexed") 362 + }) 363 + }

+715

tests/integration/post_e2e_test.go

··· 1 + package integration 2 + 3 + import ( 4 + "Coves/internal/api/handlers/post" 5 + "Coves/internal/api/middleware" 6 + "Coves/internal/atproto/auth" 7 + "Coves/internal/atproto/identity" 8 + "Coves/internal/atproto/jetstream" 9 + "Coves/internal/core/communities" 10 + "Coves/internal/core/posts" 11 + "Coves/internal/core/users" 12 + "Coves/internal/db/postgres" 13 + "bytes" 14 + "context" 15 + "database/sql" 16 + "encoding/base64" 17 + "encoding/json" 18 + "fmt" 19 + "net" 20 + "net/http" 21 + "net/http/httptest" 22 + "os" 23 + "strings" 24 + "testing" 25 + "time" 26 + 27 + "github.com/golang-jwt/jwt/v5" 28 + "github.com/gorilla/websocket" 29 + _ "github.com/lib/pq" 30 + "github.com/pressly/goose/v3" 31 + "github.com/stretchr/testify/assert" 32 + "github.com/stretchr/testify/require" 33 + ) 34 + 35 + // TestPostCreation_E2E_WithJetstream tests the full post creation flow: 36 + // XRPC endpoint → AppView Service → PDS write → Jetstream consumer → DB indexing 37 + // 38 + // This is a TRUE E2E test that simulates what happens in production: 39 + // 1. Client calls POST /xrpc/social.coves.post.create with auth token 40 + // 2. Handler validates and calls PostService.CreatePost() 41 + // 3. Service writes post to community's PDS repository 42 + // 4. PDS broadcasts event to firehose/Jetstream 43 + // 5. Jetstream consumer receives event and indexes post in AppView DB 44 + // 6. Post is now queryable from AppView 45 + // 46 + // NOTE: This test simulates the Jetstream event (step 4-5) since we don't have 47 + // a live PDS/Jetstream in test environment. For true live testing, use TestPostCreation_E2E_LivePDS. 48 + func TestPostCreation_E2E_WithJetstream(t *testing.T) { 49 + db := setupTestDB(t) 50 + defer func() { 51 + if err := db.Close(); err != nil { 52 + t.Logf("Failed to close database: %v", err) 53 + } 54 + }() 55 + 56 + // Cleanup old test data first 57 + _, _ = db.Exec("DELETE FROM posts WHERE community_did = 'did:plc:gaming123'") 58 + _, _ = db.Exec("DELETE FROM communities WHERE did = 'did:plc:gaming123'") 59 + _, _ = db.Exec("DELETE FROM users WHERE did = 'did:plc:alice123'") 60 + 61 + // Setup repositories 62 + userRepo := postgres.NewUserRepository(db) 63 + communityRepo := postgres.NewCommunityRepository(db) 64 + postRepo := postgres.NewPostRepository(db) 65 + 66 + // Setup user service for post consumer 67 + identityConfig := identity.DefaultConfig() 68 + identityResolver := identity.NewResolver(db, identityConfig) 69 + userService := users.NewUserService(userRepo, identityResolver, "http://localhost:3001") 70 + 71 + // Create test user (author) 72 + author := createTestUser(t, db, "alice.test", "did:plc:alice123") 73 + 74 + // Create test community with fake PDS credentials 75 + // In real E2E, this would be a real community provisioned on PDS 76 + community := &communities.Community{ 77 + DID: "did:plc:gaming123", 78 + Handle: "gaming.community.test.coves.social", 79 + Name: "gaming", 80 + DisplayName: "Gaming Community", 81 + OwnerDID: "did:plc:gaming123", 82 + CreatedByDID: author.DID, 83 + HostedByDID: "did:web:coves.test", 84 + Visibility: "public", 85 + ModerationType: "moderator", 86 + RecordURI: "at://did:plc:gaming123/social.coves.community.profile/self", 87 + RecordCID: "fakecid123", 88 + PDSAccessToken: "fake_token_for_testing", 89 + PDSRefreshToken: "fake_refresh_token", 90 + } 91 + _, err := communityRepo.Create(context.Background(), community) 92 + if err != nil { 93 + t.Fatalf("Failed to create test community: %v", err) 94 + } 95 + 96 + t.Run("Full E2E flow - XRPC to DB via Jetstream", func(t *testing.T) { 97 + ctx := context.Background() 98 + 99 + // STEP 1: Simulate what the XRPC handler would receive 100 + // In real flow, this comes from client with OAuth bearer token 101 + title := "My First Post" 102 + content := "This is a test post!" 103 + postReq := posts.CreatePostRequest{ 104 + Title: &title, 105 + Content: &content, 106 + // Community and AuthorDID set by handler from request context 107 + } 108 + 109 + // STEP 2: Simulate Jetstream consumer receiving the post CREATE event 110 + // In real production, this event comes from PDS via Jetstream WebSocket 111 + // For this test, we simulate the event that would be broadcast after PDS write 112 + 113 + // Generate a realistic rkey (TID - timestamp identifier) 114 + rkey := generateTID() 115 + 116 + // Build the post record as it would appear in Jetstream 117 + jetstreamEvent := jetstream.JetstreamEvent{ 118 + Did: community.DID, // Repo owner (community) 119 + Kind: "commit", 120 + Commit: &jetstream.CommitEvent{ 121 + Operation: "create", 122 + Collection: "social.coves.post.record", 123 + RKey: rkey, 124 + CID: "bafy2bzaceabc123def456", // Fake CID 125 + Record: map[string]interface{}{ 126 + "$type": "social.coves.post.record", 127 + "community": community.DID, 128 + "author": author.DID, 129 + "title": *postReq.Title, 130 + "content": *postReq.Content, 131 + "createdAt": time.Now().Format(time.RFC3339), 132 + }, 133 + }, 134 + } 135 + 136 + // STEP 3: Process event through Jetstream consumer 137 + consumer := jetstream.NewPostEventConsumer(postRepo, communityRepo, userService) 138 + err := consumer.HandleEvent(ctx, &jetstreamEvent) 139 + if err != nil { 140 + t.Fatalf("Jetstream consumer failed to process event: %v", err) 141 + } 142 + 143 + // STEP 4: Verify post was indexed in AppView database 144 + expectedURI := fmt.Sprintf("at://%s/social.coves.post.record/%s", community.DID, rkey) 145 + indexedPost, err := postRepo.GetByURI(ctx, expectedURI) 146 + if err != nil { 147 + t.Fatalf("Post not indexed in AppView: %v", err) 148 + } 149 + 150 + // STEP 5: Verify all fields are correct 151 + if indexedPost.URI != expectedURI { 152 + t.Errorf("Expected URI %s, got %s", expectedURI, indexedPost.URI) 153 + } 154 + if indexedPost.AuthorDID != author.DID { 155 + t.Errorf("Expected author %s, got %s", author.DID, indexedPost.AuthorDID) 156 + } 157 + if indexedPost.CommunityDID != community.DID { 158 + t.Errorf("Expected community %s, got %s", community.DID, indexedPost.CommunityDID) 159 + } 160 + if indexedPost.Title == nil || *indexedPost.Title != title { 161 + t.Errorf("Expected title '%s', got %v", title, indexedPost.Title) 162 + } 163 + if indexedPost.Content == nil || *indexedPost.Content != content { 164 + t.Errorf("Expected content '%s', got %v", content, indexedPost.Content) 165 + } 166 + 167 + // Verify stats initialized correctly 168 + if indexedPost.UpvoteCount != 0 { 169 + t.Errorf("Expected upvote_count 0, got %d", indexedPost.UpvoteCount) 170 + } 171 + if indexedPost.DownvoteCount != 0 { 172 + t.Errorf("Expected downvote_count 0, got %d", indexedPost.DownvoteCount) 173 + } 174 + if indexedPost.Score != 0 { 175 + t.Errorf("Expected score 0, got %d", indexedPost.Score) 176 + } 177 + 178 + t.Logf("✓ E2E test passed! Post indexed with URI: %s", indexedPost.URI) 179 + }) 180 + 181 + t.Run("Consumer validates repository ownership (security)", func(t *testing.T) { 182 + ctx := context.Background() 183 + 184 + // SECURITY TEST: Try to create a post that claims to be from the community 185 + // but actually comes from a user's repository 186 + // This should be REJECTED by the consumer 187 + 188 + maliciousEvent := jetstream.JetstreamEvent{ 189 + Did: author.DID, // Event from user's repo (NOT community repo) 190 + Kind: "commit", 191 + Commit: &jetstream.CommitEvent{ 192 + Operation: "create", 193 + Collection: "social.coves.post.record", 194 + RKey: generateTID(), 195 + CID: "bafy2bzacefake", 196 + Record: map[string]interface{}{ 197 + "$type": "social.coves.post.record", 198 + "community": community.DID, // Claims to be for this community 199 + "author": author.DID, 200 + "title": "Fake Post", 201 + "content": "This is a malicious post attempt", 202 + "createdAt": time.Now().Format(time.RFC3339), 203 + }, 204 + }, 205 + } 206 + 207 + consumer := jetstream.NewPostEventConsumer(postRepo, communityRepo, userService) 208 + err := consumer.HandleEvent(ctx, &maliciousEvent) 209 + 210 + // Should get security error 211 + if err == nil { 212 + t.Fatal("Expected security error for post from wrong repository, got nil") 213 + } 214 + 215 + if !contains(err.Error(), "repository DID") || !contains(err.Error(), "doesn't match") { 216 + t.Errorf("Expected repository mismatch error, got: %v", err) 217 + } 218 + 219 + t.Logf("✓ Security validation passed: %v", err) 220 + }) 221 + 222 + t.Run("Idempotent indexing - duplicate events", func(t *testing.T) { 223 + ctx := context.Background() 224 + 225 + // Simulate the same Jetstream event arriving twice 226 + // This can happen during Jetstream replays or network retries 227 + rkey := generateTID() 228 + event := jetstream.JetstreamEvent{ 229 + Did: community.DID, 230 + Kind: "commit", 231 + Commit: &jetstream.CommitEvent{ 232 + Operation: "create", 233 + Collection: "social.coves.post.record", 234 + RKey: rkey, 235 + CID: "bafy2bzaceidempotent", 236 + Record: map[string]interface{}{ 237 + "$type": "social.coves.post.record", 238 + "community": community.DID, 239 + "author": author.DID, 240 + "title": "Duplicate Test", 241 + "content": "Testing idempotency", 242 + "createdAt": time.Now().Format(time.RFC3339), 243 + }, 244 + }, 245 + } 246 + 247 + consumer := jetstream.NewPostEventConsumer(postRepo, communityRepo, userService) 248 + 249 + // First event - should succeed 250 + err := consumer.HandleEvent(ctx, &event) 251 + if err != nil { 252 + t.Fatalf("First event failed: %v", err) 253 + } 254 + 255 + // Second event (duplicate) - should be handled gracefully 256 + err = consumer.HandleEvent(ctx, &event) 257 + if err != nil { 258 + t.Fatalf("Duplicate event should be handled gracefully, got error: %v", err) 259 + } 260 + 261 + // Verify only one post in database 262 + uri := fmt.Sprintf("at://%s/social.coves.post.record/%s", community.DID, rkey) 263 + post, err := postRepo.GetByURI(ctx, uri) 264 + if err != nil { 265 + t.Fatalf("Post not found: %v", err) 266 + } 267 + 268 + if post.URI != uri { 269 + t.Error("Post URI mismatch - possible duplicate indexing") 270 + } 271 + 272 + t.Logf("✓ Idempotency test passed") 273 + }) 274 + 275 + t.Run("Handles orphaned posts (unknown community)", func(t *testing.T) { 276 + ctx := context.Background() 277 + 278 + // Post references a community that doesn't exist in AppView yet 279 + // This can happen if Jetstream delivers post event before community profile event 280 + unknownCommunityDID := "did:plc:unknown999" 281 + 282 + event := jetstream.JetstreamEvent{ 283 + Did: unknownCommunityDID, 284 + Kind: "commit", 285 + Commit: &jetstream.CommitEvent{ 286 + Operation: "create", 287 + Collection: "social.coves.post.record", 288 + RKey: generateTID(), 289 + CID: "bafy2bzaceorphaned", 290 + Record: map[string]interface{}{ 291 + "$type": "social.coves.post.record", 292 + "community": unknownCommunityDID, 293 + "author": author.DID, 294 + "title": "Orphaned Post", 295 + "content": "Community not indexed yet", 296 + "createdAt": time.Now().Format(time.RFC3339), 297 + }, 298 + }, 299 + } 300 + 301 + consumer := jetstream.NewPostEventConsumer(postRepo, communityRepo, userService) 302 + 303 + // Should log warning but NOT fail (eventual consistency) 304 + // Note: This will fail due to foreign key constraint in current schema 305 + // In production, you might want to handle this differently (defer indexing, etc.) 306 + err := consumer.HandleEvent(ctx, &event) 307 + 308 + // For now, we expect this to fail due to FK constraint 309 + // In future, we might make FK constraint DEFERRABLE or handle orphaned posts differently 310 + if err == nil { 311 + t.Log("⚠️ Orphaned post was indexed (FK constraint not enforced)") 312 + } else { 313 + t.Logf("✓ Orphaned post rejected by FK constraint (expected): %v", err) 314 + } 315 + }) 316 + } 317 + 318 + // TestPostCreation_E2E_LivePDS tests the COMPLETE end-to-end flow with a live PDS: 319 + // 1. HTTP POST to /xrpc/social.coves.post.create (with auth) 320 + // 2. Handler → Service → Write to community's PDS repository 321 + // 3. PDS → Jetstream firehose event 322 + // 4. Jetstream consumer → Index in AppView database 323 + // 5. Verify post appears in database with correct data 324 + // 325 + // This is a TRUE E2E test that requires: 326 + // - Live PDS running at PDS_URL (default: http://localhost:3001) 327 + // - Live Jetstream running at JETSTREAM_URL (default: ws://localhost:6008/subscribe) 328 + // - Test database running 329 + func TestPostCreation_E2E_LivePDS(t *testing.T) { 330 + if testing.Short() { 331 + t.Skip("Skipping live PDS E2E test in short mode") 332 + } 333 + 334 + // Setup test database 335 + dbURL := os.Getenv("TEST_DATABASE_URL") 336 + if dbURL == "" { 337 + dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" 338 + } 339 + 340 + db, err := sql.Open("postgres", dbURL) 341 + require.NoError(t, err, "Failed to connect to test database") 342 + defer func() { 343 + if closeErr := db.Close(); closeErr != nil { 344 + t.Logf("Failed to close database: %v", closeErr) 345 + } 346 + }() 347 + 348 + // Run migrations 349 + require.NoError(t, goose.SetDialect("postgres")) 350 + require.NoError(t, goose.Up(db, "../../internal/db/migrations")) 351 + 352 + // Check if PDS is running 353 + pdsURL := os.Getenv("PDS_URL") 354 + if pdsURL == "" { 355 + pdsURL = "http://localhost:3001" 356 + } 357 + 358 + healthResp, err := http.Get(pdsURL + "/xrpc/_health") 359 + if err != nil { 360 + t.Skipf("PDS not running at %s: %v", pdsURL, err) 361 + } 362 + _ = healthResp.Body.Close() 363 + 364 + // Get instance credentials for authentication 365 + instanceHandle := os.Getenv("PDS_INSTANCE_HANDLE") 366 + instancePassword := os.Getenv("PDS_INSTANCE_PASSWORD") 367 + if instanceHandle == "" { 368 + instanceHandle = "testuser123.local.coves.dev" 369 + } 370 + if instancePassword == "" { 371 + instancePassword = "test-password-123" 372 + } 373 + 374 + t.Logf("🔐 Authenticating with PDS as: %s", instanceHandle) 375 + 376 + // Authenticate to get instance DID (needed for provisioner domain) 377 + _, instanceDID, err := authenticateWithPDS(pdsURL, instanceHandle, instancePassword) 378 + if err != nil { 379 + t.Skipf("Failed to authenticate with PDS (may not be configured): %v", err) 380 + } 381 + 382 + t.Logf("✅ Authenticated - Instance DID: %s", instanceDID) 383 + 384 + // Extract instance domain from DID for community provisioning 385 + var instanceDomain string 386 + if strings.HasPrefix(instanceDID, "did:web:") { 387 + instanceDomain = strings.TrimPrefix(instanceDID, "did:web:") 388 + } else { 389 + // Fallback for did:plc 390 + instanceDomain = "coves.social" 391 + } 392 + 393 + // Setup repositories and services 394 + communityRepo := postgres.NewCommunityRepository(db) 395 + postRepo := postgres.NewPostRepository(db) 396 + 397 + // Setup PDS account provisioner for community creation 398 + provisioner := communities.NewPDSAccountProvisioner(instanceDomain, pdsURL) 399 + 400 + // Setup community service with real PDS provisioner 401 + communityService := communities.NewCommunityService( 402 + communityRepo, 403 + pdsURL, 404 + instanceDID, 405 + instanceDomain, 406 + provisioner, // ✅ Real provisioner for creating communities on PDS 407 + ) 408 + 409 + postService := posts.NewPostService(postRepo, communityService, pdsURL) 410 + 411 + // Setup auth middleware (skip JWT verification for testing) 412 + authMiddleware := middleware.NewAtProtoAuthMiddleware(nil, true) 413 + 414 + // Setup HTTP handler 415 + createHandler := post.NewCreateHandler(postService) 416 + 417 + ctx := context.Background() 418 + 419 + // Cleanup old test data 420 + _, _ = db.Exec("DELETE FROM posts WHERE community_did LIKE 'did:plc:e2etest%'") 421 + _, _ = db.Exec("DELETE FROM communities WHERE did LIKE 'did:plc:e2etest%'") 422 + _, _ = db.Exec("DELETE FROM users WHERE did LIKE 'did:plc:e2etest%'") 423 + 424 + // Create test user (author) 425 + author := createTestUser(t, db, "e2etestauthor.bsky.social", "did:plc:e2etestauthor123") 426 + 427 + // ==================================================================================== 428 + // Part 1: Write-Forward to PDS 429 + // ==================================================================================== 430 + t.Run("1. Write-Forward to PDS", func(t *testing.T) { 431 + // TRUE E2E: Actually provision a real community on PDS 432 + // This tests the full flow: 433 + // 1. Call com.atproto.server.createAccount on PDS 434 + // 2. PDS generates DID, keys, tokens 435 + // 3. Write community profile to PDS repository 436 + // 4. Store credentials in AppView DB 437 + // 5. Use those credentials to create a post 438 + 439 + // Use timestamp to ensure unique community name for each test run 440 + communityName := fmt.Sprintf("e2epost%d", time.Now().Unix()) 441 + 442 + t.Logf("\n📝 Provisioning test community on live PDS (name: %s)...", communityName) 443 + community, err := communityService.CreateCommunity(ctx, communities.CreateCommunityRequest{ 444 + Name: communityName, 445 + DisplayName: "E2E Test Community", 446 + Description: "Test community for E2E post creation testing", 447 + CreatedByDID: author.DID, 448 + Visibility: "public", 449 + AllowExternalDiscovery: true, 450 + }) 451 + require.NoError(t, err, "Failed to provision community on PDS") 452 + require.NotEmpty(t, community.DID, "Community should have DID from PDS") 453 + require.NotEmpty(t, community.PDSAccessToken, "Community should have access token") 454 + require.NotEmpty(t, community.PDSRefreshToken, "Community should have refresh token") 455 + 456 + t.Logf("✓ Community provisioned: DID=%s, Handle=%s", community.DID, community.Handle) 457 + 458 + // NOTE: Cleanup disabled to allow post-test inspection of indexed data 459 + // Uncomment to enable cleanup after test 460 + // defer func() { 461 + // if err := communityRepo.Delete(ctx, community.DID); err != nil { 462 + // t.Logf("Warning: Failed to cleanup test community: %v", err) 463 + // } 464 + // }() 465 + 466 + // Build HTTP request for post creation 467 + title := "E2E Test Post" 468 + content := "This post was created via full E2E test with live PDS!" 469 + reqBody := map[string]interface{}{ 470 + "community": community.DID, 471 + "title": title, 472 + "content": content, 473 + } 474 + reqJSON, err := json.Marshal(reqBody) 475 + require.NoError(t, err) 476 + 477 + // Create HTTP request 478 + req := httptest.NewRequest("POST", "/xrpc/social.coves.post.create", bytes.NewReader(reqJSON)) 479 + req.Header.Set("Content-Type", "application/json") 480 + 481 + // Create a simple JWT for testing (Phase 1: no signature verification) 482 + // In production, this would be a real OAuth token from PDS 483 + testJWT := createSimpleTestJWT(author.DID) 484 + req.Header.Set("Authorization", "Bearer "+testJWT) 485 + 486 + // Execute request through auth middleware + handler 487 + rr := httptest.NewRecorder() 488 + handler := authMiddleware.RequireAuth(http.HandlerFunc(createHandler.HandleCreate)) 489 + handler.ServeHTTP(rr, req) 490 + 491 + // Check response 492 + require.Equal(t, http.StatusOK, rr.Code, "Handler should return 200 OK, body: %s", rr.Body.String()) 493 + 494 + // Parse response 495 + var response posts.CreatePostResponse 496 + err = json.NewDecoder(rr.Body).Decode(&response) 497 + require.NoError(t, err, "Failed to parse response") 498 + 499 + t.Logf("✅ Post created on PDS:") 500 + t.Logf(" URI: %s", response.URI) 501 + t.Logf(" CID: %s", response.CID) 502 + 503 + // ==================================================================================== 504 + // Part 2: TRUE E2E - Real Jetstream Firehose Consumer 505 + // ==================================================================================== 506 + // This part tests the ACTUAL production code path in main.go 507 + // including the WebSocket connection and consumer logic 508 + t.Run("2. Real Jetstream Firehose Consumption", func(t *testing.T) { 509 + t.Logf("\n🔄 TRUE E2E: Subscribing to real Jetstream firehose...") 510 + 511 + // Get PDS hostname for Jetstream filtering 512 + pdsHostname := strings.TrimPrefix(pdsURL, "http://") 513 + pdsHostname = strings.TrimPrefix(pdsHostname, "https://") 514 + pdsHostname = strings.Split(pdsHostname, ":")[0] // Remove port 515 + 516 + // Build Jetstream URL with filters for post records 517 + jetstreamURL := fmt.Sprintf("ws://%s:6008/subscribe?wantedCollections=social.coves.post.record", 518 + pdsHostname) 519 + 520 + t.Logf(" Jetstream URL: %s", jetstreamURL) 521 + t.Logf(" Looking for post URI: %s", response.URI) 522 + t.Logf(" Community DID: %s", community.DID) 523 + 524 + // Setup user service (required by post consumer) 525 + userRepo := postgres.NewUserRepository(db) 526 + identityConfig := identity.DefaultConfig() 527 + plcURL := os.Getenv("PLC_DIRECTORY_URL") 528 + if plcURL == "" { 529 + plcURL = "http://localhost:3002" 530 + } 531 + identityConfig.PLCURL = plcURL 532 + identityResolver := identity.NewResolver(db, identityConfig) 533 + userService := users.NewUserService(userRepo, identityResolver, pdsURL) 534 + 535 + // Create post consumer (same as main.go) 536 + postConsumer := jetstream.NewPostEventConsumer(postRepo, communityRepo, userService) 537 + 538 + // Channels to receive the event 539 + eventChan := make(chan *jetstream.JetstreamEvent, 10) 540 + errorChan := make(chan error, 1) 541 + done := make(chan bool) 542 + 543 + // Start Jetstream WebSocket subscriber in background 544 + // This creates its own WebSocket connection to Jetstream 545 + go func() { 546 + err := subscribeToJetstreamForPost(ctx, jetstreamURL, community.DID, postConsumer, eventChan, errorChan, done) 547 + if err != nil { 548 + errorChan <- err 549 + } 550 + }() 551 + 552 + // Wait for event or timeout 553 + t.Logf("⏳ Waiting for Jetstream event (max 30 seconds)...") 554 + 555 + select { 556 + case event := <-eventChan: 557 + t.Logf("✅ Received real Jetstream event!") 558 + t.Logf(" Event DID: %s", event.Did) 559 + t.Logf(" Collection: %s", event.Commit.Collection) 560 + t.Logf(" Operation: %s", event.Commit.Operation) 561 + t.Logf(" RKey: %s", event.Commit.RKey) 562 + 563 + // Verify it's for our community 564 + assert.Equal(t, community.DID, event.Did, "Event should be from community repo") 565 + 566 + // Verify post was indexed in AppView database 567 + t.Logf("\n🔍 Querying AppView database for indexed post...") 568 + 569 + indexedPost, err := postRepo.GetByURI(ctx, response.URI) 570 + require.NoError(t, err, "Post should be indexed in AppView") 571 + 572 + t.Logf("✅ Post indexed in AppView:") 573 + t.Logf(" URI: %s", indexedPost.URI) 574 + t.Logf(" CID: %s", indexedPost.CID) 575 + t.Logf(" Author DID: %s", indexedPost.AuthorDID) 576 + t.Logf(" Community: %s", indexedPost.CommunityDID) 577 + t.Logf(" Title: %v", indexedPost.Title) 578 + t.Logf(" Content: %v", indexedPost.Content) 579 + 580 + // Verify all fields match what we sent 581 + assert.Equal(t, response.URI, indexedPost.URI, "URI should match") 582 + assert.Equal(t, response.CID, indexedPost.CID, "CID should match") 583 + assert.Equal(t, author.DID, indexedPost.AuthorDID, "Author DID should match") 584 + assert.Equal(t, community.DID, indexedPost.CommunityDID, "Community DID should match") 585 + assert.Equal(t, title, *indexedPost.Title, "Title should match") 586 + assert.Equal(t, content, *indexedPost.Content, "Content should match") 587 + 588 + // Verify stats initialized correctly 589 + assert.Equal(t, 0, indexedPost.UpvoteCount, "Upvote count should be 0") 590 + assert.Equal(t, 0, indexedPost.DownvoteCount, "Downvote count should be 0") 591 + assert.Equal(t, 0, indexedPost.Score, "Score should be 0") 592 + assert.Equal(t, 0, indexedPost.CommentCount, "Comment count should be 0") 593 + 594 + // Verify timestamps 595 + assert.False(t, indexedPost.CreatedAt.IsZero(), "CreatedAt should be set") 596 + assert.False(t, indexedPost.IndexedAt.IsZero(), "IndexedAt should be set") 597 + 598 + // Signal to stop Jetstream consumer 599 + close(done) 600 + 601 + t.Log("\n✅ Part 2 Complete: TRUE E2E - PDS → Jetstream → Consumer → AppView ✓") 602 + 603 + case err := <-errorChan: 604 + t.Fatalf("❌ Jetstream error: %v", err) 605 + 606 + case <-time.After(30 * time.Second): 607 + t.Fatalf("❌ Timeout: No Jetstream event received within 30 seconds") 608 + } 609 + }) 610 + }) 611 + } 612 + 613 + // createSimpleTestJWT creates a minimal JWT for testing (Phase 1 - no signature) 614 + // In production, this would be a real OAuth token from PDS with proper signatures 615 + func createSimpleTestJWT(userDID string) string { 616 + // Create minimal JWT claims using RegisteredClaims 617 + // Use userDID as issuer since we don't have a proper PDS DID for testing 618 + claims := auth.Claims{ 619 + RegisteredClaims: jwt.RegisteredClaims{ 620 + Subject: userDID, 621 + Issuer: userDID, // Use DID as issuer for testing (valid per atProto) 622 + Audience: jwt.ClaimStrings{"did:web:test.coves.social"}, 623 + IssuedAt: jwt.NewNumericDate(time.Now()), 624 + ExpiresAt: jwt.NewNumericDate(time.Now().Add(1 * time.Hour)), 625 + }, 626 + Scope: "com.atproto.access", 627 + } 628 + 629 + // For Phase 1 testing, we create an unsigned JWT 630 + // The middleware is configured with skipVerify=true for testing 631 + header := map[string]interface{}{ 632 + "alg": "none", 633 + "typ": "JWT", 634 + } 635 + 636 + headerJSON, _ := json.Marshal(header) 637 + claimsJSON, _ := json.Marshal(claims) 638 + 639 + // Base64url encode (without padding) 640 + headerB64 := base64.RawURLEncoding.EncodeToString(headerJSON) 641 + claimsB64 := base64.RawURLEncoding.EncodeToString(claimsJSON) 642 + 643 + // For "alg: none", signature is empty 644 + return headerB64 + "." + claimsB64 + "." 645 + } 646 + 647 + // generateTID generates a simple timestamp-based identifier for testing 648 + // In production, PDS generates proper TIDs 649 + func generateTID() string { 650 + return fmt.Sprintf("3k%d", time.Now().UnixNano()/1000) 651 + } 652 + 653 + // subscribeToJetstreamForPost subscribes to real Jetstream firehose and processes post events 654 + // This helper creates a WebSocket connection to Jetstream and waits for post events 655 + func subscribeToJetstreamForPost( 656 + ctx context.Context, 657 + jetstreamURL string, 658 + targetDID string, 659 + consumer *jetstream.PostEventConsumer, 660 + eventChan chan<- *jetstream.JetstreamEvent, 661 + errorChan chan<- error, 662 + done <-chan bool, 663 + ) error { 664 + conn, _, err := websocket.DefaultDialer.Dial(jetstreamURL, nil) 665 + if err != nil { 666 + return fmt.Errorf("failed to connect to Jetstream: %w", err) 667 + } 668 + defer func() { _ = conn.Close() }() 669 + 670 + // Read messages until we find our event or receive done signal 671 + for { 672 + select { 673 + case <-done: 674 + return nil 675 + case <-ctx.Done(): 676 + return ctx.Err() 677 + default: 678 + // Set read deadline to avoid blocking forever 679 + if err := conn.SetReadDeadline(time.Now().Add(5 * time.Second)); err != nil { 680 + return fmt.Errorf("failed to set read deadline: %w", err) 681 + } 682 + 683 + var event jetstream.JetstreamEvent 684 + err := conn.ReadJSON(&event) 685 + if err != nil { 686 + // Check if it's a timeout (expected) 687 + if websocket.IsCloseError(err, websocket.CloseNormalClosure) { 688 + return nil 689 + } 690 + if netErr, ok := err.(net.Error); ok && netErr.Timeout() { 691 + continue // Timeout is expected, keep listening 692 + } 693 + // For other errors, don't retry reading from a broken connection 694 + return fmt.Errorf("failed to read Jetstream message: %w", err) 695 + } 696 + 697 + // Check if this is a post event for the target DID 698 + if event.Did == targetDID && event.Kind == "commit" && 699 + event.Commit != nil && event.Commit.Collection == "social.coves.post.record" { 700 + // Process the event through the consumer 701 + if err := consumer.HandleEvent(ctx, &event); err != nil { 702 + return fmt.Errorf("failed to process event: %w", err) 703 + } 704 + 705 + // Send to channel so test can verify 706 + select { 707 + case eventChan <- &event: 708 + return nil 709 + case <-time.After(1 * time.Second): 710 + return fmt.Errorf("timeout sending event to channel") 711 + } 712 + } 713 + } 714 + } 715 + }

+470

tests/integration/post_handler_test.go

··· 1 + package integration 2 + 3 + import ( 4 + "Coves/internal/api/handlers/post" 5 + "Coves/internal/api/middleware" 6 + "Coves/internal/core/communities" 7 + "Coves/internal/core/posts" 8 + "Coves/internal/db/postgres" 9 + "bytes" 10 + "encoding/json" 11 + "net/http" 12 + "net/http/httptest" 13 + "strings" 14 + "testing" 15 + 16 + "github.com/stretchr/testify/assert" 17 + "github.com/stretchr/testify/require" 18 + ) 19 + 20 + // TestPostHandler_SecurityValidation tests HTTP handler-level security checks 21 + func TestPostHandler_SecurityValidation(t *testing.T) { 22 + if testing.Short() { 23 + t.Skip("Skipping integration test in short mode") 24 + } 25 + 26 + db := setupTestDB(t) 27 + defer func() { 28 + if err := db.Close(); err != nil { 29 + t.Logf("Failed to close database: %v", err) 30 + } 31 + }() 32 + 33 + // Setup services 34 + communityRepo := postgres.NewCommunityRepository(db) 35 + communityService := communities.NewCommunityService( 36 + communityRepo, 37 + "http://localhost:3001", 38 + "did:web:test.coves.social", 39 + "test.coves.social", 40 + nil, 41 + ) 42 + 43 + postRepo := postgres.NewPostRepository(db) 44 + postService := posts.NewPostService(postRepo, communityService, "http://localhost:3001") 45 + 46 + // Create handler 47 + handler := post.NewCreateHandler(postService) 48 + 49 + t.Run("Reject client-provided authorDid", func(t *testing.T) { 50 + // Client tries to impersonate another user 51 + payload := map[string]interface{}{ 52 + "community": "did:plc:test123", 53 + "authorDid": "did:plc:attacker", // ❌ Client trying to set author 54 + "content": "Malicious post", 55 + } 56 + 57 + body, _ := json.Marshal(payload) 58 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.post.create", bytes.NewReader(body)) 59 + 60 + // Mock authenticated user context 61 + ctx := middleware.SetTestUserDID(req.Context(), "did:plc:alice") 62 + req = req.WithContext(ctx) 63 + 64 + rec := httptest.NewRecorder() 65 + handler.HandleCreate(rec, req) 66 + 67 + // Should return 400 Bad Request 68 + assert.Equal(t, http.StatusBadRequest, rec.Code) 69 + 70 + var errResp map[string]interface{} 71 + err := json.Unmarshal(rec.Body.Bytes(), &errResp) 72 + require.NoError(t, err) 73 + 74 + assert.Equal(t, "InvalidRequest", errResp["error"]) 75 + assert.Contains(t, errResp["message"], "authorDid must not be provided") 76 + }) 77 + 78 + t.Run("Reject missing authentication", func(t *testing.T) { 79 + payload := map[string]interface{}{ 80 + "community": "did:plc:test123", 81 + "content": "Test post", 82 + } 83 + 84 + body, _ := json.Marshal(payload) 85 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.post.create", bytes.NewReader(body)) 86 + 87 + // No auth context set 88 + rec := httptest.NewRecorder() 89 + handler.HandleCreate(rec, req) 90 + 91 + // Should return 401 Unauthorized 92 + assert.Equal(t, http.StatusUnauthorized, rec.Code) 93 + 94 + var errResp map[string]interface{} 95 + err := json.Unmarshal(rec.Body.Bytes(), &errResp) 96 + require.NoError(t, err) 97 + 98 + assert.Equal(t, "AuthRequired", errResp["error"]) 99 + }) 100 + 101 + t.Run("Reject request body > 1MB", func(t *testing.T) { 102 + // Create a payload larger than 1MB 103 + largeContent := strings.Repeat("A", 1*1024*1024+1000) // 1MB + 1KB 104 + 105 + payload := map[string]interface{}{ 106 + "community": "did:plc:test123", 107 + "content": largeContent, 108 + } 109 + 110 + body, _ := json.Marshal(payload) 111 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.post.create", bytes.NewReader(body)) 112 + 113 + // Mock authenticated user context 114 + ctx := middleware.SetTestUserDID(req.Context(), "did:plc:alice") 115 + req = req.WithContext(ctx) 116 + 117 + rec := httptest.NewRecorder() 118 + handler.HandleCreate(rec, req) 119 + 120 + // Should return 413 Request Entity Too Large 121 + assert.Equal(t, http.StatusRequestEntityTooLarge, rec.Code) 122 + 123 + var errResp map[string]interface{} 124 + err := json.Unmarshal(rec.Body.Bytes(), &errResp) 125 + require.NoError(t, err) 126 + 127 + assert.Equal(t, "RequestTooLarge", errResp["error"]) 128 + }) 129 + 130 + t.Run("Reject malformed JSON", func(t *testing.T) { 131 + // Invalid JSON 132 + invalidJSON := []byte(`{"community": "did:plc:test123", "content": `) 133 + 134 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.post.create", bytes.NewReader(invalidJSON)) 135 + 136 + // Mock authenticated user context 137 + ctx := middleware.SetTestUserDID(req.Context(), "did:plc:alice") 138 + req = req.WithContext(ctx) 139 + 140 + rec := httptest.NewRecorder() 141 + handler.HandleCreate(rec, req) 142 + 143 + // Should return 400 Bad Request 144 + assert.Equal(t, http.StatusBadRequest, rec.Code) 145 + 146 + var errResp map[string]interface{} 147 + err := json.Unmarshal(rec.Body.Bytes(), &errResp) 148 + require.NoError(t, err) 149 + 150 + assert.Equal(t, "InvalidRequest", errResp["error"]) 151 + }) 152 + 153 + t.Run("Reject empty community field", func(t *testing.T) { 154 + payload := map[string]interface{}{ 155 + "community": "", // Empty community 156 + "content": "Test post", 157 + } 158 + 159 + body, _ := json.Marshal(payload) 160 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.post.create", bytes.NewReader(body)) 161 + 162 + // Mock authenticated user context 163 + ctx := middleware.SetTestUserDID(req.Context(), "did:plc:alice") 164 + req = req.WithContext(ctx) 165 + 166 + rec := httptest.NewRecorder() 167 + handler.HandleCreate(rec, req) 168 + 169 + // Should return 400 Bad Request 170 + assert.Equal(t, http.StatusBadRequest, rec.Code) 171 + 172 + var errResp map[string]interface{} 173 + err := json.Unmarshal(rec.Body.Bytes(), &errResp) 174 + require.NoError(t, err) 175 + 176 + assert.Equal(t, "InvalidRequest", errResp["error"]) 177 + assert.Contains(t, errResp["message"], "community is required") 178 + }) 179 + 180 + t.Run("Reject invalid at-identifier format", func(t *testing.T) { 181 + invalidIdentifiers := []string{ 182 + "not-a-did-or-handle", 183 + "just-plain-text", 184 + "http://example.com", 185 + } 186 + 187 + for _, invalidID := range invalidIdentifiers { 188 + t.Run(invalidID, func(t *testing.T) { 189 + payload := map[string]interface{}{ 190 + "community": invalidID, 191 + "content": "Test post", 192 + } 193 + 194 + body, _ := json.Marshal(payload) 195 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.post.create", bytes.NewReader(body)) 196 + 197 + // Mock authenticated user context 198 + ctx := middleware.SetTestUserDID(req.Context(), "did:plc:alice") 199 + req = req.WithContext(ctx) 200 + 201 + rec := httptest.NewRecorder() 202 + handler.HandleCreate(rec, req) 203 + 204 + // Should reject (either 400 InvalidRequest or 404 NotFound depending on how service resolves it) 205 + // Both are valid - the important thing is that it rejects invalid identifiers 206 + assert.True(t, rec.Code == http.StatusBadRequest || rec.Code == http.StatusNotFound, 207 + "Should reject invalid identifier with 400 or 404, got %d", rec.Code) 208 + 209 + var errResp map[string]interface{} 210 + err := json.Unmarshal(rec.Body.Bytes(), &errResp) 211 + require.NoError(t, err) 212 + 213 + // Should have an error type and message 214 + assert.NotEmpty(t, errResp["error"], "should have error type") 215 + assert.NotEmpty(t, errResp["message"], "should have error message") 216 + }) 217 + } 218 + }) 219 + 220 + t.Run("Accept valid DID format", func(t *testing.T) { 221 + validDIDs := []string{ 222 + "did:plc:test123", 223 + "did:web:example.com", 224 + } 225 + 226 + for _, validDID := range validDIDs { 227 + t.Run(validDID, func(t *testing.T) { 228 + payload := map[string]interface{}{ 229 + "community": validDID, 230 + "content": "Test post", 231 + } 232 + 233 + body, _ := json.Marshal(payload) 234 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.post.create", bytes.NewReader(body)) 235 + 236 + // Mock authenticated user context 237 + ctx := middleware.SetTestUserDID(req.Context(), "did:plc:alice") 238 + req = req.WithContext(ctx) 239 + 240 + rec := httptest.NewRecorder() 241 + handler.HandleCreate(rec, req) 242 + 243 + // May fail at service layer (community not found), but should NOT fail at validation 244 + // Looking for anything OTHER than "community must be a DID" error 245 + if rec.Code == http.StatusBadRequest { 246 + var errResp map[string]interface{} 247 + err := json.Unmarshal(rec.Body.Bytes(), &errResp) 248 + require.NoError(t, err) 249 + 250 + // Should NOT be the format validation error 251 + assert.NotContains(t, errResp["message"], "community must be a DID") 252 + } 253 + }) 254 + } 255 + }) 256 + 257 + t.Run("Accept valid scoped handle format", func(t *testing.T) { 258 + // Scoped format: !name@instance (gets converted to name.community.instance internally) 259 + validScopedHandles := []string{ 260 + "!mycommunity@bsky.social", // Scoped format 261 + "!gaming@test.coves.social", // Scoped format 262 + } 263 + 264 + for _, validHandle := range validScopedHandles { 265 + t.Run(validHandle, func(t *testing.T) { 266 + payload := map[string]interface{}{ 267 + "community": validHandle, 268 + "content": "Test post", 269 + } 270 + 271 + body, _ := json.Marshal(payload) 272 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.post.create", bytes.NewReader(body)) 273 + 274 + // Mock authenticated user context 275 + ctx := middleware.SetTestUserDID(req.Context(), "did:plc:alice") 276 + req = req.WithContext(ctx) 277 + 278 + rec := httptest.NewRecorder() 279 + handler.HandleCreate(rec, req) 280 + 281 + // May fail at service layer (community not found), but should NOT fail at format validation 282 + if rec.Code == http.StatusBadRequest { 283 + var errResp map[string]interface{} 284 + err := json.Unmarshal(rec.Body.Bytes(), &errResp) 285 + require.NoError(t, err) 286 + 287 + // Should NOT be the format validation error 288 + assert.NotContains(t, errResp["message"], "community must be a DID") 289 + assert.NotContains(t, errResp["message"], "scoped handle must include") 290 + } 291 + }) 292 + } 293 + }) 294 + 295 + t.Run("Accept valid canonical handle format", func(t *testing.T) { 296 + // Canonical format: name.community.instance (DNS-resolvable atProto handle) 297 + validCanonicalHandles := []string{ 298 + "gaming.community.test.coves.social", 299 + "books.community.bsky.social", 300 + } 301 + 302 + for _, validHandle := range validCanonicalHandles { 303 + t.Run(validHandle, func(t *testing.T) { 304 + payload := map[string]interface{}{ 305 + "community": validHandle, 306 + "content": "Test post", 307 + } 308 + 309 + body, _ := json.Marshal(payload) 310 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.post.create", bytes.NewReader(body)) 311 + 312 + // Mock authenticated user context 313 + ctx := middleware.SetTestUserDID(req.Context(), "did:plc:alice") 314 + req = req.WithContext(ctx) 315 + 316 + rec := httptest.NewRecorder() 317 + handler.HandleCreate(rec, req) 318 + 319 + // May fail at service layer (community not found), but should NOT fail at format validation 320 + // Canonical handles don't have strict validation at handler level - they're validated by the service 321 + if rec.Code == http.StatusBadRequest { 322 + var errResp map[string]interface{} 323 + err := json.Unmarshal(rec.Body.Bytes(), &errResp) 324 + require.NoError(t, err) 325 + 326 + // Should NOT be the format validation error (canonical handles pass basic validation) 327 + assert.NotContains(t, errResp["message"], "community must be a DID") 328 + } 329 + }) 330 + } 331 + }) 332 + 333 + t.Run("Accept valid @-prefixed handle format", func(t *testing.T) { 334 + // @-prefixed format: @name.community.instance (atProto standard, @ gets stripped) 335 + validAtHandles := []string{ 336 + "@gaming.community.test.coves.social", 337 + "@books.community.bsky.social", 338 + } 339 + 340 + for _, validHandle := range validAtHandles { 341 + t.Run(validHandle, func(t *testing.T) { 342 + payload := map[string]interface{}{ 343 + "community": validHandle, 344 + "content": "Test post", 345 + } 346 + 347 + body, _ := json.Marshal(payload) 348 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.post.create", bytes.NewReader(body)) 349 + 350 + // Mock authenticated user context 351 + ctx := middleware.SetTestUserDID(req.Context(), "did:plc:alice") 352 + req = req.WithContext(ctx) 353 + 354 + rec := httptest.NewRecorder() 355 + handler.HandleCreate(rec, req) 356 + 357 + // May fail at service layer (community not found), but should NOT fail at format validation 358 + // @ prefix is valid and gets stripped by the resolver 359 + if rec.Code == http.StatusBadRequest { 360 + var errResp map[string]interface{} 361 + err := json.Unmarshal(rec.Body.Bytes(), &errResp) 362 + require.NoError(t, err) 363 + 364 + // Should NOT be the format validation error 365 + assert.NotContains(t, errResp["message"], "community must be a DID") 366 + } 367 + }) 368 + } 369 + }) 370 + 371 + t.Run("Reject non-POST methods", func(t *testing.T) { 372 + methods := []string{http.MethodGet, http.MethodPut, http.MethodDelete, http.MethodPatch} 373 + 374 + for _, method := range methods { 375 + t.Run(method, func(t *testing.T) { 376 + req := httptest.NewRequest(method, "/xrpc/social.coves.post.create", nil) 377 + rec := httptest.NewRecorder() 378 + 379 + handler.HandleCreate(rec, req) 380 + 381 + // Should return 405 Method Not Allowed 382 + assert.Equal(t, http.StatusMethodNotAllowed, rec.Code) 383 + }) 384 + } 385 + }) 386 + } 387 + 388 + // TestPostHandler_SpecialCharacters tests content with special characters 389 + func TestPostHandler_SpecialCharacters(t *testing.T) { 390 + if testing.Short() { 391 + t.Skip("Skipping integration test in short mode") 392 + } 393 + 394 + db := setupTestDB(t) 395 + defer func() { 396 + if err := db.Close(); err != nil { 397 + t.Logf("Failed to close database: %v", err) 398 + } 399 + }() 400 + 401 + // Setup services 402 + communityRepo := postgres.NewCommunityRepository(db) 403 + communityService := communities.NewCommunityService( 404 + communityRepo, 405 + "http://localhost:3001", 406 + "did:web:test.coves.social", 407 + "test.coves.social", 408 + nil, 409 + ) 410 + 411 + postRepo := postgres.NewPostRepository(db) 412 + postService := posts.NewPostService(postRepo, communityService, "http://localhost:3001") 413 + 414 + handler := post.NewCreateHandler(postService) 415 + 416 + t.Run("Accept Unicode and emoji", func(t *testing.T) { 417 + content := "Hello 世界! 🌍 Testing unicode: café, naïve, Ω" 418 + 419 + payload := map[string]interface{}{ 420 + "community": "did:plc:test123", 421 + "content": content, 422 + } 423 + 424 + body, _ := json.Marshal(payload) 425 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.post.create", bytes.NewReader(body)) 426 + 427 + ctx := middleware.SetTestUserDID(req.Context(), "did:plc:alice") 428 + req = req.WithContext(ctx) 429 + 430 + rec := httptest.NewRecorder() 431 + handler.HandleCreate(rec, req) 432 + 433 + // Should NOT reject due to unicode/special characters 434 + // May fail at service layer for other reasons, but should pass handler validation 435 + assert.NotEqual(t, http.StatusBadRequest, rec.Code, "Handler should not reject valid unicode") 436 + }) 437 + 438 + t.Run("SQL injection attempt is safely handled", func(t *testing.T) { 439 + // Common SQL injection patterns 440 + sqlInjections := []string{ 441 + "'; DROP TABLE posts; --", 442 + "1' OR '1'='1", 443 + "<script>alert('xss')</script>", 444 + "../../../etc/passwd", 445 + } 446 + 447 + for _, injection := range sqlInjections { 448 + t.Run(injection, func(t *testing.T) { 449 + payload := map[string]interface{}{ 450 + "community": "did:plc:test123", 451 + "content": injection, 452 + } 453 + 454 + body, _ := json.Marshal(payload) 455 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.post.create", bytes.NewReader(body)) 456 + 457 + ctx := middleware.SetTestUserDID(req.Context(), "did:plc:alice") 458 + req = req.WithContext(ctx) 459 + 460 + rec := httptest.NewRecorder() 461 + handler.HandleCreate(rec, req) 462 + 463 + // Handler should NOT crash or return 500 464 + // These are just strings, should be handled safely 465 + assert.NotEqual(t, http.StatusInternalServerError, rec.Code, 466 + "Handler should not crash on injection attempt") 467 + }) 468 + } 469 + }) 470 + }