commit 0478370ea03bfe9194be23aac748d1d110567856 · bretton.dev/coves

+287 -18

internal/core/comments/comment_service_test.go

···

       17
       17
        
       

     

       18
       18
        
       // mockCommentRepo is a mock implementation of the comment Repository interface

     

       19
       19
        
       type mockCommentRepo struct {

     

       20
       20
       -
       	comments               map[string]*Comment

     

       20
       20
       +
       	comments                    map[string]*Comment

     

       21
       21
        
       	listByParentWithHotRankFunc func(ctx context.Context, parentURI string, sort string, timeframe string, limit int, cursor *string) ([]*Comment, *string, error)

     

       22
       22
        
       	listByParentsBatchFunc      func(ctx context.Context, parentURIs []string, sort string, limitPerParent int) (map[string][]*Comment, error)

     

       23
       23
        
       	getVoteStateForCommentsFunc func(ctx context.Context, viewerDID string, commentURIs []string) (map[string]interface{}, error)

     
···

       151
       151
        
       		return u, nil

     

       152
       152
        
       	}

     

       153
       153
        
       	return nil, errors.New("user not found")

     

       154
       154
       +
       }

     

       155
       155
       +
       

     

       156
       156
       +
       func (m *mockUserRepo) GetByDIDs(ctx context.Context, dids []string) (map[string]*users.User, error) {

     

       157
       157
       +
       	result := make(map[string]*users.User, len(dids))

     

       158
       158
       +
       	for _, did := range dids {

     

       159
       159
       +
       		if u, ok := m.users[did]; ok {

     

       160
       160
       +
       			result[did] = u

     

       161
       161
       +
       		}

     

       162
       162
       +
       	}

     

       163
       163
       +
       	return result, nil

     

       154
       164
        
       }

     

       155
       165
        
       

     

       156
       166
        
       // mockPostRepo is a mock implementation of the posts.Repository interface

     
···

       336
       346
        
       	title := "Test Post"

     

       337
       347
        
       	content := "Test content"

     

       338
       348
        
       	return &posts.Post{

     

       339
       339
       -
       		URI:          uri,

     

       340
       340
       -
       		CID:          "bafytest123",

     

       341
       341
       -
       		RKey:         "testrkey",

     

       342
       342
       -
       		AuthorDID:    authorDID,

     

       343
       343
       -
       		CommunityDID: communityDID,

     

       344
       344
       -
       		Title:        &title,

     

       345
       345
       -
       		Content:      &content,

     

       346
       346
       -
       		CreatedAt:    time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),

     

       347
       347
       -
       		IndexedAt:    time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),

     

       348
       348
       -
       		UpvoteCount:  10,

     

       349
       349
       +
       		URI:           uri,

     

       350
       350
       +
       		CID:           "bafytest123",

     

       351
       351
       +
       		RKey:          "testrkey",

     

       352
       352
       +
       		AuthorDID:     authorDID,

     

       353
       353
       +
       		CommunityDID:  communityDID,

     

       354
       354
       +
       		Title:         &title,

     

       355
       355
       +
       		Content:       &content,

     

       356
       356
       +
       		CreatedAt:     time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),

     

       357
       357
       +
       		IndexedAt:     time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),

     

       358
       358
       +
       		UpvoteCount:   10,

     

       349
       359
        
       		DownvoteCount: 2,

     

       350
       350
       -
       		Score:        8,

     

       351
       351
       -
       		CommentCount: 5,

     

       360
       360
       +
       		Score:         8,

     

       361
       361
       +
       		CommentCount:  5,

     

       352
       362
        
       	}

     

       353
       363
        
       }

     

       354
       364
        
       

     
···

       928
       938
        
       	service := NewCommentService(commentRepo, userRepo, postRepo, communityRepo).(*commentService)

     

       929
       939
        
       

     

       930
       940
        
       	// Execute

     

       931
       931
       -
       	result := service.buildCommentView(comment, nil, nil)

     

       941
       941
       +
       	result := service.buildCommentView(comment, nil, nil, make(map[string]*users.User))

     

       932
       942
        
       

     

       933
       943
        
       	// Verify basic fields

     

       934
       944
        
       	assert.Equal(t, commentURI, result.URI)

     
···

       960
       970
        
       	service := NewCommentService(commentRepo, userRepo, postRepo, communityRepo).(*commentService)

     

       961
       971
        
       

     

       962
       972
        
       	// Execute

     

       963
       963
       -
       	result := service.buildCommentView(comment, nil, nil)

     

       973
       973
       +
       	result := service.buildCommentView(comment, nil, nil, make(map[string]*users.User))

     

       964
       974
        
       

     

       965
       975
        
       	// Verify - parent should be nil for top-level comments

     

       966
       976
        
       	assert.NotNil(t, result.Post)

     
···

       985
       995
        
       	service := NewCommentService(commentRepo, userRepo, postRepo, communityRepo).(*commentService)

     

       986
       996
        
       

     

       987
       997
        
       	// Execute

     

       988
       988
       -
       	result := service.buildCommentView(comment, nil, nil)

     

       998
       998
       +
       	result := service.buildCommentView(comment, nil, nil, make(map[string]*users.User))

     

       989
       999
        
       

     

       990
       1000
        
       	// Verify - both post and parent should be present

     

       991
       1001
        
       	assert.NotNil(t, result.Post)

     
···

       1019
       1029
        
       	service := NewCommentService(commentRepo, userRepo, postRepo, communityRepo).(*commentService)

     

       1020
       1030
        
       

     

       1021
       1031
        
       	// Execute

     

       1022
       1022
       -
       	result := service.buildCommentView(comment, &viewerDID, voteStates)

     

       1032
       1032
       +
       	result := service.buildCommentView(comment, &viewerDID, voteStates, make(map[string]*users.User))

     

       1023
       1033
        
       

     

       1024
       1034
        
       	// Verify viewer state

     

       1025
       1035
        
       	assert.NotNil(t, result.Viewer)

     
···

       1048
       1058
        
       	service := NewCommentService(commentRepo, userRepo, postRepo, communityRepo).(*commentService)

     

       1049
       1059
        
       

     

       1050
       1060
        
       	// Execute

     

       1051
       1051
       -
       	result := service.buildCommentView(comment, &viewerDID, voteStates)

     

       1061
       1061
       +
       	result := service.buildCommentView(comment, &viewerDID, voteStates, make(map[string]*users.User))

     

       1052
       1062
        
       

     

       1053
       1063
        
       	// Verify viewer state exists but has no votes

     

       1054
       1064
        
       	assert.NotNil(t, result.Viewer)

     
···

       1137
       1147
        
       	assert.Error(t, err)

     

       1138
       1148
        
       	assert.Contains(t, err.Error(), "invalid timeframe")

     

       1139
       1149
        
       }

     

       1150
       1150
       +
       

     

       1151
       1151
       +
       // Test suite for mockUserRepo.GetByDIDs

     

       1152
       1152
       +
       

     

       1153
       1153
       +
       func TestMockUserRepo_GetByDIDs_EmptyArray(t *testing.T) {

     

       1154
       1154
       +
       	userRepo := newMockUserRepo()

     

       1155
       1155
       +
       	ctx := context.Background()

     

       1156
       1156
       +
       

     

       1157
       1157
       +
       	result, err := userRepo.GetByDIDs(ctx, []string{})

     

       1158
       1158
       +
       

     

       1159
       1159
       +
       	assert.NoError(t, err)

     

       1160
       1160
       +
       	assert.NotNil(t, result)

     

       1161
       1161
       +
       	assert.Len(t, result, 0)

     

       1162
       1162
       +
       }

     

       1163
       1163
       +
       

     

       1164
       1164
       +
       func TestMockUserRepo_GetByDIDs_SingleDID(t *testing.T) {

     

       1165
       1165
       +
       	userRepo := newMockUserRepo()

     

       1166
       1166
       +
       	ctx := context.Background()

     

       1167
       1167
       +
       

     

       1168
       1168
       +
       	// Add test user

     

       1169
       1169
       +
       	testUser := createTestUser("did:plc:user1", "user1.test")

     

       1170
       1170
       +
       	_, _ = userRepo.Create(ctx, testUser)

     

       1171
       1171
       +
       

     

       1172
       1172
       +
       	result, err := userRepo.GetByDIDs(ctx, []string{"did:plc:user1"})

     

       1173
       1173
       +
       

     

       1174
       1174
       +
       	assert.NoError(t, err)

     

       1175
       1175
       +
       	assert.Len(t, result, 1)

     

       1176
       1176
       +
       	assert.Equal(t, "user1.test", result["did:plc:user1"].Handle)

     

       1177
       1177
       +
       }

     

       1178
       1178
       +
       

     

       1179
       1179
       +
       func TestMockUserRepo_GetByDIDs_MultipleDIDs(t *testing.T) {

     

       1180
       1180
       +
       	userRepo := newMockUserRepo()

     

       1181
       1181
       +
       	ctx := context.Background()

     

       1182
       1182
       +
       

     

       1183
       1183
       +
       	// Add multiple test users

     

       1184
       1184
       +
       	user1 := createTestUser("did:plc:user1", "user1.test")

     

       1185
       1185
       +
       	user2 := createTestUser("did:plc:user2", "user2.test")

     

       1186
       1186
       +
       	user3 := createTestUser("did:plc:user3", "user3.test")

     

       1187
       1187
       +
       	_, _ = userRepo.Create(ctx, user1)

     

       1188
       1188
       +
       	_, _ = userRepo.Create(ctx, user2)

     

       1189
       1189
       +
       	_, _ = userRepo.Create(ctx, user3)

     

       1190
       1190
       +
       

     

       1191
       1191
       +
       	result, err := userRepo.GetByDIDs(ctx, []string{"did:plc:user1", "did:plc:user2", "did:plc:user3"})

     

       1192
       1192
       +
       

     

       1193
       1193
       +
       	assert.NoError(t, err)

     

       1194
       1194
       +
       	assert.Len(t, result, 3)

     

       1195
       1195
       +
       	assert.Equal(t, "user1.test", result["did:plc:user1"].Handle)

     

       1196
       1196
       +
       	assert.Equal(t, "user2.test", result["did:plc:user2"].Handle)

     

       1197
       1197
       +
       	assert.Equal(t, "user3.test", result["did:plc:user3"].Handle)

     

       1198
       1198
       +
       }

     

       1199
       1199
       +
       

     

       1200
       1200
       +
       func TestMockUserRepo_GetByDIDs_MissingDIDs(t *testing.T) {

     

       1201
       1201
       +
       	userRepo := newMockUserRepo()

     

       1202
       1202
       +
       	ctx := context.Background()

     

       1203
       1203
       +
       

     

       1204
       1204
       +
       	// Add only one user

     

       1205
       1205
       +
       	user1 := createTestUser("did:plc:user1", "user1.test")

     

       1206
       1206
       +
       	_, _ = userRepo.Create(ctx, user1)

     

       1207
       1207
       +
       

     

       1208
       1208
       +
       	// Query for two users, one missing

     

       1209
       1209
       +
       	result, err := userRepo.GetByDIDs(ctx, []string{"did:plc:user1", "did:plc:missing"})

     

       1210
       1210
       +
       

     

       1211
       1211
       +
       	assert.NoError(t, err)

     

       1212
       1212
       +
       	assert.Len(t, result, 1)

     

       1213
       1213
       +
       	assert.Equal(t, "user1.test", result["did:plc:user1"].Handle)

     

       1214
       1214
       +
       	assert.Nil(t, result["did:plc:missing"]) // Missing users not in map

     

       1215
       1215
       +
       }

     

       1216
       1216
       +
       

     

       1217
       1217
       +
       func TestMockUserRepo_GetByDIDs_PreservesAllFields(t *testing.T) {

     

       1218
       1218
       +
       	userRepo := newMockUserRepo()

     

       1219
       1219
       +
       	ctx := context.Background()

     

       1220
       1220
       +
       

     

       1221
       1221
       +
       	// Create user with all fields populated

     

       1222
       1222
       +
       	testUser := &users.User{

     

       1223
       1223
       +
       		DID:       "did:plc:user1",

     

       1224
       1224
       +
       		Handle:    "user1.test",

     

       1225
       1225
       +
       		PDSURL:    "https://pds.example.com",

     

       1226
       1226
       +
       		CreatedAt: time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),

     

       1227
       1227
       +
       		UpdatedAt: time.Date(2025, 1, 2, 0, 0, 0, 0, time.UTC),

     

       1228
       1228
       +
       	}

     

       1229
       1229
       +
       	_, _ = userRepo.Create(ctx, testUser)

     

       1230
       1230
       +
       

     

       1231
       1231
       +
       	result, err := userRepo.GetByDIDs(ctx, []string{"did:plc:user1"})

     

       1232
       1232
       +
       

     

       1233
       1233
       +
       	assert.NoError(t, err)

     

       1234
       1234
       +
       	user := result["did:plc:user1"]

     

       1235
       1235
       +
       	assert.Equal(t, "did:plc:user1", user.DID)

     

       1236
       1236
       +
       	assert.Equal(t, "user1.test", user.Handle)

     

       1237
       1237
       +
       	assert.Equal(t, "https://pds.example.com", user.PDSURL)

     

       1238
       1238
       +
       	assert.Equal(t, testUser.CreatedAt, user.CreatedAt)

     

       1239
       1239
       +
       	assert.Equal(t, testUser.UpdatedAt, user.UpdatedAt)

     

       1240
       1240
       +
       }

     

       1241
       1241
       +
       

     

       1242
       1242
       +
       // Test suite for JSON deserialization in buildCommentView and buildCommentRecord

     

       1243
       1243
       +
       

     

       1244
       1244
       +
       func TestBuildCommentView_ValidFacetsDeserialization(t *testing.T) {

     

       1245
       1245
       +
       	commentRepo := newMockCommentRepo()

     

       1246
       1246
       +
       	userRepo := newMockUserRepo()

     

       1247
       1247
       +
       	postRepo := newMockPostRepo()

     

       1248
       1248
       +
       	communityRepo := newMockCommunityRepo()

     

       1249
       1249
       +
       

     

       1250
       1250
       +
       	postURI := "at://did:plc:post123/app.bsky.feed.post/test"

     

       1251
       1251
       +
       	facetsJSON := `[{"index":{"byteStart":0,"byteEnd":10},"features":[{"$type":"app.bsky.richtext.facet#mention","did":"did:plc:user123"}]}]`

     

       1252
       1252
       +
       

     

       1253
       1253
       +
       	comment := createTestComment("at://did:plc:commenter123/comment/1", "did:plc:commenter123", "commenter.test", postURI, postURI, 0)

     

       1254
       1254
       +
       	comment.ContentFacets = &facetsJSON

     

       1255
       1255
       +
       

     

       1256
       1256
       +
       	service := NewCommentService(commentRepo, userRepo, postRepo, communityRepo).(*commentService)

     

       1257
       1257
       +
       

     

       1258
       1258
       +
       	result := service.buildCommentView(comment, nil, nil, make(map[string]*users.User))

     

       1259
       1259
       +
       

     

       1260
       1260
       +
       	assert.NotNil(t, result.ContentFacets)

     

       1261
       1261
       +
       	assert.Len(t, result.ContentFacets, 1)

     

       1262
       1262
       +
       }

     

       1263
       1263
       +
       

     

       1264
       1264
       +
       func TestBuildCommentView_ValidEmbedDeserialization(t *testing.T) {

     

       1265
       1265
       +
       	commentRepo := newMockCommentRepo()

     

       1266
       1266
       +
       	userRepo := newMockUserRepo()

     

       1267
       1267
       +
       	postRepo := newMockPostRepo()

     

       1268
       1268
       +
       	communityRepo := newMockCommunityRepo()

     

       1269
       1269
       +
       

     

       1270
       1270
       +
       	postURI := "at://did:plc:post123/app.bsky.feed.post/test"

     

       1271
       1271
       +
       	embedJSON := `{"$type":"app.bsky.embed.images","images":[{"alt":"test","image":{"$type":"blob","ref":"bafytest"}}]}`

     

       1272
       1272
       +
       

     

       1273
       1273
       +
       	comment := createTestComment("at://did:plc:commenter123/comment/1", "did:plc:commenter123", "commenter.test", postURI, postURI, 0)

     

       1274
       1274
       +
       	comment.Embed = &embedJSON

     

       1275
       1275
       +
       

     

       1276
       1276
       +
       	service := NewCommentService(commentRepo, userRepo, postRepo, communityRepo).(*commentService)

     

       1277
       1277
       +
       

     

       1278
       1278
       +
       	result := service.buildCommentView(comment, nil, nil, make(map[string]*users.User))

     

       1279
       1279
       +
       

     

       1280
       1280
       +
       	assert.NotNil(t, result.Embed)

     

       1281
       1281
       +
       	embedMap, ok := result.Embed.(map[string]interface{})

     

       1282
       1282
       +
       	assert.True(t, ok)

     

       1283
       1283
       +
       	assert.Equal(t, "app.bsky.embed.images", embedMap["$type"])

     

       1284
       1284
       +
       }

     

       1285
       1285
       +
       

     

       1286
       1286
       +
       func TestBuildCommentRecord_ValidLabelsDeserialization(t *testing.T) {

     

       1287
       1287
       +
       	commentRepo := newMockCommentRepo()

     

       1288
       1288
       +
       	userRepo := newMockUserRepo()

     

       1289
       1289
       +
       	postRepo := newMockPostRepo()

     

       1290
       1290
       +
       	communityRepo := newMockCommunityRepo()

     

       1291
       1291
       +
       

     

       1292
       1292
       +
       	postURI := "at://did:plc:post123/app.bsky.feed.post/test"

     

       1293
       1293
       +
       	labelsJSON := `{"$type":"com.atproto.label.defs#selfLabels","values":[{"val":"nsfw"}]}`

     

       1294
       1294
       +
       

     

       1295
       1295
       +
       	comment := createTestComment("at://did:plc:commenter123/comment/1", "did:plc:commenter123", "commenter.test", postURI, postURI, 0)

     

       1296
       1296
       +
       	comment.ContentLabels = &labelsJSON

     

       1297
       1297
       +
       

     

       1298
       1298
       +
       	service := NewCommentService(commentRepo, userRepo, postRepo, communityRepo).(*commentService)

     

       1299
       1299
       +
       

     

       1300
       1300
       +
       	record := service.buildCommentRecord(comment)

     

       1301
       1301
       +
       

     

       1302
       1302
       +
       	assert.NotNil(t, record.Labels)

     

       1303
       1303
       +
       }

     

       1304
       1304
       +
       

     

       1305
       1305
       +
       func TestBuildCommentView_MalformedJSONLogsWarning(t *testing.T) {

     

       1306
       1306
       +
       	commentRepo := newMockCommentRepo()

     

       1307
       1307
       +
       	userRepo := newMockUserRepo()

     

       1308
       1308
       +
       	postRepo := newMockPostRepo()

     

       1309
       1309
       +
       	communityRepo := newMockCommunityRepo()

     

       1310
       1310
       +
       

     

       1311
       1311
       +
       	postURI := "at://did:plc:post123/app.bsky.feed.post/test"

     

       1312
       1312
       +
       	malformedJSON := `{"invalid": json`

     

       1313
       1313
       +
       

     

       1314
       1314
       +
       	comment := createTestComment("at://did:plc:commenter123/comment/1", "did:plc:commenter123", "commenter.test", postURI, postURI, 0)

     

       1315
       1315
       +
       	comment.ContentFacets = &malformedJSON

     

       1316
       1316
       +
       

     

       1317
       1317
       +
       	service := NewCommentService(commentRepo, userRepo, postRepo, communityRepo).(*commentService)

     

       1318
       1318
       +
       

     

       1319
       1319
       +
       	// Should not panic, should log warning and return view with nil facets

     

       1320
       1320
       +
       	result := service.buildCommentView(comment, nil, nil, make(map[string]*users.User))

     

       1321
       1321
       +
       

     

       1322
       1322
       +
       	assert.NotNil(t, result)

     

       1323
       1323
       +
       	assert.Nil(t, result.ContentFacets)

     

       1324
       1324
       +
       }

     

       1325
       1325
       +
       

     

       1326
       1326
       +
       func TestBuildCommentView_EmptyStringVsNilHandling(t *testing.T) {

     

       1327
       1327
       +
       	commentRepo := newMockCommentRepo()

     

       1328
       1328
       +
       	userRepo := newMockUserRepo()

     

       1329
       1329
       +
       	postRepo := newMockPostRepo()

     

       1330
       1330
       +
       	communityRepo := newMockCommunityRepo()

     

       1331
       1331
       +
       

     

       1332
       1332
       +
       	postURI := "at://did:plc:post123/app.bsky.feed.post/test"

     

       1333
       1333
       +
       

     

       1334
       1334
       +
       	tests := []struct {

     

       1335
       1335
       +
       		name               string

     

       1336
       1336
       +
       		facetsValue        *string

     

       1337
       1337
       +
       		embedValue         *string

     

       1338
       1338
       +
       		labelsValue        *string

     

       1339
       1339
       +
       		expectFacetsNil    bool

     

       1340
       1340
       +
       		expectEmbedNil     bool

     

       1341
       1341
       +
       		expectRecordLabels bool

     

       1342
       1342
       +
       	}{

     

       1343
       1343
       +
       		{

     

       1344
       1344
       +
       			name:               "All nil",

     

       1345
       1345
       +
       			facetsValue:        nil,

     

       1346
       1346
       +
       			embedValue:         nil,

     

       1347
       1347
       +
       			labelsValue:        nil,

     

       1348
       1348
       +
       			expectFacetsNil:    true,

     

       1349
       1349
       +
       			expectEmbedNil:     true,

     

       1350
       1350
       +
       			expectRecordLabels: false,

     

       1351
       1351
       +
       		},

     

       1352
       1352
       +
       		{

     

       1353
       1353
       +
       			name:               "All empty strings",

     

       1354
       1354
       +
       			facetsValue:        strPtr(""),

     

       1355
       1355
       +
       			embedValue:         strPtr(""),

     

       1356
       1356
       +
       			labelsValue:        strPtr(""),

     

       1357
       1357
       +
       			expectFacetsNil:    true,

     

       1358
       1358
       +
       			expectEmbedNil:     true,

     

       1359
       1359
       +
       			expectRecordLabels: false,

     

       1360
       1360
       +
       		},

     

       1361
       1361
       +
       		{

     

       1362
       1362
       +
       			name:               "Valid JSON strings",

     

       1363
       1363
       +
       			facetsValue:        strPtr(`[]`),

     

       1364
       1364
       +
       			embedValue:         strPtr(`{}`),

     

       1365
       1365
       +
       			labelsValue:        strPtr(`{"$type":"com.atproto.label.defs#selfLabels","values":[]}`),

     

       1366
       1366
       +
       			expectFacetsNil:    false,

     

       1367
       1367
       +
       			expectEmbedNil:     false,

     

       1368
       1368
       +
       			expectRecordLabels: true,

     

       1369
       1369
       +
       		},

     

       1370
       1370
       +
       	}

     

       1371
       1371
       +
       

     

       1372
       1372
       +
       	for _, tt := range tests {

     

       1373
       1373
       +
       		t.Run(tt.name, func(t *testing.T) {

     

       1374
       1374
       +
       			comment := createTestComment("at://did:plc:commenter123/comment/1", "did:plc:commenter123", "commenter.test", postURI, postURI, 0)

     

       1375
       1375
       +
       			comment.ContentFacets = tt.facetsValue

     

       1376
       1376
       +
       			comment.Embed = tt.embedValue

     

       1377
       1377
       +
       			comment.ContentLabels = tt.labelsValue

     

       1378
       1378
       +
       

     

       1379
       1379
       +
       			service := NewCommentService(commentRepo, userRepo, postRepo, communityRepo).(*commentService)

     

       1380
       1380
       +
       

     

       1381
       1381
       +
       			result := service.buildCommentView(comment, nil, nil, make(map[string]*users.User))

     

       1382
       1382
       +
       

     

       1383
       1383
       +
       			if tt.expectFacetsNil {

     

       1384
       1384
       +
       				assert.Nil(t, result.ContentFacets)

     

       1385
       1385
       +
       			} else {

     

       1386
       1386
       +
       				assert.NotNil(t, result.ContentFacets)

     

       1387
       1387
       +
       			}

     

       1388
       1388
       +
       

     

       1389
       1389
       +
       			if tt.expectEmbedNil {

     

       1390
       1390
       +
       				assert.Nil(t, result.Embed)

     

       1391
       1391
       +
       			} else {

     

       1392
       1392
       +
       				assert.NotNil(t, result.Embed)

     

       1393
       1393
       +
       			}

     

       1394
       1394
       +
       

     

       1395
       1395
       +
       			record := service.buildCommentRecord(comment)

     

       1396
       1396
       +
       			if tt.expectRecordLabels {

     

       1397
       1397
       +
       				assert.NotNil(t, record.Labels)

     

       1398
       1398
       +
       			} else {

     

       1399
       1399
       +
       				assert.Nil(t, record.Labels)

     

       1400
       1400
       +
       			}

     

       1401
       1401
       +
       		})

     

       1402
       1402
       +
       	}

     

       1403
       1403
       +
       }

     

       1404
       1404
       +
       

     

       1405
       1405
       +
       // Helper function to create string pointers

     

       1406
       1406
       +
       func strPtr(s string) *string {

     

       1407
       1407
       +
       	return &s

     

       1408
       1408
       +
       }

+9 -3

tests/integration/comment_query_test.go

···

       633
       633
        
       	ctx := context.Background()

     

       634
       634
        
       	service := setupCommentService(db)

     

       635
       635
        
       

     

       636
       636
       +
       	// Create a real post for validation tests that should succeed after normalization

     

       637
       637
       +
       	testUser := createTestUser(t, db, "validation.test", "did:plc:validation123")

     

       638
       638
       +
       	testCommunity, err := createFeedTestCommunity(db, ctx, "validationcomm", "ownervalidation.test")

     

       639
       639
       +
       	require.NoError(t, err, "Failed to create test community")

     

       640
       640
       +
       	validPostURI := createTestPost(t, db, testCommunity, testUser.DID, "Validation Test Post", 0, time.Now())

     

       641
       641
       +
       

     

       636
       642
        
       	t.Run("Invalid post URI", func(t *testing.T) {

     

       637
       643
        
       		req := &comments.GetCommentsRequest{

     

       638
       644
        
       			PostURI: "not-an-at-uri",

     
···

       648
       654
        
       

     

       649
       655
        
       	t.Run("Negative depth", func(t *testing.T) {

     

       650
       656
        
       		req := &comments.GetCommentsRequest{

     

       651
       651
       -
       			PostURI: "at://did:plc:test/social.coves.feed.post/abc123",

     

       657
       657
       +
       			PostURI: validPostURI, // Use real post so validation can succeed

     

       652
       658
        
       			Sort:    "hot",

     

       653
       659
        
       			Depth:   -5,

     

       654
       660
        
       			Limit:   50,

     
···

       663
       669
        
       

     

       664
       670
        
       	t.Run("Depth exceeds max", func(t *testing.T) {

     

       665
       671
        
       		req := &comments.GetCommentsRequest{

     

       666
       666
       -
       			PostURI: "at://did:plc:test/social.coves.feed.post/abc123",

     

       672
       672
       +
       			PostURI: validPostURI, // Use real post so validation can succeed

     

       667
       673
        
       			Sort:    "hot",

     

       668
       674
        
       			Depth:   150, // Exceeds max of 100

     

       669
       675
        
       			Limit:   50,

     
···

       677
       683
        
       

     

       678
       684
        
       	t.Run("Limit exceeds max", func(t *testing.T) {

     

       679
       685
        
       		req := &comments.GetCommentsRequest{

     

       680
       680
       -
       			PostURI: "at://did:plc:test/social.coves.feed.post/abc123",

     

       686
       686
       +
       			PostURI: validPostURI, // Use real post so validation can succeed

     

       681
       687
        
       			Sort:    "hot",

     

       682
       688
        
       			Depth:   10,

     

       683
       689
        
       			Limit:   150, // Exceeds max of 100

+164

tests/integration/user_test.go

···

       313
       313
        
       	})

     

       314
       314
        
       }

     

       315
       315
        
       

     

       316
       316
       +
       // TestUserRepository_GetByDIDs tests the batch user retrieval functionality

     

       317
       317
       +
       func TestUserRepository_GetByDIDs(t *testing.T) {

     

       318
       318
       +
       	db := setupTestDB(t)

     

       319
       319
       +
       	defer func() {

     

       320
       320
       +
       		if err := db.Close(); err != nil {

     

       321
       321
       +
       			t.Logf("Failed to close database: %v", err)

     

       322
       322
       +
       		}

     

       323
       323
       +
       	}()

     

       324
       324
       +
       

     

       325
       325
       +
       	userRepo := postgres.NewUserRepository(db)

     

       326
       326
       +
       	ctx := context.Background()

     

       327
       327
       +
       

     

       328
       328
       +
       	// Create test users

     

       329
       329
       +
       	user1 := &users.User{

     

       330
       330
       +
       		DID:    "did:plc:getbydids1",

     

       331
       331
       +
       		Handle: "user1.test",

     

       332
       332
       +
       		PDSURL: "https://pds1.example.com",

     

       333
       333
       +
       	}

     

       334
       334
       +
       	user2 := &users.User{

     

       335
       335
       +
       		DID:    "did:plc:getbydids2",

     

       336
       336
       +
       		Handle: "user2.test",

     

       337
       337
       +
       		PDSURL: "https://pds2.example.com",

     

       338
       338
       +
       	}

     

       339
       339
       +
       	user3 := &users.User{

     

       340
       340
       +
       		DID:    "did:plc:getbydids3",

     

       341
       341
       +
       		Handle: "user3.test",

     

       342
       342
       +
       		PDSURL: "https://pds3.example.com",

     

       343
       343
       +
       	}

     

       344
       344
       +
       

     

       345
       345
       +
       	_, err := userRepo.Create(ctx, user1)

     

       346
       346
       +
       	if err != nil {

     

       347
       347
       +
       		t.Fatalf("Failed to create user1: %v", err)

     

       348
       348
       +
       	}

     

       349
       349
       +
       	_, err = userRepo.Create(ctx, user2)

     

       350
       350
       +
       	if err != nil {

     

       351
       351
       +
       		t.Fatalf("Failed to create user2: %v", err)

     

       352
       352
       +
       	}

     

       353
       353
       +
       	_, err = userRepo.Create(ctx, user3)

     

       354
       354
       +
       	if err != nil {

     

       355
       355
       +
       		t.Fatalf("Failed to create user3: %v", err)

     

       356
       356
       +
       	}

     

       357
       357
       +
       

     

       358
       358
       +
       	t.Run("Empty array returns empty map", func(t *testing.T) {

     

       359
       359
       +
       		result, err := userRepo.GetByDIDs(ctx, []string{})

     

       360
       360
       +
       		if err != nil {

     

       361
       361
       +
       			t.Errorf("Expected no error for empty array, got: %v", err)

     

       362
       362
       +
       		}

     

       363
       363
       +
       		if result == nil {

     

       364
       364
       +
       			t.Error("Expected non-nil map, got nil")

     

       365
       365
       +
       		}

     

       366
       366
       +
       		if len(result) != 0 {

     

       367
       367
       +
       			t.Errorf("Expected empty map, got length: %d", len(result))

     

       368
       368
       +
       		}

     

       369
       369
       +
       	})

     

       370
       370
       +
       

     

       371
       371
       +
       	t.Run("Single DID returns one user", func(t *testing.T) {

     

       372
       372
       +
       		result, err := userRepo.GetByDIDs(ctx, []string{"did:plc:getbydids1"})

     

       373
       373
       +
       		if err != nil {

     

       374
       374
       +
       			t.Fatalf("Failed to get user by DID: %v", err)

     

       375
       375
       +
       		}

     

       376
       376
       +
       		if len(result) != 1 {

     

       377
       377
       +
       			t.Errorf("Expected 1 user, got %d", len(result))

     

       378
       378
       +
       		}

     

       379
       379
       +
       		if user, found := result["did:plc:getbydids1"]; !found {

     

       380
       380
       +
       			t.Error("Expected user1 to be in result")

     

       381
       381
       +
       		} else if user.Handle != "user1.test" {

     

       382
       382
       +
       			t.Errorf("Expected handle user1.test, got %s", user.Handle)

     

       383
       383
       +
       		}

     

       384
       384
       +
       	})

     

       385
       385
       +
       

     

       386
       386
       +
       	t.Run("Multiple DIDs returns multiple users", func(t *testing.T) {

     

       387
       387
       +
       		result, err := userRepo.GetByDIDs(ctx, []string{

     

       388
       388
       +
       			"did:plc:getbydids1",

     

       389
       389
       +
       			"did:plc:getbydids2",

     

       390
       390
       +
       			"did:plc:getbydids3",

     

       391
       391
       +
       		})

     

       392
       392
       +
       		if err != nil {

     

       393
       393
       +
       			t.Fatalf("Failed to get users by DIDs: %v", err)

     

       394
       394
       +
       		}

     

       395
       395
       +
       		if len(result) != 3 {

     

       396
       396
       +
       			t.Errorf("Expected 3 users, got %d", len(result))

     

       397
       397
       +
       		}

     

       398
       398
       +
       		if result["did:plc:getbydids1"].Handle != "user1.test" {

     

       399
       399
       +
       			t.Errorf("User1 handle mismatch")

     

       400
       400
       +
       		}

     

       401
       401
       +
       		if result["did:plc:getbydids2"].Handle != "user2.test" {

     

       402
       402
       +
       			t.Errorf("User2 handle mismatch")

     

       403
       403
       +
       		}

     

       404
       404
       +
       		if result["did:plc:getbydids3"].Handle != "user3.test" {

     

       405
       405
       +
       			t.Errorf("User3 handle mismatch")

     

       406
       406
       +
       		}

     

       407
       407
       +
       	})

     

       408
       408
       +
       

     

       409
       409
       +
       	t.Run("Missing DIDs not in result map", func(t *testing.T) {

     

       410
       410
       +
       		result, err := userRepo.GetByDIDs(ctx, []string{

     

       411
       411
       +
       			"did:plc:getbydids1",

     

       412
       412
       +
       			"did:plc:nonexistent",

     

       413
       413
       +
       		})

     

       414
       414
       +
       		if err != nil {

     

       415
       415
       +
       			t.Fatalf("Failed to get users by DIDs: %v", err)

     

       416
       416
       +
       		}

     

       417
       417
       +
       		if len(result) != 1 {

     

       418
       418
       +
       			t.Errorf("Expected 1 user (missing not included), got %d", len(result))

     

       419
       419
       +
       		}

     

       420
       420
       +
       		if _, found := result["did:plc:nonexistent"]; found {

     

       421
       421
       +
       			t.Error("Expected nonexistent user to not be in result")

     

       422
       422
       +
       		}

     

       423
       423
       +
       	})

     

       424
       424
       +
       

     

       425
       425
       +
       	t.Run("Preserves all user fields correctly", func(t *testing.T) {

     

       426
       426
       +
       		result, err := userRepo.GetByDIDs(ctx, []string{"did:plc:getbydids1"})

     

       427
       427
       +
       		if err != nil {

     

       428
       428
       +
       			t.Fatalf("Failed to get user by DID: %v", err)

     

       429
       429
       +
       		}

     

       430
       430
       +
       		user := result["did:plc:getbydids1"]

     

       431
       431
       +
       		if user.DID != "did:plc:getbydids1" {

     

       432
       432
       +
       			t.Errorf("DID mismatch: expected did:plc:getbydids1, got %s", user.DID)

     

       433
       433
       +
       		}

     

       434
       434
       +
       		if user.Handle != "user1.test" {

     

       435
       435
       +
       			t.Errorf("Handle mismatch: expected user1.test, got %s", user.Handle)

     

       436
       436
       +
       		}

     

       437
       437
       +
       		if user.PDSURL != "https://pds1.example.com" {

     

       438
       438
       +
       			t.Errorf("PDSURL mismatch: expected https://pds1.example.com, got %s", user.PDSURL)

     

       439
       439
       +
       		}

     

       440
       440
       +
       		if user.CreatedAt.IsZero() {

     

       441
       441
       +
       			t.Error("CreatedAt should not be zero")

     

       442
       442
       +
       		}

     

       443
       443
       +
       		if user.UpdatedAt.IsZero() {

     

       444
       444
       +
       			t.Error("UpdatedAt should not be zero")

     

       445
       445
       +
       		}

     

       446
       446
       +
       	})

     

       447
       447
       +
       

     

       448
       448
       +
       	t.Run("Validates batch size limit", func(t *testing.T) {

     

       449
       449
       +
       		// Create array exceeding MaxBatchSize (1000)

     

       450
       450
       +
       		largeDIDs := make([]string, 1001)

     

       451
       451
       +
       		for i := 0; i < 1001; i++ {

     

       452
       452
       +
       			largeDIDs[i] = fmt.Sprintf("did:plc:test%d", i)

     

       453
       453
       +
       		}

     

       454
       454
       +
       

     

       455
       455
       +
       		_, err := userRepo.GetByDIDs(ctx, largeDIDs)

     

       456
       456
       +
       		if err == nil {

     

       457
       457
       +
       			t.Error("Expected error for batch size exceeding limit, got nil")

     

       458
       458
       +
       		}

     

       459
       459
       +
       		if !strings.Contains(err.Error(), "exceeds maximum") {

     

       460
       460
       +
       			t.Errorf("Expected batch size error, got: %v", err)

     

       461
       461
       +
       		}

     

       462
       462
       +
       	})

     

       463
       463
       +
       

     

       464
       464
       +
       	t.Run("Validates DID format", func(t *testing.T) {

     

       465
       465
       +
       		invalidDIDs := []string{

     

       466
       466
       +
       			"did:plc:getbydids1",

     

       467
       467
       +
       			"invalid-did", // Invalid DID format

     

       468
       468
       +
       		}

     

       469
       469
       +
       

     

       470
       470
       +
       		_, err := userRepo.GetByDIDs(ctx, invalidDIDs)

     

       471
       471
       +
       		if err == nil {

     

       472
       472
       +
       			t.Error("Expected error for invalid DID format, got nil")

     

       473
       473
       +
       		}

     

       474
       474
       +
       		if !strings.Contains(err.Error(), "invalid DID format") {

     

       475
       475
       +
       			t.Errorf("Expected invalid DID format error, got: %v", err)

     

       476
       476
       +
       		}

     

       477
       477
       +
       	})

     

       478
       478
       +
       }

     

       479
       479
       +
       

     

       316
       480
        
       // TestHandleValidation tests atProto handle validation rules

     

       317
       481
        
       func TestHandleValidation(t *testing.T) {

     

       318
       482
        
       	db := setupTestDB(t)