+1 -1

.env.dev

··· 77 77 # Local E2E Testing: Use local Jetstream (indexes only local PDS) 78 78 # 1. Start local Jetstream: docker-compose --profile jetstream up pds jetstream 79 79 # 2. Use this URL: 80 80 - JETSTREAM_URL=ws://localhost:6008/subscribe 80 80 + JETSTREAM_URL=ws://localhost:6008/subscribe?wantedCollections=app.bsky.actor.profile 81 81 82 82 # Optional: Filter events to specific PDS 83 83 # JETSTREAM_PDS_FILTER=http://localhost:3001

+2 -1

.env.dev.example

··· 60 60 # ============================================================================= 61 61 # Jetstream Configuration 62 62 # ============================================================================= 63 63 - JETSTREAM_URL=ws://localhost:6008/subscribe 63 63 + # User profile indexing - wantedCollections filters to profile events only 64 64 + JETSTREAM_URL=ws://localhost:6008/subscribe?wantedCollections=app.bsky.actor.profile 64 65 65 66 # ============================================================================= 66 67 # Identity Resolution

+2 -1

cmd/server/main.go

··· 669 669 log.Println(" - Updating: Post comment counts and comment reply counts atomically") 670 670 671 671 // Register XRPC routes 672 672 - routes.RegisterUserRoutes(r, userService, authMiddleware) 672 672 + routes.RegisterUserRoutes(r, userService, authMiddleware, blobService) 673 673 log.Println("User XRPC endpoints registered") 674 674 log.Println(" - GET /xrpc/social.coves.actor.getprofile (public)") 675 675 log.Println(" - POST /xrpc/social.coves.actor.signup (public)") 676 676 log.Println(" - POST /xrpc/social.coves.actor.deleteAccount (requires OAuth)") 677 677 + log.Println(" - POST /xrpc/social.coves.actor.updateProfile (requires OAuth)") 677 678 678 679 routes.RegisterCommunityRoutes(r, communityService, communityRepo, authMiddleware, allowedCommunityCreators) 679 680 log.Println("Community XRPC endpoints registered with OAuth authentication")

+4

internal/api/handlers/actor/get_comments_test.go

··· 93 93 return nil 94 94 } 95 95 96 96 + func (m *mockUserServiceForComments) UpdateProfile(ctx context.Context, did string, input users.UpdateProfileInput) (*users.User, error) { 97 97 + return nil, nil 98 98 + } 99 99 + 96 100 // mockVoteServiceForComments implements votes.Service for testing getComments 97 101 type mockVoteServiceForComments struct{} 98 102

+4

internal/api/handlers/actor/get_posts_test.go

··· 78 78 return nil 79 79 } 80 80 81 81 + func (m *mockUserService) UpdateProfile(ctx context.Context, did string, input users.UpdateProfileInput) (*users.User, error) { 82 82 + return nil, nil 83 83 + } 84 84 + 81 85 // mockVoteService implements votes.Service for testing 82 86 type mockVoteService struct{} 83 87

+8

internal/api/handlers/user/delete_test.go

··· 83 83 return args.Error(0) 84 84 } 85 85 86 86 + func (m *MockUserService) UpdateProfile(ctx context.Context, did string, input users.UpdateProfileInput) (*users.User, error) { 87 87 + args := m.Called(ctx, did, input) 88 88 + if args.Get(0) == nil { 89 89 + return nil, args.Error(1) 90 90 + } 91 91 + return args.Get(0).(*users.User), args.Error(1) 92 92 + } 93 93 + 86 94 // TestDeleteAccountHandler_Success tests successful account deletion via XRPC 87 95 // Uses the actual production handler with middleware context injection 88 96 func TestDeleteAccountHandler_Success(t *testing.T) {

+416

internal/api/handlers/user/update_profile.go

··· 1 1 + package user 2 2 + 3 3 + import ( 4 4 + "bytes" 5 5 + "context" 6 6 + "encoding/json" 7 7 + "errors" 8 8 + "fmt" 9 9 + "io" 10 10 + "log/slog" 11 11 + "net/http" 12 12 + "time" 13 13 + 14 14 + "Coves/internal/api/middleware" 15 15 + "Coves/internal/core/blobs" 16 16 + 17 17 + oauthlib "github.com/bluesky-social/indigo/atproto/auth/oauth" 18 18 + ) 19 19 + 20 20 + const ( 21 21 + // MaxDisplayNameLength is the maximum allowed length for display names (per atProto lexicon) 22 22 + MaxDisplayNameLength = 64 23 23 + // MaxBioLength is the maximum allowed length for bio/description (per atProto lexicon) 24 24 + MaxBioLength = 256 25 25 + // MaxAvatarBlobSize is the maximum allowed avatar size in bytes (1MB per lexicon) 26 26 + MaxAvatarBlobSize = 1_000_000 27 27 + // MaxBannerBlobSize is the maximum allowed banner size in bytes (2MB per lexicon) 28 28 + MaxBannerBlobSize = 2_000_000 29 29 + // MaxRequestBodySize is the maximum request body size (10MB to accommodate base64 overhead) 30 30 + MaxRequestBodySize = 10_000_000 31 31 + ) 32 32 + 33 33 + // pdsError represents an error returned from the PDS with a specific status code 34 34 + type pdsError struct { 35 35 + StatusCode int 36 36 + } 37 37 + 38 38 + func (e *pdsError) Error() string { 39 39 + return fmt.Sprintf("PDS returned error %d", e.StatusCode) 40 40 + } 41 41 + 42 42 + // UpdateProfileRequest represents the request body for updating a user profile 43 43 + type UpdateProfileRequest struct { 44 44 + DisplayName *string `json:"displayName,omitempty"` 45 45 + Bio *string `json:"bio,omitempty"` 46 46 + AvatarBlob []byte `json:"avatarBlob,omitempty"` 47 47 + AvatarMimeType string `json:"avatarMimeType,omitempty"` 48 48 + BannerBlob []byte `json:"bannerBlob,omitempty"` 49 49 + BannerMimeType string `json:"bannerMimeType,omitempty"` 50 50 + } 51 51 + 52 52 + // UpdateProfileResponse represents the response from updating a profile 53 53 + type UpdateProfileResponse struct { 54 54 + URI string `json:"uri"` 55 55 + CID string `json:"cid"` 56 56 + } 57 57 + 58 58 + // userBlobOwner implements blobs.BlobOwner for users 59 59 + // This allows us to use the blob service to upload blobs on behalf of users 60 60 + type userBlobOwner struct { 61 61 + pdsURL string 62 62 + accessToken string 63 63 + } 64 64 + 65 65 + // GetPDSURL returns the PDS URL for this user 66 66 + func (u *userBlobOwner) GetPDSURL() string { 67 67 + return u.pdsURL 68 68 + } 69 69 + 70 70 + // GetPDSAccessToken returns the access token for authenticating with the PDS 71 71 + func (u *userBlobOwner) GetPDSAccessToken() string { 72 72 + return u.accessToken 73 73 + } 74 74 + 75 75 + // UpdateProfileHandler handles POST /xrpc/social.coves.actor.updateProfile 76 76 + // This endpoint allows authenticated users to update their profile on their PDS. 77 77 + // The handler: 78 78 + // 1. Validates the user is authenticated via OAuth 79 79 + // 2. Validates avatar/banner size and mime type constraints 80 80 + // 3. Uploads any provided blobs to the user's PDS 81 81 + // 4. Puts the profile record to the user's PDS via com.atproto.repo.putRecord 82 82 + type UpdateProfileHandler struct { 83 83 + blobService blobs.Service 84 84 + httpClient *http.Client // For making PDS calls 85 85 + } 86 86 + 87 87 + // NewUpdateProfileHandler creates a new update profile handler 88 88 + func NewUpdateProfileHandler(blobService blobs.Service, httpClient *http.Client) *UpdateProfileHandler { 89 89 + // Use default client if none provided 90 90 + if httpClient == nil { 91 91 + httpClient = &http.Client{ 92 92 + Timeout: 30 * time.Second, 93 93 + } 94 94 + } 95 95 + return &UpdateProfileHandler{ 96 96 + blobService: blobService, 97 97 + httpClient: httpClient, 98 98 + } 99 99 + } 100 100 + 101 101 + // ServeHTTP handles the update profile request 102 102 + func (h *UpdateProfileHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { 103 103 + ctx := r.Context() 104 104 + 105 105 + // Check HTTP method 106 106 + if r.Method != http.MethodPost { 107 107 + http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) 108 108 + return 109 109 + } 110 110 + 111 111 + // 1. Get authenticated user from context 112 112 + userDID := middleware.GetUserDID(r) 113 113 + if userDID == "" { 114 114 + writeUpdateProfileError(w, http.StatusUnauthorized, "AuthRequired", "Authentication required") 115 115 + return 116 116 + } 117 117 + 118 118 + // Get OAuth session for PDS URL and access token 119 119 + session := middleware.GetOAuthSession(r) 120 120 + if session == nil { 121 121 + writeUpdateProfileError(w, http.StatusUnauthorized, "MissingSession", "Missing PDS credentials") 122 122 + return 123 123 + } 124 124 + 125 125 + pdsURL := session.HostURL 126 126 + accessToken := session.AccessToken 127 127 + if pdsURL == "" || accessToken == "" { 128 128 + writeUpdateProfileError(w, http.StatusUnauthorized, "MissingCredentials", "Missing PDS credentials") 129 129 + return 130 130 + } 131 131 + 132 132 + // 2. Parse request 133 133 + r.Body = http.MaxBytesReader(w, r.Body, MaxRequestBodySize) 134 134 + var req UpdateProfileRequest 135 135 + if err := json.NewDecoder(r.Body).Decode(&req); err != nil { 136 136 + writeUpdateProfileError(w, http.StatusBadRequest, "InvalidRequest", "Invalid request body") 137 137 + return 138 138 + } 139 139 + 140 140 + // Validate displayName length 141 141 + if req.DisplayName != nil && len(*req.DisplayName) > MaxDisplayNameLength { 142 142 + writeUpdateProfileError(w, http.StatusBadRequest, "DisplayNameTooLong", 143 143 + fmt.Sprintf("Display name exceeds %d character limit", MaxDisplayNameLength)) 144 144 + return 145 145 + } 146 146 + 147 147 + // Validate bio length 148 148 + if req.Bio != nil && len(*req.Bio) > MaxBioLength { 149 149 + writeUpdateProfileError(w, http.StatusBadRequest, "BioTooLong", 150 150 + fmt.Sprintf("Bio exceeds %d character limit", MaxBioLength)) 151 151 + return 152 152 + } 153 153 + 154 154 + // 3. Validate blob sizes and mime types 155 155 + if len(req.AvatarBlob) > 0 { 156 156 + // Validate mime type is provided when blob is provided 157 157 + if req.AvatarMimeType == "" { 158 158 + writeUpdateProfileError(w, http.StatusBadRequest, "InvalidRequest", "Avatar blob provided without mime type") 159 159 + return 160 160 + } 161 161 + // Validate size (1MB max for avatar per lexicon) 162 162 + if len(req.AvatarBlob) > MaxAvatarBlobSize { 163 163 + writeUpdateProfileError(w, http.StatusBadRequest, "AvatarTooLarge", "Avatar exceeds 1MB limit") 164 164 + return 165 165 + } 166 166 + if !isValidImageMimeType(req.AvatarMimeType) { 167 167 + writeUpdateProfileError(w, http.StatusBadRequest, "InvalidMimeType", "Invalid avatar mime type") 168 168 + return 169 169 + } 170 170 + } 171 171 + 172 172 + if len(req.BannerBlob) > 0 { 173 173 + // Validate mime type is provided when blob is provided 174 174 + if req.BannerMimeType == "" { 175 175 + writeUpdateProfileError(w, http.StatusBadRequest, "InvalidRequest", "Banner blob provided without mime type") 176 176 + return 177 177 + } 178 178 + // Validate size (2MB max for banner per lexicon) 179 179 + if len(req.BannerBlob) > MaxBannerBlobSize { 180 180 + writeUpdateProfileError(w, http.StatusBadRequest, "BannerTooLarge", "Banner exceeds 2MB limit") 181 181 + return 182 182 + } 183 183 + if !isValidImageMimeType(req.BannerMimeType) { 184 184 + writeUpdateProfileError(w, http.StatusBadRequest, "InvalidMimeType", "Invalid banner mime type") 185 185 + return 186 186 + } 187 187 + } 188 188 + 189 189 + // 4. Create blob owner for user (implements blobs.BlobOwner interface) 190 190 + owner := &userBlobOwner{pdsURL: pdsURL, accessToken: accessToken} 191 191 + 192 192 + // 5. Build profile record 193 193 + profile := map[string]interface{}{ 194 194 + "$type": "app.bsky.actor.profile", 195 195 + } 196 196 + 197 197 + // Add displayName if provided 198 198 + if req.DisplayName != nil { 199 199 + profile["displayName"] = *req.DisplayName 200 200 + } 201 201 + 202 202 + // Add bio (description) if provided 203 203 + if req.Bio != nil { 204 204 + profile["description"] = *req.Bio 205 205 + } 206 206 + 207 207 + // 6. Upload avatar blob if provided 208 208 + if len(req.AvatarBlob) > 0 { 209 209 + avatarRef, err := h.blobService.UploadBlob(ctx, owner, req.AvatarBlob, req.AvatarMimeType) 210 210 + if err != nil { 211 211 + slog.Error("failed to upload avatar blob", 212 212 + slog.String("did", userDID), 213 213 + slog.String("error", err.Error()), 214 214 + ) 215 215 + writeUpdateProfileError(w, http.StatusInternalServerError, "BlobUploadFailed", "Failed to upload avatar") 216 216 + return 217 217 + } 218 218 + if avatarRef == nil || avatarRef.Ref == nil || avatarRef.Type == "" { 219 219 + slog.Error("invalid blob reference returned from avatar upload", slog.String("did", userDID)) 220 220 + writeUpdateProfileError(w, http.StatusInternalServerError, "BlobUploadFailed", "Invalid avatar blob reference") 221 221 + return 222 222 + } 223 223 + profile["avatar"] = map[string]interface{}{ 224 224 + "$type": avatarRef.Type, 225 225 + "ref": avatarRef.Ref, 226 226 + "mimeType": avatarRef.MimeType, 227 227 + "size": avatarRef.Size, 228 228 + } 229 229 + } 230 230 + 231 231 + // 7. Upload banner blob if provided 232 232 + if len(req.BannerBlob) > 0 { 233 233 + bannerRef, err := h.blobService.UploadBlob(ctx, owner, req.BannerBlob, req.BannerMimeType) 234 234 + if err != nil { 235 235 + slog.Error("failed to upload banner blob", 236 236 + slog.String("did", userDID), 237 237 + slog.String("error", err.Error()), 238 238 + ) 239 239 + writeUpdateProfileError(w, http.StatusInternalServerError, "BlobUploadFailed", "Failed to upload banner") 240 240 + return 241 241 + } 242 242 + if bannerRef == nil || bannerRef.Ref == nil || bannerRef.Type == "" { 243 243 + slog.Error("invalid blob reference returned from banner upload", slog.String("did", userDID)) 244 244 + writeUpdateProfileError(w, http.StatusInternalServerError, "BlobUploadFailed", "Invalid banner blob reference") 245 245 + return 246 246 + } 247 247 + profile["banner"] = map[string]interface{}{ 248 248 + "$type": bannerRef.Type, 249 249 + "ref": bannerRef.Ref, 250 250 + "mimeType": bannerRef.MimeType, 251 251 + "size": bannerRef.Size, 252 252 + } 253 253 + } 254 254 + 255 255 + // 8. Put profile record to PDS using com.atproto.repo.putRecord 256 256 + uri, cid, err := h.putProfileRecord(ctx, session, userDID, profile) 257 257 + if err != nil { 258 258 + slog.Error("failed to put profile record to PDS", 259 259 + slog.String("did", userDID), 260 260 + slog.String("pds_url", pdsURL), 261 261 + slog.String("error", err.Error()), 262 262 + ) 263 263 + // Map PDS status codes to user-friendly messages 264 264 + var pdsErr *pdsError 265 265 + if errors.As(err, &pdsErr) { 266 266 + switch pdsErr.StatusCode { 267 267 + case http.StatusUnauthorized, http.StatusForbidden: 268 268 + writeUpdateProfileError(w, http.StatusUnauthorized, "AuthExpired", "Your session may have expired. Please re-authenticate.") 269 269 + return 270 270 + case http.StatusTooManyRequests: 271 271 + writeUpdateProfileError(w, http.StatusTooManyRequests, "RateLimited", "Too many requests. Please try again later.") 272 272 + return 273 273 + case http.StatusRequestEntityTooLarge: 274 274 + writeUpdateProfileError(w, http.StatusBadRequest, "PayloadTooLarge", "Profile data exceeds PDS limits.") 275 275 + return 276 276 + } 277 277 + } 278 278 + writeUpdateProfileError(w, http.StatusInternalServerError, "PDSError", "Failed to update profile") 279 279 + return 280 280 + } 281 281 + 282 282 + // 9. Return success response 283 283 + resp := UpdateProfileResponse{URI: uri, CID: cid} 284 284 + 285 285 + // Marshal to bytes first to catch encoding errors before writing headers 286 286 + responseBytes, err := json.Marshal(resp) 287 287 + if err != nil { 288 288 + slog.Error("failed to marshal update profile response", 289 289 + slog.String("did", userDID), 290 290 + slog.String("error", err.Error()), 291 291 + ) 292 292 + writeUpdateProfileError(w, http.StatusInternalServerError, "InternalError", "Failed to encode response") 293 293 + return 294 294 + } 295 295 + 296 296 + w.Header().Set("Content-Type", "application/json") 297 297 + w.WriteHeader(http.StatusOK) 298 298 + if _, writeErr := w.Write(responseBytes); writeErr != nil { 299 299 + slog.Warn("failed to write update profile response", 300 300 + slog.String("did", userDID), 301 301 + slog.String("error", writeErr.Error()), 302 302 + ) 303 303 + } 304 304 + } 305 305 + 306 306 + // putProfileRecord calls com.atproto.repo.putRecord on the user's PDS 307 307 + // This creates or updates the user's profile record at: 308 308 + // at://{did}/app.bsky.actor.profile/self 309 309 + func (h *UpdateProfileHandler) putProfileRecord(ctx context.Context, session *oauthlib.ClientSessionData, did string, profile map[string]interface{}) (string, string, error) { 310 310 + pdsURL := session.HostURL 311 311 + accessToken := session.AccessToken 312 312 + 313 313 + // Build the putRecord request body 314 314 + putRecordReq := map[string]interface{}{ 315 315 + "repo": did, 316 316 + "collection": "app.bsky.actor.profile", 317 317 + "rkey": "self", 318 318 + "record": profile, 319 319 + } 320 320 + 321 321 + reqBody, err := json.Marshal(putRecordReq) 322 322 + if err != nil { 323 323 + return "", "", fmt.Errorf("failed to marshal putRecord request: %w", err) 324 324 + } 325 325 + 326 326 + // Build the endpoint URL 327 327 + endpoint := fmt.Sprintf("%s/xrpc/com.atproto.repo.putRecord", pdsURL) 328 328 + 329 329 + // Create the HTTP request 330 330 + req, err := http.NewRequestWithContext(ctx, "POST", endpoint, bytes.NewReader(reqBody)) 331 331 + if err != nil { 332 332 + return "", "", fmt.Errorf("failed to create PDS request: %w", err) 333 333 + } 334 334 + 335 335 + // Set headers 336 336 + req.Header.Set("Content-Type", "application/json") 337 337 + req.Header.Set("Authorization", "Bearer "+accessToken) 338 338 + 339 339 + // Execute the request 340 340 + resp, err := h.httpClient.Do(req) 341 341 + if err != nil { 342 342 + return "", "", fmt.Errorf("PDS request failed: %w", err) 343 343 + } 344 344 + defer func() { 345 345 + if closeErr := resp.Body.Close(); closeErr != nil { 346 346 + slog.Warn("failed to close PDS response body", slog.String("error", closeErr.Error())) 347 347 + } 348 348 + }() 349 349 + 350 350 + // Read response body 351 351 + body, err := io.ReadAll(resp.Body) 352 352 + if err != nil { 353 353 + return "", "", fmt.Errorf("failed to read PDS response: %w", err) 354 354 + } 355 355 + 356 356 + // Check for errors 357 357 + if resp.StatusCode != http.StatusOK { 358 358 + // Truncate error body for logging to prevent leaking sensitive data 359 359 + bodyPreview := string(body) 360 360 + if len(bodyPreview) > 200 { 361 361 + bodyPreview = bodyPreview[:200] + "... (truncated)" 362 362 + } 363 363 + slog.Error("PDS putRecord failed", 364 364 + slog.Int("status", resp.StatusCode), 365 365 + slog.String("body", bodyPreview), 366 366 + ) 367 367 + return "", "", &pdsError{StatusCode: resp.StatusCode} 368 368 + } 369 369 + 370 370 + // Parse the successful response 371 371 + var result struct { 372 372 + URI string `json:"uri"` 373 373 + CID string `json:"cid"` 374 374 + } 375 375 + if err := json.Unmarshal(body, &result); err != nil { 376 376 + return "", "", fmt.Errorf("failed to parse PDS response: %w", err) 377 377 + } 378 378 + 379 379 + if result.URI == "" || result.CID == "" { 380 380 + return "", "", fmt.Errorf("PDS response missing required fields (uri or cid)") 381 381 + } 382 382 + 383 383 + return result.URI, result.CID, nil 384 384 + } 385 385 + 386 386 + // isValidImageMimeType checks if the MIME type is allowed for profile images 387 387 + func isValidImageMimeType(mimeType string) bool { 388 388 + switch mimeType { 389 389 + case "image/png", "image/jpeg", "image/webp": 390 390 + return true 391 391 + default: 392 392 + return false 393 393 + } 394 394 + } 395 395 + 396 396 + // writeUpdateProfileError writes a JSON error response for update profile failures 397 397 + func writeUpdateProfileError(w http.ResponseWriter, statusCode int, errorType, message string) { 398 398 + responseBytes, err := json.Marshal(map[string]interface{}{ 399 399 + "error": errorType, 400 400 + "message": message, 401 401 + }) 402 402 + if err != nil { 403 403 + // Fallback to plain text if JSON encoding fails 404 404 + slog.Error("failed to marshal error response", slog.String("error", err.Error())) 405 405 + w.Header().Set("Content-Type", "text/plain") 406 406 + w.WriteHeader(statusCode) 407 407 + _, _ = w.Write([]byte(message)) 408 408 + return 409 409 + } 410 410 + 411 411 + w.Header().Set("Content-Type", "application/json") 412 412 + w.WriteHeader(statusCode) 413 413 + if _, writeErr := w.Write(responseBytes); writeErr != nil { 414 414 + slog.Warn("failed to write error response", slog.String("error", writeErr.Error())) 415 415 + } 416 416 + }

+1035

internal/api/handlers/user/update_profile_test.go

··· 1 1 + package user 2 2 + 3 3 + import ( 4 4 + "bytes" 5 5 + "context" 6 6 + "encoding/json" 7 7 + "errors" 8 8 + "net/http" 9 9 + "net/http/httptest" 10 10 + "strings" 11 11 + "testing" 12 12 + 13 13 + "Coves/internal/api/middleware" 14 14 + "Coves/internal/core/blobs" 15 15 + 16 16 + oauthlib "github.com/bluesky-social/indigo/atproto/auth/oauth" 17 17 + "github.com/bluesky-social/indigo/atproto/syntax" 18 18 + "github.com/stretchr/testify/assert" 19 19 + "github.com/stretchr/testify/mock" 20 20 + ) 21 21 + 22 22 + // MockBlobService is a mock implementation of blobs.Service for testing 23 23 + type MockBlobService struct { 24 24 + mock.Mock 25 25 + } 26 26 + 27 27 + func (m *MockBlobService) UploadBlobFromURL(ctx context.Context, owner blobs.BlobOwner, imageURL string) (*blobs.BlobRef, error) { 28 28 + args := m.Called(ctx, owner, imageURL) 29 29 + if args.Get(0) == nil { 30 30 + return nil, args.Error(1) 31 31 + } 32 32 + return args.Get(0).(*blobs.BlobRef), args.Error(1) 33 33 + } 34 34 + 35 35 + func (m *MockBlobService) UploadBlob(ctx context.Context, owner blobs.BlobOwner, data []byte, mimeType string) (*blobs.BlobRef, error) { 36 36 + args := m.Called(ctx, owner, data, mimeType) 37 37 + if args.Get(0) == nil { 38 38 + return nil, args.Error(1) 39 39 + } 40 40 + return args.Get(0).(*blobs.BlobRef), args.Error(1) 41 41 + } 42 42 + 43 43 + // MockPDSClient is a mock HTTP client for PDS interactions 44 44 + type MockPDSClient struct { 45 45 + mock.Mock 46 46 + } 47 47 + 48 48 + // mockRoundTripper implements http.RoundTripper for testing 49 49 + type mockRoundTripper struct { 50 50 + mock.Mock 51 51 + } 52 52 + 53 53 + func (m *mockRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) { 54 54 + args := m.Called(req) 55 55 + if args.Get(0) == nil { 56 56 + return nil, args.Error(1) 57 57 + } 58 58 + return args.Get(0).(*http.Response), args.Error(1) 59 59 + } 60 60 + 61 61 + // createTestOAuthSession creates a test OAuth session for testing 62 62 + func createTestOAuthSession(did string) *oauthlib.ClientSessionData { 63 63 + parsedDID, _ := syntax.ParseDID(did) 64 64 + return &oauthlib.ClientSessionData{ 65 65 + AccountDID: parsedDID, 66 66 + SessionID: "test-session-id", 67 67 + HostURL: "https://test.pds.example", 68 68 + AccessToken: "test-access-token", 69 69 + } 70 70 + } 71 71 + 72 72 + // setTestOAuthSession sets both user DID and OAuth session in context 73 73 + func setTestOAuthSession(ctx context.Context, userDID string, session *oauthlib.ClientSessionData) context.Context { 74 74 + ctx = middleware.SetTestUserDID(ctx, userDID) 75 75 + ctx = context.WithValue(ctx, middleware.OAuthSessionKey, session) 76 76 + ctx = context.WithValue(ctx, middleware.UserAccessToken, session.AccessToken) 77 77 + return ctx 78 78 + } 79 79 + 80 80 + // TestUpdateProfileHandler_Unauthenticated tests that unauthenticated requests return 401 81 81 + func TestUpdateProfileHandler_Unauthenticated(t *testing.T) { 82 82 + mockBlobService := new(MockBlobService) 83 83 + handler := NewUpdateProfileHandler(mockBlobService, nil) 84 84 + 85 85 + reqBody := UpdateProfileRequest{ 86 86 + DisplayName: strPtr("Test User"), 87 87 + } 88 88 + body, _ := json.Marshal(reqBody) 89 89 + 90 90 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 91 91 + req.Header.Set("Content-Type", "application/json") 92 92 + // No auth context - simulates unauthenticated request 93 93 + 94 94 + w := httptest.NewRecorder() 95 95 + handler.ServeHTTP(w, req) 96 96 + 97 97 + assert.Equal(t, http.StatusUnauthorized, w.Code) 98 98 + assert.Contains(t, w.Body.String(), "AuthRequired") 99 99 + 100 100 + mockBlobService.AssertNotCalled(t, "UploadBlob", mock.Anything, mock.Anything, mock.Anything, mock.Anything) 101 101 + } 102 102 + 103 103 + // TestUpdateProfileHandler_MissingOAuthSession tests that missing OAuth session returns 401 104 104 + func TestUpdateProfileHandler_MissingOAuthSession(t *testing.T) { 105 105 + mockBlobService := new(MockBlobService) 106 106 + handler := NewUpdateProfileHandler(mockBlobService, nil) 107 107 + 108 108 + reqBody := UpdateProfileRequest{ 109 109 + DisplayName: strPtr("Test User"), 110 110 + } 111 111 + body, _ := json.Marshal(reqBody) 112 112 + 113 113 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 114 114 + req.Header.Set("Content-Type", "application/json") 115 115 + 116 116 + // Set user DID but no OAuth session 117 117 + ctx := middleware.SetTestUserDID(req.Context(), "did:plc:testuser123") 118 118 + req = req.WithContext(ctx) 119 119 + 120 120 + w := httptest.NewRecorder() 121 121 + handler.ServeHTTP(w, req) 122 122 + 123 123 + assert.Equal(t, http.StatusUnauthorized, w.Code) 124 124 + assert.Contains(t, w.Body.String(), "Missing PDS credentials") 125 125 + } 126 126 + 127 127 + // TestUpdateProfileHandler_InvalidRequestBody tests that invalid JSON returns 400 128 128 + func TestUpdateProfileHandler_InvalidRequestBody(t *testing.T) { 129 129 + mockBlobService := new(MockBlobService) 130 130 + handler := NewUpdateProfileHandler(mockBlobService, nil) 131 131 + 132 132 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", strings.NewReader("not valid json")) 133 133 + req.Header.Set("Content-Type", "application/json") 134 134 + 135 135 + testDID := "did:plc:testuser123" 136 136 + session := createTestOAuthSession(testDID) 137 137 + ctx := setTestOAuthSession(req.Context(), testDID, session) 138 138 + req = req.WithContext(ctx) 139 139 + 140 140 + w := httptest.NewRecorder() 141 141 + handler.ServeHTTP(w, req) 142 142 + 143 143 + assert.Equal(t, http.StatusBadRequest, w.Code) 144 144 + assert.Contains(t, w.Body.String(), "Invalid request body") 145 145 + } 146 146 + 147 147 + // TestUpdateProfileHandler_AvatarSizeExceedsLimit tests that avatar over 1MB is rejected 148 148 + func TestUpdateProfileHandler_AvatarSizeExceedsLimit(t *testing.T) { 149 149 + mockBlobService := new(MockBlobService) 150 150 + handler := NewUpdateProfileHandler(mockBlobService, nil) 151 151 + 152 152 + // Create avatar blob larger than 1MB (1,000,001 bytes) 153 153 + largeBlob := make([]byte, 1_000_001) 154 154 + 155 155 + reqBody := UpdateProfileRequest{ 156 156 + DisplayName: strPtr("Test User"), 157 157 + AvatarBlob: largeBlob, 158 158 + AvatarMimeType: "image/jpeg", 159 159 + } 160 160 + body, _ := json.Marshal(reqBody) 161 161 + 162 162 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 163 163 + req.Header.Set("Content-Type", "application/json") 164 164 + 165 165 + testDID := "did:plc:testuser123" 166 166 + session := createTestOAuthSession(testDID) 167 167 + ctx := setTestOAuthSession(req.Context(), testDID, session) 168 168 + req = req.WithContext(ctx) 169 169 + 170 170 + w := httptest.NewRecorder() 171 171 + handler.ServeHTTP(w, req) 172 172 + 173 173 + assert.Equal(t, http.StatusBadRequest, w.Code) 174 174 + assert.Contains(t, w.Body.String(), "Avatar exceeds 1MB limit") 175 175 + 176 176 + mockBlobService.AssertNotCalled(t, "UploadBlob", mock.Anything, mock.Anything, mock.Anything, mock.Anything) 177 177 + } 178 178 + 179 179 + // TestUpdateProfileHandler_BannerSizeExceedsLimit tests that banner over 2MB is rejected 180 180 + func TestUpdateProfileHandler_BannerSizeExceedsLimit(t *testing.T) { 181 181 + mockBlobService := new(MockBlobService) 182 182 + handler := NewUpdateProfileHandler(mockBlobService, nil) 183 183 + 184 184 + // Create banner blob larger than 2MB (2,000,001 bytes) 185 185 + largeBlob := make([]byte, 2_000_001) 186 186 + 187 187 + reqBody := UpdateProfileRequest{ 188 188 + DisplayName: strPtr("Test User"), 189 189 + BannerBlob: largeBlob, 190 190 + BannerMimeType: "image/jpeg", 191 191 + } 192 192 + body, _ := json.Marshal(reqBody) 193 193 + 194 194 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 195 195 + req.Header.Set("Content-Type", "application/json") 196 196 + 197 197 + testDID := "did:plc:testuser123" 198 198 + session := createTestOAuthSession(testDID) 199 199 + ctx := setTestOAuthSession(req.Context(), testDID, session) 200 200 + req = req.WithContext(ctx) 201 201 + 202 202 + w := httptest.NewRecorder() 203 203 + handler.ServeHTTP(w, req) 204 204 + 205 205 + assert.Equal(t, http.StatusBadRequest, w.Code) 206 206 + assert.Contains(t, w.Body.String(), "Banner exceeds 2MB limit") 207 207 + 208 208 + mockBlobService.AssertNotCalled(t, "UploadBlob", mock.Anything, mock.Anything, mock.Anything, mock.Anything) 209 209 + } 210 210 + 211 211 + // TestUpdateProfileHandler_InvalidAvatarMimeType tests that invalid avatar mime type is rejected 212 212 + func TestUpdateProfileHandler_InvalidAvatarMimeType(t *testing.T) { 213 213 + mockBlobService := new(MockBlobService) 214 214 + handler := NewUpdateProfileHandler(mockBlobService, nil) 215 215 + 216 216 + reqBody := UpdateProfileRequest{ 217 217 + DisplayName: strPtr("Test User"), 218 218 + AvatarBlob: []byte("fake image data"), 219 219 + AvatarMimeType: "image/gif", // Not allowed - only png/jpeg/webp 220 220 + } 221 221 + body, _ := json.Marshal(reqBody) 222 222 + 223 223 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 224 224 + req.Header.Set("Content-Type", "application/json") 225 225 + 226 226 + testDID := "did:plc:testuser123" 227 227 + session := createTestOAuthSession(testDID) 228 228 + ctx := setTestOAuthSession(req.Context(), testDID, session) 229 229 + req = req.WithContext(ctx) 230 230 + 231 231 + w := httptest.NewRecorder() 232 232 + handler.ServeHTTP(w, req) 233 233 + 234 234 + assert.Equal(t, http.StatusBadRequest, w.Code) 235 235 + assert.Contains(t, w.Body.String(), "Invalid avatar mime type") 236 236 + } 237 237 + 238 238 + // TestUpdateProfileHandler_InvalidBannerMimeType tests that invalid banner mime type is rejected 239 239 + func TestUpdateProfileHandler_InvalidBannerMimeType(t *testing.T) { 240 240 + mockBlobService := new(MockBlobService) 241 241 + handler := NewUpdateProfileHandler(mockBlobService, nil) 242 242 + 243 243 + reqBody := UpdateProfileRequest{ 244 244 + DisplayName: strPtr("Test User"), 245 245 + BannerBlob: []byte("fake image data"), 246 246 + BannerMimeType: "application/pdf", // Not allowed 247 247 + } 248 248 + body, _ := json.Marshal(reqBody) 249 249 + 250 250 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 251 251 + req.Header.Set("Content-Type", "application/json") 252 252 + 253 253 + testDID := "did:plc:testuser123" 254 254 + session := createTestOAuthSession(testDID) 255 255 + ctx := setTestOAuthSession(req.Context(), testDID, session) 256 256 + req = req.WithContext(ctx) 257 257 + 258 258 + w := httptest.NewRecorder() 259 259 + handler.ServeHTTP(w, req) 260 260 + 261 261 + assert.Equal(t, http.StatusBadRequest, w.Code) 262 262 + assert.Contains(t, w.Body.String(), "Invalid banner mime type") 263 263 + } 264 264 + 265 265 + // TestUpdateProfileHandler_ValidMimeTypes tests that all valid mime types are accepted 266 266 + func TestUpdateProfileHandler_ValidMimeTypes(t *testing.T) { 267 267 + validMimeTypes := []string{"image/png", "image/jpeg", "image/webp"} 268 268 + 269 269 + for _, mimeType := range validMimeTypes { 270 270 + t.Run(mimeType, func(t *testing.T) { 271 271 + mockBlobService := new(MockBlobService) 272 272 + 273 273 + // Set up mock PDS server for putRecord 274 274 + mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 275 275 + w.Header().Set("Content-Type", "application/json") 276 276 + json.NewEncoder(w).Encode(map[string]interface{}{ 277 277 + "uri": "at://did:plc:testuser123/app.bsky.actor.profile/self", 278 278 + "cid": "bafyreicid123", 279 279 + }) 280 280 + })) 281 281 + defer mockPDS.Close() 282 282 + 283 283 + handler := NewUpdateProfileHandler(mockBlobService, http.DefaultClient) 284 284 + 285 285 + avatarData := []byte("fake avatar image data") 286 286 + expectedBlobRef := &blobs.BlobRef{ 287 287 + Type: "blob", 288 288 + Ref: map[string]string{"$link": "bafyreiabc123"}, 289 289 + MimeType: mimeType, 290 290 + Size: len(avatarData), 291 291 + } 292 292 + 293 293 + mockBlobService.On("UploadBlob", mock.Anything, mock.Anything, avatarData, mimeType). 294 294 + Return(expectedBlobRef, nil) 295 295 + 296 296 + reqBody := UpdateProfileRequest{ 297 297 + DisplayName: strPtr("Test User"), 298 298 + AvatarBlob: avatarData, 299 299 + AvatarMimeType: mimeType, 300 300 + } 301 301 + body, _ := json.Marshal(reqBody) 302 302 + 303 303 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 304 304 + req.Header.Set("Content-Type", "application/json") 305 305 + 306 306 + testDID := "did:plc:testuser123" 307 307 + session := createTestOAuthSession(testDID) 308 308 + session.HostURL = mockPDS.URL // Point to mock PDS 309 309 + ctx := setTestOAuthSession(req.Context(), testDID, session) 310 310 + req = req.WithContext(ctx) 311 311 + 312 312 + w := httptest.NewRecorder() 313 313 + handler.ServeHTTP(w, req) 314 314 + 315 315 + // Should succeed or fail at PDS call, not at validation 316 316 + // We just verify the mime type validation passed 317 317 + assert.NotEqual(t, http.StatusBadRequest, w.Code) 318 318 + mockBlobService.AssertExpectations(t) 319 319 + }) 320 320 + } 321 321 + } 322 322 + 323 323 + // TestUpdateProfileHandler_AvatarBlobUploadFailure tests handling of blob upload failure 324 324 + func TestUpdateProfileHandler_AvatarBlobUploadFailure(t *testing.T) { 325 325 + mockBlobService := new(MockBlobService) 326 326 + handler := NewUpdateProfileHandler(mockBlobService, nil) 327 327 + 328 328 + avatarData := []byte("fake avatar image data") 329 329 + mockBlobService.On("UploadBlob", mock.Anything, mock.Anything, avatarData, "image/jpeg"). 330 330 + Return(nil, errors.New("PDS upload failed")) 331 331 + 332 332 + reqBody := UpdateProfileRequest{ 333 333 + DisplayName: strPtr("Test User"), 334 334 + AvatarBlob: avatarData, 335 335 + AvatarMimeType: "image/jpeg", 336 336 + } 337 337 + body, _ := json.Marshal(reqBody) 338 338 + 339 339 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 340 340 + req.Header.Set("Content-Type", "application/json") 341 341 + 342 342 + testDID := "did:plc:testuser123" 343 343 + session := createTestOAuthSession(testDID) 344 344 + ctx := setTestOAuthSession(req.Context(), testDID, session) 345 345 + req = req.WithContext(ctx) 346 346 + 347 347 + w := httptest.NewRecorder() 348 348 + handler.ServeHTTP(w, req) 349 349 + 350 350 + assert.Equal(t, http.StatusInternalServerError, w.Code) 351 351 + assert.Contains(t, w.Body.String(), "Failed to upload avatar") 352 352 + 353 353 + mockBlobService.AssertExpectations(t) 354 354 + } 355 355 + 356 356 + // TestUpdateProfileHandler_BannerBlobUploadFailure tests handling of banner blob upload failure 357 357 + func TestUpdateProfileHandler_BannerBlobUploadFailure(t *testing.T) { 358 358 + mockBlobService := new(MockBlobService) 359 359 + handler := NewUpdateProfileHandler(mockBlobService, nil) 360 360 + 361 361 + bannerData := []byte("fake banner image data") 362 362 + mockBlobService.On("UploadBlob", mock.Anything, mock.Anything, bannerData, "image/png"). 363 363 + Return(nil, errors.New("PDS upload failed")) 364 364 + 365 365 + reqBody := UpdateProfileRequest{ 366 366 + DisplayName: strPtr("Test User"), 367 367 + BannerBlob: bannerData, 368 368 + BannerMimeType: "image/png", 369 369 + } 370 370 + body, _ := json.Marshal(reqBody) 371 371 + 372 372 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 373 373 + req.Header.Set("Content-Type", "application/json") 374 374 + 375 375 + testDID := "did:plc:testuser123" 376 376 + session := createTestOAuthSession(testDID) 377 377 + ctx := setTestOAuthSession(req.Context(), testDID, session) 378 378 + req = req.WithContext(ctx) 379 379 + 380 380 + w := httptest.NewRecorder() 381 381 + handler.ServeHTTP(w, req) 382 382 + 383 383 + assert.Equal(t, http.StatusInternalServerError, w.Code) 384 384 + assert.Contains(t, w.Body.String(), "Failed to upload banner") 385 385 + 386 386 + mockBlobService.AssertExpectations(t) 387 387 + } 388 388 + 389 389 + // TestUpdateProfileHandler_PartialUpdateDisplayNameOnly tests updating only displayName (no blobs) 390 390 + func TestUpdateProfileHandler_PartialUpdateDisplayNameOnly(t *testing.T) { 391 391 + mockBlobService := new(MockBlobService) 392 392 + 393 393 + // Mock PDS server for putRecord 394 394 + mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 395 395 + // Verify it's the right endpoint 396 396 + assert.Equal(t, "/xrpc/com.atproto.repo.putRecord", r.URL.Path) 397 397 + 398 398 + // Parse request body 399 399 + var putReq map[string]interface{} 400 400 + json.NewDecoder(r.Body).Decode(&putReq) 401 401 + 402 402 + // Verify record structure 403 403 + record, ok := putReq["record"].(map[string]interface{}) 404 404 + assert.True(t, ok, "record should exist") 405 405 + assert.Equal(t, "app.bsky.actor.profile", record["$type"]) 406 406 + assert.Equal(t, "Updated Display Name", record["displayName"]) 407 407 + assert.Nil(t, record["avatar"], "avatar should not be set") 408 408 + assert.Nil(t, record["banner"], "banner should not be set") 409 409 + 410 410 + w.Header().Set("Content-Type", "application/json") 411 411 + json.NewEncoder(w).Encode(map[string]interface{}{ 412 412 + "uri": "at://did:plc:testuser123/app.bsky.actor.profile/self", 413 413 + "cid": "bafyreicid123", 414 414 + }) 415 415 + })) 416 416 + defer mockPDS.Close() 417 417 + 418 418 + handler := NewUpdateProfileHandler(mockBlobService, http.DefaultClient) 419 419 + 420 420 + reqBody := UpdateProfileRequest{ 421 421 + DisplayName: strPtr("Updated Display Name"), 422 422 + } 423 423 + body, _ := json.Marshal(reqBody) 424 424 + 425 425 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 426 426 + req.Header.Set("Content-Type", "application/json") 427 427 + 428 428 + testDID := "did:plc:testuser123" 429 429 + session := createTestOAuthSession(testDID) 430 430 + session.HostURL = mockPDS.URL 431 431 + ctx := setTestOAuthSession(req.Context(), testDID, session) 432 432 + req = req.WithContext(ctx) 433 433 + 434 434 + w := httptest.NewRecorder() 435 435 + handler.ServeHTTP(w, req) 436 436 + 437 437 + assert.Equal(t, http.StatusOK, w.Code) 438 438 + 439 439 + var response UpdateProfileResponse 440 440 + json.Unmarshal(w.Body.Bytes(), &response) 441 441 + assert.Contains(t, response.URI, "did:plc:testuser123") 442 442 + assert.NotEmpty(t, response.CID) 443 443 + 444 444 + // No blob uploads should have been called 445 445 + mockBlobService.AssertNotCalled(t, "UploadBlob", mock.Anything, mock.Anything, mock.Anything, mock.Anything) 446 446 + } 447 447 + 448 448 + // TestUpdateProfileHandler_PartialUpdateBioOnly tests updating only bio (description) 449 449 + func TestUpdateProfileHandler_PartialUpdateBioOnly(t *testing.T) { 450 450 + mockBlobService := new(MockBlobService) 451 451 + 452 452 + // Mock PDS server for putRecord 453 453 + mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 454 454 + var putReq map[string]interface{} 455 455 + json.NewDecoder(r.Body).Decode(&putReq) 456 456 + 457 457 + record := putReq["record"].(map[string]interface{}) 458 458 + assert.Equal(t, "This is my updated bio", record["description"]) 459 459 + assert.Nil(t, record["displayName"], "displayName should not be set if not provided") 460 460 + 461 461 + w.Header().Set("Content-Type", "application/json") 462 462 + json.NewEncoder(w).Encode(map[string]interface{}{ 463 463 + "uri": "at://did:plc:testuser123/app.bsky.actor.profile/self", 464 464 + "cid": "bafyreicid123", 465 465 + }) 466 466 + })) 467 467 + defer mockPDS.Close() 468 468 + 469 469 + handler := NewUpdateProfileHandler(mockBlobService, http.DefaultClient) 470 470 + 471 471 + reqBody := UpdateProfileRequest{ 472 472 + Bio: strPtr("This is my updated bio"), 473 473 + } 474 474 + body, _ := json.Marshal(reqBody) 475 475 + 476 476 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 477 477 + req.Header.Set("Content-Type", "application/json") 478 478 + 479 479 + testDID := "did:plc:testuser123" 480 480 + session := createTestOAuthSession(testDID) 481 481 + session.HostURL = mockPDS.URL 482 482 + ctx := setTestOAuthSession(req.Context(), testDID, session) 483 483 + req = req.WithContext(ctx) 484 484 + 485 485 + w := httptest.NewRecorder() 486 486 + handler.ServeHTTP(w, req) 487 487 + 488 488 + assert.Equal(t, http.StatusOK, w.Code) 489 489 + mockBlobService.AssertNotCalled(t, "UploadBlob", mock.Anything, mock.Anything, mock.Anything, mock.Anything) 490 490 + } 491 491 + 492 492 + // TestUpdateProfileHandler_FullUpdate tests updating displayName, bio, avatar, and banner 493 493 + func TestUpdateProfileHandler_FullUpdate(t *testing.T) { 494 494 + mockBlobService := new(MockBlobService) 495 495 + 496 496 + avatarData := []byte("avatar image data") 497 497 + bannerData := []byte("banner image data") 498 498 + 499 499 + avatarBlobRef := &blobs.BlobRef{ 500 500 + Type: "blob", 501 501 + Ref: map[string]string{"$link": "bafyreiavatarcid"}, 502 502 + MimeType: "image/jpeg", 503 503 + Size: len(avatarData), 504 504 + } 505 505 + bannerBlobRef := &blobs.BlobRef{ 506 506 + Type: "blob", 507 507 + Ref: map[string]string{"$link": "bafyreibannercid"}, 508 508 + MimeType: "image/png", 509 509 + Size: len(bannerData), 510 510 + } 511 511 + 512 512 + mockBlobService.On("UploadBlob", mock.Anything, mock.Anything, avatarData, "image/jpeg"). 513 513 + Return(avatarBlobRef, nil) 514 514 + mockBlobService.On("UploadBlob", mock.Anything, mock.Anything, bannerData, "image/png"). 515 515 + Return(bannerBlobRef, nil) 516 516 + 517 517 + // Mock PDS server for putRecord 518 518 + mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 519 519 + var putReq map[string]interface{} 520 520 + json.NewDecoder(r.Body).Decode(&putReq) 521 521 + 522 522 + record := putReq["record"].(map[string]interface{}) 523 523 + assert.Equal(t, "Full Update User", record["displayName"]) 524 524 + assert.Equal(t, "Updated bio with full profile", record["description"]) 525 525 + assert.NotNil(t, record["avatar"], "avatar should be set") 526 526 + assert.NotNil(t, record["banner"], "banner should be set") 527 527 + 528 528 + w.Header().Set("Content-Type", "application/json") 529 529 + json.NewEncoder(w).Encode(map[string]interface{}{ 530 530 + "uri": "at://did:plc:testuser123/app.bsky.actor.profile/self", 531 531 + "cid": "bafyreifullcid", 532 532 + }) 533 533 + })) 534 534 + defer mockPDS.Close() 535 535 + 536 536 + handler := NewUpdateProfileHandler(mockBlobService, http.DefaultClient) 537 537 + 538 538 + reqBody := UpdateProfileRequest{ 539 539 + DisplayName: strPtr("Full Update User"), 540 540 + Bio: strPtr("Updated bio with full profile"), 541 541 + AvatarBlob: avatarData, 542 542 + AvatarMimeType: "image/jpeg", 543 543 + BannerBlob: bannerData, 544 544 + BannerMimeType: "image/png", 545 545 + } 546 546 + body, _ := json.Marshal(reqBody) 547 547 + 548 548 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 549 549 + req.Header.Set("Content-Type", "application/json") 550 550 + 551 551 + testDID := "did:plc:testuser123" 552 552 + session := createTestOAuthSession(testDID) 553 553 + session.HostURL = mockPDS.URL 554 554 + ctx := setTestOAuthSession(req.Context(), testDID, session) 555 555 + req = req.WithContext(ctx) 556 556 + 557 557 + w := httptest.NewRecorder() 558 558 + handler.ServeHTTP(w, req) 559 559 + 560 560 + assert.Equal(t, http.StatusOK, w.Code) 561 561 + 562 562 + var response UpdateProfileResponse 563 563 + json.Unmarshal(w.Body.Bytes(), &response) 564 564 + assert.Contains(t, response.URI, "did:plc:testuser123") 565 565 + assert.Equal(t, "bafyreifullcid", response.CID) 566 566 + 567 567 + mockBlobService.AssertExpectations(t) 568 568 + } 569 569 + 570 570 + // TestUpdateProfileHandler_PDSPutRecordFailure tests handling of PDS putRecord failure 571 571 + func TestUpdateProfileHandler_PDSPutRecordFailure(t *testing.T) { 572 572 + mockBlobService := new(MockBlobService) 573 573 + 574 574 + // Mock PDS server that returns an error 575 575 + mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 576 576 + w.Header().Set("Content-Type", "application/json") 577 577 + w.WriteHeader(http.StatusInternalServerError) 578 578 + json.NewEncoder(w).Encode(map[string]interface{}{ 579 579 + "error": "InternalError", 580 580 + "message": "Failed to update record", 581 581 + }) 582 582 + })) 583 583 + defer mockPDS.Close() 584 584 + 585 585 + handler := NewUpdateProfileHandler(mockBlobService, http.DefaultClient) 586 586 + 587 587 + reqBody := UpdateProfileRequest{ 588 588 + DisplayName: strPtr("Test User"), 589 589 + } 590 590 + body, _ := json.Marshal(reqBody) 591 591 + 592 592 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 593 593 + req.Header.Set("Content-Type", "application/json") 594 594 + 595 595 + testDID := "did:plc:testuser123" 596 596 + session := createTestOAuthSession(testDID) 597 597 + session.HostURL = mockPDS.URL 598 598 + ctx := setTestOAuthSession(req.Context(), testDID, session) 599 599 + req = req.WithContext(ctx) 600 600 + 601 601 + w := httptest.NewRecorder() 602 602 + handler.ServeHTTP(w, req) 603 603 + 604 604 + assert.Equal(t, http.StatusInternalServerError, w.Code) 605 605 + assert.Contains(t, w.Body.String(), "Failed to update profile") 606 606 + } 607 607 + 608 608 + // TestUpdateProfileHandler_MethodNotAllowed tests that non-POST methods are rejected 609 609 + func TestUpdateProfileHandler_MethodNotAllowed(t *testing.T) { 610 610 + mockBlobService := new(MockBlobService) 611 611 + handler := NewUpdateProfileHandler(mockBlobService, nil) 612 612 + 613 613 + methods := []string{http.MethodGet, http.MethodPut, http.MethodDelete, http.MethodPatch} 614 614 + 615 615 + for _, method := range methods { 616 616 + t.Run(method, func(t *testing.T) { 617 617 + req := httptest.NewRequest(method, "/xrpc/social.coves.actor.updateProfile", nil) 618 618 + 619 619 + testDID := "did:plc:testuser123" 620 620 + session := createTestOAuthSession(testDID) 621 621 + ctx := setTestOAuthSession(req.Context(), testDID, session) 622 622 + req = req.WithContext(ctx) 623 623 + 624 624 + w := httptest.NewRecorder() 625 625 + handler.ServeHTTP(w, req) 626 626 + 627 627 + assert.Equal(t, http.StatusMethodNotAllowed, w.Code) 628 628 + }) 629 629 + } 630 630 + } 631 631 + 632 632 + // TestUpdateProfileHandler_AvatarBlobWithoutMimeType tests that providing blob without mime type fails 633 633 + func TestUpdateProfileHandler_AvatarBlobWithoutMimeType(t *testing.T) { 634 634 + mockBlobService := new(MockBlobService) 635 635 + handler := NewUpdateProfileHandler(mockBlobService, nil) 636 636 + 637 637 + reqBody := UpdateProfileRequest{ 638 638 + DisplayName: strPtr("Test User"), 639 639 + AvatarBlob: []byte("fake image data"), 640 640 + // Missing AvatarMimeType 641 641 + } 642 642 + body, _ := json.Marshal(reqBody) 643 643 + 644 644 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 645 645 + req.Header.Set("Content-Type", "application/json") 646 646 + 647 647 + testDID := "did:plc:testuser123" 648 648 + session := createTestOAuthSession(testDID) 649 649 + ctx := setTestOAuthSession(req.Context(), testDID, session) 650 650 + req = req.WithContext(ctx) 651 651 + 652 652 + w := httptest.NewRecorder() 653 653 + handler.ServeHTTP(w, req) 654 654 + 655 655 + assert.Equal(t, http.StatusBadRequest, w.Code) 656 656 + assert.Contains(t, w.Body.String(), "mime type") 657 657 + } 658 658 + 659 659 + // TestUpdateProfileHandler_BannerBlobWithoutMimeType tests that providing banner without mime type fails 660 660 + func TestUpdateProfileHandler_BannerBlobWithoutMimeType(t *testing.T) { 661 661 + mockBlobService := new(MockBlobService) 662 662 + handler := NewUpdateProfileHandler(mockBlobService, nil) 663 663 + 664 664 + reqBody := UpdateProfileRequest{ 665 665 + DisplayName: strPtr("Test User"), 666 666 + BannerBlob: []byte("fake image data"), 667 667 + // Missing BannerMimeType 668 668 + } 669 669 + body, _ := json.Marshal(reqBody) 670 670 + 671 671 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 672 672 + req.Header.Set("Content-Type", "application/json") 673 673 + 674 674 + testDID := "did:plc:testuser123" 675 675 + session := createTestOAuthSession(testDID) 676 676 + ctx := setTestOAuthSession(req.Context(), testDID, session) 677 677 + req = req.WithContext(ctx) 678 678 + 679 679 + w := httptest.NewRecorder() 680 680 + handler.ServeHTTP(w, req) 681 681 + 682 682 + assert.Equal(t, http.StatusBadRequest, w.Code) 683 683 + assert.Contains(t, w.Body.String(), "mime type") 684 684 + } 685 685 + 686 686 + // TestUpdateProfileHandler_UserBlobOwnerInterface tests that userBlobOwner correctly implements BlobOwner 687 687 + func TestUpdateProfileHandler_UserBlobOwnerInterface(t *testing.T) { 688 688 + owner := &userBlobOwner{ 689 689 + pdsURL: "https://test.pds.example", 690 690 + accessToken: "test-token-123", 691 691 + } 692 692 + 693 693 + // Verify interface compliance 694 694 + var _ blobs.BlobOwner = owner 695 695 + 696 696 + assert.Equal(t, "https://test.pds.example", owner.GetPDSURL()) 697 697 + assert.Equal(t, "test-token-123", owner.GetPDSAccessToken()) 698 698 + } 699 699 + 700 700 + // TestUpdateProfileHandler_EmptyRequest tests that empty request body is handled 701 701 + func TestUpdateProfileHandler_EmptyRequest(t *testing.T) { 702 702 + mockBlobService := new(MockBlobService) 703 703 + 704 704 + // Mock PDS server - even empty update should work 705 705 + mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 706 706 + w.Header().Set("Content-Type", "application/json") 707 707 + json.NewEncoder(w).Encode(map[string]interface{}{ 708 708 + "uri": "at://did:plc:testuser123/app.bsky.actor.profile/self", 709 709 + "cid": "bafyreicid123", 710 710 + }) 711 711 + })) 712 712 + defer mockPDS.Close() 713 713 + 714 714 + handler := NewUpdateProfileHandler(mockBlobService, http.DefaultClient) 715 715 + 716 716 + // Empty JSON object 717 717 + reqBody := UpdateProfileRequest{} 718 718 + body, _ := json.Marshal(reqBody) 719 719 + 720 720 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 721 721 + req.Header.Set("Content-Type", "application/json") 722 722 + 723 723 + testDID := "did:plc:testuser123" 724 724 + session := createTestOAuthSession(testDID) 725 725 + session.HostURL = mockPDS.URL 726 726 + ctx := setTestOAuthSession(req.Context(), testDID, session) 727 727 + req = req.WithContext(ctx) 728 728 + 729 729 + w := httptest.NewRecorder() 730 730 + handler.ServeHTTP(w, req) 731 731 + 732 732 + // Empty update is valid - just puts an empty profile record 733 733 + assert.Equal(t, http.StatusOK, w.Code) 734 734 + } 735 735 + 736 736 + // TestUpdateProfileHandler_PDSURLFromSession tests that PDS URL is correctly extracted from OAuth session 737 737 + func TestUpdateProfileHandler_PDSURLFromSession(t *testing.T) { 738 738 + mockBlobService := new(MockBlobService) 739 739 + 740 740 + mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 741 741 + // Verify request was received at the mock PDS 742 742 + assert.NotEmpty(t, r.URL.Path) 743 743 + w.Header().Set("Content-Type", "application/json") 744 744 + json.NewEncoder(w).Encode(map[string]interface{}{ 745 745 + "uri": "at://did:plc:testuser123/app.bsky.actor.profile/self", 746 746 + "cid": "bafyreicid123", 747 747 + }) 748 748 + })) 749 749 + defer mockPDS.Close() 750 750 + 751 751 + handler := NewUpdateProfileHandler(mockBlobService, http.DefaultClient) 752 752 + 753 753 + reqBody := UpdateProfileRequest{ 754 754 + DisplayName: strPtr("Test User"), 755 755 + } 756 756 + body, _ := json.Marshal(reqBody) 757 757 + 758 758 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 759 759 + req.Header.Set("Content-Type", "application/json") 760 760 + 761 761 + testDID := "did:plc:testuser123" 762 762 + session := createTestOAuthSession(testDID) 763 763 + // Use the mock server URL 764 764 + session.HostURL = mockPDS.URL 765 765 + ctx := setTestOAuthSession(req.Context(), testDID, session) 766 766 + req = req.WithContext(ctx) 767 767 + 768 768 + w := httptest.NewRecorder() 769 769 + handler.ServeHTTP(w, req) 770 770 + 771 771 + assert.Equal(t, http.StatusOK, w.Code) 772 772 + } 773 773 + 774 774 + // TestUpdateProfileHandler_AvatarExactly1MB tests boundary condition - avatar exactly 1MB should be accepted 775 775 + func TestUpdateProfileHandler_AvatarExactly1MB(t *testing.T) { 776 776 + mockBlobService := new(MockBlobService) 777 777 + 778 778 + // Create avatar blob exactly 1MB (1,000,000 bytes) 779 779 + avatarData := make([]byte, 1_000_000) 780 780 + 781 781 + expectedBlobRef := &blobs.BlobRef{ 782 782 + Type: "blob", 783 783 + Ref: map[string]string{"$link": "bafyreiabc123"}, 784 784 + MimeType: "image/jpeg", 785 785 + Size: len(avatarData), 786 786 + } 787 787 + mockBlobService.On("UploadBlob", mock.Anything, mock.Anything, avatarData, "image/jpeg"). 788 788 + Return(expectedBlobRef, nil) 789 789 + 790 790 + mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 791 791 + w.Header().Set("Content-Type", "application/json") 792 792 + json.NewEncoder(w).Encode(map[string]interface{}{ 793 793 + "uri": "at://did:plc:testuser123/app.bsky.actor.profile/self", 794 794 + "cid": "bafyreicid123", 795 795 + }) 796 796 + })) 797 797 + defer mockPDS.Close() 798 798 + 799 799 + handler := NewUpdateProfileHandler(mockBlobService, http.DefaultClient) 800 800 + 801 801 + reqBody := UpdateProfileRequest{ 802 802 + AvatarBlob: avatarData, 803 803 + AvatarMimeType: "image/jpeg", 804 804 + } 805 805 + body, _ := json.Marshal(reqBody) 806 806 + 807 807 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 808 808 + req.Header.Set("Content-Type", "application/json") 809 809 + 810 810 + testDID := "did:plc:testuser123" 811 811 + session := createTestOAuthSession(testDID) 812 812 + session.HostURL = mockPDS.URL 813 813 + ctx := setTestOAuthSession(req.Context(), testDID, session) 814 814 + req = req.WithContext(ctx) 815 815 + 816 816 + w := httptest.NewRecorder() 817 817 + handler.ServeHTTP(w, req) 818 818 + 819 819 + assert.Equal(t, http.StatusOK, w.Code) 820 820 + mockBlobService.AssertExpectations(t) 821 821 + } 822 822 + 823 823 + // TestUpdateProfileHandler_BannerExactly2MB tests boundary condition - banner exactly 2MB should be accepted 824 824 + func TestUpdateProfileHandler_BannerExactly2MB(t *testing.T) { 825 825 + mockBlobService := new(MockBlobService) 826 826 + 827 827 + // Create banner blob exactly 2MB (2,000,000 bytes) 828 828 + bannerData := make([]byte, 2_000_000) 829 829 + 830 830 + expectedBlobRef := &blobs.BlobRef{ 831 831 + Type: "blob", 832 832 + Ref: map[string]string{"$link": "bafyreiabc123"}, 833 833 + MimeType: "image/png", 834 834 + Size: len(bannerData), 835 835 + } 836 836 + mockBlobService.On("UploadBlob", mock.Anything, mock.Anything, bannerData, "image/png"). 837 837 + Return(expectedBlobRef, nil) 838 838 + 839 839 + mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 840 840 + w.Header().Set("Content-Type", "application/json") 841 841 + json.NewEncoder(w).Encode(map[string]interface{}{ 842 842 + "uri": "at://did:plc:testuser123/app.bsky.actor.profile/self", 843 843 + "cid": "bafyreicid123", 844 844 + }) 845 845 + })) 846 846 + defer mockPDS.Close() 847 847 + 848 848 + handler := NewUpdateProfileHandler(mockBlobService, http.DefaultClient) 849 849 + 850 850 + reqBody := UpdateProfileRequest{ 851 851 + BannerBlob: bannerData, 852 852 + BannerMimeType: "image/png", 853 853 + } 854 854 + body, _ := json.Marshal(reqBody) 855 855 + 856 856 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 857 857 + req.Header.Set("Content-Type", "application/json") 858 858 + 859 859 + testDID := "did:plc:testuser123" 860 860 + session := createTestOAuthSession(testDID) 861 861 + session.HostURL = mockPDS.URL 862 862 + ctx := setTestOAuthSession(req.Context(), testDID, session) 863 863 + req = req.WithContext(ctx) 864 864 + 865 865 + w := httptest.NewRecorder() 866 866 + handler.ServeHTTP(w, req) 867 867 + 868 868 + assert.Equal(t, http.StatusOK, w.Code) 869 869 + mockBlobService.AssertExpectations(t) 870 870 + } 871 871 + 872 872 + // TestUpdateProfileHandler_PDSNetworkError tests handling of network errors when calling PDS 873 873 + func TestUpdateProfileHandler_PDSNetworkError(t *testing.T) { 874 874 + mockBlobService := new(MockBlobService) 875 875 + 876 876 + // Create a handler with a client that will fail 877 877 + handler := NewUpdateProfileHandler(mockBlobService, http.DefaultClient) 878 878 + 879 879 + reqBody := UpdateProfileRequest{ 880 880 + DisplayName: strPtr("Test User"), 881 881 + } 882 882 + body, _ := json.Marshal(reqBody) 883 883 + 884 884 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 885 885 + req.Header.Set("Content-Type", "application/json") 886 886 + 887 887 + testDID := "did:plc:testuser123" 888 888 + session := createTestOAuthSession(testDID) 889 889 + // Use an invalid URL that will fail connection 890 890 + session.HostURL = "http://localhost:1" // Port 1 is typically refused 891 891 + ctx := setTestOAuthSession(req.Context(), testDID, session) 892 892 + req = req.WithContext(ctx) 893 893 + 894 894 + w := httptest.NewRecorder() 895 895 + handler.ServeHTTP(w, req) 896 896 + 897 897 + assert.Equal(t, http.StatusInternalServerError, w.Code) 898 898 + assert.Contains(t, w.Body.String(), "Failed to update profile") 899 899 + } 900 900 + 901 901 + // TestUpdateProfileHandler_ResponseFormat tests that response matches expected format 902 902 + func TestUpdateProfileHandler_ResponseFormat(t *testing.T) { 903 903 + mockBlobService := new(MockBlobService) 904 904 + 905 905 + expectedURI := "at://did:plc:testuser123/app.bsky.actor.profile/self" 906 906 + expectedCID := "bafyreicid456" 907 907 + 908 908 + mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 909 909 + w.Header().Set("Content-Type", "application/json") 910 910 + json.NewEncoder(w).Encode(map[string]interface{}{ 911 911 + "uri": expectedURI, 912 912 + "cid": expectedCID, 913 913 + }) 914 914 + })) 915 915 + defer mockPDS.Close() 916 916 + 917 917 + handler := NewUpdateProfileHandler(mockBlobService, http.DefaultClient) 918 918 + 919 919 + reqBody := UpdateProfileRequest{ 920 920 + DisplayName: strPtr("Test User"), 921 921 + } 922 922 + body, _ := json.Marshal(reqBody) 923 923 + 924 924 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 925 925 + req.Header.Set("Content-Type", "application/json") 926 926 + 927 927 + testDID := "did:plc:testuser123" 928 928 + session := createTestOAuthSession(testDID) 929 929 + session.HostURL = mockPDS.URL 930 930 + ctx := setTestOAuthSession(req.Context(), testDID, session) 931 931 + req = req.WithContext(ctx) 932 932 + 933 933 + w := httptest.NewRecorder() 934 934 + handler.ServeHTTP(w, req) 935 935 + 936 936 + assert.Equal(t, http.StatusOK, w.Code) 937 937 + 938 938 + var response UpdateProfileResponse 939 939 + err := json.Unmarshal(w.Body.Bytes(), &response) 940 940 + assert.NoError(t, err) 941 941 + assert.Equal(t, expectedURI, response.URI) 942 942 + assert.Equal(t, expectedCID, response.CID) 943 943 + } 944 944 + 945 945 + // Helper function to create string pointers 946 946 + func strPtr(s string) *string { 947 947 + return &s 948 948 + } 949 949 + 950 950 + // TestUserBlobOwner_ImplementsBlobOwnerInterface verifies interface compliance at compile time 951 951 + func TestUserBlobOwner_ImplementsBlobOwnerInterface(t *testing.T) { 952 952 + // This test ensures at compile time that userBlobOwner implements blobs.BlobOwner 953 953 + var owner blobs.BlobOwner = &userBlobOwner{ 954 954 + pdsURL: "https://test.example", 955 955 + accessToken: "token", 956 956 + } 957 957 + assert.NotNil(t, owner) 958 958 + } 959 959 + 960 960 + // TestUpdateProfileHandler_PDSReturnsEmptyURIOrCID tests handling when PDS returns 200 but with empty URI or CID 961 961 + func TestUpdateProfileHandler_PDSReturnsEmptyURIOrCID(t *testing.T) { 962 962 + testCases := []struct { 963 963 + name string 964 964 + response map[string]interface{} 965 965 + }{ 966 966 + { 967 967 + name: "empty URI", 968 968 + response: map[string]interface{}{ 969 969 + "uri": "", 970 970 + "cid": "bafyreicid123", 971 971 + }, 972 972 + }, 973 973 + { 974 974 + name: "empty CID", 975 975 + response: map[string]interface{}{ 976 976 + "uri": "at://did:plc:testuser123/app.bsky.actor.profile/self", 977 977 + "cid": "", 978 978 + }, 979 979 + }, 980 980 + { 981 981 + name: "missing URI", 982 982 + response: map[string]interface{}{ 983 983 + "cid": "bafyreicid123", 984 984 + }, 985 985 + }, 986 986 + { 987 987 + name: "missing CID", 988 988 + response: map[string]interface{}{ 989 989 + "uri": "at://did:plc:testuser123/app.bsky.actor.profile/self", 990 990 + }, 991 991 + }, 992 992 + { 993 993 + name: "both empty", 994 994 + response: map[string]interface{}{}, 995 995 + }, 996 996 + } 997 997 + 998 998 + for _, tc := range testCases { 999 999 + t.Run(tc.name, func(t *testing.T) { 1000 1000 + mockBlobService := new(MockBlobService) 1001 1001 + 1002 1002 + // Mock PDS server that returns 200 but with empty/missing fields 1003 1003 + mockPDS := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 1004 1004 + w.Header().Set("Content-Type", "application/json") 1005 1005 + w.WriteHeader(http.StatusOK) 1006 1006 + json.NewEncoder(w).Encode(tc.response) 1007 1007 + })) 1008 1008 + defer mockPDS.Close() 1009 1009 + 1010 1010 + handler := NewUpdateProfileHandler(mockBlobService, http.DefaultClient) 1011 1011 + 1012 1012 + reqBody := UpdateProfileRequest{ 1013 1013 + DisplayName: strPtr("Test User"), 1014 1014 + } 1015 1015 + body, _ := json.Marshal(reqBody) 1016 1016 + 1017 1017 + req := httptest.NewRequest(http.MethodPost, "/xrpc/social.coves.actor.updateProfile", bytes.NewReader(body)) 1018 1018 + req.Header.Set("Content-Type", "application/json") 1019 1019 + 1020 1020 + testDID := "did:plc:testuser123" 1021 1021 + session := createTestOAuthSession(testDID) 1022 1022 + session.HostURL = mockPDS.URL 1023 1023 + ctx := setTestOAuthSession(req.Context(), testDID, session) 1024 1024 + req = req.WithContext(ctx) 1025 1025 + 1026 1026 + w := httptest.NewRecorder() 1027 1027 + handler.ServeHTTP(w, req) 1028 1028 + 1029 1029 + // Should return an internal server error because URI/CID are required 1030 1030 + assert.Equal(t, http.StatusInternalServerError, w.Code) 1031 1031 + assert.Contains(t, w.Body.String(), "PDSError") 1032 1032 + }) 1033 1033 + } 1034 1034 + } 1035 1035 +

+8 -1

internal/api/routes/user.go

··· 3 3 import ( 4 4 "Coves/internal/api/handlers/user" 5 5 "Coves/internal/api/middleware" 6 6 + "Coves/internal/core/blobs" 6 7 "Coves/internal/core/users" 7 8 "encoding/json" 8 9 "errors" ··· 27 28 28 29 // RegisterUserRoutes registers user-related XRPC endpoints on the router 29 30 // Implements social.coves.actor.* lexicon endpoints 30 30 - func RegisterUserRoutes(r chi.Router, service users.UserService, authMiddleware *middleware.OAuthAuthMiddleware) { 31 31 + func RegisterUserRoutes(r chi.Router, service users.UserService, authMiddleware *middleware.OAuthAuthMiddleware, blobService blobs.Service) { 31 32 h := NewUserHandler(service) 32 33 33 34 // social.coves.actor.getprofile - query endpoint (public) ··· 41 42 // This ONLY deletes AppView indexed data, NOT the user's atProto identity on their PDS. 42 43 deleteHandler := user.NewDeleteHandler(service) 43 44 r.With(authMiddleware.RequireAuth).Post("/xrpc/social.coves.actor.deleteAccount", deleteHandler.HandleDeleteAccount) 45 45 + 46 46 + // social.coves.actor.updateProfile - procedure endpoint (authenticated) 47 47 + // Updates the authenticated user's profile on their PDS (avatar, banner, displayName, bio). 48 48 + // This writes directly to the user's PDS and the Jetstream consumer will index the change. 49 49 + updateProfileHandler := user.NewUpdateProfileHandler(blobService, nil) 50 50 + r.With(authMiddleware.RequireAuth).Post("/xrpc/social.coves.actor.updateProfile", updateProfileHandler.ServeHTTP) 44 51 } 45 52 46 53 // GetProfile handles social.coves.actor.getprofile

+105 -2

internal/atproto/jetstream/user_consumer.go

··· 8 8 "errors" 9 9 "fmt" 10 10 "log" 11 11 + "log/slog" 11 12 "sync" 12 13 "time" 13 14 ··· 196 197 return fmt.Errorf("failed to parse event: %w", err) 197 198 } 198 199 199 199 - // We're interested in identity events (handle updates) and account events (new users) 200 200 + // We're interested in identity events (handle updates), account events (new users), 201 201 + // and commit events (profile updates from app.bsky.actor.profile) 200 202 switch event.Kind { 201 203 case "identity": 202 204 return c.handleIdentityEvent(ctx, &event) 203 205 case "account": 204 206 return c.handleAccountEvent(ctx, &event) 207 207 + case "commit": 208 208 + return c.handleCommitEvent(ctx, &event) 205 209 default: 206 206 - // Ignore other event types (commits, etc.) 210 210 + // Ignore other event types 207 211 return nil 208 212 } 209 213 } ··· 298 302 // Users are indexed via OAuth login or signup, not from account events. 299 303 return nil 300 304 } 305 305 + 306 306 + // handleCommitEvent processes commit events for user profile updates 307 307 + // Only handles app.bsky.actor.profile collection for users already in our database. 308 308 + // This syncs profile data (displayName, bio, avatar, banner) from Bluesky profiles. 309 309 + func (c *UserEventConsumer) handleCommitEvent(ctx context.Context, event *JetstreamEvent) error { 310 310 + if event.Commit == nil { 311 311 + slog.Debug("received nil commit in handleCommitEvent", slog.String("did", event.Did)) 312 312 + return nil 313 313 + } 314 314 + 315 315 + // Only handle app.bsky.actor.profile collection 316 316 + if event.Commit.Collection != "app.bsky.actor.profile" { 317 317 + return nil 318 318 + } 319 319 + 320 320 + // Only process users who exist in our database 321 321 + _, err := c.userService.GetUserByDID(ctx, event.Did) 322 322 + if err != nil { 323 323 + if errors.Is(err, users.ErrUserNotFound) { 324 324 + // User doesn't exist in our database - skip this event 325 325 + // They'll be indexed when they actually interact with Coves 326 326 + return nil 327 327 + } 328 328 + // Database error - propagate so it can be retried 329 329 + return fmt.Errorf("failed to check if user exists: %w", err) 330 330 + } 331 331 + 332 332 + switch event.Commit.Operation { 333 333 + case "create", "update": 334 334 + return c.handleProfileUpdate(ctx, event.Did, event.Commit) 335 335 + case "delete": 336 336 + return c.handleProfileDelete(ctx, event.Did) 337 337 + default: 338 338 + return nil 339 339 + } 340 340 + } 341 341 + 342 342 + // handleProfileUpdate processes profile create/update operations 343 343 + // Extracts displayName, description (bio), avatar, and banner from the record 344 344 + func (c *UserEventConsumer) handleProfileUpdate(ctx context.Context, did string, commit *CommitEvent) error { 345 345 + if commit.Record == nil { 346 346 + slog.Debug("received nil record in profile commit", 347 347 + slog.String("did", did), 348 348 + slog.String("operation", string(commit.Operation))) 349 349 + return nil 350 350 + } 351 351 + 352 352 + input := users.UpdateProfileInput{} 353 353 + 354 354 + // Extract displayName 355 355 + if dn, ok := commit.Record["displayName"].(string); ok { 356 356 + input.DisplayName = &dn 357 357 + } 358 358 + 359 359 + // Extract description (bio) 360 360 + if desc, ok := commit.Record["description"].(string); ok { 361 361 + input.Bio = &desc 362 362 + } 363 363 + 364 364 + // Extract avatar CID from blob ref structure 365 365 + if avatarMap, ok := commit.Record["avatar"].(map[string]interface{}); ok { 366 366 + if cid, ok := extractBlobCID(avatarMap); ok { 367 367 + input.AvatarCID = &cid 368 368 + } 369 369 + } 370 370 + 371 371 + // Extract banner CID from blob ref structure 372 372 + if bannerMap, ok := commit.Record["banner"].(map[string]interface{}); ok { 373 373 + if cid, ok := extractBlobCID(bannerMap); ok { 374 374 + input.BannerCID = &cid 375 375 + } 376 376 + } 377 377 + 378 378 + _, err := c.userService.UpdateProfile(ctx, did, input) 379 379 + if err != nil { 380 380 + return fmt.Errorf("failed to update user profile: %w", err) 381 381 + } 382 382 + 383 383 + log.Printf("Updated profile for user %s", did) 384 384 + return nil 385 385 + } 386 386 + 387 387 + // handleProfileDelete processes profile delete operations 388 388 + // Clears all profile fields by passing empty strings 389 389 + func (c *UserEventConsumer) handleProfileDelete(ctx context.Context, did string) error { 390 390 + empty := "" 391 391 + input := users.UpdateProfileInput{ 392 392 + DisplayName: &empty, 393 393 + Bio: &empty, 394 394 + AvatarCID: &empty, 395 395 + BannerCID: &empty, 396 396 + } 397 397 + _, err := c.userService.UpdateProfile(ctx, did, input) 398 398 + if err != nil { 399 399 + return fmt.Errorf("failed to clear user profile: %w", err) 400 400 + } 401 401 + log.Printf("Cleared profile for user %s", did) 402 402 + return nil 403 403 + }

+816

internal/atproto/jetstream/user_consumer_test.go

··· 1 1 + package jetstream 2 2 + 3 3 + import ( 4 4 + "Coves/internal/atproto/identity" 5 5 + "Coves/internal/core/users" 6 6 + "context" 7 7 + "encoding/json" 8 8 + "errors" 9 9 + "testing" 10 10 + "time" 11 11 + ) 12 12 + 13 13 + // mockUserService is a test double for users.UserService 14 14 + type mockUserService struct { 15 15 + users map[string]*users.User 16 16 + updatedCalls []users.UpdateProfileInput 17 17 + updatedDIDs []string 18 18 + shouldFailGet bool 19 19 + getError error 20 20 + updateError error 21 21 + } 22 22 + 23 23 + func newMockUserService() *mockUserService { 24 24 + return &mockUserService{ 25 25 + users: make(map[string]*users.User), 26 26 + updatedCalls: []users.UpdateProfileInput{}, 27 27 + updatedDIDs: []string{}, 28 28 + } 29 29 + } 30 30 + 31 31 + func (m *mockUserService) CreateUser(ctx context.Context, req users.CreateUserRequest) (*users.User, error) { 32 32 + return nil, nil 33 33 + } 34 34 + 35 35 + func (m *mockUserService) GetUserByDID(ctx context.Context, did string) (*users.User, error) { 36 36 + if m.shouldFailGet { 37 37 + return nil, m.getError 38 38 + } 39 39 + user, exists := m.users[did] 40 40 + if !exists { 41 41 + return nil, users.ErrUserNotFound 42 42 + } 43 43 + return user, nil 44 44 + } 45 45 + 46 46 + func (m *mockUserService) GetUserByHandle(ctx context.Context, handle string) (*users.User, error) { 47 47 + return nil, nil 48 48 + } 49 49 + 50 50 + func (m *mockUserService) UpdateHandle(ctx context.Context, did, newHandle string) (*users.User, error) { 51 51 + return nil, nil 52 52 + } 53 53 + 54 54 + func (m *mockUserService) ResolveHandleToDID(ctx context.Context, handle string) (string, error) { 55 55 + return "", nil 56 56 + } 57 57 + 58 58 + func (m *mockUserService) RegisterAccount(ctx context.Context, req users.RegisterAccountRequest) (*users.RegisterAccountResponse, error) { 59 59 + return nil, nil 60 60 + } 61 61 + 62 62 + func (m *mockUserService) IndexUser(ctx context.Context, did, handle, pdsURL string) error { 63 63 + return nil 64 64 + } 65 65 + 66 66 + func (m *mockUserService) GetProfile(ctx context.Context, did string) (*users.ProfileViewDetailed, error) { 67 67 + return nil, nil 68 68 + } 69 69 + 70 70 + func (m *mockUserService) UpdateProfile(ctx context.Context, did string, input users.UpdateProfileInput) (*users.User, error) { 71 71 + if m.updateError != nil { 72 72 + return nil, m.updateError 73 73 + } 74 74 + m.updatedCalls = append(m.updatedCalls, input) 75 75 + m.updatedDIDs = append(m.updatedDIDs, did) 76 76 + user := m.users[did] 77 77 + if user == nil { 78 78 + return nil, users.ErrUserNotFound 79 79 + } 80 80 + // Apply updates to mock user 81 81 + if input.DisplayName != nil { 82 82 + user.DisplayName = *input.DisplayName 83 83 + } 84 84 + if input.Bio != nil { 85 85 + user.Bio = *input.Bio 86 86 + } 87 87 + if input.AvatarCID != nil { 88 88 + user.AvatarCID = *input.AvatarCID 89 89 + } 90 90 + if input.BannerCID != nil { 91 91 + user.BannerCID = *input.BannerCID 92 92 + } 93 93 + return user, nil 94 94 + } 95 95 + 96 96 + func (m *mockUserService) DeleteAccount(ctx context.Context, did string) error { 97 97 + return nil 98 98 + } 99 99 + 100 100 + // mockIdentityResolverForUser is a test double for identity.Resolver 101 101 + type mockIdentityResolverForUser struct{} 102 102 + 103 103 + func (m *mockIdentityResolverForUser) Resolve(ctx context.Context, identifier string) (*identity.Identity, error) { 104 104 + return nil, nil 105 105 + } 106 106 + 107 107 + func (m *mockIdentityResolverForUser) ResolveHandle(ctx context.Context, handle string) (string, string, error) { 108 108 + return "", "", nil 109 109 + } 110 110 + 111 111 + func (m *mockIdentityResolverForUser) ResolveDID(ctx context.Context, did string) (*identity.DIDDocument, error) { 112 112 + return nil, nil 113 113 + } 114 114 + 115 115 + func (m *mockIdentityResolverForUser) Purge(ctx context.Context, identifier string) error { 116 116 + return nil 117 117 + } 118 118 + 119 119 + func TestUserConsumer_HandleProfileCommit(t *testing.T) { 120 120 + t.Run("ignores commits for unknown collections", func(t *testing.T) { 121 121 + mockService := newMockUserService() 122 122 + mockResolver := &mockIdentityResolverForUser{} 123 123 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 124 124 + ctx := context.Background() 125 125 + 126 126 + // Event with a non-profile collection (e.g., social.coves.post) 127 127 + event := &JetstreamEvent{ 128 128 + Did: "did:plc:testuser123", 129 129 + TimeUS: time.Now().UnixMicro(), 130 130 + Kind: "commit", 131 131 + Commit: &CommitEvent{ 132 132 + Rev: "rev123", 133 133 + Operation: "create", 134 134 + Collection: "social.coves.post", // Not app.bsky.actor.profile 135 135 + RKey: "post123", 136 136 + CID: "bafy123", 137 137 + Record: map[string]interface{}{ 138 138 + "text": "Hello world", 139 139 + }, 140 140 + }, 141 141 + } 142 142 + 143 143 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 144 144 + if err != nil { 145 145 + t.Errorf("Expected no error for unknown collection, got: %v", err) 146 146 + } 147 147 + 148 148 + // Verify no UpdateProfile calls were made 149 149 + if len(mockService.updatedCalls) != 0 { 150 150 + t.Errorf("Expected 0 UpdateProfile calls, got %d", len(mockService.updatedCalls)) 151 151 + } 152 152 + }) 153 153 + 154 154 + t.Run("ignores commits for users not in database", func(t *testing.T) { 155 155 + mockService := newMockUserService() 156 156 + // Don't add any users - the user lookup will fail 157 157 + mockResolver := &mockIdentityResolverForUser{} 158 158 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 159 159 + ctx := context.Background() 160 160 + 161 161 + event := &JetstreamEvent{ 162 162 + Did: "did:plc:unknownuser", 163 163 + TimeUS: time.Now().UnixMicro(), 164 164 + Kind: "commit", 165 165 + Commit: &CommitEvent{ 166 166 + Rev: "rev123", 167 167 + Operation: "create", 168 168 + Collection: "app.bsky.actor.profile", 169 169 + RKey: "self", 170 170 + CID: "bafy123", 171 171 + Record: map[string]interface{}{ 172 172 + "displayName": "Unknown User", 173 173 + }, 174 174 + }, 175 175 + } 176 176 + 177 177 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 178 178 + // Should return nil (not an error) for users not in our database 179 179 + if err != nil { 180 180 + t.Errorf("Expected nil error for unknown user, got: %v", err) 181 181 + } 182 182 + 183 183 + // Verify no UpdateProfile calls were made 184 184 + if len(mockService.updatedCalls) != 0 { 185 185 + t.Errorf("Expected 0 UpdateProfile calls, got %d", len(mockService.updatedCalls)) 186 186 + } 187 187 + }) 188 188 + 189 189 + t.Run("extracts displayName from record", func(t *testing.T) { 190 190 + mockService := newMockUserService() 191 191 + mockService.users["did:plc:testuser"] = &users.User{ 192 192 + DID: "did:plc:testuser", 193 193 + Handle: "testuser.bsky.social", 194 194 + PDSURL: "https://bsky.social", 195 195 + } 196 196 + mockResolver := &mockIdentityResolverForUser{} 197 197 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 198 198 + ctx := context.Background() 199 199 + 200 200 + event := &JetstreamEvent{ 201 201 + Did: "did:plc:testuser", 202 202 + TimeUS: time.Now().UnixMicro(), 203 203 + Kind: "commit", 204 204 + Commit: &CommitEvent{ 205 205 + Rev: "rev123", 206 206 + Operation: "create", 207 207 + Collection: "app.bsky.actor.profile", 208 208 + RKey: "self", 209 209 + CID: "bafy123", 210 210 + Record: map[string]interface{}{ 211 211 + "displayName": "Test Display Name", 212 212 + }, 213 213 + }, 214 214 + } 215 215 + 216 216 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 217 217 + if err != nil { 218 218 + t.Fatalf("Expected no error, got: %v", err) 219 219 + } 220 220 + 221 221 + if len(mockService.updatedCalls) != 1 { 222 222 + t.Fatalf("Expected 1 UpdateProfile call, got %d", len(mockService.updatedCalls)) 223 223 + } 224 224 + 225 225 + call := mockService.updatedCalls[0] 226 226 + if call.DisplayName == nil || *call.DisplayName != "Test Display Name" { 227 227 + t.Errorf("Expected displayName 'Test Display Name', got %v", call.DisplayName) 228 228 + } 229 229 + }) 230 230 + 231 231 + t.Run("extracts description (bio) from record", func(t *testing.T) { 232 232 + mockService := newMockUserService() 233 233 + mockService.users["did:plc:testuser"] = &users.User{ 234 234 + DID: "did:plc:testuser", 235 235 + Handle: "testuser.bsky.social", 236 236 + PDSURL: "https://bsky.social", 237 237 + } 238 238 + mockResolver := &mockIdentityResolverForUser{} 239 239 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 240 240 + ctx := context.Background() 241 241 + 242 242 + event := &JetstreamEvent{ 243 243 + Did: "did:plc:testuser", 244 244 + TimeUS: time.Now().UnixMicro(), 245 245 + Kind: "commit", 246 246 + Commit: &CommitEvent{ 247 247 + Rev: "rev123", 248 248 + Operation: "create", 249 249 + Collection: "app.bsky.actor.profile", 250 250 + RKey: "self", 251 251 + CID: "bafy123", 252 252 + Record: map[string]interface{}{ 253 253 + "description": "This is my bio", 254 254 + }, 255 255 + }, 256 256 + } 257 257 + 258 258 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 259 259 + if err != nil { 260 260 + t.Fatalf("Expected no error, got: %v", err) 261 261 + } 262 262 + 263 263 + if len(mockService.updatedCalls) != 1 { 264 264 + t.Fatalf("Expected 1 UpdateProfile call, got %d", len(mockService.updatedCalls)) 265 265 + } 266 266 + 267 267 + call := mockService.updatedCalls[0] 268 268 + if call.Bio == nil || *call.Bio != "This is my bio" { 269 269 + t.Errorf("Expected bio 'This is my bio', got %v", call.Bio) 270 270 + } 271 271 + }) 272 272 + 273 273 + t.Run("extracts avatar CID from blob ref structure", func(t *testing.T) { 274 274 + mockService := newMockUserService() 275 275 + mockService.users["did:plc:testuser"] = &users.User{ 276 276 + DID: "did:plc:testuser", 277 277 + Handle: "testuser.bsky.social", 278 278 + PDSURL: "https://bsky.social", 279 279 + } 280 280 + mockResolver := &mockIdentityResolverForUser{} 281 281 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 282 282 + ctx := context.Background() 283 283 + 284 284 + event := &JetstreamEvent{ 285 285 + Did: "did:plc:testuser", 286 286 + TimeUS: time.Now().UnixMicro(), 287 287 + Kind: "commit", 288 288 + Commit: &CommitEvent{ 289 289 + Rev: "rev123", 290 290 + Operation: "create", 291 291 + Collection: "app.bsky.actor.profile", 292 292 + RKey: "self", 293 293 + CID: "bafy123", 294 294 + Record: map[string]interface{}{ 295 295 + "avatar": map[string]interface{}{ 296 296 + "$type": "blob", 297 297 + "ref": map[string]interface{}{"$link": "bafkavatar123"}, 298 298 + "mimeType": "image/jpeg", 299 299 + "size": float64(12345), 300 300 + }, 301 301 + }, 302 302 + }, 303 303 + } 304 304 + 305 305 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 306 306 + if err != nil { 307 307 + t.Fatalf("Expected no error, got: %v", err) 308 308 + } 309 309 + 310 310 + if len(mockService.updatedCalls) != 1 { 311 311 + t.Fatalf("Expected 1 UpdateProfile call, got %d", len(mockService.updatedCalls)) 312 312 + } 313 313 + 314 314 + call := mockService.updatedCalls[0] 315 315 + if call.AvatarCID == nil || *call.AvatarCID != "bafkavatar123" { 316 316 + t.Errorf("Expected avatar CID 'bafkavatar123', got %v", call.AvatarCID) 317 317 + } 318 318 + }) 319 319 + 320 320 + t.Run("extracts banner CID from blob ref structure", func(t *testing.T) { 321 321 + mockService := newMockUserService() 322 322 + mockService.users["did:plc:testuser"] = &users.User{ 323 323 + DID: "did:plc:testuser", 324 324 + Handle: "testuser.bsky.social", 325 325 + PDSURL: "https://bsky.social", 326 326 + } 327 327 + mockResolver := &mockIdentityResolverForUser{} 328 328 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 329 329 + ctx := context.Background() 330 330 + 331 331 + event := &JetstreamEvent{ 332 332 + Did: "did:plc:testuser", 333 333 + TimeUS: time.Now().UnixMicro(), 334 334 + Kind: "commit", 335 335 + Commit: &CommitEvent{ 336 336 + Rev: "rev123", 337 337 + Operation: "create", 338 338 + Collection: "app.bsky.actor.profile", 339 339 + RKey: "self", 340 340 + CID: "bafy123", 341 341 + Record: map[string]interface{}{ 342 342 + "banner": map[string]interface{}{ 343 343 + "$type": "blob", 344 344 + "ref": map[string]interface{}{"$link": "bafkbanner456"}, 345 345 + "mimeType": "image/png", 346 346 + "size": float64(54321), 347 347 + }, 348 348 + }, 349 349 + }, 350 350 + } 351 351 + 352 352 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 353 353 + if err != nil { 354 354 + t.Fatalf("Expected no error, got: %v", err) 355 355 + } 356 356 + 357 357 + if len(mockService.updatedCalls) != 1 { 358 358 + t.Fatalf("Expected 1 UpdateProfile call, got %d", len(mockService.updatedCalls)) 359 359 + } 360 360 + 361 361 + call := mockService.updatedCalls[0] 362 362 + if call.BannerCID == nil || *call.BannerCID != "bafkbanner456" { 363 363 + t.Errorf("Expected banner CID 'bafkbanner456', got %v", call.BannerCID) 364 364 + } 365 365 + }) 366 366 + 367 367 + t.Run("extracts all profile fields together", func(t *testing.T) { 368 368 + mockService := newMockUserService() 369 369 + mockService.users["did:plc:testuser"] = &users.User{ 370 370 + DID: "did:plc:testuser", 371 371 + Handle: "testuser.bsky.social", 372 372 + PDSURL: "https://bsky.social", 373 373 + } 374 374 + mockResolver := &mockIdentityResolverForUser{} 375 375 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 376 376 + ctx := context.Background() 377 377 + 378 378 + event := &JetstreamEvent{ 379 379 + Did: "did:plc:testuser", 380 380 + TimeUS: time.Now().UnixMicro(), 381 381 + Kind: "commit", 382 382 + Commit: &CommitEvent{ 383 383 + Rev: "rev123", 384 384 + Operation: "create", 385 385 + Collection: "app.bsky.actor.profile", 386 386 + RKey: "self", 387 387 + CID: "bafy123", 388 388 + Record: map[string]interface{}{ 389 389 + "displayName": "Full Profile User", 390 390 + "description": "A complete bio", 391 391 + "avatar": map[string]interface{}{ 392 392 + "$type": "blob", 393 393 + "ref": map[string]interface{}{"$link": "bafkfullav123"}, 394 394 + "mimeType": "image/jpeg", 395 395 + "size": float64(10000), 396 396 + }, 397 397 + "banner": map[string]interface{}{ 398 398 + "$type": "blob", 399 399 + "ref": map[string]interface{}{"$link": "bafkfullbn456"}, 400 400 + "mimeType": "image/png", 401 401 + "size": float64(20000), 402 402 + }, 403 403 + }, 404 404 + }, 405 405 + } 406 406 + 407 407 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 408 408 + if err != nil { 409 409 + t.Fatalf("Expected no error, got: %v", err) 410 410 + } 411 411 + 412 412 + if len(mockService.updatedCalls) != 1 { 413 413 + t.Fatalf("Expected 1 UpdateProfile call, got %d", len(mockService.updatedCalls)) 414 414 + } 415 415 + 416 416 + call := mockService.updatedCalls[0] 417 417 + if call.DisplayName == nil || *call.DisplayName != "Full Profile User" { 418 418 + t.Errorf("Expected displayName 'Full Profile User', got %v", call.DisplayName) 419 419 + } 420 420 + if call.Bio == nil || *call.Bio != "A complete bio" { 421 421 + t.Errorf("Expected bio 'A complete bio', got %v", call.Bio) 422 422 + } 423 423 + if call.AvatarCID == nil || *call.AvatarCID != "bafkfullav123" { 424 424 + t.Errorf("Expected avatar CID 'bafkfullav123', got %v", call.AvatarCID) 425 425 + } 426 426 + if call.BannerCID == nil || *call.BannerCID != "bafkfullbn456" { 427 427 + t.Errorf("Expected banner CID 'bafkfullbn456', got %v", call.BannerCID) 428 428 + } 429 429 + }) 430 430 + 431 431 + t.Run("handles delete operation by clearing profile fields", func(t *testing.T) { 432 432 + mockService := newMockUserService() 433 433 + mockService.users["did:plc:testuser"] = &users.User{ 434 434 + DID: "did:plc:testuser", 435 435 + Handle: "testuser.bsky.social", 436 436 + PDSURL: "https://bsky.social", 437 437 + DisplayName: "Existing Name", 438 438 + Bio: "Existing Bio", 439 439 + AvatarCID: "existingavatar", 440 440 + BannerCID: "existingbanner", 441 441 + } 442 442 + mockResolver := &mockIdentityResolverForUser{} 443 443 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 444 444 + ctx := context.Background() 445 445 + 446 446 + event := &JetstreamEvent{ 447 447 + Did: "did:plc:testuser", 448 448 + TimeUS: time.Now().UnixMicro(), 449 449 + Kind: "commit", 450 450 + Commit: &CommitEvent{ 451 451 + Rev: "rev123", 452 452 + Operation: "delete", 453 453 + Collection: "app.bsky.actor.profile", 454 454 + RKey: "self", 455 455 + }, 456 456 + } 457 457 + 458 458 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 459 459 + if err != nil { 460 460 + t.Fatalf("Expected no error, got: %v", err) 461 461 + } 462 462 + 463 463 + if len(mockService.updatedCalls) != 1 { 464 464 + t.Fatalf("Expected 1 UpdateProfile call, got %d", len(mockService.updatedCalls)) 465 465 + } 466 466 + 467 467 + call := mockService.updatedCalls[0] 468 468 + // Delete should pass empty strings to clear fields 469 469 + if call.DisplayName == nil || *call.DisplayName != "" { 470 470 + t.Errorf("Expected empty displayName for delete, got %v", call.DisplayName) 471 471 + } 472 472 + if call.Bio == nil || *call.Bio != "" { 473 473 + t.Errorf("Expected empty bio for delete, got %v", call.Bio) 474 474 + } 475 475 + if call.AvatarCID == nil || *call.AvatarCID != "" { 476 476 + t.Errorf("Expected empty avatar CID for delete, got %v", call.AvatarCID) 477 477 + } 478 478 + if call.BannerCID == nil || *call.BannerCID != "" { 479 479 + t.Errorf("Expected empty banner CID for delete, got %v", call.BannerCID) 480 480 + } 481 481 + }) 482 482 + 483 483 + t.Run("handles update operation same as create", func(t *testing.T) { 484 484 + mockService := newMockUserService() 485 485 + mockService.users["did:plc:testuser"] = &users.User{ 486 486 + DID: "did:plc:testuser", 487 487 + Handle: "testuser.bsky.social", 488 488 + PDSURL: "https://bsky.social", 489 489 + DisplayName: "Old Name", 490 490 + } 491 491 + mockResolver := &mockIdentityResolverForUser{} 492 492 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 493 493 + ctx := context.Background() 494 494 + 495 495 + event := &JetstreamEvent{ 496 496 + Did: "did:plc:testuser", 497 497 + TimeUS: time.Now().UnixMicro(), 498 498 + Kind: "commit", 499 499 + Commit: &CommitEvent{ 500 500 + Rev: "rev124", 501 501 + Operation: "update", // Update operation instead of create 502 502 + Collection: "app.bsky.actor.profile", 503 503 + RKey: "self", 504 504 + CID: "bafy456", 505 505 + Record: map[string]interface{}{ 506 506 + "displayName": "Updated Name", 507 507 + "description": "Updated bio", 508 508 + }, 509 509 + }, 510 510 + } 511 511 + 512 512 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 513 513 + if err != nil { 514 514 + t.Fatalf("Expected no error, got: %v", err) 515 515 + } 516 516 + 517 517 + if len(mockService.updatedCalls) != 1 { 518 518 + t.Fatalf("Expected 1 UpdateProfile call, got %d", len(mockService.updatedCalls)) 519 519 + } 520 520 + 521 521 + call := mockService.updatedCalls[0] 522 522 + if call.DisplayName == nil || *call.DisplayName != "Updated Name" { 523 523 + t.Errorf("Expected displayName 'Updated Name', got %v", call.DisplayName) 524 524 + } 525 525 + if call.Bio == nil || *call.Bio != "Updated bio" { 526 526 + t.Errorf("Expected bio 'Updated bio', got %v", call.Bio) 527 527 + } 528 528 + }) 529 529 + 530 530 + t.Run("propagates database errors from GetUserByDID", func(t *testing.T) { 531 531 + mockService := newMockUserService() 532 532 + mockService.shouldFailGet = true 533 533 + mockService.getError = errors.New("database connection error") 534 534 + mockResolver := &mockIdentityResolverForUser{} 535 535 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 536 536 + ctx := context.Background() 537 537 + 538 538 + event := &JetstreamEvent{ 539 539 + Did: "did:plc:testuser", 540 540 + TimeUS: time.Now().UnixMicro(), 541 541 + Kind: "commit", 542 542 + Commit: &CommitEvent{ 543 543 + Rev: "rev123", 544 544 + Operation: "create", 545 545 + Collection: "app.bsky.actor.profile", 546 546 + RKey: "self", 547 547 + CID: "bafy123", 548 548 + Record: map[string]interface{}{ 549 549 + "displayName": "Test User", 550 550 + }, 551 551 + }, 552 552 + } 553 553 + 554 554 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 555 555 + if err == nil { 556 556 + t.Fatal("Expected error for database failure, got nil") 557 557 + } 558 558 + if !errors.Is(err, mockService.getError) && err.Error() != "failed to check if user exists: database connection error" { 559 559 + t.Errorf("Expected wrapped database error, got: %v", err) 560 560 + } 561 561 + }) 562 562 + 563 563 + t.Run("handles nil commit gracefully", func(t *testing.T) { 564 564 + mockService := newMockUserService() 565 565 + mockResolver := &mockIdentityResolverForUser{} 566 566 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 567 567 + ctx := context.Background() 568 568 + 569 569 + event := &JetstreamEvent{ 570 570 + Did: "did:plc:testuser", 571 571 + TimeUS: time.Now().UnixMicro(), 572 572 + Kind: "commit", 573 573 + Commit: nil, // No commit data 574 574 + } 575 575 + 576 576 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 577 577 + if err != nil { 578 578 + t.Errorf("Expected no error for nil commit, got: %v", err) 579 579 + } 580 580 + }) 581 581 + 582 582 + t.Run("handles nil record in commit gracefully", func(t *testing.T) { 583 583 + mockService := newMockUserService() 584 584 + mockService.users["did:plc:testuser"] = &users.User{ 585 585 + DID: "did:plc:testuser", 586 586 + Handle: "testuser.bsky.social", 587 587 + PDSURL: "https://bsky.social", 588 588 + } 589 589 + mockResolver := &mockIdentityResolverForUser{} 590 590 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 591 591 + ctx := context.Background() 592 592 + 593 593 + event := &JetstreamEvent{ 594 594 + Did: "did:plc:testuser", 595 595 + TimeUS: time.Now().UnixMicro(), 596 596 + Kind: "commit", 597 597 + Commit: &CommitEvent{ 598 598 + Rev: "rev123", 599 599 + Operation: "create", 600 600 + Collection: "app.bsky.actor.profile", 601 601 + RKey: "self", 602 602 + CID: "bafy123", 603 603 + Record: nil, // No record data 604 604 + }, 605 605 + } 606 606 + 607 607 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 608 608 + if err != nil { 609 609 + t.Errorf("Expected no error for nil record, got: %v", err) 610 610 + } 611 611 + }) 612 612 + 613 613 + t.Run("handles invalid blob structure gracefully", func(t *testing.T) { 614 614 + mockService := newMockUserService() 615 615 + mockService.users["did:plc:testuser"] = &users.User{ 616 616 + DID: "did:plc:testuser", 617 617 + Handle: "testuser.bsky.social", 618 618 + PDSURL: "https://bsky.social", 619 619 + } 620 620 + mockResolver := &mockIdentityResolverForUser{} 621 621 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 622 622 + ctx := context.Background() 623 623 + 624 624 + event := &JetstreamEvent{ 625 625 + Did: "did:plc:testuser", 626 626 + TimeUS: time.Now().UnixMicro(), 627 627 + Kind: "commit", 628 628 + Commit: &CommitEvent{ 629 629 + Rev: "rev123", 630 630 + Operation: "create", 631 631 + Collection: "app.bsky.actor.profile", 632 632 + RKey: "self", 633 633 + CID: "bafy123", 634 634 + Record: map[string]interface{}{ 635 635 + "displayName": "Test User", 636 636 + "avatar": map[string]interface{}{ 637 637 + "$type": "not-a-blob", // Invalid type 638 638 + }, 639 639 + "banner": "not-a-map", // Invalid structure 640 640 + }, 641 641 + }, 642 642 + } 643 643 + 644 644 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 645 645 + if err != nil { 646 646 + t.Fatalf("Expected no error, got: %v", err) 647 647 + } 648 648 + 649 649 + if len(mockService.updatedCalls) != 1 { 650 650 + t.Fatalf("Expected 1 UpdateProfile call, got %d", len(mockService.updatedCalls)) 651 651 + } 652 652 + 653 653 + call := mockService.updatedCalls[0] 654 654 + // displayName should be extracted 655 655 + if call.DisplayName == nil || *call.DisplayName != "Test User" { 656 656 + t.Errorf("Expected displayName 'Test User', got %v", call.DisplayName) 657 657 + } 658 658 + // Avatar and banner should be nil (not extracted due to invalid structure) 659 659 + if call.AvatarCID != nil { 660 660 + t.Errorf("Expected nil avatar CID for invalid blob, got %v", call.AvatarCID) 661 661 + } 662 662 + if call.BannerCID != nil { 663 663 + t.Errorf("Expected nil banner CID for invalid structure, got %v", call.BannerCID) 664 664 + } 665 665 + }) 666 666 + } 667 667 + 668 668 + func TestUserConsumer_PropagatesUpdateProfileError(t *testing.T) { 669 669 + t.Run("propagates_database_errors_from_UpdateProfile", func(t *testing.T) { 670 670 + mockService := newMockUserService() 671 671 + mockService.users["did:plc:testuser"] = &users.User{ 672 672 + DID: "did:plc:testuser", 673 673 + Handle: "testuser.bsky.social", 674 674 + PDSURL: "https://bsky.social", 675 675 + } 676 676 + mockService.updateError = errors.New("database write error") 677 677 + mockResolver := &mockIdentityResolverForUser{} 678 678 + consumer := NewUserEventConsumer(mockService, mockResolver, "wss://jetstream.example.com", "") 679 679 + ctx := context.Background() 680 680 + 681 681 + event := &JetstreamEvent{ 682 682 + Did: "did:plc:testuser", 683 683 + TimeUS: time.Now().UnixMicro(), 684 684 + Kind: "commit", 685 685 + Commit: &CommitEvent{ 686 686 + Rev: "rev123", 687 687 + Operation: "create", 688 688 + Collection: "app.bsky.actor.profile", 689 689 + RKey: "self", 690 690 + CID: "bafy123", 691 691 + Record: map[string]interface{}{ 692 692 + "displayName": "Test User", 693 693 + }, 694 694 + }, 695 695 + } 696 696 + 697 697 + err := consumer.handleEvent(ctx, mustMarshalEvent(event)) 698 698 + if err == nil { 699 699 + t.Fatal("Expected error for UpdateProfile failure, got nil") 700 700 + } 701 701 + if !errors.Is(err, mockService.updateError) && err.Error() != "failed to update user profile: database write error" { 702 702 + t.Errorf("Expected wrapped database error, got: %v", err) 703 703 + } 704 704 + }) 705 705 + } 706 706 + 707 707 + func TestExtractBlobCID(t *testing.T) { 708 708 + t.Run("extracts CID from valid blob structure", func(t *testing.T) { 709 709 + blob := map[string]interface{}{ 710 710 + "$type": "blob", 711 711 + "ref": map[string]interface{}{"$link": "bafktest123"}, 712 712 + "mimeType": "image/jpeg", 713 713 + "size": float64(12345), 714 714 + } 715 715 + 716 716 + cid, ok := extractBlobCID(blob) 717 717 + if !ok { 718 718 + t.Fatal("Expected successful extraction") 719 719 + } 720 720 + if cid != "bafktest123" { 721 721 + t.Errorf("Expected CID 'bafktest123', got '%s'", cid) 722 722 + } 723 723 + }) 724 724 + 725 725 + t.Run("returns false for nil blob", func(t *testing.T) { 726 726 + cid, ok := extractBlobCID(nil) 727 727 + if ok { 728 728 + t.Error("Expected false for nil blob") 729 729 + } 730 730 + if cid != "" { 731 731 + t.Errorf("Expected empty CID for nil blob, got '%s'", cid) 732 732 + } 733 733 + }) 734 734 + 735 735 + t.Run("returns false for wrong $type", func(t *testing.T) { 736 736 + blob := map[string]interface{}{ 737 737 + "$type": "image", 738 738 + "ref": map[string]interface{}{"$link": "bafktest123"}, 739 739 + } 740 740 + 741 741 + cid, ok := extractBlobCID(blob) 742 742 + if ok { 743 743 + t.Error("Expected false for wrong $type") 744 744 + } 745 745 + if cid != "" { 746 746 + t.Errorf("Expected empty CID for wrong type, got '%s'", cid) 747 747 + } 748 748 + }) 749 749 + 750 750 + t.Run("returns false for missing $type", func(t *testing.T) { 751 751 + blob := map[string]interface{}{ 752 752 + "ref": map[string]interface{}{"$link": "bafktest123"}, 753 753 + } 754 754 + 755 755 + cid, ok := extractBlobCID(blob) 756 756 + if ok { 757 757 + t.Error("Expected false for missing $type") 758 758 + } 759 759 + if cid != "" { 760 760 + t.Errorf("Expected empty CID for missing type, got '%s'", cid) 761 761 + } 762 762 + }) 763 763 + 764 764 + t.Run("returns false for missing ref", func(t *testing.T) { 765 765 + blob := map[string]interface{}{ 766 766 + "$type": "blob", 767 767 + } 768 768 + 769 769 + cid, ok := extractBlobCID(blob) 770 770 + if ok { 771 771 + t.Error("Expected false for missing ref") 772 772 + } 773 773 + if cid != "" { 774 774 + t.Errorf("Expected empty CID for missing ref, got '%s'", cid) 775 775 + } 776 776 + }) 777 777 + 778 778 + t.Run("returns false for missing $link", func(t *testing.T) { 779 779 + blob := map[string]interface{}{ 780 780 + "$type": "blob", 781 781 + "ref": map[string]interface{}{}, 782 782 + } 783 783 + 784 784 + cid, ok := extractBlobCID(blob) 785 785 + if ok { 786 786 + t.Error("Expected false for missing $link") 787 787 + } 788 788 + if cid != "" { 789 789 + t.Errorf("Expected empty CID for missing link, got '%s'", cid) 790 790 + } 791 791 + }) 792 792 + 793 793 + t.Run("returns false for non-map ref", func(t *testing.T) { 794 794 + blob := map[string]interface{}{ 795 795 + "$type": "blob", 796 796 + "ref": "not-a-map", 797 797 + } 798 798 + 799 799 + cid, ok := extractBlobCID(blob) 800 800 + if ok { 801 801 + t.Error("Expected false for non-map ref") 802 802 + } 803 803 + if cid != "" { 804 804 + t.Errorf("Expected empty CID for non-map ref, got '%s'", cid) 805 805 + } 806 806 + }) 807 807 + } 808 808 + 809 809 + // mustMarshalEvent marshals an event to JSON bytes for testing 810 810 + func mustMarshalEvent(event *JetstreamEvent) []byte { 811 811 + data, err := json.Marshal(event) 812 812 + if err != nil { 813 813 + panic(err) 814 814 + } 815 815 + return data 816 816 + }

+20

internal/core/comments/comment_service_test.go

··· 209 209 return nil 210 210 } 211 211 212 212 + func (m *mockUserRepo) UpdateProfile(ctx context.Context, did string, input users.UpdateProfileInput) (*users.User, error) { 213 213 + user, exists := m.users[did] 214 214 + if !exists { 215 215 + return nil, users.ErrUserNotFound 216 216 + } 217 217 + if input.DisplayName != nil { 218 218 + user.DisplayName = *input.DisplayName 219 219 + } 220 220 + if input.Bio != nil { 221 221 + user.Bio = *input.Bio 222 222 + } 223 223 + if input.AvatarCID != nil { 224 224 + user.AvatarCID = *input.AvatarCID 225 225 + } 226 226 + if input.BannerCID != nil { 227 227 + user.BannerCID = *input.BannerCID 228 228 + } 229 229 + return user, nil 230 230 + } 231 231 + 212 232 // mockPostRepo is a mock implementation of the posts.Repository interface 213 233 type mockPostRepo struct { 214 234 posts map[string]*posts.Post

+25

internal/core/users/interfaces.go

··· 2 2 3 3 import "context" 4 4 5 5 + // UpdateProfileInput contains the fields that can be updated on a user's profile. 6 6 + // Nil values mean "don't change this field" - only non-nil values are updated. 7 7 + // Empty string values (*string pointing to "") will clear the field in the database. 8 8 + type UpdateProfileInput struct { 9 9 + DisplayName *string 10 10 + Bio *string 11 11 + AvatarCID *string 12 12 + BannerCID *string 13 13 + } 14 14 + 5 15 // UserRepository defines the interface for user data persistence 6 16 type UserRepository interface { 7 17 Create(ctx context.Context, user *User) (*User, error) ··· 34 44 // Returns counts of posts, comments, subscriptions, memberships, and total reputation. 35 45 GetProfileStats(ctx context.Context, did string) (*ProfileStats, error) 36 46 47 47 + // UpdateProfile updates a user's profile fields (display name, bio, avatar, banner). 48 48 + // Nil values in the input mean "don't change this field" - only non-nil values are updated. 49 49 + // Empty string values will clear the field in the database. 50 50 + // Returns the updated user with all fields populated. 51 51 + // Returns ErrUserNotFound if the user does not exist. 52 52 + UpdateProfile(ctx context.Context, did string, input UpdateProfileInput) (*User, error) 53 53 + 37 54 // Delete removes a user and all associated data from the AppView database. 38 55 // This performs a cascading delete across all tables that reference the user's DID. 39 56 // The operation is atomic - either all data is deleted or none. ··· 72 89 73 90 // GetProfile retrieves a user's full profile with aggregated statistics. 74 91 // Returns a ProfileViewDetailed matching the social.coves.actor.defs#profileViewDetailed lexicon. 92 92 + // Avatar and Banner CIDs are transformed to URLs using the user's PDS URL. 75 93 GetProfile(ctx context.Context, did string) (*ProfileViewDetailed, error) 94 94 + 95 95 + // UpdateProfile updates a user's profile fields (display name, bio, avatar, banner). 96 96 + // Nil values in the input mean "don't change this field" - only non-nil values are updated. 97 97 + // Empty string values will clear the field in the database. 98 98 + // Returns the updated user with all fields populated. 99 99 + // Returns ErrUserNotFound if the user does not exist. 100 100 + UpdateProfile(ctx context.Context, did string, input UpdateProfileInput) (*User, error) 76 101 77 102 // DeleteAccount removes a user and all associated data from the Coves AppView. 78 103 // This ONLY deletes AppView indexed data, NOT the user's atProto identity on their PDS.

+37 -6

internal/core/users/service.go

··· 266 266 267 267 // GetProfile retrieves a user's full profile with aggregated statistics. 268 268 // Returns a ProfileViewDetailed matching the social.coves.actor.defs#profileViewDetailed lexicon. 269 269 + // Avatar and Banner CIDs are transformed to URLs using the user's PDS URL. 269 270 func (s *userService) GetProfile(ctx context.Context, did string) (*ProfileViewDetailed, error) { 270 271 did = strings.TrimSpace(did) 271 272 if did == "" { ··· 284 285 return nil, fmt.Errorf("failed to get profile stats: %w", err) 285 286 } 286 287 287 287 - return &ProfileViewDetailed{ 288 288 - DID: user.DID, 289 289 - Handle: user.Handle, 290 290 - CreatedAt: user.CreatedAt, 291 291 - Stats: stats, 292 292 - }, nil 288 288 + profile := &ProfileViewDetailed{ 289 289 + DID: user.DID, 290 290 + Handle: user.Handle, 291 291 + CreatedAt: user.CreatedAt, 292 292 + Stats: stats, 293 293 + DisplayName: user.DisplayName, 294 294 + Bio: user.Bio, 295 295 + } 296 296 + 297 297 + // Transform avatar CID to URL if both CID and PDS URL are present 298 298 + if user.AvatarCID != "" && user.PDSURL != "" { 299 299 + profile.Avatar = fmt.Sprintf("%s/xrpc/com.atproto.sync.getBlob?did=%s&cid=%s", 300 300 + strings.TrimSuffix(user.PDSURL, "/"), user.DID, user.AvatarCID) 301 301 + } 302 302 + 303 303 + // Transform banner CID to URL if both CID and PDS URL are present 304 304 + if user.BannerCID != "" && user.PDSURL != "" { 305 305 + profile.Banner = fmt.Sprintf("%s/xrpc/com.atproto.sync.getBlob?did=%s&cid=%s", 306 306 + strings.TrimSuffix(user.PDSURL, "/"), user.DID, user.BannerCID) 307 307 + } 308 308 + 309 309 + return profile, nil 310 310 + } 311 311 + 312 312 + // UpdateProfile updates a user's profile fields (display name, bio, avatar, banner). 313 313 + // Nil values in the input mean "don't change this field" - only non-nil values are updated. 314 314 + // Empty string values will clear the field in the database. 315 315 + // Returns the updated user with all fields populated. 316 316 + // Returns ErrUserNotFound if the user does not exist. 317 317 + func (s *userService) UpdateProfile(ctx context.Context, did string, input UpdateProfileInput) (*User, error) { 318 318 + did = strings.TrimSpace(did) 319 319 + if did == "" { 320 320 + return nil, fmt.Errorf("DID is required") 321 321 + } 322 322 + 323 323 + return s.userRepo.UpdateProfile(ctx, did, input) 293 324 } 294 325 295 326 func (s *userService) validateCreateRequest(req CreateUserRequest) error {

+376

internal/core/users/service_test.go

··· 71 71 return args.Error(0) 72 72 } 73 73 74 74 + func (m *MockUserRepository) UpdateProfile(ctx context.Context, did string, input UpdateProfileInput) (*User, error) { 75 75 + args := m.Called(ctx, did, input) 76 76 + if args.Get(0) == nil { 77 77 + return nil, args.Error(1) 78 78 + } 79 79 + return args.Get(0).(*User), args.Error(1) 80 80 + } 81 81 + 74 82 // MockIdentityResolver is a mock implementation of identity.Resolver 75 83 type MockIdentityResolver struct { 76 84 mock.Mock ··· 465 473 466 474 mockRepo.AssertExpectations(t) 467 475 } 476 476 + 477 477 + // TestGetProfile_WithAvatarAndBanner tests that GetProfile transforms CIDs to URLs 478 478 + func TestGetProfile_WithAvatarAndBanner(t *testing.T) { 479 479 + mockRepo := new(MockUserRepository) 480 480 + mockResolver := new(MockIdentityResolver) 481 481 + 482 482 + testDID := "did:plc:avataruser" 483 483 + testUser := &User{ 484 484 + DID: testDID, 485 485 + Handle: "avataruser.test", 486 486 + PDSURL: "https://test.pds", 487 487 + DisplayName: "Avatar User", 488 488 + Bio: "Test bio for avatar user", 489 489 + AvatarCID: "bafkreiabc123avatar", 490 490 + BannerCID: "bafkreixyz789banner", 491 491 + CreatedAt: time.Now(), 492 492 + } 493 493 + testStats := &ProfileStats{ 494 494 + PostCount: 5, 495 495 + CommentCount: 10, 496 496 + CommunityCount: 2, 497 497 + MembershipCount: 1, 498 498 + Reputation: 50, 499 499 + } 500 500 + 501 501 + mockRepo.On("GetByDID", mock.Anything, testDID).Return(testUser, nil) 502 502 + mockRepo.On("GetProfileStats", mock.Anything, testDID).Return(testStats, nil) 503 503 + 504 504 + service := NewUserService(mockRepo, mockResolver, "https://default.pds") 505 505 + ctx := context.Background() 506 506 + 507 507 + profile, err := service.GetProfile(ctx, testDID) 508 508 + require.NoError(t, err) 509 509 + 510 510 + // Verify basic fields 511 511 + assert.Equal(t, testDID, profile.DID) 512 512 + assert.Equal(t, "avataruser.test", profile.Handle) 513 513 + assert.Equal(t, "Avatar User", profile.DisplayName) 514 514 + assert.Equal(t, "Test bio for avatar user", profile.Bio) 515 515 + 516 516 + // Verify CID-to-URL transformation 517 517 + expectedAvatarURL := "https://test.pds/xrpc/com.atproto.sync.getBlob?did=did:plc:avataruser&cid=bafkreiabc123avatar" 518 518 + expectedBannerURL := "https://test.pds/xrpc/com.atproto.sync.getBlob?did=did:plc:avataruser&cid=bafkreixyz789banner" 519 519 + assert.Equal(t, expectedAvatarURL, profile.Avatar) 520 520 + assert.Equal(t, expectedBannerURL, profile.Banner) 521 521 + 522 522 + mockRepo.AssertExpectations(t) 523 523 + } 524 524 + 525 525 + // TestGetProfile_WithAvatarOnly tests GetProfile with only avatar CID set 526 526 + func TestGetProfile_WithAvatarOnly(t *testing.T) { 527 527 + mockRepo := new(MockUserRepository) 528 528 + mockResolver := new(MockIdentityResolver) 529 529 + 530 530 + testDID := "did:plc:avataronly" 531 531 + testUser := &User{ 532 532 + DID: testDID, 533 533 + Handle: "avataronly.test", 534 534 + PDSURL: "https://test.pds", 535 535 + DisplayName: "Avatar Only User", 536 536 + Bio: "", 537 537 + AvatarCID: "bafkreiavataronly", 538 538 + BannerCID: "", // No banner 539 539 + CreatedAt: time.Now(), 540 540 + } 541 541 + testStats := &ProfileStats{} 542 542 + 543 543 + mockRepo.On("GetByDID", mock.Anything, testDID).Return(testUser, nil) 544 544 + mockRepo.On("GetProfileStats", mock.Anything, testDID).Return(testStats, nil) 545 545 + 546 546 + service := NewUserService(mockRepo, mockResolver, "https://default.pds") 547 547 + ctx := context.Background() 548 548 + 549 549 + profile, err := service.GetProfile(ctx, testDID) 550 550 + require.NoError(t, err) 551 551 + 552 552 + // Avatar should be transformed to URL 553 553 + expectedAvatarURL := "https://test.pds/xrpc/com.atproto.sync.getBlob?did=did:plc:avataronly&cid=bafkreiavataronly" 554 554 + assert.Equal(t, expectedAvatarURL, profile.Avatar) 555 555 + 556 556 + // Banner should be empty 557 557 + assert.Empty(t, profile.Banner) 558 558 + 559 559 + mockRepo.AssertExpectations(t) 560 560 + } 561 561 + 562 562 + // TestGetProfile_WithNoCIDsOrProfile tests GetProfile with no avatar/banner/display name/bio 563 563 + func TestGetProfile_WithNoCIDsOrProfile(t *testing.T) { 564 564 + mockRepo := new(MockUserRepository) 565 565 + mockResolver := new(MockIdentityResolver) 566 566 + 567 567 + testDID := "did:plc:basicuser" 568 568 + testUser := &User{ 569 569 + DID: testDID, 570 570 + Handle: "basicuser.test", 571 571 + PDSURL: "https://test.pds", 572 572 + DisplayName: "", 573 573 + Bio: "", 574 574 + AvatarCID: "", 575 575 + BannerCID: "", 576 576 + CreatedAt: time.Now(), 577 577 + } 578 578 + testStats := &ProfileStats{} 579 579 + 580 580 + mockRepo.On("GetByDID", mock.Anything, testDID).Return(testUser, nil) 581 581 + mockRepo.On("GetProfileStats", mock.Anything, testDID).Return(testStats, nil) 582 582 + 583 583 + service := NewUserService(mockRepo, mockResolver, "https://default.pds") 584 584 + ctx := context.Background() 585 585 + 586 586 + profile, err := service.GetProfile(ctx, testDID) 587 587 + require.NoError(t, err) 588 588 + 589 589 + // All profile fields should be empty 590 590 + assert.Empty(t, profile.DisplayName) 591 591 + assert.Empty(t, profile.Bio) 592 592 + assert.Empty(t, profile.Avatar) 593 593 + assert.Empty(t, profile.Banner) 594 594 + 595 595 + mockRepo.AssertExpectations(t) 596 596 + } 597 597 + 598 598 + // TestGetProfile_WithEmptyPDSURL tests GetProfile does not create URLs when PDSURL is empty 599 599 + func TestGetProfile_WithEmptyPDSURL(t *testing.T) { 600 600 + mockRepo := new(MockUserRepository) 601 601 + mockResolver := new(MockIdentityResolver) 602 602 + 603 603 + testDID := "did:plc:nopdsurl" 604 604 + testUser := &User{ 605 605 + DID: testDID, 606 606 + Handle: "nopdsurl.test", 607 607 + PDSURL: "", // No PDS URL 608 608 + DisplayName: "No PDS URL User", 609 609 + Bio: "Test bio", 610 610 + AvatarCID: "bafkreiavatarcid", // Has CID but no PDS URL 611 611 + BannerCID: "bafkreibannercid", 612 612 + CreatedAt: time.Now(), 613 613 + } 614 614 + testStats := &ProfileStats{} 615 615 + 616 616 + mockRepo.On("GetByDID", mock.Anything, testDID).Return(testUser, nil) 617 617 + mockRepo.On("GetProfileStats", mock.Anything, testDID).Return(testStats, nil) 618 618 + 619 619 + service := NewUserService(mockRepo, mockResolver, "https://default.pds") 620 620 + ctx := context.Background() 621 621 + 622 622 + profile, err := service.GetProfile(ctx, testDID) 623 623 + require.NoError(t, err) 624 624 + 625 625 + // Avatar and Banner should be empty since we can't construct URLs without PDS URL 626 626 + assert.Empty(t, profile.Avatar) 627 627 + assert.Empty(t, profile.Banner) 628 628 + 629 629 + // But display name and bio should still be set 630 630 + assert.Equal(t, "No PDS URL User", profile.DisplayName) 631 631 + assert.Equal(t, "Test bio", profile.Bio) 632 632 + 633 633 + mockRepo.AssertExpectations(t) 634 634 + } 635 635 + 636 636 + // TestUpdateProfile_Success tests successful profile update 637 637 + func TestUpdateProfile_Success(t *testing.T) { 638 638 + mockRepo := new(MockUserRepository) 639 639 + mockResolver := new(MockIdentityResolver) 640 640 + 641 641 + testDID := "did:plc:updateuser" 642 642 + displayName := "Updated Name" 643 643 + bio := "Updated bio" 644 644 + avatarCID := "bafkreinewavatar" 645 645 + bannerCID := "bafkreinewbanner" 646 646 + 647 647 + updatedUser := &User{ 648 648 + DID: testDID, 649 649 + Handle: "updateuser.test", 650 650 + PDSURL: "https://test.pds", 651 651 + DisplayName: displayName, 652 652 + Bio: bio, 653 653 + AvatarCID: avatarCID, 654 654 + BannerCID: bannerCID, 655 655 + CreatedAt: time.Now(), 656 656 + UpdatedAt: time.Now(), 657 657 + } 658 658 + 659 659 + input := UpdateProfileInput{ 660 660 + DisplayName: &displayName, 661 661 + Bio: &bio, 662 662 + AvatarCID: &avatarCID, 663 663 + BannerCID: &bannerCID, 664 664 + } 665 665 + mockRepo.On("UpdateProfile", mock.Anything, testDID, input).Return(updatedUser, nil) 666 666 + 667 667 + service := NewUserService(mockRepo, mockResolver, "https://default.pds") 668 668 + ctx := context.Background() 669 669 + 670 670 + user, err := service.UpdateProfile(ctx, testDID, input) 671 671 + require.NoError(t, err) 672 672 + 673 673 + assert.Equal(t, displayName, user.DisplayName) 674 674 + assert.Equal(t, bio, user.Bio) 675 675 + assert.Equal(t, avatarCID, user.AvatarCID) 676 676 + assert.Equal(t, bannerCID, user.BannerCID) 677 677 + 678 678 + mockRepo.AssertExpectations(t) 679 679 + } 680 680 + 681 681 + // TestUpdateProfile_PartialUpdate tests updating only some fields 682 682 + func TestUpdateProfile_PartialUpdate(t *testing.T) { 683 683 + mockRepo := new(MockUserRepository) 684 684 + mockResolver := new(MockIdentityResolver) 685 685 + 686 686 + testDID := "did:plc:partialupdate" 687 687 + displayName := "Partial Update Name" 688 688 + // Other fields are nil (don't change) 689 689 + 690 690 + updatedUser := &User{ 691 691 + DID: testDID, 692 692 + Handle: "partialupdate.test", 693 693 + PDSURL: "https://test.pds", 694 694 + DisplayName: displayName, 695 695 + Bio: "existing bio", 696 696 + AvatarCID: "existingavatar", 697 697 + BannerCID: "existingbanner", 698 698 + CreatedAt: time.Now(), 699 699 + UpdatedAt: time.Now(), 700 700 + } 701 701 + 702 702 + // Only displayName is provided, others are nil 703 703 + input := UpdateProfileInput{ 704 704 + DisplayName: &displayName, 705 705 + } 706 706 + mockRepo.On("UpdateProfile", mock.Anything, testDID, input).Return(updatedUser, nil) 707 707 + 708 708 + service := NewUserService(mockRepo, mockResolver, "https://default.pds") 709 709 + ctx := context.Background() 710 710 + 711 711 + user, err := service.UpdateProfile(ctx, testDID, input) 712 712 + require.NoError(t, err) 713 713 + 714 714 + assert.Equal(t, displayName, user.DisplayName) 715 715 + // Existing values should be preserved 716 716 + assert.Equal(t, "existing bio", user.Bio) 717 717 + assert.Equal(t, "existingavatar", user.AvatarCID) 718 718 + 719 719 + mockRepo.AssertExpectations(t) 720 720 + } 721 721 + 722 722 + // TestUpdateProfile_ClearFields tests clearing fields with empty strings 723 723 + func TestUpdateProfile_ClearFields(t *testing.T) { 724 724 + mockRepo := new(MockUserRepository) 725 725 + mockResolver := new(MockIdentityResolver) 726 726 + 727 727 + testDID := "did:plc:clearfields" 728 728 + emptyDisplayName := "" 729 729 + emptyBio := "" 730 730 + 731 731 + updatedUser := &User{ 732 732 + DID: testDID, 733 733 + Handle: "clearfields.test", 734 734 + PDSURL: "https://test.pds", 735 735 + DisplayName: "", 736 736 + Bio: "", 737 737 + AvatarCID: "existingavatar", 738 738 + BannerCID: "existingbanner", 739 739 + CreatedAt: time.Now(), 740 740 + UpdatedAt: time.Now(), 741 741 + } 742 742 + 743 743 + input := UpdateProfileInput{ 744 744 + DisplayName: &emptyDisplayName, 745 745 + Bio: &emptyBio, 746 746 + } 747 747 + mockRepo.On("UpdateProfile", mock.Anything, testDID, input).Return(updatedUser, nil) 748 748 + 749 749 + service := NewUserService(mockRepo, mockResolver, "https://default.pds") 750 750 + ctx := context.Background() 751 751 + 752 752 + user, err := service.UpdateProfile(ctx, testDID, input) 753 753 + require.NoError(t, err) 754 754 + 755 755 + assert.Empty(t, user.DisplayName) 756 756 + assert.Empty(t, user.Bio) 757 757 + 758 758 + mockRepo.AssertExpectations(t) 759 759 + } 760 760 + 761 761 + // TestUpdateProfile_RepoError tests UpdateProfile returns error on repo failure 762 762 + func TestUpdateProfile_RepoError(t *testing.T) { 763 763 + mockRepo := new(MockUserRepository) 764 764 + mockResolver := new(MockIdentityResolver) 765 765 + 766 766 + testDID := "did:plc:erroruser" 767 767 + displayName := "Error User" 768 768 + 769 769 + input := UpdateProfileInput{ 770 770 + DisplayName: &displayName, 771 771 + } 772 772 + mockRepo.On("UpdateProfile", mock.Anything, testDID, input).Return(nil, errors.New("database error")) 773 773 + 774 774 + service := NewUserService(mockRepo, mockResolver, "https://default.pds") 775 775 + ctx := context.Background() 776 776 + 777 777 + _, err := service.UpdateProfile(ctx, testDID, input) 778 778 + assert.Error(t, err) 779 779 + assert.Contains(t, err.Error(), "database error") 780 780 + 781 781 + mockRepo.AssertExpectations(t) 782 782 + } 783 783 + 784 784 + // TestUpdateProfile_UserNotFound tests UpdateProfile with non-existent user 785 785 + func TestUpdateProfile_UserNotFound(t *testing.T) { 786 786 + mockRepo := new(MockUserRepository) 787 787 + mockResolver := new(MockIdentityResolver) 788 788 + 789 789 + testDID := "did:plc:notfound" 790 790 + displayName := "Not Found User" 791 791 + 792 792 + input := UpdateProfileInput{ 793 793 + DisplayName: &displayName, 794 794 + } 795 795 + mockRepo.On("UpdateProfile", mock.Anything, testDID, input).Return(nil, ErrUserNotFound) 796 796 + 797 797 + service := NewUserService(mockRepo, mockResolver, "https://default.pds") 798 798 + ctx := context.Background() 799 799 + 800 800 + _, err := service.UpdateProfile(ctx, testDID, input) 801 801 + assert.ErrorIs(t, err, ErrUserNotFound) 802 802 + 803 803 + mockRepo.AssertExpectations(t) 804 804 + } 805 805 + 806 806 + // TestUpdateProfile_EmptyDID tests UpdateProfile with empty DID 807 807 + func TestUpdateProfile_EmptyDID(t *testing.T) { 808 808 + mockRepo := new(MockUserRepository) 809 809 + mockResolver := new(MockIdentityResolver) 810 810 + 811 811 + service := NewUserService(mockRepo, mockResolver, "https://default.pds") 812 812 + ctx := context.Background() 813 813 + 814 814 + displayName := "Test Name" 815 815 + input := UpdateProfileInput{ 816 816 + DisplayName: &displayName, 817 817 + } 818 818 + _, err := service.UpdateProfile(ctx, "", input) 819 819 + assert.Error(t, err) 820 820 + assert.Contains(t, err.Error(), "DID is required") 821 821 + 822 822 + // Repo should not be called with empty DID 823 823 + mockRepo.AssertNotCalled(t, "UpdateProfile", mock.Anything, mock.Anything, mock.Anything) 824 824 + } 825 825 + 826 826 + // TestUpdateProfile_WhitespaceDID tests UpdateProfile with whitespace-only DID 827 827 + func TestUpdateProfile_WhitespaceDID(t *testing.T) { 828 828 + mockRepo := new(MockUserRepository) 829 829 + mockResolver := new(MockIdentityResolver) 830 830 + 831 831 + service := NewUserService(mockRepo, mockResolver, "https://default.pds") 832 832 + ctx := context.Background() 833 833 + 834 834 + displayName := "Test Name" 835 835 + input := UpdateProfileInput{ 836 836 + DisplayName: &displayName, 837 837 + } 838 838 + _, err := service.UpdateProfile(ctx, " ", input) 839 839 + assert.Error(t, err) 840 840 + assert.Contains(t, err.Error(), "DID is required") 841 841 + 842 842 + mockRepo.AssertNotCalled(t, "UpdateProfile", mock.Anything, mock.Anything, mock.Anything) 843 843 + }

+18 -11

internal/core/users/user.go

··· 8 8 // This is NOT the user's repository - that lives in the PDS 9 9 // This table only tracks metadata for efficient AppView queries 10 10 type User struct { 11 11 - CreatedAt time.Time `json:"createdAt" db:"created_at"` 12 12 - UpdatedAt time.Time `json:"updatedAt" db:"updated_at"` 13 13 - DID string `json:"did" db:"did"` 14 14 - Handle string `json:"handle" db:"handle"` 15 15 - PDSURL string `json:"pdsUrl" db:"pds_url"` 11 11 + CreatedAt time.Time `json:"createdAt" db:"created_at"` 12 12 + UpdatedAt time.Time `json:"updatedAt" db:"updated_at"` 13 13 + DID string `json:"did" db:"did"` 14 14 + Handle string `json:"handle" db:"handle"` 15 15 + PDSURL string `json:"pdsUrl" db:"pds_url"` 16 16 + DisplayName string `json:"displayName,omitempty" db:"display_name"` 17 17 + Bio string `json:"bio,omitempty" db:"bio"` 18 18 + AvatarCID string `json:"avatarCid,omitempty" db:"avatar_cid"` 19 19 + BannerCID string `json:"bannerCid,omitempty" db:"banner_cid"` 16 20 } 17 21 18 22 // CreateUserRequest represents the input for creating a new user ··· 52 56 // ProfileViewDetailed is the full profile response 53 57 // Matches the social.coves.actor.defs#profileViewDetailed lexicon 54 58 type ProfileViewDetailed struct { 55 55 - DID string `json:"did"` 56 56 - Handle string `json:"handle,omitempty"` 57 57 - CreatedAt time.Time `json:"createdAt"` 58 58 - Stats *ProfileStats `json:"stats,omitempty"` 59 59 - // Future fields (require additional infrastructure): 60 60 - // DisplayName, Bio, Avatar, Banner (from PDS profile record) 59 59 + DID string `json:"did"` 60 60 + Handle string `json:"handle,omitempty"` 61 61 + CreatedAt time.Time `json:"createdAt"` 62 62 + Stats *ProfileStats `json:"stats,omitempty"` 63 63 + DisplayName string `json:"displayName,omitempty"` 64 64 + // Bio is the user's biography/description. Maps to JSON "description" for atProto lexicon compatibility. 65 65 + Bio string `json:"description,omitempty"` 66 66 + Avatar string `json:"avatar,omitempty"` // URL, not CID 67 67 + Banner string `json:"banner,omitempty"` // URL, not CID 61 68 // Viewer (requires user-to-user blocking infrastructure) 62 69 }

+11

internal/db/migrations/027_add_user_profile_fields.sql

··· 1 1 + -- +goose Up 2 2 + ALTER TABLE users ADD COLUMN display_name TEXT CHECK (display_name IS NULL OR length(display_name) <= 64); 3 3 + ALTER TABLE users ADD COLUMN bio TEXT CHECK (bio IS NULL OR length(bio) <= 256); 4 4 + ALTER TABLE users ADD COLUMN avatar_cid TEXT; 5 5 + ALTER TABLE users ADD COLUMN banner_cid TEXT; 6 6 + 7 7 + -- +goose Down 8 8 + ALTER TABLE users DROP COLUMN IF EXISTS banner_cid; 9 9 + ALTER TABLE users DROP COLUMN IF EXISTS avatar_cid; 10 10 + ALTER TABLE users DROP COLUMN IF EXISTS bio; 11 11 + ALTER TABLE users DROP COLUMN IF EXISTS display_name;

+104 -8

internal/db/postgres/user_repo.go

··· 48 48 // GetByDID retrieves a user by their DID 49 49 func (r *postgresUserRepo) GetByDID(ctx context.Context, did string) (*users.User, error) { 50 50 user := &users.User{} 51 51 - query := `SELECT did, handle, pds_url, created_at, updated_at FROM users WHERE did = $1` 51 51 + query := `SELECT did, handle, pds_url, created_at, updated_at, display_name, bio, avatar_cid, banner_cid FROM users WHERE did = $1` 52 52 53 53 + var displayName, bio, avatarCID, bannerCID sql.NullString 53 54 err := r.db.QueryRowContext(ctx, query, did). 54 54 - Scan(&user.DID, &user.Handle, &user.PDSURL, &user.CreatedAt, &user.UpdatedAt) 55 55 + Scan(&user.DID, &user.Handle, &user.PDSURL, &user.CreatedAt, &user.UpdatedAt, 56 56 + &displayName, &bio, &avatarCID, &bannerCID) 55 57 56 58 if err == sql.ErrNoRows { 57 59 return nil, users.ErrUserNotFound ··· 60 62 return nil, fmt.Errorf("failed to get user by DID: %w", err) 61 63 } 62 64 65 65 + user.DisplayName = displayName.String 66 66 + user.Bio = bio.String 67 67 + user.AvatarCID = avatarCID.String 68 68 + user.BannerCID = bannerCID.String 69 69 + 63 70 return user, nil 64 71 } 65 72 66 73 // GetByHandle retrieves a user by their handle 67 74 func (r *postgresUserRepo) GetByHandle(ctx context.Context, handle string) (*users.User, error) { 68 75 user := &users.User{} 69 69 - query := `SELECT did, handle, pds_url, created_at, updated_at FROM users WHERE handle = $1` 76 76 + query := `SELECT did, handle, pds_url, created_at, updated_at, display_name, bio, avatar_cid, banner_cid FROM users WHERE handle = $1` 70 77 78 78 + var displayName, bio, avatarCID, bannerCID sql.NullString 71 79 err := r.db.QueryRowContext(ctx, query, handle). 72 72 - Scan(&user.DID, &user.Handle, &user.PDSURL, &user.CreatedAt, &user.UpdatedAt) 80 80 + Scan(&user.DID, &user.Handle, &user.PDSURL, &user.CreatedAt, &user.UpdatedAt, 81 81 + &displayName, &bio, &avatarCID, &bannerCID) 73 82 74 83 if err == sql.ErrNoRows { 75 84 return nil, users.ErrUserNotFound ··· 78 87 return nil, fmt.Errorf("failed to get user by handle: %w", err) 79 88 } 80 89 90 90 + user.DisplayName = displayName.String 91 91 + user.Bio = bio.String 92 92 + user.AvatarCID = avatarCID.String 93 93 + user.BannerCID = bannerCID.String 94 94 + 81 95 return user, nil 82 96 } 83 97 ··· 88 102 UPDATE users 89 103 SET handle = $2, updated_at = NOW() 90 104 WHERE did = $1 91 91 - RETURNING did, handle, pds_url, created_at, updated_at` 105 105 + RETURNING did, handle, pds_url, created_at, updated_at, display_name, bio, avatar_cid, banner_cid` 92 106 107 107 + var displayName, bio, avatarCID, bannerCID sql.NullString 93 108 err := r.db.QueryRowContext(ctx, query, did, newHandle). 94 94 - Scan(&user.DID, &user.Handle, &user.PDSURL, &user.CreatedAt, &user.UpdatedAt) 109 109 + Scan(&user.DID, &user.Handle, &user.PDSURL, &user.CreatedAt, &user.UpdatedAt, 110 110 + &displayName, &bio, &avatarCID, &bannerCID) 95 111 96 112 if err == sql.ErrNoRows { 97 113 return nil, users.ErrUserNotFound ··· 104 120 return nil, fmt.Errorf("failed to update handle: %w", err) 105 121 } 106 122 123 123 + user.DisplayName = displayName.String 124 124 + user.Bio = bio.String 125 125 + user.AvatarCID = avatarCID.String 126 126 + user.BannerCID = bannerCID.String 127 127 + 107 128 return user, nil 108 129 } 109 130 ··· 132 153 133 154 // Build parameterized query with IN clause 134 155 // Use ANY($1) for PostgreSQL array support with pq.Array() for type conversion 135 135 - query := `SELECT did, handle, pds_url, created_at, updated_at FROM users WHERE did = ANY($1)` 156 156 + query := `SELECT did, handle, pds_url, created_at, updated_at, display_name, bio, avatar_cid, banner_cid FROM users WHERE did = ANY($1)` 136 157 137 158 rows, err := r.db.QueryContext(ctx, query, pq.Array(dids)) 138 159 if err != nil { ··· 148 169 result := make(map[string]*users.User, len(dids)) 149 170 for rows.Next() { 150 171 user := &users.User{} 151 151 - err := rows.Scan(&user.DID, &user.Handle, &user.PDSURL, &user.CreatedAt, &user.UpdatedAt) 172 172 + var displayName, bio, avatarCID, bannerCID sql.NullString 173 173 + err := rows.Scan(&user.DID, &user.Handle, &user.PDSURL, &user.CreatedAt, &user.UpdatedAt, 174 174 + &displayName, &bio, &avatarCID, &bannerCID) 152 175 if err != nil { 153 176 return nil, fmt.Errorf("failed to scan user row: %w", err) 154 177 } 178 178 + user.DisplayName = displayName.String 179 179 + user.Bio = bio.String 180 180 + user.AvatarCID = avatarCID.String 181 181 + user.BannerCID = bannerCID.String 155 182 result[user.DID] = user 156 183 } 157 184 ··· 283 310 284 311 return nil 285 312 } 313 313 + 314 314 + // UpdateProfile updates a user's profile fields (display name, bio, avatar, banner). 315 315 + // Nil values in the input mean "don't change this field" - only non-nil values are updated. 316 316 + // Empty string values will clear the field in the database. 317 317 + // Returns the updated user with all fields populated. 318 318 + // Returns ErrUserNotFound if the user does not exist. 319 319 + func (r *postgresUserRepo) UpdateProfile(ctx context.Context, did string, input users.UpdateProfileInput) (*users.User, error) { 320 320 + // Validate DID format 321 321 + if !strings.HasPrefix(did, "did:") { 322 322 + return nil, &users.InvalidDIDError{DID: did, Reason: "must start with 'did:'"} 323 323 + } 324 324 + 325 325 + // Build dynamic UPDATE query based on which fields are provided 326 326 + setClauses := []string{"updated_at = NOW()"} 327 327 + args := []interface{}{} 328 328 + argNum := 1 329 329 + 330 330 + if input.DisplayName != nil { 331 331 + setClauses = append(setClauses, fmt.Sprintf("display_name = $%d", argNum)) 332 332 + args = append(args, *input.DisplayName) 333 333 + argNum++ 334 334 + } 335 335 + if input.Bio != nil { 336 336 + setClauses = append(setClauses, fmt.Sprintf("bio = $%d", argNum)) 337 337 + args = append(args, *input.Bio) 338 338 + argNum++ 339 339 + } 340 340 + if input.AvatarCID != nil { 341 341 + setClauses = append(setClauses, fmt.Sprintf("avatar_cid = $%d", argNum)) 342 342 + args = append(args, *input.AvatarCID) 343 343 + argNum++ 344 344 + } 345 345 + if input.BannerCID != nil { 346 346 + setClauses = append(setClauses, fmt.Sprintf("banner_cid = $%d", argNum)) 347 347 + args = append(args, *input.BannerCID) 348 348 + argNum++ 349 349 + } 350 350 + 351 351 + // Add the DID as the final parameter for the WHERE clause 352 352 + args = append(args, did) 353 353 + 354 354 + query := fmt.Sprintf(` 355 355 + UPDATE users 356 356 + SET %s 357 357 + WHERE did = $%d 358 358 + RETURNING did, handle, pds_url, created_at, updated_at, display_name, bio, avatar_cid, banner_cid`, 359 359 + strings.Join(setClauses, ", "), argNum) 360 360 + 361 361 + user := &users.User{} 362 362 + var displayNameVal, bioVal, avatarCIDVal, bannerCIDVal sql.NullString 363 363 + 364 364 + err := r.db.QueryRowContext(ctx, query, args...). 365 365 + Scan(&user.DID, &user.Handle, &user.PDSURL, &user.CreatedAt, &user.UpdatedAt, 366 366 + &displayNameVal, &bioVal, &avatarCIDVal, &bannerCIDVal) 367 367 + 368 368 + if err == sql.ErrNoRows { 369 369 + return nil, users.ErrUserNotFound 370 370 + } 371 371 + if err != nil { 372 372 + return nil, fmt.Errorf("failed to update profile: %w", err) 373 373 + } 374 374 + 375 375 + user.DisplayName = displayNameVal.String 376 376 + user.Bio = bioVal.String 377 377 + user.AvatarCID = avatarCIDVal.String 378 378 + user.BannerCID = bannerCIDVal.String 379 379 + 380 380 + return user, nil 381 381 + }

+388

internal/db/postgres/user_repo_test.go

··· 701 701 702 702 t.Logf("Deletion of user with %d comments and %d votes took %v", 10, 10, elapsed) 703 703 } 704 704 + 705 705 + // ============================================================================ 706 706 + // Profile Update Tests (Phase 2: User Profile Avatar & Banner) 707 707 + // ============================================================================ 708 708 + 709 709 + // stringPtr returns a pointer to the provided string (helper for optional params) 710 710 + func stringPtr(s string) *string { 711 711 + return &s 712 712 + } 713 713 + 714 714 + func TestUserRepo_UpdateProfile(t *testing.T) { 715 715 + db := setupUserTestDB(t) 716 716 + defer func() { _ = db.Close() }() 717 717 + 718 718 + testDID := "did:plc:testupdateprofile" 719 719 + testHandle := "testupdateprofile.test" 720 720 + 721 721 + defer cleanupUserData(t, db, testDID) 722 722 + 723 723 + repo := NewUserRepository(db) 724 724 + ctx := context.Background() 725 725 + 726 726 + // Create user first 727 727 + user := &users.User{ 728 728 + DID: testDID, 729 729 + Handle: testHandle, 730 730 + PDSURL: "https://test.pds", 731 731 + } 732 732 + _, err := repo.Create(ctx, user) 733 733 + require.NoError(t, err) 734 734 + 735 735 + // Update profile with all fields 736 736 + displayName := "Test User" 737 737 + bio := "A test user biography" 738 738 + avatarCID := "bafyavatarcid123" 739 739 + bannerCID := "bafybannercid456" 740 740 + 741 741 + input := users.UpdateProfileInput{ 742 742 + DisplayName: &displayName, 743 743 + Bio: &bio, 744 744 + AvatarCID: &avatarCID, 745 745 + BannerCID: &bannerCID, 746 746 + } 747 747 + updated, err := repo.UpdateProfile(ctx, testDID, input) 748 748 + assert.NoError(t, err) 749 749 + require.NotNil(t, updated) 750 750 + 751 751 + // Verify all fields were updated 752 752 + assert.Equal(t, testDID, updated.DID) 753 753 + assert.Equal(t, testHandle, updated.Handle) 754 754 + assert.Equal(t, displayName, updated.DisplayName) 755 755 + assert.Equal(t, bio, updated.Bio) 756 756 + assert.Equal(t, avatarCID, updated.AvatarCID) 757 757 + assert.Equal(t, bannerCID, updated.BannerCID) 758 758 + } 759 759 + 760 760 + func TestUserRepo_UpdateProfile_PartialUpdate(t *testing.T) { 761 761 + db := setupUserTestDB(t) 762 762 + defer func() { _ = db.Close() }() 763 763 + 764 764 + testDID := "did:plc:testpartialupdate" 765 765 + testHandle := "testpartialupdate.test" 766 766 + 767 767 + defer cleanupUserData(t, db, testDID) 768 768 + 769 769 + repo := NewUserRepository(db) 770 770 + ctx := context.Background() 771 771 + 772 772 + // Create user first 773 773 + user := &users.User{ 774 774 + DID: testDID, 775 775 + Handle: testHandle, 776 776 + PDSURL: "https://test.pds", 777 777 + } 778 778 + _, err := repo.Create(ctx, user) 779 779 + require.NoError(t, err) 780 780 + 781 781 + // First update: set display name and avatar 782 782 + displayName := "Initial Name" 783 783 + avatarCID := "bafyinitialavatar" 784 784 + input1 := users.UpdateProfileInput{ 785 785 + DisplayName: &displayName, 786 786 + AvatarCID: &avatarCID, 787 787 + } 788 788 + _, err = repo.UpdateProfile(ctx, testDID, input1) 789 789 + require.NoError(t, err) 790 790 + 791 791 + // Second update: only update bio (leave other fields alone) 792 792 + bio := "New bio text" 793 793 + input2 := users.UpdateProfileInput{ 794 794 + Bio: &bio, 795 795 + } 796 796 + updated, err := repo.UpdateProfile(ctx, testDID, input2) 797 797 + assert.NoError(t, err) 798 798 + require.NotNil(t, updated) 799 799 + 800 800 + // Verify bio was updated 801 801 + assert.Equal(t, bio, updated.Bio) 802 802 + 803 803 + // Verify previous values are preserved (nil means "don't change") 804 804 + assert.Equal(t, displayName, updated.DisplayName) 805 805 + assert.Equal(t, avatarCID, updated.AvatarCID) 806 806 + assert.Empty(t, updated.BannerCID) // Was never set 807 807 + } 808 808 + 809 809 + func TestUserRepo_UpdateProfile_ReturnsUpdatedUser(t *testing.T) { 810 810 + db := setupUserTestDB(t) 811 811 + defer func() { _ = db.Close() }() 812 812 + 813 813 + testDID := "did:plc:testreturnsupdated" 814 814 + testHandle := "testreturnsupdated.test" 815 815 + 816 816 + defer cleanupUserData(t, db, testDID) 817 817 + 818 818 + repo := NewUserRepository(db) 819 819 + ctx := context.Background() 820 820 + 821 821 + // Create user first 822 822 + user := &users.User{ 823 823 + DID: testDID, 824 824 + Handle: testHandle, 825 825 + PDSURL: "https://test.pds", 826 826 + } 827 827 + created, err := repo.Create(ctx, user) 828 828 + require.NoError(t, err) 829 829 + 830 830 + // Update profile 831 831 + displayName := "Updated Name" 832 832 + input := users.UpdateProfileInput{ 833 833 + DisplayName: &displayName, 834 834 + } 835 835 + updated, err := repo.UpdateProfile(ctx, testDID, input) 836 836 + assert.NoError(t, err) 837 837 + require.NotNil(t, updated) 838 838 + 839 839 + // Verify the returned user has all core fields populated 840 840 + assert.Equal(t, testDID, updated.DID) 841 841 + assert.Equal(t, testHandle, updated.Handle) 842 842 + assert.Equal(t, "https://test.pds", updated.PDSURL) 843 843 + assert.Equal(t, displayName, updated.DisplayName) 844 844 + assert.NotZero(t, updated.CreatedAt) 845 845 + assert.NotZero(t, updated.UpdatedAt) 846 846 + 847 847 + // UpdatedAt should be after CreatedAt (or equal if very fast) 848 848 + assert.True(t, updated.UpdatedAt.After(created.CreatedAt) || updated.UpdatedAt.Equal(created.CreatedAt)) 849 849 + } 850 850 + 851 851 + func TestUserRepo_UpdateProfile_UserNotFound(t *testing.T) { 852 852 + db := setupUserTestDB(t) 853 853 + defer func() { _ = db.Close() }() 854 854 + 855 855 + repo := NewUserRepository(db) 856 856 + ctx := context.Background() 857 857 + 858 858 + // Try to update a non-existent user 859 859 + displayName := "Ghost User" 860 860 + input := users.UpdateProfileInput{ 861 861 + DisplayName: &displayName, 862 862 + } 863 863 + _, err := repo.UpdateProfile(ctx, "did:plc:nonexistentuserprofile", input) 864 864 + assert.ErrorIs(t, err, users.ErrUserNotFound) 865 865 + } 866 866 + 867 867 + func TestUserRepo_UpdateProfile_ClearFields(t *testing.T) { 868 868 + db := setupUserTestDB(t) 869 869 + defer func() { _ = db.Close() }() 870 870 + 871 871 + testDID := "did:plc:testclearfields" 872 872 + testHandle := "testclearfields.test" 873 873 + 874 874 + defer cleanupUserData(t, db, testDID) 875 875 + 876 876 + repo := NewUserRepository(db) 877 877 + ctx := context.Background() 878 878 + 879 879 + // Create user first 880 880 + user := &users.User{ 881 881 + DID: testDID, 882 882 + Handle: testHandle, 883 883 + PDSURL: "https://test.pds", 884 884 + } 885 885 + _, err := repo.Create(ctx, user) 886 886 + require.NoError(t, err) 887 887 + 888 888 + // Set profile fields 889 889 + displayName := "Has Name" 890 890 + bio := "Has Bio" 891 891 + avatarCID := "bafyhasavatar" 892 892 + input1 := users.UpdateProfileInput{ 893 893 + DisplayName: &displayName, 894 894 + Bio: &bio, 895 895 + AvatarCID: &avatarCID, 896 896 + } 897 897 + _, err = repo.UpdateProfile(ctx, testDID, input1) 898 898 + require.NoError(t, err) 899 899 + 900 900 + // Clear display name by passing empty string 901 901 + emptyName := "" 902 902 + input2 := users.UpdateProfileInput{ 903 903 + DisplayName: &emptyName, 904 904 + } 905 905 + updated, err := repo.UpdateProfile(ctx, testDID, input2) 906 906 + assert.NoError(t, err) 907 907 + require.NotNil(t, updated) 908 908 + 909 909 + // Verify display name was cleared 910 910 + assert.Empty(t, updated.DisplayName) 911 911 + // Other fields should remain 912 912 + assert.Equal(t, bio, updated.Bio) 913 913 + assert.Equal(t, avatarCID, updated.AvatarCID) 914 914 + } 915 915 + 916 916 + func TestUserRepo_GetByDID_ReturnsNewFields(t *testing.T) { 917 917 + db := setupUserTestDB(t) 918 918 + defer func() { _ = db.Close() }() 919 919 + 920 920 + testDID := "did:plc:testgetbydidnewfields" 921 921 + testHandle := "testgetbydidnewfields.test" 922 922 + 923 923 + defer cleanupUserData(t, db, testDID) 924 924 + 925 925 + repo := NewUserRepository(db) 926 926 + ctx := context.Background() 927 927 + 928 928 + // Create user first 929 929 + user := &users.User{ 930 930 + DID: testDID, 931 931 + Handle: testHandle, 932 932 + PDSURL: "https://test.pds", 933 933 + } 934 934 + _, err := repo.Create(ctx, user) 935 935 + require.NoError(t, err) 936 936 + 937 937 + // Update profile with all fields 938 938 + displayName := "Profile Name" 939 939 + bio := "Profile bio for testing" 940 940 + avatarCID := "bafyprofileavatar" 941 941 + bannerCID := "bafyprofilebanner" 942 942 + input := users.UpdateProfileInput{ 943 943 + DisplayName: &displayName, 944 944 + Bio: &bio, 945 945 + AvatarCID: &avatarCID, 946 946 + BannerCID: &bannerCID, 947 947 + } 948 948 + _, err = repo.UpdateProfile(ctx, testDID, input) 949 949 + require.NoError(t, err) 950 950 + 951 951 + // Retrieve user with GetByDID 952 952 + retrieved, err := repo.GetByDID(ctx, testDID) 953 953 + assert.NoError(t, err) 954 954 + require.NotNil(t, retrieved) 955 955 + 956 956 + // Verify all profile fields are returned 957 957 + assert.Equal(t, testDID, retrieved.DID) 958 958 + assert.Equal(t, testHandle, retrieved.Handle) 959 959 + assert.Equal(t, displayName, retrieved.DisplayName) 960 960 + assert.Equal(t, bio, retrieved.Bio) 961 961 + assert.Equal(t, avatarCID, retrieved.AvatarCID) 962 962 + assert.Equal(t, bannerCID, retrieved.BannerCID) 963 963 + } 964 964 + 965 965 + func TestUserRepo_GetByHandle_ReturnsNewFields(t *testing.T) { 966 966 + db := setupUserTestDB(t) 967 967 + defer func() { _ = db.Close() }() 968 968 + 969 969 + testDID := "did:plc:testgetbyhandlenewfields" 970 970 + testHandle := "testgetbyhandlenewfields.test" 971 971 + 972 972 + defer cleanupUserData(t, db, testDID) 973 973 + 974 974 + repo := NewUserRepository(db) 975 975 + ctx := context.Background() 976 976 + 977 977 + // Create user first 978 978 + user := &users.User{ 979 979 + DID: testDID, 980 980 + Handle: testHandle, 981 981 + PDSURL: "https://test.pds", 982 982 + } 983 983 + _, err := repo.Create(ctx, user) 984 984 + require.NoError(t, err) 985 985 + 986 986 + // Update profile with all fields 987 987 + displayName := "Handle Test Name" 988 988 + bio := "Handle test bio" 989 989 + avatarCID := "bafyhandleavatar" 990 990 + bannerCID := "bafyhandlebanner" 991 991 + input := users.UpdateProfileInput{ 992 992 + DisplayName: &displayName, 993 993 + Bio: &bio, 994 994 + AvatarCID: &avatarCID, 995 995 + BannerCID: &bannerCID, 996 996 + } 997 997 + _, err = repo.UpdateProfile(ctx, testDID, input) 998 998 + require.NoError(t, err) 999 999 + 1000 1000 + // Retrieve user with GetByHandle 1001 1001 + retrieved, err := repo.GetByHandle(ctx, testHandle) 1002 1002 + assert.NoError(t, err) 1003 1003 + require.NotNil(t, retrieved) 1004 1004 + 1005 1005 + // Verify all profile fields are returned 1006 1006 + assert.Equal(t, testDID, retrieved.DID) 1007 1007 + assert.Equal(t, testHandle, retrieved.Handle) 1008 1008 + assert.Equal(t, displayName, retrieved.DisplayName) 1009 1009 + assert.Equal(t, bio, retrieved.Bio) 1010 1010 + assert.Equal(t, avatarCID, retrieved.AvatarCID) 1011 1011 + assert.Equal(t, bannerCID, retrieved.BannerCID) 1012 1012 + } 1013 1013 + 1014 1014 + func TestUpdateProfile_InvalidDID(t *testing.T) { 1015 1015 + db := setupUserTestDB(t) 1016 1016 + defer func() { _ = db.Close() }() 1017 1017 + 1018 1018 + repo := NewUserRepository(db) 1019 1019 + ctx := context.Background() 1020 1020 + 1021 1021 + displayName := "Test" 1022 1022 + input := users.UpdateProfileInput{DisplayName: &displayName} 1023 1023 + 1024 1024 + _, err := repo.UpdateProfile(ctx, "invalid-did", input) 1025 1025 + 1026 1026 + require.Error(t, err) 1027 1027 + var didErr *users.InvalidDIDError 1028 1028 + require.ErrorAs(t, err, &didErr) 1029 1029 + assert.Equal(t, "invalid-did", didErr.DID) 1030 1030 + } 1031 1031 + 1032 1032 + func TestUserRepo_GetByDIDs_ReturnsNewFields(t *testing.T) { 1033 1033 + db := setupUserTestDB(t) 1034 1034 + defer func() { _ = db.Close() }() 1035 1035 + 1036 1036 + testDID1 := "did:plc:testgetbydidsbatch1" 1037 1037 + testHandle1 := "testgetbydidsbatch1.test" 1038 1038 + testDID2 := "did:plc:testgetbydidsbatch2" 1039 1039 + testHandle2 := "testgetbydidsbatch2.test" 1040 1040 + 1041 1041 + defer cleanupUserData(t, db, testDID1) 1042 1042 + defer cleanupUserData(t, db, testDID2) 1043 1043 + 1044 1044 + repo := NewUserRepository(db) 1045 1045 + ctx := context.Background() 1046 1046 + 1047 1047 + // Create users 1048 1048 + user1 := &users.User{DID: testDID1, Handle: testHandle1, PDSURL: "https://test.pds"} 1049 1049 + user2 := &users.User{DID: testDID2, Handle: testHandle2, PDSURL: "https://test.pds"} 1050 1050 + _, err := repo.Create(ctx, user1) 1051 1051 + require.NoError(t, err) 1052 1052 + _, err = repo.Create(ctx, user2) 1053 1053 + require.NoError(t, err) 1054 1054 + 1055 1055 + // Update profiles 1056 1056 + displayName1 := "Batch User 1" 1057 1057 + avatarCID1 := "bafybatchavatar1" 1058 1058 + displayName2 := "Batch User 2" 1059 1059 + bio2 := "Batch user 2 bio" 1060 1060 + input1 := users.UpdateProfileInput{ 1061 1061 + DisplayName: &displayName1, 1062 1062 + AvatarCID: &avatarCID1, 1063 1063 + } 1064 1064 + _, err = repo.UpdateProfile(ctx, testDID1, input1) 1065 1065 + require.NoError(t, err) 1066 1066 + input2 := users.UpdateProfileInput{ 1067 1067 + DisplayName: &displayName2, 1068 1068 + Bio: &bio2, 1069 1069 + } 1070 1070 + _, err = repo.UpdateProfile(ctx, testDID2, input2) 1071 1071 + require.NoError(t, err) 1072 1072 + 1073 1073 + // Retrieve with GetByDIDs 1074 1074 + userMap, err := repo.GetByDIDs(ctx, []string{testDID1, testDID2}) 1075 1075 + assert.NoError(t, err) 1076 1076 + assert.Len(t, userMap, 2) 1077 1077 + 1078 1078 + // Verify user 1 1079 1079 + u1 := userMap[testDID1] 1080 1080 + require.NotNil(t, u1) 1081 1081 + assert.Equal(t, displayName1, u1.DisplayName) 1082 1082 + assert.Equal(t, avatarCID1, u1.AvatarCID) 1083 1083 + assert.Empty(t, u1.Bio) 1084 1084 + 1085 1085 + // Verify user 2 1086 1086 + u2 := userMap[testDID2] 1087 1087 + require.NotNil(t, u2) 1088 1088 + assert.Equal(t, displayName2, u2.DisplayName) 1089 1089 + assert.Equal(t, bio2, u2.Bio) 1090 1090 + assert.Empty(t, u2.AvatarCID) 1091 1091 + }

+1026

tests/integration/user_profile_avatar_e2e_test.go

··· 1 1 + package integration 2 2 + 3 3 + import ( 4 4 + "Coves/internal/api/handlers/user" 5 5 + "Coves/internal/api/routes" 6 6 + "Coves/internal/atproto/identity" 7 7 + "Coves/internal/atproto/jetstream" 8 8 + "Coves/internal/core/blobs" 9 9 + "Coves/internal/core/users" 10 10 + "Coves/internal/db/postgres" 11 11 + "bytes" 12 12 + "context" 13 13 + "database/sql" 14 14 + "encoding/json" 15 15 + "fmt" 16 16 + "image" 17 17 + "image/color" 18 18 + "image/png" 19 19 + "net" 20 20 + "net/http" 21 21 + "net/http/httptest" 22 22 + "os" 23 23 + "strings" 24 24 + "testing" 25 25 + "time" 26 26 + 27 27 + "github.com/go-chi/chi/v5" 28 28 + "github.com/gorilla/websocket" 29 29 + _ "github.com/lib/pq" 30 30 + "github.com/pressly/goose/v3" 31 31 + "github.com/stretchr/testify/assert" 32 32 + "github.com/stretchr/testify/require" 33 33 + ) 34 34 + 35 35 + // createTestAvatarPNG creates a simple PNG image for avatar testing 36 36 + // Parameters: 37 37 + // - width, height: image dimensions in pixels 38 38 + // - c: fill color for the image 39 39 + // Returns the PNG encoded as bytes 40 40 + func createTestAvatarPNG(width, height int, c color.Color) []byte { 41 41 + img := image.NewRGBA(image.Rect(0, 0, width, height)) 42 42 + for y := 0; y < height; y++ { 43 43 + for x := 0; x < width; x++ { 44 44 + img.Set(x, y, c) 45 45 + } 46 46 + } 47 47 + var buf bytes.Buffer 48 48 + if err := png.Encode(&buf, img); err != nil { 49 49 + panic(fmt.Sprintf("createTestAvatarPNG: failed to encode PNG: %v", err)) 50 50 + } 51 51 + return buf.Bytes() 52 52 + } 53 53 + 54 54 + // TestUserProfileAvatarE2E_UpdateWithAvatar tests the full flow of updating a user profile with an avatar: 55 55 + // 1. User updates profile via Coves API (POST /xrpc/social.coves.actor.updateProfile) 56 56 + // 2. Profile record is written to PDS (app.bsky.actor.profile) 57 57 + // 3. Jetstream consumer receives and processes the event 58 58 + // 4. GetProfile returns the correct avatar URL 59 59 + func TestUserProfileAvatarE2E_UpdateWithAvatar(t *testing.T) { 60 60 + if testing.Short() { 61 61 + t.Skip("Skipping E2E test in short mode") 62 62 + } 63 63 + 64 64 + // Setup test database 65 65 + dbURL := os.Getenv("TEST_DATABASE_URL") 66 66 + if dbURL == "" { 67 67 + dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" 68 68 + } 69 69 + 70 70 + db, err := sql.Open("postgres", dbURL) 71 71 + require.NoError(t, err, "Failed to connect to test database") 72 72 + defer func() { _ = db.Close() }() 73 73 + 74 74 + // Run migrations 75 75 + require.NoError(t, goose.SetDialect("postgres")) 76 76 + require.NoError(t, goose.Up(db, "../../internal/db/migrations")) 77 77 + 78 78 + // Check if PDS is running 79 79 + pdsURL := os.Getenv("PDS_URL") 80 80 + if pdsURL == "" { 81 81 + pdsURL = "http://localhost:3001" 82 82 + } 83 83 + 84 84 + healthResp, err := http.Get(pdsURL + "/xrpc/_health") 85 85 + if err != nil { 86 86 + t.Skipf("PDS not running at %s: %v. Run 'make dev-up' to start.", pdsURL, err) 87 87 + } 88 88 + _ = healthResp.Body.Close() 89 89 + 90 90 + // Check if Jetstream is running 91 91 + pdsHostname := strings.TrimPrefix(pdsURL, "http://") 92 92 + pdsHostname = strings.TrimPrefix(pdsHostname, "https://") 93 93 + pdsHostname = strings.Split(pdsHostname, ":")[0] 94 94 + jetstreamURL := fmt.Sprintf("ws://%s:6008/subscribe?wantedCollections=app.bsky.actor.profile", pdsHostname) 95 95 + 96 96 + testConn, _, connErr := websocket.DefaultDialer.Dial(jetstreamURL, nil) 97 97 + if connErr != nil { 98 98 + t.Skipf("Jetstream not available at %s: %v. Run 'make dev-up' to start.", jetstreamURL, connErr) 99 99 + } 100 100 + _ = testConn.Close() 101 101 + t.Logf("Jetstream available at %s", jetstreamURL) 102 102 + 103 103 + ctx := context.Background() 104 104 + 105 105 + // Setup identity resolver 106 106 + plcURL := os.Getenv("PLC_DIRECTORY_URL") 107 107 + if plcURL == "" { 108 108 + plcURL = "http://localhost:3002" 109 109 + } 110 110 + identityConfig := identity.DefaultConfig() 111 111 + identityConfig.PLCURL = plcURL 112 112 + identityResolver := identity.NewResolver(db, identityConfig) 113 113 + 114 114 + // Setup services 115 115 + userRepo := postgres.NewUserRepository(db) 116 116 + userService := users.NewUserService(userRepo, identityResolver, pdsURL) 117 117 + blobService := blobs.NewBlobService(pdsURL) 118 118 + 119 119 + // Setup user consumer for processing Jetstream events 120 120 + userConsumer := jetstream.NewUserEventConsumer(userService, identityResolver, jetstreamURL, "") 121 121 + 122 122 + // Setup HTTP server with all user routes 123 123 + e2eAuth := NewE2EOAuthMiddleware() 124 124 + r := chi.NewRouter() 125 125 + routes.RegisterUserRoutes(r, userService, e2eAuth.OAuthAuthMiddleware, blobService) 126 126 + httpServer := httptest.NewServer(r) 127 127 + defer httpServer.Close() 128 128 + 129 129 + // Cleanup old test data 130 130 + timestamp := time.Now().Unix() 131 131 + shortTS := timestamp % 10000 132 132 + _, _ = db.Exec("DELETE FROM users WHERE handle LIKE 'avatartest%.local.coves.dev'") 133 133 + 134 134 + t.Run("update profile with avatar via real PDS and Jetstream", func(t *testing.T) { 135 135 + // Create test user account on PDS 136 136 + userHandle := fmt.Sprintf("avatartest%d.local.coves.dev", shortTS) 137 137 + email := fmt.Sprintf("avatartest%d@test.com", shortTS) 138 138 + password := "test-password-avatar-123" 139 139 + 140 140 + t.Logf("\n Creating test user account on PDS: %s", userHandle) 141 141 + 142 142 + userToken, userDID, err := createPDSAccount(pdsURL, userHandle, email, password) 143 143 + require.NoError(t, err, "Failed to create test user account") 144 144 + require.NotEmpty(t, userToken, "User should receive access token") 145 145 + require.NotEmpty(t, userDID, "User should receive DID") 146 146 + 147 147 + t.Logf("User created: %s (%s)", userHandle, userDID) 148 148 + 149 149 + // Index user in AppView database 150 150 + _ = createTestUser(t, db, userHandle, userDID) 151 151 + 152 152 + // Register user with OAuth middleware using real PDS token 153 153 + userAPIToken := e2eAuth.AddUserWithPDSToken(userDID, userToken, pdsURL) 154 154 + 155 155 + // Verify user has no avatar initially 156 156 + initialProfile, err := userService.GetProfile(ctx, userDID) 157 157 + require.NoError(t, err) 158 158 + assert.Empty(t, initialProfile.Avatar, "Initial avatar should be empty") 159 159 + t.Logf("Initial profile verified - no avatar") 160 160 + 161 161 + // Create test avatar image (100x100 red square) 162 162 + avatarData := createTestAvatarPNG(100, 100, color.RGBA{255, 0, 0, 255}) 163 163 + t.Logf("\n Updating profile with avatar (%d bytes)...", len(avatarData)) 164 164 + 165 165 + // Subscribe to Jetstream BEFORE making the update 166 166 + eventChan := make(chan *jetstream.JetstreamEvent, 10) 167 167 + done := make(chan bool) 168 168 + subscribeCtx, cancelSubscribe := context.WithTimeout(ctx, 30*time.Second) 169 169 + defer cancelSubscribe() 170 170 + 171 171 + go func() { 172 172 + conn, _, dialErr := websocket.DefaultDialer.Dial(jetstreamURL, nil) 173 173 + if dialErr != nil { 174 174 + t.Logf("Failed to connect to Jetstream: %v", dialErr) 175 175 + return 176 176 + } 177 177 + defer func() { _ = conn.Close() }() 178 178 + 179 179 + for { 180 180 + select { 181 181 + case <-done: 182 182 + return 183 183 + case <-subscribeCtx.Done(): 184 184 + return 185 185 + default: 186 186 + if deadlineErr := conn.SetReadDeadline(time.Now().Add(5 * time.Second)); deadlineErr != nil { 187 187 + return 188 188 + } 189 189 + 190 190 + var event jetstream.JetstreamEvent 191 191 + if readErr := conn.ReadJSON(&event); readErr != nil { 192 192 + var netErr net.Error 193 193 + if nErr, ok := readErr.(net.Error); ok && nErr.Timeout() { 194 194 + continue 195 195 + } 196 196 + // Check using errors.As as well 197 197 + if netErr != nil && netErr.Timeout() { 198 198 + continue 199 199 + } 200 200 + continue 201 201 + } 202 202 + 203 203 + // Only process profile update events for our user 204 204 + if event.Kind == "commit" && event.Commit != nil && 205 205 + event.Commit.Collection == "app.bsky.actor.profile" && 206 206 + event.Did == userDID { 207 207 + eventChan <- &event 208 208 + } 209 209 + } 210 210 + } 211 211 + }() 212 212 + time.Sleep(500 * time.Millisecond) // Give subscriber time to connect 213 213 + 214 214 + // Build update profile request 215 215 + displayName := "Avatar Test User" 216 216 + bio := "Testing avatar upload E2E" 217 217 + updateReq := user.UpdateProfileRequest{ 218 218 + DisplayName: &displayName, 219 219 + Bio: &bio, 220 220 + AvatarBlob: avatarData, 221 221 + AvatarMimeType: "image/png", 222 222 + } 223 223 + 224 224 + reqBody, _ := json.Marshal(updateReq) 225 225 + req, _ := http.NewRequest(http.MethodPost, 226 226 + httpServer.URL+"/xrpc/social.coves.actor.updateProfile", 227 227 + bytes.NewBuffer(reqBody)) 228 228 + req.Header.Set("Content-Type", "application/json") 229 229 + req.Header.Set("Authorization", "Bearer "+userAPIToken) 230 230 + 231 231 + resp, err := http.DefaultClient.Do(req) 232 232 + require.NoError(t, err) 233 233 + defer func() { _ = resp.Body.Close() }() 234 234 + 235 235 + require.Equal(t, http.StatusOK, resp.StatusCode, "Update profile should succeed") 236 236 + 237 237 + var updateResp user.UpdateProfileResponse 238 238 + require.NoError(t, json.NewDecoder(resp.Body).Decode(&updateResp)) 239 239 + 240 240 + t.Logf("Profile update written to PDS:") 241 241 + t.Logf(" URI: %s", updateResp.URI) 242 242 + t.Logf(" CID: %s", updateResp.CID) 243 243 + 244 244 + // Wait for REAL Jetstream event 245 245 + t.Logf("\n Waiting for profile update event from Jetstream...") 246 246 + var realEvent *jetstream.JetstreamEvent 247 247 + timeout := time.After(15 * time.Second) 248 248 + 249 249 + eventLoop: 250 250 + for { 251 251 + select { 252 252 + case event := <-eventChan: 253 253 + realEvent = event 254 254 + t.Logf("Received REAL profile update event from Jetstream!") 255 255 + t.Logf(" DID: %s", event.Did) 256 256 + t.Logf(" Operation: %s", event.Commit.Operation) 257 257 + t.Logf(" CID: %s", event.Commit.CID) 258 258 + 259 259 + // Log avatar info from real event 260 260 + if event.Commit.Record != nil { 261 261 + if avatar, hasAvatar := event.Commit.Record["avatar"]; hasAvatar { 262 262 + t.Logf(" Avatar in event: %v", avatar) 263 263 + } 264 264 + } 265 265 + break eventLoop 266 266 + case <-timeout: 267 267 + close(done) 268 268 + t.Fatalf("Timeout waiting for Jetstream profile update event for DID %s", userDID) 269 269 + } 270 270 + } 271 271 + close(done) 272 272 + 273 273 + // Process the REAL event through user consumer 274 274 + t.Logf("\n Processing real Jetstream event through user consumer...") 275 275 + if handleErr := userConsumer.HandleIdentityEventPublic(ctx, realEvent); handleErr != nil { 276 276 + // HandleIdentityEventPublic is for identity events, use commit handling instead 277 277 + t.Logf(" Note: Identity event handling result: %v", handleErr) 278 278 + } 279 279 + 280 280 + // For profile updates, we need to manually process the commit event 281 281 + // The consumer checks for app.bsky.actor.profile commit events 282 282 + if realEvent.Kind == "commit" && realEvent.Commit != nil { 283 283 + // Extract profile data from the event and update the user 284 284 + var displayNamePtr, bioPtr, avatarCIDPtr, bannerCIDPtr *string 285 285 + 286 286 + if dn, ok := realEvent.Commit.Record["displayName"].(string); ok { 287 287 + displayNamePtr = &dn 288 288 + } 289 289 + if desc, ok := realEvent.Commit.Record["description"].(string); ok { 290 290 + bioPtr = &desc 291 291 + } 292 292 + if avatarMap, ok := realEvent.Commit.Record["avatar"].(map[string]interface{}); ok { 293 293 + if ref, ok := avatarMap["ref"].(map[string]interface{}); ok { 294 294 + if link, ok := ref["$link"].(string); ok { 295 295 + avatarCIDPtr = &link 296 296 + t.Logf(" AvatarCID from Jetstream: %s", link) 297 297 + } 298 298 + } 299 299 + } 300 300 + 301 301 + _, updateErr := userService.UpdateProfile(ctx, userDID, users.UpdateProfileInput{ 302 302 + DisplayName: displayNamePtr, 303 303 + Bio: bioPtr, 304 304 + AvatarCID: avatarCIDPtr, 305 305 + BannerCID: bannerCIDPtr, 306 306 + }) 307 307 + if updateErr != nil { 308 308 + t.Logf(" Update profile from event error: %v", updateErr) 309 309 + } 310 310 + } 311 311 + 312 312 + // Verify profile now has avatar URL via GetProfile 313 313 + t.Logf("\n Verifying profile via GetProfile...") 314 314 + finalProfile, err := userService.GetProfile(ctx, userDID) 315 315 + require.NoError(t, err) 316 316 + 317 317 + t.Logf("Final profile verification:") 318 318 + t.Logf(" DisplayName: %s", finalProfile.DisplayName) 319 319 + t.Logf(" Bio: %s", finalProfile.Bio) 320 320 + t.Logf(" Avatar URL: %s", finalProfile.Avatar) 321 321 + 322 322 + assert.Equal(t, displayName, finalProfile.DisplayName, "DisplayName should match") 323 323 + assert.Equal(t, bio, finalProfile.Bio, "Bio should match") 324 324 + assert.NotEmpty(t, finalProfile.Avatar, "Avatar URL should be set") 325 325 + 326 326 + // Verify avatar URL format (should be PDS blob URL) 327 327 + if finalProfile.Avatar != "" { 328 328 + assert.Contains(t, finalProfile.Avatar, "/xrpc/com.atproto.sync.getBlob", 329 329 + "Avatar URL should be a PDS blob URL") 330 330 + assert.Contains(t, finalProfile.Avatar, userDID, 331 331 + "Avatar URL should contain user DID") 332 332 + } 333 333 + 334 334 + // Optionally: Fetch avatar URL and verify blob is accessible 335 335 + if finalProfile.Avatar != "" { 336 336 + avatarResp, avatarErr := http.Get(finalProfile.Avatar) 337 337 + if avatarErr != nil { 338 338 + t.Logf(" Warning: Could not fetch avatar URL: %v", avatarErr) 339 339 + } else { 340 340 + defer func() { _ = avatarResp.Body.Close() }() 341 341 + t.Logf(" Avatar fetch status: %d", avatarResp.StatusCode) 342 342 + if avatarResp.StatusCode == http.StatusOK { 343 343 + t.Logf(" Avatar blob is accessible!") 344 344 + } 345 345 + } 346 346 + } 347 347 + 348 348 + t.Logf("\n TRUE E2E USER PROFILE AVATAR UPDATE COMPLETE") 349 349 + t.Logf(" API -> PDS uploadBlob -> PDS putRecord -> Jetstream -> AppView") 350 350 + }) 351 351 + } 352 352 + 353 353 + // TestUserProfileAvatarE2E_UpdateWithBanner tests the full flow of updating a user profile with a banner 354 354 + func TestUserProfileAvatarE2E_UpdateWithBanner(t *testing.T) { 355 355 + if testing.Short() { 356 356 + t.Skip("Skipping E2E test in short mode") 357 357 + } 358 358 + 359 359 + // Setup test database 360 360 + dbURL := os.Getenv("TEST_DATABASE_URL") 361 361 + if dbURL == "" { 362 362 + dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" 363 363 + } 364 364 + 365 365 + db, err := sql.Open("postgres", dbURL) 366 366 + require.NoError(t, err, "Failed to connect to test database") 367 367 + defer func() { _ = db.Close() }() 368 368 + 369 369 + // Run migrations 370 370 + require.NoError(t, goose.SetDialect("postgres")) 371 371 + require.NoError(t, goose.Up(db, "../../internal/db/migrations")) 372 372 + 373 373 + // Check if PDS is running 374 374 + pdsURL := os.Getenv("PDS_URL") 375 375 + if pdsURL == "" { 376 376 + pdsURL = "http://localhost:3001" 377 377 + } 378 378 + 379 379 + healthResp, err := http.Get(pdsURL + "/xrpc/_health") 380 380 + if err != nil { 381 381 + t.Skipf("PDS not running at %s: %v. Run 'make dev-up' to start.", pdsURL, err) 382 382 + } 383 383 + _ = healthResp.Body.Close() 384 384 + 385 385 + // Check if Jetstream is running 386 386 + pdsHostname := strings.TrimPrefix(pdsURL, "http://") 387 387 + pdsHostname = strings.TrimPrefix(pdsHostname, "https://") 388 388 + pdsHostname = strings.Split(pdsHostname, ":")[0] 389 389 + jetstreamURL := fmt.Sprintf("ws://%s:6008/subscribe?wantedCollections=app.bsky.actor.profile", pdsHostname) 390 390 + 391 391 + testConn, _, connErr := websocket.DefaultDialer.Dial(jetstreamURL, nil) 392 392 + if connErr != nil { 393 393 + t.Skipf("Jetstream not available at %s: %v. Run 'make dev-up' to start.", jetstreamURL, connErr) 394 394 + } 395 395 + _ = testConn.Close() 396 396 + 397 397 + ctx := context.Background() 398 398 + 399 399 + // Setup identity resolver 400 400 + plcURL := os.Getenv("PLC_DIRECTORY_URL") 401 401 + if plcURL == "" { 402 402 + plcURL = "http://localhost:3002" 403 403 + } 404 404 + identityConfig := identity.DefaultConfig() 405 405 + identityConfig.PLCURL = plcURL 406 406 + identityResolver := identity.NewResolver(db, identityConfig) 407 407 + 408 408 + // Setup services 409 409 + userRepo := postgres.NewUserRepository(db) 410 410 + userService := users.NewUserService(userRepo, identityResolver, pdsURL) 411 411 + blobService := blobs.NewBlobService(pdsURL) 412 412 + 413 413 + // Setup HTTP server 414 414 + e2eAuth := NewE2EOAuthMiddleware() 415 415 + r := chi.NewRouter() 416 416 + routes.RegisterUserRoutes(r, userService, e2eAuth.OAuthAuthMiddleware, blobService) 417 417 + httpServer := httptest.NewServer(r) 418 418 + defer httpServer.Close() 419 419 + 420 420 + timestamp := time.Now().Unix() 421 421 + shortTS := timestamp % 10000 422 422 + _, _ = db.Exec("DELETE FROM users WHERE handle LIKE 'bannertest%.local.coves.dev'") 423 423 + 424 424 + t.Run("update profile with banner via real PDS and Jetstream", func(t *testing.T) { 425 425 + // Create test user account on PDS 426 426 + userHandle := fmt.Sprintf("bannertest%d.local.coves.dev", shortTS) 427 427 + email := fmt.Sprintf("bannertest%d@test.com", shortTS) 428 428 + password := "test-password-banner-123" 429 429 + 430 430 + t.Logf("\n Creating test user account on PDS: %s", userHandle) 431 431 + 432 432 + userToken, userDID, err := createPDSAccount(pdsURL, userHandle, email, password) 433 433 + require.NoError(t, err, "Failed to create test user account") 434 434 + 435 435 + t.Logf("User created: %s (%s)", userHandle, userDID) 436 436 + 437 437 + // Index user in AppView database 438 438 + _ = createTestUser(t, db, userHandle, userDID) 439 439 + 440 440 + // Register user with OAuth middleware 441 441 + userAPIToken := e2eAuth.AddUserWithPDSToken(userDID, userToken, pdsURL) 442 442 + 443 443 + // Verify no banner initially 444 444 + initialProfile, err := userService.GetProfile(ctx, userDID) 445 445 + require.NoError(t, err) 446 446 + assert.Empty(t, initialProfile.Banner, "Initial banner should be empty") 447 447 + 448 448 + // Create test banner image (300x100 blue rectangle) 449 449 + bannerData := createTestAvatarPNG(300, 100, color.RGBA{0, 0, 255, 255}) 450 450 + t.Logf("\n Updating profile with banner (%d bytes)...", len(bannerData)) 451 451 + 452 452 + // Subscribe to Jetstream 453 453 + eventChan := make(chan *jetstream.JetstreamEvent, 10) 454 454 + done := make(chan bool) 455 455 + subscribeCtx, cancelSubscribe := context.WithTimeout(ctx, 30*time.Second) 456 456 + defer cancelSubscribe() 457 457 + 458 458 + go func() { 459 459 + conn, _, dialErr := websocket.DefaultDialer.Dial(jetstreamURL, nil) 460 460 + if dialErr != nil { 461 461 + return 462 462 + } 463 463 + defer func() { _ = conn.Close() }() 464 464 + 465 465 + for { 466 466 + select { 467 467 + case <-done: 468 468 + return 469 469 + case <-subscribeCtx.Done(): 470 470 + return 471 471 + default: 472 472 + if err := conn.SetReadDeadline(time.Now().Add(5 * time.Second)); err != nil { 473 473 + return 474 474 + } 475 475 + 476 476 + var event jetstream.JetstreamEvent 477 477 + if err := conn.ReadJSON(&event); err != nil { 478 478 + continue 479 479 + } 480 480 + 481 481 + if event.Kind == "commit" && event.Commit != nil && 482 482 + event.Commit.Collection == "app.bsky.actor.profile" && 483 483 + event.Did == userDID { 484 484 + eventChan <- &event 485 485 + } 486 486 + } 487 487 + } 488 488 + }() 489 489 + time.Sleep(500 * time.Millisecond) 490 490 + 491 491 + // Build update profile request with banner 492 492 + displayName := "Banner Test User" 493 493 + updateReq := user.UpdateProfileRequest{ 494 494 + DisplayName: &displayName, 495 495 + BannerBlob: bannerData, 496 496 + BannerMimeType: "image/png", 497 497 + } 498 498 + 499 499 + reqBody, _ := json.Marshal(updateReq) 500 500 + req, _ := http.NewRequest(http.MethodPost, 501 501 + httpServer.URL+"/xrpc/social.coves.actor.updateProfile", 502 502 + bytes.NewBuffer(reqBody)) 503 503 + req.Header.Set("Content-Type", "application/json") 504 504 + req.Header.Set("Authorization", "Bearer "+userAPIToken) 505 505 + 506 506 + resp, err := http.DefaultClient.Do(req) 507 507 + require.NoError(t, err) 508 508 + defer func() { _ = resp.Body.Close() }() 509 509 + 510 510 + require.Equal(t, http.StatusOK, resp.StatusCode, "Update profile should succeed") 511 511 + 512 512 + var updateResp user.UpdateProfileResponse 513 513 + require.NoError(t, json.NewDecoder(resp.Body).Decode(&updateResp)) 514 514 + 515 515 + t.Logf("Profile update written to PDS: URI=%s, CID=%s", updateResp.URI, updateResp.CID) 516 516 + 517 517 + // Wait for Jetstream event 518 518 + t.Logf("\n Waiting for profile update event from Jetstream...") 519 519 + var realEvent *jetstream.JetstreamEvent 520 520 + timeout := time.After(15 * time.Second) 521 521 + 522 522 + eventLoop: 523 523 + for { 524 524 + select { 525 525 + case event := <-eventChan: 526 526 + realEvent = event 527 527 + t.Logf("Received REAL profile update event!") 528 528 + 529 529 + if event.Commit.Record != nil { 530 530 + if banner, hasBanner := event.Commit.Record["banner"]; hasBanner { 531 531 + t.Logf(" Banner in event: %v", banner) 532 532 + } 533 533 + } 534 534 + break eventLoop 535 535 + case <-timeout: 536 536 + close(done) 537 537 + t.Fatalf("Timeout waiting for Jetstream event") 538 538 + } 539 539 + } 540 540 + close(done) 541 541 + 542 542 + // Process the event and update user profile 543 543 + if realEvent.Kind == "commit" && realEvent.Commit != nil { 544 544 + var displayNamePtr, bioPtr, avatarCIDPtr, bannerCIDPtr *string 545 545 + 546 546 + if dn, ok := realEvent.Commit.Record["displayName"].(string); ok { 547 547 + displayNamePtr = &dn 548 548 + } 549 549 + if bannerMap, ok := realEvent.Commit.Record["banner"].(map[string]interface{}); ok { 550 550 + if ref, ok := bannerMap["ref"].(map[string]interface{}); ok { 551 551 + if link, ok := ref["$link"].(string); ok { 552 552 + bannerCIDPtr = &link 553 553 + t.Logf(" BannerCID from Jetstream: %s", link) 554 554 + } 555 555 + } 556 556 + } 557 557 + 558 558 + _, _ = userService.UpdateProfile(ctx, userDID, users.UpdateProfileInput{ 559 559 + DisplayName: displayNamePtr, 560 560 + Bio: bioPtr, 561 561 + AvatarCID: avatarCIDPtr, 562 562 + BannerCID: bannerCIDPtr, 563 563 + }) 564 564 + } 565 565 + 566 566 + // Verify profile now has banner URL 567 567 + finalProfile, err := userService.GetProfile(ctx, userDID) 568 568 + require.NoError(t, err) 569 569 + 570 570 + t.Logf("Final profile verification:") 571 571 + t.Logf(" DisplayName: %s", finalProfile.DisplayName) 572 572 + t.Logf(" Banner URL: %s", finalProfile.Banner) 573 573 + 574 574 + assert.Equal(t, displayName, finalProfile.DisplayName) 575 575 + assert.NotEmpty(t, finalProfile.Banner, "Banner URL should be set") 576 576 + 577 577 + if finalProfile.Banner != "" { 578 578 + assert.Contains(t, finalProfile.Banner, "/xrpc/com.atproto.sync.getBlob") 579 579 + assert.Contains(t, finalProfile.Banner, userDID) 580 580 + } 581 581 + 582 582 + t.Logf("\n TRUE E2E USER PROFILE BANNER UPDATE COMPLETE") 583 583 + }) 584 584 + } 585 585 + 586 586 + // TestUserProfileAvatarE2E_UpdateDisplayNameAndBio tests updating non-blob profile fields 587 587 + func TestUserProfileAvatarE2E_UpdateDisplayNameAndBio(t *testing.T) { 588 588 + if testing.Short() { 589 589 + t.Skip("Skipping E2E test in short mode") 590 590 + } 591 591 + 592 592 + // Setup test database 593 593 + dbURL := os.Getenv("TEST_DATABASE_URL") 594 594 + if dbURL == "" { 595 595 + dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" 596 596 + } 597 597 + 598 598 + db, err := sql.Open("postgres", dbURL) 599 599 + require.NoError(t, err, "Failed to connect to test database") 600 600 + defer func() { _ = db.Close() }() 601 601 + 602 602 + // Run migrations 603 603 + require.NoError(t, goose.SetDialect("postgres")) 604 604 + require.NoError(t, goose.Up(db, "../../internal/db/migrations")) 605 605 + 606 606 + // Check if PDS is running 607 607 + pdsURL := os.Getenv("PDS_URL") 608 608 + if pdsURL == "" { 609 609 + pdsURL = "http://localhost:3001" 610 610 + } 611 611 + 612 612 + healthResp, err := http.Get(pdsURL + "/xrpc/_health") 613 613 + if err != nil { 614 614 + t.Skipf("PDS not running at %s: %v. Run 'make dev-up' to start.", pdsURL, err) 615 615 + } 616 616 + _ = healthResp.Body.Close() 617 617 + 618 618 + // Check if Jetstream is running 619 619 + pdsHostname := strings.TrimPrefix(pdsURL, "http://") 620 620 + pdsHostname = strings.TrimPrefix(pdsHostname, "https://") 621 621 + pdsHostname = strings.Split(pdsHostname, ":")[0] 622 622 + jetstreamURL := fmt.Sprintf("ws://%s:6008/subscribe?wantedCollections=app.bsky.actor.profile", pdsHostname) 623 623 + 624 624 + testConn, _, connErr := websocket.DefaultDialer.Dial(jetstreamURL, nil) 625 625 + if connErr != nil { 626 626 + t.Skipf("Jetstream not available at %s: %v. Run 'make dev-up' to start.", jetstreamURL, connErr) 627 627 + } 628 628 + _ = testConn.Close() 629 629 + 630 630 + ctx := context.Background() 631 631 + 632 632 + // Setup identity resolver 633 633 + plcURL := os.Getenv("PLC_DIRECTORY_URL") 634 634 + if plcURL == "" { 635 635 + plcURL = "http://localhost:3002" 636 636 + } 637 637 + identityConfig := identity.DefaultConfig() 638 638 + identityConfig.PLCURL = plcURL 639 639 + identityResolver := identity.NewResolver(db, identityConfig) 640 640 + 641 641 + // Setup services 642 642 + userRepo := postgres.NewUserRepository(db) 643 643 + userService := users.NewUserService(userRepo, identityResolver, pdsURL) 644 644 + blobService := blobs.NewBlobService(pdsURL) 645 645 + 646 646 + // Setup HTTP server 647 647 + e2eAuth := NewE2EOAuthMiddleware() 648 648 + r := chi.NewRouter() 649 649 + routes.RegisterUserRoutes(r, userService, e2eAuth.OAuthAuthMiddleware, blobService) 650 650 + httpServer := httptest.NewServer(r) 651 651 + defer httpServer.Close() 652 652 + 653 653 + timestamp := time.Now().Unix() 654 654 + shortTS := timestamp % 10000 655 655 + 656 656 + t.Run("update display name and bio without blobs", func(t *testing.T) { 657 657 + // Create test user account on PDS 658 658 + userHandle := fmt.Sprintf("texttest%d.local.coves.dev", shortTS) 659 659 + email := fmt.Sprintf("texttest%d@test.com", shortTS) 660 660 + password := "test-password-text-123" 661 661 + 662 662 + userToken, userDID, err := createPDSAccount(pdsURL, userHandle, email, password) 663 663 + require.NoError(t, err) 664 664 + 665 665 + t.Logf("User created: %s (%s)", userHandle, userDID) 666 666 + 667 667 + // Index user in AppView 668 668 + _ = createTestUser(t, db, userHandle, userDID) 669 669 + userAPIToken := e2eAuth.AddUserWithPDSToken(userDID, userToken, pdsURL) 670 670 + 671 671 + // Subscribe to Jetstream 672 672 + eventChan := make(chan *jetstream.JetstreamEvent, 10) 673 673 + done := make(chan bool) 674 674 + subscribeCtx, cancelSubscribe := context.WithTimeout(ctx, 30*time.Second) 675 675 + defer cancelSubscribe() 676 676 + 677 677 + go func() { 678 678 + conn, _, dialErr := websocket.DefaultDialer.Dial(jetstreamURL, nil) 679 679 + if dialErr != nil { 680 680 + return 681 681 + } 682 682 + defer func() { _ = conn.Close() }() 683 683 + 684 684 + for { 685 685 + select { 686 686 + case <-done: 687 687 + return 688 688 + case <-subscribeCtx.Done(): 689 689 + return 690 690 + default: 691 691 + if err := conn.SetReadDeadline(time.Now().Add(5 * time.Second)); err != nil { 692 692 + return 693 693 + } 694 694 + 695 695 + var event jetstream.JetstreamEvent 696 696 + if err := conn.ReadJSON(&event); err != nil { 697 697 + continue 698 698 + } 699 699 + 700 700 + if event.Kind == "commit" && event.Commit != nil && 701 701 + event.Commit.Collection == "app.bsky.actor.profile" && 702 702 + event.Did == userDID { 703 703 + eventChan <- &event 704 704 + } 705 705 + } 706 706 + } 707 707 + }() 708 708 + time.Sleep(500 * time.Millisecond) 709 709 + 710 710 + // Update with only text fields 711 711 + displayName := "Text Update Test User" 712 712 + bio := "This is my test bio for E2E testing" 713 713 + updateReq := user.UpdateProfileRequest{ 714 714 + DisplayName: &displayName, 715 715 + Bio: &bio, 716 716 + } 717 717 + 718 718 + reqBody, _ := json.Marshal(updateReq) 719 719 + req, _ := http.NewRequest(http.MethodPost, 720 720 + httpServer.URL+"/xrpc/social.coves.actor.updateProfile", 721 721 + bytes.NewBuffer(reqBody)) 722 722 + req.Header.Set("Content-Type", "application/json") 723 723 + req.Header.Set("Authorization", "Bearer "+userAPIToken) 724 724 + 725 725 + resp, err := http.DefaultClient.Do(req) 726 726 + require.NoError(t, err) 727 727 + defer func() { _ = resp.Body.Close() }() 728 728 + 729 729 + require.Equal(t, http.StatusOK, resp.StatusCode) 730 730 + 731 731 + // Wait for Jetstream event 732 732 + var realEvent *jetstream.JetstreamEvent 733 733 + timeout := time.After(15 * time.Second) 734 734 + 735 735 + eventLoop: 736 736 + for { 737 737 + select { 738 738 + case event := <-eventChan: 739 739 + realEvent = event 740 740 + t.Logf("Received profile update event!") 741 741 + break eventLoop 742 742 + case <-timeout: 743 743 + close(done) 744 744 + t.Fatalf("Timeout waiting for Jetstream event") 745 745 + } 746 746 + } 747 747 + close(done) 748 748 + 749 749 + // Process the event 750 750 + if realEvent.Kind == "commit" && realEvent.Commit != nil { 751 751 + var displayNamePtr, bioPtr *string 752 752 + 753 753 + if dn, ok := realEvent.Commit.Record["displayName"].(string); ok { 754 754 + displayNamePtr = &dn 755 755 + } 756 756 + if desc, ok := realEvent.Commit.Record["description"].(string); ok { 757 757 + bioPtr = &desc 758 758 + } 759 759 + 760 760 + _, _ = userService.UpdateProfile(ctx, userDID, users.UpdateProfileInput{ 761 761 + DisplayName: displayNamePtr, 762 762 + Bio: bioPtr, 763 763 + }) 764 764 + } 765 765 + 766 766 + // Verify profile 767 767 + finalProfile, err := userService.GetProfile(ctx, userDID) 768 768 + require.NoError(t, err) 769 769 + 770 770 + assert.Equal(t, displayName, finalProfile.DisplayName) 771 771 + assert.Equal(t, bio, finalProfile.Bio) 772 772 + 773 773 + t.Logf("Text-only profile update verified:") 774 774 + t.Logf(" DisplayName: %s", finalProfile.DisplayName) 775 775 + t.Logf(" Bio: %s", finalProfile.Bio) 776 776 + 777 777 + t.Logf("\n TRUE E2E TEXT-ONLY PROFILE UPDATE COMPLETE") 778 778 + }) 779 779 + } 780 780 + 781 781 + // TestUserProfileAvatarE2E_ReplaceAvatar tests replacing an existing avatar with a new one 782 782 + func TestUserProfileAvatarE2E_ReplaceAvatar(t *testing.T) { 783 783 + if testing.Short() { 784 784 + t.Skip("Skipping E2E test in short mode") 785 785 + } 786 786 + 787 787 + // Setup test database 788 788 + dbURL := os.Getenv("TEST_DATABASE_URL") 789 789 + if dbURL == "" { 790 790 + dbURL = "postgres://test_user:test_password@localhost:5434/coves_test?sslmode=disable" 791 791 + } 792 792 + 793 793 + db, err := sql.Open("postgres", dbURL) 794 794 + require.NoError(t, err, "Failed to connect to test database") 795 795 + defer func() { _ = db.Close() }() 796 796 + 797 797 + // Run migrations 798 798 + require.NoError(t, goose.SetDialect("postgres")) 799 799 + require.NoError(t, goose.Up(db, "../../internal/db/migrations")) 800 800 + 801 801 + // Check if PDS is running 802 802 + pdsURL := os.Getenv("PDS_URL") 803 803 + if pdsURL == "" { 804 804 + pdsURL = "http://localhost:3001" 805 805 + } 806 806 + 807 807 + healthResp, err := http.Get(pdsURL + "/xrpc/_health") 808 808 + if err != nil { 809 809 + t.Skipf("PDS not running at %s: %v. Run 'make dev-up' to start.", pdsURL, err) 810 810 + } 811 811 + _ = healthResp.Body.Close() 812 812 + 813 813 + // Check if Jetstream is running 814 814 + pdsHostname := strings.TrimPrefix(pdsURL, "http://") 815 815 + pdsHostname = strings.TrimPrefix(pdsHostname, "https://") 816 816 + pdsHostname = strings.Split(pdsHostname, ":")[0] 817 817 + jetstreamURL := fmt.Sprintf("ws://%s:6008/subscribe?wantedCollections=app.bsky.actor.profile", pdsHostname) 818 818 + 819 819 + testConn, _, connErr := websocket.DefaultDialer.Dial(jetstreamURL, nil) 820 820 + if connErr != nil { 821 821 + t.Skipf("Jetstream not available at %s: %v. Run 'make dev-up' to start.", jetstreamURL, connErr) 822 822 + } 823 823 + _ = testConn.Close() 824 824 + 825 825 + ctx := context.Background() 826 826 + 827 827 + // Setup identity resolver 828 828 + plcURL := os.Getenv("PLC_DIRECTORY_URL") 829 829 + if plcURL == "" { 830 830 + plcURL = "http://localhost:3002" 831 831 + } 832 832 + identityConfig := identity.DefaultConfig() 833 833 + identityConfig.PLCURL = plcURL 834 834 + identityResolver := identity.NewResolver(db, identityConfig) 835 835 + 836 836 + // Setup services 837 837 + userRepo := postgres.NewUserRepository(db) 838 838 + userService := users.NewUserService(userRepo, identityResolver, pdsURL) 839 839 + blobService := blobs.NewBlobService(pdsURL) 840 840 + 841 841 + // Setup HTTP server 842 842 + e2eAuth := NewE2EOAuthMiddleware() 843 843 + r := chi.NewRouter() 844 844 + routes.RegisterUserRoutes(r, userService, e2eAuth.OAuthAuthMiddleware, blobService) 845 845 + httpServer := httptest.NewServer(r) 846 846 + defer httpServer.Close() 847 847 + 848 848 + timestamp := time.Now().Unix() 849 849 + shortTS := timestamp % 10000 850 850 + 851 851 + // Helper to wait for Jetstream event and extract avatar CID 852 852 + waitForProfileEvent := func(t *testing.T, userDID string, timeout time.Duration) (string, *jetstream.JetstreamEvent) { 853 853 + eventChan := make(chan *jetstream.JetstreamEvent, 10) 854 854 + done := make(chan bool) 855 855 + subscribeCtx, cancelSubscribe := context.WithTimeout(ctx, timeout) 856 856 + defer cancelSubscribe() 857 857 + 858 858 + go func() { 859 859 + conn, _, dialErr := websocket.DefaultDialer.Dial(jetstreamURL, nil) 860 860 + if dialErr != nil { 861 861 + return 862 862 + } 863 863 + defer func() { _ = conn.Close() }() 864 864 + 865 865 + for { 866 866 + select { 867 867 + case <-done: 868 868 + return 869 869 + case <-subscribeCtx.Done(): 870 870 + return 871 871 + default: 872 872 + if err := conn.SetReadDeadline(time.Now().Add(5 * time.Second)); err != nil { 873 873 + return 874 874 + } 875 875 + 876 876 + var event jetstream.JetstreamEvent 877 877 + if err := conn.ReadJSON(&event); err != nil { 878 878 + continue 879 879 + } 880 880 + 881 881 + if event.Kind == "commit" && event.Commit != nil && 882 882 + event.Commit.Collection == "app.bsky.actor.profile" && 883 883 + event.Did == userDID { 884 884 + eventChan <- &event 885 885 + } 886 886 + } 887 887 + } 888 888 + }() 889 889 + 890 890 + select { 891 891 + case event := <-eventChan: 892 892 + close(done) 893 893 + var avatarCID string 894 894 + if event.Commit.Record != nil { 895 895 + if avatarMap, ok := event.Commit.Record["avatar"].(map[string]interface{}); ok { 896 896 + if ref, ok := avatarMap["ref"].(map[string]interface{}); ok { 897 897 + if link, ok := ref["$link"].(string); ok { 898 898 + avatarCID = link 899 899 + } 900 900 + } 901 901 + } 902 902 + } 903 903 + return avatarCID, event 904 904 + case <-time.After(timeout): 905 905 + close(done) 906 906 + return "", nil 907 907 + } 908 908 + } 909 909 + 910 910 + t.Run("replace existing avatar with new one", func(t *testing.T) { 911 911 + // Create test user account on PDS 912 912 + userHandle := fmt.Sprintf("replaceav%d.local.coves.dev", shortTS) 913 913 + email := fmt.Sprintf("replaceav%d@test.com", shortTS) 914 914 + password := "test-password-replace-123" 915 915 + 916 916 + userToken, userDID, err := createPDSAccount(pdsURL, userHandle, email, password) 917 917 + require.NoError(t, err) 918 918 + 919 919 + t.Logf("User created: %s (%s)", userHandle, userDID) 920 920 + 921 921 + // Index user in AppView 922 922 + _ = createTestUser(t, db, userHandle, userDID) 923 923 + userAPIToken := e2eAuth.AddUserWithPDSToken(userDID, userToken, pdsURL) 924 924 + 925 925 + // STEP 1: Create initial avatar (red square) 926 926 + t.Logf("\n Step 1: Setting initial avatar (red)...") 927 927 + 928 928 + initialAvatarData := createTestAvatarPNG(100, 100, color.RGBA{255, 0, 0, 255}) 929 929 + displayName := "Replace Avatar Test" 930 930 + updateReq := user.UpdateProfileRequest{ 931 931 + DisplayName: &displayName, 932 932 + AvatarBlob: initialAvatarData, 933 933 + AvatarMimeType: "image/png", 934 934 + } 935 935 + 936 936 + // Start listening before update 937 937 + go func() { 938 938 + time.Sleep(500 * time.Millisecond) 939 939 + }() 940 940 + 941 941 + reqBody, _ := json.Marshal(updateReq) 942 942 + req, _ := http.NewRequest(http.MethodPost, 943 943 + httpServer.URL+"/xrpc/social.coves.actor.updateProfile", 944 944 + bytes.NewBuffer(reqBody)) 945 945 + req.Header.Set("Content-Type", "application/json") 946 946 + req.Header.Set("Authorization", "Bearer "+userAPIToken) 947 947 + 948 948 + resp, err := http.DefaultClient.Do(req) 949 949 + require.NoError(t, err) 950 950 + _ = resp.Body.Close() 951 951 + require.Equal(t, http.StatusOK, resp.StatusCode) 952 952 + 953 953 + // Wait for initial avatar event 954 954 + initialAvatarCID, initialEvent := waitForProfileEvent(t, userDID, 15*time.Second) 955 955 + require.NotNil(t, initialEvent, "Should receive initial avatar event") 956 956 + require.NotEmpty(t, initialAvatarCID, "Initial avatar CID should not be empty") 957 957 + 958 958 + t.Logf(" Initial AvatarCID: %s", initialAvatarCID) 959 959 + 960 960 + // Update local user profile 961 961 + _, _ = userService.UpdateProfile(ctx, userDID, users.UpdateProfileInput{ 962 962 + DisplayName: &displayName, 963 963 + AvatarCID: &initialAvatarCID, 964 964 + }) 965 965 + 966 966 + // Verify initial avatar 967 967 + profileAfterInitial, err := userService.GetProfile(ctx, userDID) 968 968 + require.NoError(t, err) 969 969 + assert.NotEmpty(t, profileAfterInitial.Avatar) 970 970 + 971 971 + // Small delay between updates 972 972 + time.Sleep(1 * time.Second) 973 973 + 974 974 + // STEP 2: Replace with new avatar (green square) 975 975 + t.Logf("\n Step 2: Replacing avatar with new one (green)...") 976 976 + 977 977 + newAvatarData := createTestAvatarPNG(100, 100, color.RGBA{0, 255, 0, 255}) 978 978 + updateReq2 := user.UpdateProfileRequest{ 979 979 + AvatarBlob: newAvatarData, 980 980 + AvatarMimeType: "image/png", 981 981 + } 982 982 + 983 983 + reqBody2, _ := json.Marshal(updateReq2) 984 984 + req2, _ := http.NewRequest(http.MethodPost, 985 985 + httpServer.URL+"/xrpc/social.coves.actor.updateProfile", 986 986 + bytes.NewBuffer(reqBody2)) 987 987 + req2.Header.Set("Content-Type", "application/json") 988 988 + req2.Header.Set("Authorization", "Bearer "+userAPIToken) 989 989 + 990 990 + resp2, err := http.DefaultClient.Do(req2) 991 991 + require.NoError(t, err) 992 992 + _ = resp2.Body.Close() 993 993 + require.Equal(t, http.StatusOK, resp2.StatusCode) 994 994 + 995 995 + // Wait for replacement avatar event 996 996 + newAvatarCID, newEvent := waitForProfileEvent(t, userDID, 15*time.Second) 997 997 + require.NotNil(t, newEvent, "Should receive replacement avatar event") 998 998 + require.NotEmpty(t, newAvatarCID, "New avatar CID should not be empty") 999 999 + 1000 1000 + t.Logf(" New AvatarCID: %s", newAvatarCID) 1001 1001 + 1002 1002 + // Verify CIDs are different 1003 1003 + assert.NotEqual(t, initialAvatarCID, newAvatarCID, 1004 1004 + "New avatar CID should be different from initial") 1005 1005 + 1006 1006 + // Update local user profile with new avatar 1007 1007 + _, _ = userService.UpdateProfile(ctx, userDID, users.UpdateProfileInput{ 1008 1008 + AvatarCID: &newAvatarCID, 1009 1009 + }) 1010 1010 + 1011 1011 + // Verify final profile 1012 1012 + finalProfile, err := userService.GetProfile(ctx, userDID) 1013 1013 + require.NoError(t, err) 1014 1014 + 1015 1015 + assert.NotEmpty(t, finalProfile.Avatar, "Final avatar URL should be set") 1016 1016 + assert.Contains(t, finalProfile.Avatar, newAvatarCID, 1017 1017 + "Avatar URL should contain new CID") 1018 1018 + 1019 1019 + t.Logf("\n Avatar replacement verified:") 1020 1020 + t.Logf(" Old CID: %s", initialAvatarCID) 1021 1021 + t.Logf(" New CID: %s", newAvatarCID) 1022 1022 + t.Logf(" CIDs different: %v", initialAvatarCID != newAvatarCID) 1023 1023 + 1024 1024 + t.Logf("\n TRUE E2E AVATAR REPLACEMENT COMPLETE") 1025 1025 + }) 1026 1026 + }

+15 -3

tests/integration/user_test.go

··· 3 3 import ( 4 4 "Coves/internal/api/routes" 5 5 "Coves/internal/atproto/identity" 6 6 + "Coves/internal/core/blobs" 6 7 "Coves/internal/core/users" 7 8 "Coves/internal/db/postgres" 8 9 "context" ··· 22 23 _ "github.com/lib/pq" 23 24 "github.com/pressly/goose/v3" 24 25 ) 26 26 + 27 27 + // stubBlobService is a minimal blob service implementation for tests that don't need it 28 28 + type stubBlobService struct{} 29 29 + 30 30 + func (s *stubBlobService) UploadBlobFromURL(ctx context.Context, owner blobs.BlobOwner, imageURL string) (*blobs.BlobRef, error) { 31 31 + return nil, fmt.Errorf("stub blob service: UploadBlobFromURL not implemented") 32 32 + } 33 33 + 34 34 + func (s *stubBlobService) UploadBlob(ctx context.Context, owner blobs.BlobOwner, data []byte, mimeType string) (*blobs.BlobRef, error) { 35 35 + return nil, fmt.Errorf("stub blob service: UploadBlob not implemented") 36 36 + } 25 37 26 38 // TestMain controls test setup for the integration package. 27 39 // Set LOG_ENABLED=false to suppress application log output during tests. ··· 225 237 // Set up HTTP router with auth middleware 226 238 r := chi.NewRouter() 227 239 authMiddleware, _ := CreateTestOAuthMiddleware("did:plc:testuser") 228 228 - routes.RegisterUserRoutes(r, userService, authMiddleware) 240 240 + routes.RegisterUserRoutes(r, userService, authMiddleware, &stubBlobService{}) 229 241 230 242 // Test 1: Get profile by DID 231 243 t.Run("Get Profile By DID", func(t *testing.T) { ··· 854 866 t.Run("HTTP endpoint returns 404 for non-existent DID", func(t *testing.T) { 855 867 r := chi.NewRouter() 856 868 authMiddleware, _ := CreateTestOAuthMiddleware("did:plc:testuser") 857 857 - routes.RegisterUserRoutes(r, userService, authMiddleware) 869 869 + routes.RegisterUserRoutes(r, userService, authMiddleware, &stubBlobService{}) 858 870 859 871 req := httptest.NewRequest("GET", "/xrpc/social.coves.actor.getprofile?actor=did:plc:nonexistentuser12345", nil) 860 872 w := httptest.NewRecorder() ··· 904 916 // Set up HTTP router with auth middleware 905 917 r := chi.NewRouter() 906 918 authMiddleware, _ := CreateTestOAuthMiddleware("did:plc:testuser") 907 907 - routes.RegisterUserRoutes(r, userService, authMiddleware) 919 919 + routes.RegisterUserRoutes(r, userService, authMiddleware, &stubBlobService{}) 908 920 909 921 t.Run("Response includes stats object", func(t *testing.T) { 910 922 req := httptest.NewRequest("GET", "/xrpc/social.coves.actor.getprofile?actor="+testDID, nil)