bretton.dev
+1
-5
lib/main.dart
+1
-5
lib/main.dart
···
72
72
),
73
73
update: (context, auth, vote, previous) {
74
74
// Reuse existing provider to maintain state across rebuilds
75
-
return previous ??
76
-
FeedProvider(
77
-
auth,
78
-
voteProvider: vote,
79
-
);
75
+
return previous ?? FeedProvider(auth, voteProvider: vote);
80
76
},
81
77
),
82
78
ChangeNotifierProxyProvider2<
+1
-1
lib/providers/comments_provider.dart
+1
-1
lib/providers/comments_provider.dart
···
108
108
String get sort => _sort;
109
109
String? get timeframe => _timeframe;
110
110
ValueNotifier<DateTime?> get currentTimeNotifier => _currentTimeNotifier;
111
-
Set<String> get collapsedComments => _collapsedComments;
111
+
Set<String> get collapsedComments => Set.unmodifiable(_collapsedComments);
112
112
113
113
/// Toggle collapsed state for a comment thread
114
114
///
+6
-10
lib/screens/home/feed_screen.dart
+6
-10
lib/screens/home/feed_screen.dart
···
73
73
);
74
74
final isLoading = context.select<FeedProvider, bool>((p) => p.isLoading);
75
75
final error = context.select<FeedProvider, String?>((p) => p.error);
76
-
final feedType = context.select<FeedProvider, FeedType>(
77
-
(p) => p.feedType,
78
-
);
76
+
final feedType = context.select<FeedProvider, FeedType>((p) => p.feedType);
79
77
80
78
// IMPORTANT: This relies on FeedProvider creating new list instances
81
79
// (_posts = [..._posts, ...response.feed]) rather than mutating in-place.
···
106
104
currentTime: currentTime,
107
105
),
108
106
// Transparent header overlay
109
-
_buildHeader(
110
-
feedType: feedType,
111
-
isAuthenticated: isAuthenticated,
112
-
),
107
+
_buildHeader(feedType: feedType, isAuthenticated: isAuthenticated),
113
108
],
114
109
),
115
110
),
···
218
213
Text(
219
214
label,
220
215
style: TextStyle(
221
-
color: isActive
222
-
? AppColors.textPrimary
223
-
: AppColors.textSecondary.withValues(alpha: 0.6),
216
+
color:
217
+
isActive
218
+
? AppColors.textPrimary
219
+
: AppColors.textSecondary.withValues(alpha: 0.6),
224
220
fontSize: 16,
225
221
fontWeight: isActive ? FontWeight.w700 : FontWeight.w400,
226
222
),
+5
-4
lib/screens/home/post_detail_screen.dart
+5
-4
lib/screens/home/post_detail_screen.dart
···
454
454
// Navigate to reply screen with comment context
455
455
Navigator.of(context).push(
456
456
MaterialPageRoute<void>(
457
-
builder: (context) => ReplyScreen(
458
-
comment: comment,
459
-
onSubmit: (content) => _handleCommentReply(content, comment),
460
-
),
457
+
builder:
458
+
(context) => ReplyScreen(
459
+
comment: comment,
460
+
onSubmit: (content) => _handleCommentReply(content, comment),
461
+
),
461
462
),
462
463
);
463
464
}
+1
-3
lib/services/comment_service.dart
+1
-3
lib/services/comment_service.dart
···
119
119
final cid = data['cid'] as String?;
120
120
121
121
if (uri == null || uri.isEmpty || cid == null || cid.isEmpty) {
122
-
throw ApiException(
123
-
'Invalid response from server - missing uri or cid',
124
-
);
122
+
throw ApiException('Invalid response from server - missing uri or cid');
125
123
}
126
124
127
125
if (kDebugMode) {
+111
-93
lib/widgets/comment_card.dart
+111
-93
lib/widgets/comment_card.dart
···
66
66
// the stroke width)
67
67
final borderLeftOffset = (threadingLineCount * 6.0) + 2.0;
68
68
69
-
return GestureDetector(
70
-
onLongPress: onLongPress != null
71
-
? () {
72
-
HapticFeedback.mediumImpact();
73
-
onLongPress!();
74
-
}
75
-
: null,
76
-
child: InkWell(
77
-
onTap: onTap,
78
-
child: Container(
79
-
decoration: const BoxDecoration(color: AppColors.background),
80
-
child: Stack(
81
-
children: [
82
-
// Threading indicators - vertical lines showing nesting ancestry
83
-
Positioned.fill(
84
-
child: CustomPaint(
85
-
painter: _CommentDepthPainter(depth: threadingLineCount),
69
+
return Semantics(
70
+
button: true,
71
+
hint:
72
+
onLongPress != null
73
+
? (isCollapsed
74
+
? 'Double tap and hold to expand thread'
75
+
: 'Double tap and hold to collapse thread')
76
+
: null,
77
+
child: GestureDetector(
78
+
onLongPress:
79
+
onLongPress != null
80
+
? () {
81
+
HapticFeedback.mediumImpact();
82
+
onLongPress!();
83
+
}
84
+
: null,
85
+
child: InkWell(
86
+
onTap: onTap,
87
+
child: Container(
88
+
decoration: const BoxDecoration(color: AppColors.background),
89
+
child: Stack(
90
+
children: [
91
+
// Threading indicators - vertical lines showing nesting ancestry
92
+
Positioned.fill(
93
+
child: CustomPaint(
94
+
painter: _CommentDepthPainter(depth: threadingLineCount),
95
+
),
86
96
),
87
-
),
88
-
// Collapsed count badge - positioned after threading lines
89
-
// to avoid overlap at any depth level
90
-
if (isCollapsed && collapsedCount > 0)
97
+
// Bottom border
98
+
// (starts after threading lines, not overlapping them)
91
99
Positioned(
92
-
left: borderLeftOffset + 4,
93
-
bottom: 8,
94
-
child: Container(
95
-
padding: const EdgeInsets.symmetric(
96
-
horizontal: 6,
97
-
vertical: 2,
98
-
),
99
-
decoration: BoxDecoration(
100
-
color: AppColors.primary,
101
-
borderRadius: BorderRadius.circular(8),
102
-
),
103
-
child: Text(
104
-
'+$collapsedCount hidden',
105
-
style: const TextStyle(
106
-
color: AppColors.textPrimary,
107
-
fontSize: 10,
108
-
fontWeight: FontWeight.w500,
109
-
),
110
-
),
111
-
),
100
+
left: borderLeftOffset,
101
+
right: 0,
102
+
bottom: 0,
103
+
child: Container(height: 1, color: AppColors.border),
112
104
),
113
-
// Bottom border
114
-
// (starts after threading lines, not overlapping them)
115
-
Positioned(
116
-
left: borderLeftOffset,
117
-
right: 0,
118
-
bottom: 0,
119
-
child: Container(height: 1, color: AppColors.border),
120
-
),
121
-
// Comment content with depth-based left padding
122
-
Padding(
123
-
padding: EdgeInsets.fromLTRB(leftPadding, 12, 16, 8),
124
-
child: Column(
125
-
crossAxisAlignment: CrossAxisAlignment.start,
126
-
children: [
127
-
// Author info row
128
-
Row(
105
+
// Comment content with depth-based left padding
106
+
// Animate height changes when collapsing/expanding
107
+
AnimatedSize(
108
+
duration: const Duration(milliseconds: 250),
109
+
curve: Curves.easeInOutCubic,
110
+
alignment: Alignment.topCenter,
111
+
child: Padding(
112
+
padding: EdgeInsets.fromLTRB(
113
+
leftPadding,
114
+
isCollapsed ? 10 : 12,
115
+
16,
116
+
isCollapsed ? 10 : 8,
117
+
),
118
+
child: Column(
119
+
crossAxisAlignment: CrossAxisAlignment.start,
129
120
children: [
130
-
// Author avatar
131
-
_buildAuthorAvatar(comment.author),
132
-
const SizedBox(width: 8),
133
-
Expanded(
134
-
child: Column(
135
-
crossAxisAlignment: CrossAxisAlignment.start,
136
-
children: [
137
-
// Author handle
138
-
Text(
121
+
// Author info row
122
+
Row(
123
+
children: [
124
+
// Author avatar
125
+
_buildAuthorAvatar(comment.author),
126
+
const SizedBox(width: 8),
127
+
Expanded(
128
+
child: Text(
139
129
'@${comment.author.handle}',
140
130
style: TextStyle(
141
131
color: AppColors.textPrimary.withValues(
142
-
alpha: 0.5,
132
+
alpha: isCollapsed ? 0.7 : 0.5,
143
133
),
144
134
fontSize: 13,
145
135
fontWeight: FontWeight.w500,
146
136
),
147
137
),
148
-
],
149
-
),
150
-
),
151
-
// Time ago
152
-
Text(
153
-
DateTimeUtils.formatTimeAgo(
154
-
comment.createdAt,
155
-
currentTime: currentTime,
156
-
),
157
-
style: TextStyle(
158
-
color: AppColors.textPrimary.withValues(alpha: 0.5),
159
-
fontSize: 12,
160
-
),
138
+
),
139
+
// Show collapsed count OR time ago
140
+
if (isCollapsed && collapsedCount > 0)
141
+
_buildCollapsedBadge()
142
+
else
143
+
Text(
144
+
DateTimeUtils.formatTimeAgo(
145
+
comment.createdAt,
146
+
currentTime: currentTime,
147
+
),
148
+
style: TextStyle(
149
+
color: AppColors.textPrimary.withValues(
150
+
alpha: 0.5,
151
+
),
152
+
fontSize: 12,
153
+
),
154
+
),
155
+
],
161
156
),
162
-
],
163
-
),
164
-
const SizedBox(height: 8),
165
157
166
-
// Comment content
167
-
if (comment.content.isNotEmpty) ...[
168
-
_buildCommentContent(comment),
169
-
const SizedBox(height: 8),
170
-
],
158
+
// Only show content and actions when expanded
159
+
if (!isCollapsed) ...[
160
+
const SizedBox(height: 8),
171
161
172
-
// Action buttons (just vote for now)
173
-
_buildActionButtons(context),
174
-
],
162
+
// Comment content
163
+
if (comment.content.isNotEmpty) ...[
164
+
_buildCommentContent(comment),
165
+
const SizedBox(height: 8),
166
+
],
167
+
168
+
// Action buttons (just vote for now)
169
+
_buildActionButtons(context),
170
+
],
171
+
],
172
+
),
173
+
),
175
174
),
176
-
),
177
-
],
175
+
],
176
+
),
178
177
),
179
178
),
180
179
),
···
220
219
fontSize: 12,
221
220
fontWeight: FontWeight.bold,
222
221
),
222
+
),
223
+
),
224
+
);
225
+
}
226
+
227
+
/// Builds the compact collapsed badge showing "+X"
228
+
Widget _buildCollapsedBadge() {
229
+
return Container(
230
+
padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 3),
231
+
decoration: BoxDecoration(
232
+
color: AppColors.primary.withValues(alpha: 0.15),
233
+
borderRadius: BorderRadius.circular(10),
234
+
),
235
+
child: Text(
236
+
'+$collapsedCount',
237
+
style: TextStyle(
238
+
color: AppColors.primary.withValues(alpha: 0.9),
239
+
fontSize: 12,
240
+
fontWeight: FontWeight.w600,
223
241
),
224
242
),
225
243
);
+88
-31
lib/widgets/comment_thread.dart
+88
-31
lib/widgets/comment_thread.dart
···
76
76
// Only build replies widget when NOT collapsed (optimization)
77
77
// When collapsed, AnimatedSwitcher shows SizedBox.shrink() so children
78
78
// are never mounted - no need to build them at all
79
-
final repliesWidget = hasReplies && !isCollapsed
80
-
? Column(
81
-
key: const ValueKey('replies'),
82
-
crossAxisAlignment: CrossAxisAlignment.start,
83
-
children: thread.replies!.map((reply) {
84
-
return CommentThread(
85
-
thread: reply,
86
-
depth: depth + 1,
87
-
maxDepth: maxDepth,
88
-
currentTime: currentTime,
89
-
onLoadMoreReplies: onLoadMoreReplies,
90
-
onCommentTap: onCommentTap,
91
-
collapsedComments: collapsedComments,
92
-
onCollapseToggle: onCollapseToggle,
93
-
);
94
-
}).toList(),
95
-
)
96
-
: null;
79
+
final repliesWidget =
80
+
hasReplies && !isCollapsed
81
+
? Column(
82
+
key: const ValueKey('replies'),
83
+
crossAxisAlignment: CrossAxisAlignment.start,
84
+
children:
85
+
thread.replies!.map((reply) {
86
+
return CommentThread(
87
+
thread: reply,
88
+
depth: depth + 1,
89
+
maxDepth: maxDepth,
90
+
currentTime: currentTime,
91
+
onLoadMoreReplies: onLoadMoreReplies,
92
+
onCommentTap: onCommentTap,
93
+
collapsedComments: collapsedComments,
94
+
onCollapseToggle: onCollapseToggle,
95
+
);
96
+
}).toList(),
97
+
)
98
+
: null;
97
99
98
100
return Column(
99
101
crossAxisAlignment: CrossAxisAlignment.start,
···
104
106
depth: effectiveDepth,
105
107
currentTime: currentTime,
106
108
onTap: onCommentTap != null ? () => onCommentTap!(thread) : null,
107
-
onLongPress: onCollapseToggle != null
108
-
? () => onCollapseToggle!(thread.comment.uri)
109
-
: null,
109
+
onLongPress:
110
+
onCollapseToggle != null
111
+
? () => onCollapseToggle!(thread.comment.uri)
112
+
: null,
110
113
isCollapsed: isCollapsed,
111
114
collapsedCount: collapsedCount,
112
115
),
···
114
117
// Render replies with animation
115
118
if (hasReplies)
116
119
AnimatedSwitcher(
117
-
duration: const Duration(milliseconds: 200),
118
-
switchInCurve: Curves.easeInOutCubicEmphasized,
119
-
switchOutCurve: Curves.easeInOutCubicEmphasized,
120
+
duration: const Duration(milliseconds: 350),
121
+
reverseDuration: const Duration(milliseconds: 280),
122
+
switchInCurve: Curves.easeOutCubic,
123
+
switchOutCurve: Curves.easeInCubic,
120
124
transitionBuilder: (Widget child, Animation<double> animation) {
121
-
return SizeTransition(
122
-
sizeFactor: animation,
123
-
axisAlignment: -1,
124
-
child: child,
125
+
// Determine if we're expanding or collapsing based on key
126
+
final isExpanding = child.key == const ValueKey('replies');
127
+
128
+
// Different fade curves for expand vs collapse
129
+
final fadeCurve =
130
+
isExpanding
131
+
? const Interval(0, 0.7, curve: Curves.easeOut)
132
+
: const Interval(0, 0.5, curve: Curves.easeIn);
133
+
134
+
// Slide down from parent on expand, slide up on collapse
135
+
final slideOffset =
136
+
isExpanding
137
+
? Tween<Offset>(
138
+
begin: const Offset(0, -0.15),
139
+
end: Offset.zero,
140
+
).animate(
141
+
CurvedAnimation(
142
+
parent: animation,
143
+
curve: const Interval(
144
+
0.2,
145
+
1,
146
+
curve: Curves.easeOutCubic,
147
+
),
148
+
),
149
+
)
150
+
: Tween<Offset>(
151
+
begin: Offset.zero,
152
+
end: const Offset(0, -0.05),
153
+
).animate(
154
+
CurvedAnimation(
155
+
parent: animation,
156
+
curve: Curves.easeIn,
157
+
),
158
+
);
159
+
160
+
return FadeTransition(
161
+
opacity: CurvedAnimation(parent: animation, curve: fadeCurve),
162
+
child: ClipRect(
163
+
child: SizeTransition(
164
+
sizeFactor: animation,
165
+
axisAlignment: -1,
166
+
child: SlideTransition(position: slideOffset, child: child),
167
+
),
168
+
),
169
+
);
170
+
},
171
+
layoutBuilder: (currentChild, previousChildren) {
172
+
// Stack children during transition - ClipRect prevents
173
+
// overflow artifacts on deeply nested threads
174
+
return ClipRect(
175
+
child: Stack(
176
+
children: [
177
+
...previousChildren,
178
+
if (currentChild != null) currentChild,
179
+
],
180
+
),
125
181
);
126
182
},
127
-
child: isCollapsed
128
-
? const SizedBox.shrink(key: ValueKey('collapsed'))
129
-
: repliesWidget,
183
+
child:
184
+
isCollapsed
185
+
? const SizedBox.shrink(key: ValueKey('collapsed'))
186
+
: repliesWidget,
130
187
),
131
188
132
189
// Show "Load more replies" button if there are more (and not collapsed)
+170
-39
test/providers/comments_provider_test.dart
+170
-39
test/providers/comments_provider_test.dart
···
200
200
),
201
201
).thenAnswer((_) async => secondResponse);
202
202
203
-
await commentsProvider.loadComments(postUri: testPostUri, postCid: testPostCid);
203
+
await commentsProvider.loadComments(
204
+
postUri: testPostUri,
205
+
postCid: testPostCid,
206
+
);
204
207
205
208
expect(commentsProvider.comments.length, 2);
206
209
expect(commentsProvider.comments[0].comment.uri, 'comment1');
···
1286
1289
);
1287
1290
});
1288
1291
1292
+
group('Collapsed comments', () {
1293
+
test('should toggle collapsed state for a comment', () {
1294
+
const commentUri = 'at://did:plc:test/comment/123';
1295
+
1296
+
// Initially not collapsed
1297
+
expect(commentsProvider.isCollapsed(commentUri), false);
1298
+
expect(commentsProvider.collapsedComments.isEmpty, true);
1299
+
1300
+
// Toggle to collapsed
1301
+
commentsProvider.toggleCollapsed(commentUri);
1302
+
1303
+
expect(commentsProvider.isCollapsed(commentUri), true);
1304
+
expect(commentsProvider.collapsedComments.contains(commentUri), true);
1305
+
1306
+
// Toggle back to expanded
1307
+
commentsProvider.toggleCollapsed(commentUri);
1308
+
1309
+
expect(commentsProvider.isCollapsed(commentUri), false);
1310
+
expect(commentsProvider.collapsedComments.contains(commentUri), false);
1311
+
});
1312
+
1313
+
test('should track multiple collapsed comments', () {
1314
+
const comment1 = 'at://did:plc:test/comment/1';
1315
+
const comment2 = 'at://did:plc:test/comment/2';
1316
+
const comment3 = 'at://did:plc:test/comment/3';
1317
+
1318
+
commentsProvider
1319
+
..toggleCollapsed(comment1)
1320
+
..toggleCollapsed(comment2);
1321
+
1322
+
expect(commentsProvider.isCollapsed(comment1), true);
1323
+
expect(commentsProvider.isCollapsed(comment2), true);
1324
+
expect(commentsProvider.isCollapsed(comment3), false);
1325
+
expect(commentsProvider.collapsedComments.length, 2);
1326
+
});
1327
+
1328
+
test('should notify listeners when collapse state changes', () {
1329
+
var notificationCount = 0;
1330
+
commentsProvider.addListener(() {
1331
+
notificationCount++;
1332
+
});
1333
+
1334
+
commentsProvider.toggleCollapsed('at://did:plc:test/comment/1');
1335
+
expect(notificationCount, 1);
1336
+
1337
+
commentsProvider.toggleCollapsed('at://did:plc:test/comment/1');
1338
+
expect(notificationCount, 2);
1339
+
});
1340
+
1341
+
test('should clear collapsed state on reset', () async {
1342
+
// Collapse some comments
1343
+
commentsProvider
1344
+
..toggleCollapsed('at://did:plc:test/comment/1')
1345
+
..toggleCollapsed('at://did:plc:test/comment/2');
1346
+
1347
+
expect(commentsProvider.collapsedComments.length, 2);
1348
+
1349
+
// Reset should clear collapsed state
1350
+
commentsProvider.reset();
1351
+
1352
+
expect(commentsProvider.collapsedComments.isEmpty, true);
1353
+
expect(
1354
+
commentsProvider.isCollapsed('at://did:plc:test/comment/1'),
1355
+
false,
1356
+
);
1357
+
expect(
1358
+
commentsProvider.isCollapsed('at://did:plc:test/comment/2'),
1359
+
false,
1360
+
);
1361
+
});
1362
+
1363
+
test('collapsedComments getter returns unmodifiable set', () {
1364
+
commentsProvider.toggleCollapsed('at://did:plc:test/comment/1');
1365
+
1366
+
final collapsed = commentsProvider.collapsedComments;
1367
+
1368
+
// Attempting to modify should throw
1369
+
expect(
1370
+
() => collapsed.add('at://did:plc:test/comment/2'),
1371
+
throwsUnsupportedError,
1372
+
);
1373
+
});
1374
+
1375
+
test('should clear collapsed state on post change', () async {
1376
+
// Setup mock response
1377
+
final response = CommentsResponse(
1378
+
post: {},
1379
+
comments: [_createMockThreadComment('comment1')],
1380
+
);
1381
+
1382
+
when(
1383
+
mockApiService.getComments(
1384
+
postUri: anyNamed('postUri'),
1385
+
sort: anyNamed('sort'),
1386
+
timeframe: anyNamed('timeframe'),
1387
+
depth: anyNamed('depth'),
1388
+
limit: anyNamed('limit'),
1389
+
cursor: anyNamed('cursor'),
1390
+
),
1391
+
).thenAnswer((_) async => response);
1392
+
1393
+
// Load first post
1394
+
await commentsProvider.loadComments(
1395
+
postUri: testPostUri,
1396
+
postCid: testPostCid,
1397
+
refresh: true,
1398
+
);
1399
+
1400
+
// Collapse a comment
1401
+
commentsProvider.toggleCollapsed('at://did:plc:test/comment/1');
1402
+
expect(commentsProvider.collapsedComments.length, 1);
1403
+
1404
+
// Load different post
1405
+
await commentsProvider.loadComments(
1406
+
postUri: 'at://did:plc:test/social.coves.post.record/456',
1407
+
postCid: 'different-cid',
1408
+
refresh: true,
1409
+
);
1410
+
1411
+
// Collapsed state should be cleared
1412
+
expect(commentsProvider.collapsedComments.isEmpty, true);
1413
+
});
1414
+
});
1415
+
1289
1416
group('createComment', () {
1290
1417
late MockCommentService mockCommentService;
1291
1418
late CommentsProvider providerWithCommentService;
···
1341
1468
);
1342
1469
});
1343
1470
1344
-
test('should throw ValidationException for whitespace-only content', () async {
1345
-
await providerWithCommentService.loadComments(
1346
-
postUri: testPostUri,
1347
-
postCid: testPostCid,
1348
-
refresh: true,
1349
-
);
1471
+
test(
1472
+
'should throw ValidationException for whitespace-only content',
1473
+
() async {
1474
+
await providerWithCommentService.loadComments(
1475
+
postUri: testPostUri,
1476
+
postCid: testPostCid,
1477
+
refresh: true,
1478
+
);
1350
1479
1351
-
expect(
1352
-
() => providerWithCommentService.createComment(content: ' \n\t '),
1353
-
throwsA(isA<ValidationException>()),
1354
-
);
1355
-
});
1480
+
expect(
1481
+
() =>
1482
+
providerWithCommentService.createComment(content: ' \n\t '),
1483
+
throwsA(isA<ValidationException>()),
1484
+
);
1485
+
},
1486
+
);
1356
1487
1357
-
test('should throw ValidationException for content exceeding limit', () async {
1358
-
await providerWithCommentService.loadComments(
1359
-
postUri: testPostUri,
1360
-
postCid: testPostCid,
1361
-
refresh: true,
1362
-
);
1488
+
test(
1489
+
'should throw ValidationException for content exceeding limit',
1490
+
() async {
1491
+
await providerWithCommentService.loadComments(
1492
+
postUri: testPostUri,
1493
+
postCid: testPostCid,
1494
+
refresh: true,
1495
+
);
1363
1496
1364
-
// Create a string longer than 10000 characters
1365
-
final longContent = 'a' * 10001;
1497
+
// Create a string longer than 10000 characters
1498
+
final longContent = 'a' * 10001;
1366
1499
1367
-
expect(
1368
-
() => providerWithCommentService.createComment(content: longContent),
1369
-
throwsA(
1370
-
isA<ValidationException>().having(
1371
-
(e) => e.message,
1372
-
'message',
1373
-
contains('too long'),
1500
+
expect(
1501
+
() =>
1502
+
providerWithCommentService.createComment(content: longContent),
1503
+
throwsA(
1504
+
isA<ValidationException>().having(
1505
+
(e) => e.message,
1506
+
'message',
1507
+
contains('too long'),
1508
+
),
1374
1509
),
1375
-
),
1376
-
);
1377
-
});
1510
+
);
1511
+
},
1512
+
);
1378
1513
1379
1514
test('should count emoji correctly in character limit', () async {
1380
1515
await providerWithCommentService.loadComments(
···
1420
1555
// Don't call loadComments first - no post context
1421
1556
1422
1557
expect(
1423
-
() => providerWithCommentService.createComment(
1424
-
content: 'Test comment',
1425
-
),
1558
+
() =>
1559
+
providerWithCommentService.createComment(content: 'Test comment'),
1426
1560
throwsA(
1427
1561
isA<ApiException>().having(
1428
1562
(e) => e.message,
···
1602
1736
),
1603
1737
);
1604
1738
1605
-
await providerWithCommentService.createComment(
1606
-
content: 'Test comment',
1607
-
);
1739
+
await providerWithCommentService.createComment(content: 'Test comment');
1608
1740
1609
1741
// Should have called getComments twice - once for initial load,
1610
1742
// once for refresh after comment creation
···
1638
1770
).thenThrow(ApiException('Network error'));
1639
1771
1640
1772
expect(
1641
-
() => providerWithCommentService.createComment(
1642
-
content: 'Test comment',
1643
-
),
1773
+
() =>
1774
+
providerWithCommentService.createComment(content: 'Test comment'),
1644
1775
throwsA(
1645
1776
isA<ApiException>().having(
1646
1777
(e) => e.message,
+96
-87
test/services/comment_service_test.dart
+96
-87
test/services/comment_service_test.dart
···
178
178
);
179
179
});
180
180
181
-
test('should throw ApiException on invalid response (null data)', () async {
182
-
when(
183
-
mockDio.post<Map<String, dynamic>>(
184
-
'/xrpc/social.coves.community.comment.create',
185
-
data: anyNamed('data'),
186
-
),
187
-
).thenAnswer(
188
-
(_) async => Response(
189
-
requestOptions: RequestOptions(path: ''),
190
-
statusCode: 200,
191
-
data: null,
192
-
),
193
-
);
181
+
test(
182
+
'should throw ApiException on invalid response (null data)',
183
+
() async {
184
+
when(
185
+
mockDio.post<Map<String, dynamic>>(
186
+
'/xrpc/social.coves.community.comment.create',
187
+
data: anyNamed('data'),
188
+
),
189
+
).thenAnswer(
190
+
(_) async => Response(
191
+
requestOptions: RequestOptions(path: ''),
192
+
statusCode: 200,
193
+
data: null,
194
+
),
195
+
);
194
196
195
-
expect(
196
-
() => commentService.createComment(
197
-
rootUri: 'at://did:plc:author/post/123',
198
-
rootCid: 'rootCid',
199
-
parentUri: 'at://did:plc:author/post/123',
200
-
parentCid: 'parentCid',
201
-
content: 'Test comment',
202
-
),
203
-
throwsA(
204
-
isA<ApiException>().having(
205
-
(e) => e.message,
206
-
'message',
207
-
contains('no data'),
197
+
expect(
198
+
() => commentService.createComment(
199
+
rootUri: 'at://did:plc:author/post/123',
200
+
rootCid: 'rootCid',
201
+
parentUri: 'at://did:plc:author/post/123',
202
+
parentCid: 'parentCid',
203
+
content: 'Test comment',
208
204
),
209
-
),
210
-
);
211
-
});
205
+
throwsA(
206
+
isA<ApiException>().having(
207
+
(e) => e.message,
208
+
'message',
209
+
contains('no data'),
210
+
),
211
+
),
212
+
);
213
+
},
214
+
);
212
215
213
-
test('should throw ApiException on invalid response (missing uri)', () async {
214
-
when(
215
-
mockDio.post<Map<String, dynamic>>(
216
-
'/xrpc/social.coves.community.comment.create',
217
-
data: anyNamed('data'),
218
-
),
219
-
).thenAnswer(
220
-
(_) async => Response(
221
-
requestOptions: RequestOptions(path: ''),
222
-
statusCode: 200,
223
-
data: {'cid': 'bafy123'},
224
-
),
225
-
);
216
+
test(
217
+
'should throw ApiException on invalid response (missing uri)',
218
+
() async {
219
+
when(
220
+
mockDio.post<Map<String, dynamic>>(
221
+
'/xrpc/social.coves.community.comment.create',
222
+
data: anyNamed('data'),
223
+
),
224
+
).thenAnswer(
225
+
(_) async => Response(
226
+
requestOptions: RequestOptions(path: ''),
227
+
statusCode: 200,
228
+
data: {'cid': 'bafy123'},
229
+
),
230
+
);
226
231
227
-
expect(
228
-
() => commentService.createComment(
229
-
rootUri: 'at://did:plc:author/post/123',
230
-
rootCid: 'rootCid',
231
-
parentUri: 'at://did:plc:author/post/123',
232
-
parentCid: 'parentCid',
233
-
content: 'Test comment',
234
-
),
235
-
throwsA(
236
-
isA<ApiException>().having(
237
-
(e) => e.message,
238
-
'message',
239
-
contains('missing uri'),
232
+
expect(
233
+
() => commentService.createComment(
234
+
rootUri: 'at://did:plc:author/post/123',
235
+
rootCid: 'rootCid',
236
+
parentUri: 'at://did:plc:author/post/123',
237
+
parentCid: 'parentCid',
238
+
content: 'Test comment',
240
239
),
241
-
),
242
-
);
243
-
});
240
+
throwsA(
241
+
isA<ApiException>().having(
242
+
(e) => e.message,
243
+
'message',
244
+
contains('missing uri'),
245
+
),
246
+
),
247
+
);
248
+
},
249
+
);
244
250
245
-
test('should throw ApiException on invalid response (empty uri)', () async {
246
-
when(
247
-
mockDio.post<Map<String, dynamic>>(
248
-
'/xrpc/social.coves.community.comment.create',
249
-
data: anyNamed('data'),
250
-
),
251
-
).thenAnswer(
252
-
(_) async => Response(
253
-
requestOptions: RequestOptions(path: ''),
254
-
statusCode: 200,
255
-
data: {'uri': '', 'cid': 'bafy123'},
256
-
),
257
-
);
251
+
test(
252
+
'should throw ApiException on invalid response (empty uri)',
253
+
() async {
254
+
when(
255
+
mockDio.post<Map<String, dynamic>>(
256
+
'/xrpc/social.coves.community.comment.create',
257
+
data: anyNamed('data'),
258
+
),
259
+
).thenAnswer(
260
+
(_) async => Response(
261
+
requestOptions: RequestOptions(path: ''),
262
+
statusCode: 200,
263
+
data: {'uri': '', 'cid': 'bafy123'},
264
+
),
265
+
);
258
266
259
-
expect(
260
-
() => commentService.createComment(
261
-
rootUri: 'at://did:plc:author/post/123',
262
-
rootCid: 'rootCid',
263
-
parentUri: 'at://did:plc:author/post/123',
264
-
parentCid: 'parentCid',
265
-
content: 'Test comment',
266
-
),
267
-
throwsA(
268
-
isA<ApiException>().having(
269
-
(e) => e.message,
270
-
'message',
271
-
contains('missing uri'),
267
+
expect(
268
+
() => commentService.createComment(
269
+
rootUri: 'at://did:plc:author/post/123',
270
+
rootCid: 'rootCid',
271
+
parentUri: 'at://did:plc:author/post/123',
272
+
parentCid: 'parentCid',
273
+
content: 'Test comment',
274
+
),
275
+
throwsA(
276
+
isA<ApiException>().having(
277
+
(e) => e.message,
278
+
'message',
279
+
contains('missing uri'),
280
+
),
272
281
),
273
-
),
274
-
);
275
-
});
282
+
);
283
+
},
284
+
);
276
285
277
286
test('should throw ApiException on server error', () async {
278
287
when(