commit 4770eb042edbedaefea41a8c2c88cbfa2f45d414 · bretton.dev/coves-mobile

+280

test/services/streamable_service_test.dart

···

       1
       +
       import 'package:coves_flutter/services/streamable_service.dart';

     

       2
       +
       import 'package:dio/dio.dart';

     

       3
       +
       import 'package:flutter_test/flutter_test.dart';

     

       4
       +
       import 'package:http_mock_adapter/http_mock_adapter.dart';

     

       5
       +
       

     

       6
       +
       void main() {

     

       7
       +
         group('StreamableService', () {

     

       8
       +
           late Dio dio;

     

       9
       +
           late DioAdapter dioAdapter;

     

       10
       +
           late StreamableService service;

     

       11
       +
       

     

       12
       +
           setUp(() {

     

       13
       +
             dio = Dio();

     

       14
       +
             dioAdapter = DioAdapter(dio: dio);

     

       15
       +
             service = StreamableService(dio: dio);

     

       16
       +
           });

     

       17
       +
       

     

       18
       +
           group('extractShortcode', () {

     

       19
       +
             test('extracts shortcode from standard URL', () {

     

       20
       +
               expect(

     

       21
       +
                 StreamableService.extractShortcode('https://streamable.com/abc123'),

     

       22
       +
                 'abc123',

     

       23
       +
               );

     

       24
       +
             });

     

       25
       +
       

     

       26
       +
             test('extracts shortcode from /e/ URL', () {

     

       27
       +
               expect(

     

       28
       +
                 StreamableService.extractShortcode('https://streamable.com/e/abc123'),

     

       29
       +
                 'abc123',

     

       30
       +
               );

     

       31
       +
             });

     

       32
       +
       

     

       33
       +
             test('extracts shortcode from URL without scheme', () {

     

       34
       +
               expect(

     

       35
       +
                 StreamableService.extractShortcode('streamable.com/xyz789'),

     

       36
       +
                 'xyz789',

     

       37
       +
               );

     

       38
       +
             });

     

       39
       +
       

     

       40
       +
             test('extracts shortcode from /e/ URL without scheme', () {

     

       41
       +
               expect(

     

       42
       +
                 StreamableService.extractShortcode('streamable.com/e/xyz789'),

     

       43
       +
                 'xyz789',

     

       44
       +
               );

     

       45
       +
             });

     

       46
       +
       

     

       47
       +
             test('returns null for empty path', () {

     

       48
       +
               expect(

     

       49
       +
                 StreamableService.extractShortcode('https://streamable.com/'),

     

       50
       +
                 null,

     

       51
       +
               );

     

       52
       +
             });

     

       53
       +
       

     

       54
       +
             test('returns null for invalid URL', () {

     

       55
       +
               expect(StreamableService.extractShortcode('not a url'), null);

     

       56
       +
             });

     

       57
       +
       

     

       58
       +
             test('handles URL with query parameters', () {

     

       59
       +
               expect(

     

       60
       +
                 StreamableService.extractShortcode(

     

       61
       +
                   'https://streamable.com/abc123?autoplay=1',

     

       62
       +
                 ),

     

       63
       +
                 'abc123',

     

       64
       +
               );

     

       65
       +
             });

     

       66
       +
       

     

       67
       +
             test('handles /e/ URL with query parameters', () {

     

       68
       +
               expect(

     

       69
       +
                 StreamableService.extractShortcode(

     

       70
       +
                   'https://streamable.com/e/abc123?autoplay=1',

     

       71
       +
                 ),

     

       72
       +
                 'abc123',

     

       73
       +
               );

     

       74
       +
             });

     

       75
       +
           });

     

       76
       +
       

     

       77
       +
           group('getVideoUrl', () {

     

       78
       +
             test('fetches and returns MP4 URL successfully', () async {

     

       79
       +
               const shortcode = 'abc123';

     

       80
       +
               const videoUrl = '//cdn.streamable.com/video/mp4/abc123.mp4';

     

       81
       +
       

     

       82
       +
               dioAdapter.onGet(

     

       83
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       84
       +
                 (server) => server.reply(200, {

     

       85
       +
                   'files': {

     

       86
       +
                     'mp4': {'url': videoUrl},

     

       87
       +
                   },

     

       88
       +
                 }),

     

       89
       +
               );

     

       90
       +
       

     

       91
       +
               final result = await service.getVideoUrl(

     

       92
       +
                 'https://streamable.com/$shortcode',

     

       93
       +
               );

     

       94
       +
       

     

       95
       +
               expect(result, 'https:$videoUrl');

     

       96
       +
             });

     

       97
       +
       

     

       98
       +
             test('handles /e/ URL format', () async {

     

       99
       +
               const shortcode = 'xyz789';

     

       100
       +
               const videoUrl = '//cdn.streamable.com/video/mp4/xyz789.mp4';

     

       101
       +
       

     

       102
       +
               dioAdapter.onGet(

     

       103
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       104
       +
                 (server) => server.reply(200, {

     

       105
       +
                   'files': {

     

       106
       +
                     'mp4': {'url': videoUrl},

     

       107
       +
                   },

     

       108
       +
                 }),

     

       109
       +
               );

     

       110
       +
       

     

       111
       +
               final result = await service.getVideoUrl(

     

       112
       +
                 'https://streamable.com/e/$shortcode',

     

       113
       +
               );

     

       114
       +
       

     

       115
       +
               expect(result, 'https:$videoUrl');

     

       116
       +
             });

     

       117
       +
       

     

       118
       +
             test('caches video URLs', () async {

     

       119
       +
               const shortcode = 'cached123';

     

       120
       +
               const videoUrl = '//cdn.streamable.com/video/mp4/cached123.mp4';

     

       121
       +
       

     

       122
       +
               dioAdapter.onGet(

     

       123
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       124
       +
                 (server) => server.reply(200, {

     

       125
       +
                   'files': {

     

       126
       +
                     'mp4': {'url': videoUrl},

     

       127
       +
                   },

     

       128
       +
                 }),

     

       129
       +
               );

     

       130
       +
       

     

       131
       +
               // First call - should hit the API

     

       132
       +
               final result1 = await service.getVideoUrl(

     

       133
       +
                 'https://streamable.com/$shortcode',

     

       134
       +
               );

     

       135
       +
               expect(result1, 'https:$videoUrl');

     

       136
       +
       

     

       137
       +
               // Second call - should use cache (no additional network request)

     

       138
       +
               final result2 = await service.getVideoUrl(

     

       139
       +
                 'https://streamable.com/$shortcode',

     

       140
       +
               );

     

       141
       +
               expect(result2, 'https:$videoUrl');

     

       142
       +
             });

     

       143
       +
       

     

       144
       +
             test('returns null for invalid shortcode', () async {

     

       145
       +
               const shortcode = 'invalid';

     

       146
       +
       

     

       147
       +
               dioAdapter.onGet(

     

       148
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       149
       +
                 (server) => server.reply(404, {'error': 'Not found'}),

     

       150
       +
               );

     

       151
       +
       

     

       152
       +
               final result = await service.getVideoUrl(

     

       153
       +
                 'https://streamable.com/$shortcode',

     

       154
       +
               );

     

       155
       +
       

     

       156
       +
               expect(result, null);

     

       157
       +
             });

     

       158
       +
       

     

       159
       +
             test('returns null when files field is missing', () async {

     

       160
       +
               const shortcode = 'nofiles123';

     

       161
       +
       

     

       162
       +
               dioAdapter.onGet(

     

       163
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       164
       +
                 (server) => server.reply(200, {'status': 'ok'}),

     

       165
       +
               );

     

       166
       +
       

     

       167
       +
               final result = await service.getVideoUrl(

     

       168
       +
                 'https://streamable.com/$shortcode',

     

       169
       +
               );

     

       170
       +
       

     

       171
       +
               expect(result, null);

     

       172
       +
             });

     

       173
       +
       

     

       174
       +
             test('returns null when mp4 field is missing', () async {

     

       175
       +
               const shortcode = 'nomp4123';

     

       176
       +
       

     

       177
       +
               dioAdapter.onGet(

     

       178
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       179
       +
                 (server) => server.reply(200, {

     

       180
       +
                   'files': {'webm': {}},

     

       181
       +
                 }),

     

       182
       +
               );

     

       183
       +
       

     

       184
       +
               final result = await service.getVideoUrl(

     

       185
       +
                 'https://streamable.com/$shortcode',

     

       186
       +
               );

     

       187
       +
       

     

       188
       +
               expect(result, null);

     

       189
       +
             });

     

       190
       +
       

     

       191
       +
             test('returns null when URL field is missing', () async {

     

       192
       +
               const shortcode = 'nourl123';

     

       193
       +
       

     

       194
       +
               dioAdapter.onGet(

     

       195
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       196
       +
                 (server) => server.reply(200, {

     

       197
       +
                   'files': {

     

       198
       +
                     'mp4': {'status': 'processing'},

     

       199
       +
                   },

     

       200
       +
                 }),

     

       201
       +
               );

     

       202
       +
       

     

       203
       +
               final result = await service.getVideoUrl(

     

       204
       +
                 'https://streamable.com/$shortcode',

     

       205
       +
               );

     

       206
       +
       

     

       207
       +
               expect(result, null);

     

       208
       +
             });

     

       209
       +
       

     

       210
       +
             test('returns null on network error', () async {

     

       211
       +
               const shortcode = 'error500';

     

       212
       +
       

     

       213
       +
               dioAdapter.onGet(

     

       214
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       215
       +
                 (server) => server.throws(

     

       216
       +
                   500,

     

       217
       +
                   DioException(

     

       218
       +
                     requestOptions: RequestOptions(

     

       219
       +
                       path: 'https://api.streamable.com/videos/$shortcode',

     

       220
       +
                     ),

     

       221
       +
                   ),

     

       222
       +
                 ),

     

       223
       +
               );

     

       224
       +
       

     

       225
       +
               final result = await service.getVideoUrl(

     

       226
       +
                 'https://streamable.com/$shortcode',

     

       227
       +
               );

     

       228
       +
       

     

       229
       +
               expect(result, null);

     

       230
       +
             });

     

       231
       +
       

     

       232
       +
             test('returns null when shortcode extraction fails', () async {

     

       233
       +
               final result = await service.getVideoUrl('invalid-url');

     

       234
       +
               expect(result, null);

     

       235
       +
             });

     

       236
       +
       

     

       237
       +
             test('prepends https to protocol-relative URLs', () async {

     

       238
       +
               const shortcode = 'protocol123';

     

       239
       +
               const videoUrl = '//cdn.streamable.com/video/mp4/protocol123.mp4';

     

       240
       +
       

     

       241
       +
               dioAdapter.onGet(

     

       242
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       243
       +
                 (server) => server.reply(200, {

     

       244
       +
                   'files': {

     

       245
       +
                     'mp4': {'url': videoUrl},

     

       246
       +
                   },

     

       247
       +
                 }),

     

       248
       +
               );

     

       249
       +
       

     

       250
       +
               final result = await service.getVideoUrl(

     

       251
       +
                 'https://streamable.com/$shortcode',

     

       252
       +
               );

     

       253
       +
       

     

       254
       +
               expect(result, startsWith('https://'));

     

       255
       +
               expect(result, 'https:$videoUrl');

     

       256
       +
             });

     

       257
       +
       

     

       258
       +
             test('does not modify URLs that already have protocol', () async {

     

       259
       +
               const shortcode = 'hasprotocol123';

     

       260
       +
               const videoUrl =

     

       261
       +
                   'https://cdn.streamable.com/video/mp4/hasprotocol123.mp4';

     

       262
       +
       

     

       263
       +
               dioAdapter.onGet(

     

       264
       +
                 'https://api.streamable.com/videos/$shortcode',

     

       265
       +
                 (server) => server.reply(200, {

     

       266
       +
                   'files': {

     

       267
       +
                     'mp4': {'url': videoUrl},

     

       268
       +
                   },

     

       269
       +
                 }),

     

       270
       +
               );

     

       271
       +
       

     

       272
       +
               final result = await service.getVideoUrl(

     

       273
       +
                 'https://streamable.com/$shortcode',

     

       274
       +
               );

     

       275
       +
       

     

       276
       +
               expect(result, videoUrl);

     

       277
       +
             });

     

       278
       +
           });

     

       279
       +
         });

     

       280
       +
       }

+368 -180

test/widgets/post_card_test.dart

···

       1
        
       import 'package:coves_flutter/models/post.dart';

     

       0
        
       
     

       2
        
       import 'package:coves_flutter/widgets/post_card.dart';

     

       0
        
       
     

       3
        
       import 'package:flutter/material.dart';

     

       4
        
       import 'package:flutter_test/flutter_test.dart';

     

       0
        
       
     

       5
        
       import 'package:provider/provider.dart';

     

       6
        
       

     

       7
        
       import '../test_helpers/mock_providers.dart';

     
···

       15
        
           mockVoteProvider = MockVoteProvider();

     

       16
        
         });

     

       17
        
       

     

       18
       -
         Widget createTestWidget(FeedViewPost post) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       19
        
           return MultiProvider(

     

       20
        
             providers: [

     

       21
        
               // ignore: argument_type_not_assignable

     

       22
        
               ChangeNotifierProvider<MockAuthProvider>.value(value: mockAuthProvider),

     

       23
        
               // ignore: argument_type_not_assignable

     

       24
        
               ChangeNotifierProvider<MockVoteProvider>.value(value: mockVoteProvider),

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25
        
             ],

     

       26
        
             child: MaterialApp(home: Scaffold(body: PostCard(post: post))),

     

       27
        
           );

     

       28
        
         }

     

       29
        
       

     

       30
       -
         group('PostCard', skip: 'Provider type compatibility issues - needs mock refactoring', () {

     

       31
       -
           testWidgets('renders all basic components', (tester) async {

     

       32
       -
             final post = FeedViewPost(

     

       33
       -
               post: PostView(

     

       34
       -
                 uri: 'at://did:example/post/123',

     

       35
       -
                 cid: 'cid123',

     

       36
       -
                 rkey: '123',

     

       37
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       38
       -
                 community: CommunityRef(

     

       39
       -
                   did: 'did:plc:community',

     

       40
       -
                   name: 'test-community',

     

       41
       -
                 ),

     

       42
       -
                 createdAt: DateTime(2024, 1, 1),

     

       43
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       44
       -
                 text: 'Test post content',

     

       45
       -
                 title: 'Test Post Title',

     

       46
       -
                 stats: PostStats(

     

       47
       -
                   upvotes: 10,

     

       48
       -
                   downvotes: 2,

     

       49
       -
                   score: 8,

     

       50
       -
                   commentCount: 5,

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       51
        
                 ),

     

       52
       -
               ),

     

       53
       -
             );

     

       54
        
       

     

       55
       -
             await tester.pumpWidget(createTestWidget(post));

     

       56
        
       

     

       57
       -
             // Verify title is displayed

     

       58
       -
             expect(find.text('Test Post Title'), findsOneWidget);

     

       59
        
       

     

       60
       -
             // Verify community name is displayed

     

       61
       -
             expect(find.text('c/test-community'), findsOneWidget);

     

       62
        
       

     

       63
       -
             // Verify author handle is displayed

     

       64
       -
             expect(find.text('@author.test'), findsOneWidget);

     

       65
        
       

     

       66
       -
             // Verify text content is displayed

     

       67
       -
             expect(find.text('Test post content'), findsOneWidget);

     

       68
        
       

     

       69
       -
             // Verify stats are displayed

     

       70
       -
             expect(find.text('8'), findsOneWidget); // score

     

       71
       -
             expect(find.text('5'), findsOneWidget); // comment count

     

       72
       -
           });

     

       73
        
       

     

       74
       -
           testWidgets('displays community avatar when available', (tester) async {

     

       75
       -
             final post = FeedViewPost(

     

       76
       -
               post: PostView(

     

       77
       -
                 uri: 'at://did:example/post/123',

     

       78
       -
                 cid: 'cid123',

     

       79
       -
                 rkey: '123',

     

       80
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       81
       -
                 community: CommunityRef(

     

       82
       -
                   did: 'did:plc:community',

     

       83
       -
                   name: 'test-community',

     

       84
       -
                   avatar: 'https://example.com/avatar.jpg',

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       85
        
                 ),

     

       86
       -
                 createdAt: DateTime(2024, 1, 1),

     

       87
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       88
       -
                 text: '',

     

       89
       -
                 stats: PostStats(upvotes: 0, downvotes: 0, score: 0, commentCount: 0),

     

       90
       -
               ),

     

       91
       -
             );

     

       92
        
       

     

       93
       -
             await tester.pumpWidget(createTestWidget(post));

     

       94
       -
             await tester.pumpAndSettle();

     

       95
        
       

     

       96
       -
             // Avatar image should be present

     

       97
       -
             expect(find.byType(Image), findsWidgets);

     

       98
       -
           });

     

       99
        
       

     

       100
       -
           testWidgets('shows fallback avatar when no avatar URL', (tester) async {

     

       101
       -
             final post = FeedViewPost(

     

       102
       -
               post: PostView(

     

       103
       -
                 uri: 'at://did:example/post/123',

     

       104
       -
                 cid: 'cid123',

     

       105
       -
                 rkey: '123',

     

       106
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       107
       -
                 community: CommunityRef(

     

       108
       -
                   did: 'did:plc:community',

     

       109
       -
                   name: 'TestCommunity',

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       110
        
                 ),

     

       111
       -
                 createdAt: DateTime(2024, 1, 1),

     

       112
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       113
       -
                 text: '',

     

       114
       -
                 stats: PostStats(upvotes: 0, downvotes: 0, score: 0, commentCount: 0),

     

       115
       -
               ),

     

       116
       -
             );

     

       117
        
       

     

       118
       -
             await tester.pumpWidget(createTestWidget(post));

     

       119
        
       

     

       120
       -
             // Verify fallback shows first letter

     

       121
       -
             expect(find.text('T'), findsOneWidget);

     

       122
       -
           });

     

       123
        
       

     

       124
       -
           testWidgets('displays external link bar when embed present', (

     

       125
       -
             tester,

     

       126
       -
           ) async {

     

       127
       -
             final post = FeedViewPost(

     

       128
       -
               post: PostView(

     

       129
       -
                 uri: 'at://did:example/post/123',

     

       130
       -
                 cid: 'cid123',

     

       131
       -
                 rkey: '123',

     

       132
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       133
       -
                 community: CommunityRef(

     

       134
       -
                   did: 'did:plc:community',

     

       135
       -
                   name: 'test-community',

     

       136
       -
                 ),

     

       137
       -
                 createdAt: DateTime(2024, 1, 1),

     

       138
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       139
       -
                 text: '',

     

       140
       -
                 stats: PostStats(upvotes: 0, downvotes: 0, score: 0, commentCount: 0),

     

       141
       -
                 embed: PostEmbed(

     

       142
       -
                   type: 'social.coves.embed.external',

     

       143
       -
                   external: ExternalEmbed(

     

       144
       -
                     uri: 'https://example.com/article',

     

       145
       -
                     domain: 'example.com',

     

       146
       -
                     title: 'Example Article',

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       147
        
                   ),

     

       148
       -
                   data: const {},

     

       149
        
                 ),

     

       150
       -
               ),

     

       151
       -
             );

     

       152
        
       

     

       153
       -
             await tester.pumpWidget(createTestWidget(post));

     

       154
        
       

     

       155
       -
             // Verify external link bar is present

     

       156
       -
             expect(find.text('example.com'), findsOneWidget);

     

       157
       -
             expect(find.byIcon(Icons.open_in_new), findsOneWidget);

     

       158
       -
           });

     

       159
        
       

     

       160
       -
           testWidgets('displays embed image when available', (tester) async {

     

       161
       -
             final post = FeedViewPost(

     

       162
       -
               post: PostView(

     

       163
       -
                 uri: 'at://did:example/post/123',

     

       164
       -
                 cid: 'cid123',

     

       165
       -
                 rkey: '123',

     

       166
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       167
       -
                 community: CommunityRef(

     

       168
       -
                   did: 'did:plc:community',

     

       169
       -
                   name: 'test-community',

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       170
        
                 ),

     

       171
       -
                 createdAt: DateTime(2024, 1, 1),

     

       172
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       173
       -
                 text: '',

     

       174
       -
                 stats: PostStats(upvotes: 0, downvotes: 0, score: 0, commentCount: 0),

     

       175
       -
                 embed: PostEmbed(

     

       176
       -
                   type: 'social.coves.embed.external',

     

       177
       -
                   external: ExternalEmbed(

     

       178
       -
                     uri: 'https://example.com/article',

     

       179
       -
                     thumb: 'https://example.com/thumb.jpg',

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       180
        
                   ),

     

       181
       -
                   data: const {},

     

       182
        
                 ),

     

       183
       -
               ),

     

       184
       -
             );

     

       185
        
       

     

       186
       -
             await tester.pumpWidget(createTestWidget(post));

     

       187
       -
             await tester.pump();

     

       188
        
       

     

       189
       -
             // Embed image should be loading/present

     

       190
       -
             expect(find.byType(Image), findsWidgets);

     

       191
       -
           });

     

       0
        
       
     

       192
        
       

     

       193
       -
           testWidgets('renders without title', (tester) async {

     

       194
       -
             final post = FeedViewPost(

     

       195
       -
               post: PostView(

     

       196
       -
                 uri: 'at://did:example/post/123',

     

       197
       -
                 cid: 'cid123',

     

       198
       -
                 rkey: '123',

     

       199
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       200
       -
                 community: CommunityRef(

     

       201
       -
                   did: 'did:plc:community',

     

       202
       -
                   name: 'test-community',

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       203
        
                 ),

     

       204
       -
                 createdAt: DateTime(2024, 1, 1),

     

       205
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       206
       -
                 text: 'Just body text',

     

       207
       -
                 stats: PostStats(upvotes: 0, downvotes: 0, score: 0, commentCount: 0),

     

       208
       -
               ),

     

       209
       -
             );

     

       210
        
       

     

       211
       -
             await tester.pumpWidget(createTestWidget(post));

     

       212
        
       

     

       213
       -
             // Should render without errors

     

       214
       -
             expect(find.text('Just body text'), findsOneWidget);

     

       215
       -
             expect(find.text('c/test-community'), findsOneWidget);

     

       216
       -
           });

     

       0
        
       
     

       217
        
       

     

       218
       -
           testWidgets('has action buttons', (tester) async {

     

       219
       -
             final post = FeedViewPost(

     

       220
       -
               post: PostView(

     

       221
       -
                 uri: 'at://did:example/post/123',

     

       222
       -
                 cid: 'cid123',

     

       223
       -
                 rkey: '123',

     

       224
       -
                 author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       225
       -
                 community: CommunityRef(

     

       226
       -
                   did: 'did:plc:community',

     

       227
       -
                   name: 'test-community',

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       228
        
                 ),

     

       229
       -
                 createdAt: DateTime(2024, 1, 1),

     

       230
       -
                 indexedAt: DateTime(2024, 1, 1),

     

       231
       -
                 text: '',

     

       232
       -
                 stats: PostStats(upvotes: 0, downvotes: 0, score: 0, commentCount: 0),

     

       233
       -
               ),

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       234
        
             );

     

       235
        
       

     

       236
       -
             await tester.pumpWidget(createTestWidget(post));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       237
        
       

     

       238
       -
             // Verify action buttons are present

     

       239
       -
             expect(find.byIcon(Icons.more_horiz), findsOneWidget); // menu

     

       240
       -
             // Share, comment, and heart icons are custom widgets, verify by count

     

       241
       -
             expect(find.byType(InkWell), findsWidgets);

     

       242
       -
           });

     

       243
       -
         });

     

       0
        
       
     

       0
        
       
     

       244
        
       }

···

       1
        
       import 'package:coves_flutter/models/post.dart';

     

       2
       +
       import 'package:coves_flutter/services/streamable_service.dart';

     

       3
        
       import 'package:coves_flutter/widgets/post_card.dart';

     

       4
       +
       import 'package:dio/dio.dart';

     

       5
        
       import 'package:flutter/material.dart';

     

       6
        
       import 'package:flutter_test/flutter_test.dart';

     

       7
       +
       import 'package:http_mock_adapter/http_mock_adapter.dart';

     

       8
        
       import 'package:provider/provider.dart';

     

       9
        
       

     

       10
        
       import '../test_helpers/mock_providers.dart';

     
···

       18
        
           mockVoteProvider = MockVoteProvider();

     

       19
        
         });

     

       20
        
       

     

       21
       +
         Widget createTestWidget(

     

       22
       +
           FeedViewPost post, {

     

       23
       +
           StreamableService? streamableService,

     

       24
       +
         }) {

     

       25
        
           return MultiProvider(

     

       26
        
             providers: [

     

       27
        
               // ignore: argument_type_not_assignable

     

       28
        
               ChangeNotifierProvider<MockAuthProvider>.value(value: mockAuthProvider),

     

       29
        
               // ignore: argument_type_not_assignable

     

       30
        
               ChangeNotifierProvider<MockVoteProvider>.value(value: mockVoteProvider),

     

       31
       +
               Provider<StreamableService>.value(

     

       32
       +
                 value: streamableService ?? StreamableService(),

     

       33
       +
               ),

     

       34
        
             ],

     

       35
        
             child: MaterialApp(home: Scaffold(body: PostCard(post: post))),

     

       36
        
           );

     

       37
        
         }

     

       38
        
       

     

       39
       +
         group(

     

       40
       +
           'PostCard',

     

       41
       +
           skip: 'Provider type compatibility issues - needs mock refactoring',

     

       42
       +
           () {

     

       43
       +
             testWidgets('renders all basic components', (tester) async {

     

       44
       +
               final post = FeedViewPost(

     

       45
       +
                 post: PostView(

     

       46
       +
                   uri: 'at://did:example/post/123',

     

       47
       +
                   cid: 'cid123',

     

       48
       +
                   rkey: '123',

     

       49
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       50
       +
                   community: CommunityRef(

     

       51
       +
                     did: 'did:plc:community',

     

       52
       +
                     name: 'test-community',

     

       53
       +
                   ),

     

       54
       +
                   createdAt: DateTime(2024, 1, 1),

     

       55
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       56
       +
                   text: 'Test post content',

     

       57
       +
                   title: 'Test Post Title',

     

       58
       +
                   stats: PostStats(

     

       59
       +
                     upvotes: 10,

     

       60
       +
                     downvotes: 2,

     

       61
       +
                     score: 8,

     

       62
       +
                     commentCount: 5,

     

       63
       +
                   ),

     

       64
        
                 ),

     

       65
       +
               );

     

       0
        
       
     

       66
        
       

     

       67
       +
               await tester.pumpWidget(createTestWidget(post));

     

       68
        
       

     

       69
       +
               // Verify title is displayed

     

       70
       +
               expect(find.text('Test Post Title'), findsOneWidget);

     

       71
        
       

     

       72
       +
               // Verify community name is displayed

     

       73
       +
               expect(find.text('c/test-community'), findsOneWidget);

     

       74
        
       

     

       75
       +
               // Verify author handle is displayed

     

       76
       +
               expect(find.text('@author.test'), findsOneWidget);

     

       77
        
       

     

       78
       +
               // Verify text content is displayed

     

       79
       +
               expect(find.text('Test post content'), findsOneWidget);

     

       80
        
       

     

       81
       +
               // Verify stats are displayed

     

       82
       +
               expect(find.text('8'), findsOneWidget); // score

     

       83
       +
               expect(find.text('5'), findsOneWidget); // comment count

     

       84
       +
             });

     

       85
        
       

     

       86
       +
             testWidgets('displays community avatar when available', (tester) async {

     

       87
       +
               final post = FeedViewPost(

     

       88
       +
                 post: PostView(

     

       89
       +
                   uri: 'at://did:example/post/123',

     

       90
       +
                   cid: 'cid123',

     

       91
       +
                   rkey: '123',

     

       92
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       93
       +
                   community: CommunityRef(

     

       94
       +
                     did: 'did:plc:community',

     

       95
       +
                     name: 'test-community',

     

       96
       +
                     avatar: 'https://example.com/avatar.jpg',

     

       97
       +
                   ),

     

       98
       +
                   createdAt: DateTime(2024, 1, 1),

     

       99
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       100
       +
                   text: '',

     

       101
       +
                   stats: PostStats(

     

       102
       +
                     upvotes: 0,

     

       103
       +
                     downvotes: 0,

     

       104
       +
                     score: 0,

     

       105
       +
                     commentCount: 0,

     

       106
       +
                   ),

     

       107
        
                 ),

     

       108
       +
               );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       109
        
       

     

       110
       +
               await tester.pumpWidget(createTestWidget(post));

     

       111
       +
               await tester.pumpAndSettle();

     

       112
        
       

     

       113
       +
               // Avatar image should be present

     

       114
       +
               expect(find.byType(Image), findsWidgets);

     

       115
       +
             });

     

       116
        
       

     

       117
       +
             testWidgets('shows fallback avatar when no avatar URL', (tester) async {

     

       118
       +
               final post = FeedViewPost(

     

       119
       +
                 post: PostView(

     

       120
       +
                   uri: 'at://did:example/post/123',

     

       121
       +
                   cid: 'cid123',

     

       122
       +
                   rkey: '123',

     

       123
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       124
       +
                   community: CommunityRef(

     

       125
       +
                     did: 'did:plc:community',

     

       126
       +
                     name: 'TestCommunity',

     

       127
       +
                   ),

     

       128
       +
                   createdAt: DateTime(2024, 1, 1),

     

       129
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       130
       +
                   text: '',

     

       131
       +
                   stats: PostStats(

     

       132
       +
                     upvotes: 0,

     

       133
       +
                     downvotes: 0,

     

       134
       +
                     score: 0,

     

       135
       +
                     commentCount: 0,

     

       136
       +
                   ),

     

       137
        
                 ),

     

       138
       +
               );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       139
        
       

     

       140
       +
               await tester.pumpWidget(createTestWidget(post));

     

       141
        
       

     

       142
       +
               // Verify fallback shows first letter

     

       143
       +
               expect(find.text('T'), findsOneWidget);

     

       144
       +
             });

     

       145
        
       

     

       146
       +
             testWidgets('displays external link bar when embed present', (

     

       147
       +
               tester,

     

       148
       +
             ) async {

     

       149
       +
               final post = FeedViewPost(

     

       150
       +
                 post: PostView(

     

       151
       +
                   uri: 'at://did:example/post/123',

     

       152
       +
                   cid: 'cid123',

     

       153
       +
                   rkey: '123',

     

       154
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       155
       +
                   community: CommunityRef(

     

       156
       +
                     did: 'did:plc:community',

     

       157
       +
                     name: 'test-community',

     

       158
       +
                   ),

     

       159
       +
                   createdAt: DateTime(2024, 1, 1),

     

       160
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       161
       +
                   text: '',

     

       162
       +
                   stats: PostStats(

     

       163
       +
                     upvotes: 0,

     

       164
       +
                     downvotes: 0,

     

       165
       +
                     score: 0,

     

       166
       +
                     commentCount: 0,

     

       167
       +
                   ),

     

       168
       +
                   embed: PostEmbed(

     

       169
       +
                     type: 'social.coves.embed.external',

     

       170
       +
                     external: ExternalEmbed(

     

       171
       +
                       uri: 'https://example.com/article',

     

       172
       +
                       domain: 'example.com',

     

       173
       +
                       title: 'Example Article',

     

       174
       +
                     ),

     

       175
       +
                     data: const {},

     

       176
        
                   ),

     

       0
        
       
     

       177
        
                 ),

     

       178
       +
               );

     

       0
        
       
     

       179
        
       

     

       180
       +
               await tester.pumpWidget(createTestWidget(post));

     

       181
        
       

     

       182
       +
               // Verify external link bar is present

     

       183
       +
               expect(find.text('example.com'), findsOneWidget);

     

       184
       +
               expect(find.byIcon(Icons.open_in_new), findsOneWidget);

     

       185
       +
             });

     

       186
        
       

     

       187
       +
             testWidgets('displays embed image when available', (tester) async {

     

       188
       +
               final post = FeedViewPost(

     

       189
       +
                 post: PostView(

     

       190
       +
                   uri: 'at://did:example/post/123',

     

       191
       +
                   cid: 'cid123',

     

       192
       +
                   rkey: '123',

     

       193
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       194
       +
                   community: CommunityRef(

     

       195
       +
                     did: 'did:plc:community',

     

       196
       +
                     name: 'test-community',

     

       197
       +
                   ),

     

       198
       +
                   createdAt: DateTime(2024, 1, 1),

     

       199
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       200
       +
                   text: '',

     

       201
       +
                   stats: PostStats(

     

       202
       +
                     upvotes: 0,

     

       203
       +
                     downvotes: 0,

     

       204
       +
                     score: 0,

     

       205
       +
                     commentCount: 0,

     

       206
       +
                   ),

     

       207
       +
                   embed: PostEmbed(

     

       208
       +
                     type: 'social.coves.embed.external',

     

       209
       +
                     external: ExternalEmbed(

     

       210
       +
                       uri: 'https://example.com/article',

     

       211
       +
                       thumb: 'https://example.com/thumb.jpg',

     

       212
       +
                     ),

     

       213
       +
                     data: const {},

     

       214
       +
                   ),

     

       215
        
                 ),

     

       216
       +
               );

     

       217
       +
       

     

       218
       +
               await tester.pumpWidget(createTestWidget(post));

     

       219
       +
               await tester.pump();

     

       220
       +
       

     

       221
       +
               // Embed image should be loading/present

     

       222
       +
               expect(find.byType(Image), findsWidgets);

     

       223
       +
             });

     

       224
       +
       

     

       225
       +
             testWidgets('renders without title', (tester) async {

     

       226
       +
               final post = FeedViewPost(

     

       227
       +
                 post: PostView(

     

       228
       +
                   uri: 'at://did:example/post/123',

     

       229
       +
                   cid: 'cid123',

     

       230
       +
                   rkey: '123',

     

       231
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       232
       +
                   community: CommunityRef(

     

       233
       +
                     did: 'did:plc:community',

     

       234
       +
                     name: 'test-community',

     

       235
       +
                   ),

     

       236
       +
                   createdAt: DateTime(2024, 1, 1),

     

       237
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       238
       +
                   text: 'Just body text',

     

       239
       +
                   stats: PostStats(

     

       240
       +
                     upvotes: 0,

     

       241
       +
                     downvotes: 0,

     

       242
       +
                     score: 0,

     

       243
       +
                     commentCount: 0,

     

       244
        
                   ),

     

       0
        
       
     

       245
        
                 ),

     

       246
       +
               );

     

       0
        
       
     

       247
        
       

     

       248
       +
               await tester.pumpWidget(createTestWidget(post));

     

       0
        
       
     

       249
        
       

     

       250
       +
               // Should render without errors

     

       251
       +
               expect(find.text('Just body text'), findsOneWidget);

     

       252
       +
               expect(find.text('c/test-community'), findsOneWidget);

     

       253
       +
             });

     

       254
        
       

     

       255
       +
             testWidgets('has action buttons', (tester) async {

     

       256
       +
               final post = FeedViewPost(

     

       257
       +
                 post: PostView(

     

       258
       +
                   uri: 'at://did:example/post/123',

     

       259
       +
                   cid: 'cid123',

     

       260
       +
                   rkey: '123',

     

       261
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       262
       +
                   community: CommunityRef(

     

       263
       +
                     did: 'did:plc:community',

     

       264
       +
                     name: 'test-community',

     

       265
       +
                   ),

     

       266
       +
                   createdAt: DateTime(2024, 1, 1),

     

       267
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       268
       +
                   text: '',

     

       269
       +
                   stats: PostStats(

     

       270
       +
                     upvotes: 0,

     

       271
       +
                     downvotes: 0,

     

       272
       +
                     score: 0,

     

       273
       +
                     commentCount: 0,

     

       274
       +
                   ),

     

       275
        
                 ),

     

       276
       +
               );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       277
        
       

     

       278
       +
               await tester.pumpWidget(createTestWidget(post));

     

       279
        
       

     

       280
       +
               // Verify action buttons are present

     

       281
       +
               expect(find.byIcon(Icons.more_horiz), findsOneWidget); // menu

     

       282
       +
               // Share, comment, and heart icons are custom widgets, verify by count

     

       283
       +
               expect(find.byType(InkWell), findsWidgets);

     

       284
       +
             });

     

       285
        
       

     

       286
       +
             testWidgets('displays play button overlay for Streamable videos', (

     

       287
       +
               tester,

     

       288
       +
             ) async {

     

       289
       +
               final post = FeedViewPost(

     

       290
       +
                 post: PostView(

     

       291
       +
                   uri: 'at://did:example/post/123',

     

       292
       +
                   cid: 'cid123',

     

       293
       +
                   rkey: '123',

     

       294
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       295
       +
                   community: CommunityRef(

     

       296
       +
                     did: 'did:plc:community',

     

       297
       +
                     name: 'test-community',

     

       298
       +
                   ),

     

       299
       +
                   createdAt: DateTime(2024, 1, 1),

     

       300
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       301
       +
                   text: '',

     

       302
       +
                   stats: PostStats(

     

       303
       +
                     upvotes: 0,

     

       304
       +
                     downvotes: 0,

     

       305
       +
                     score: 0,

     

       306
       +
                     commentCount: 0,

     

       307
       +
                   ),

     

       308
       +
                   embed: PostEmbed(

     

       309
       +
                     type: 'social.coves.embed.external',

     

       310
       +
                     external: ExternalEmbed(

     

       311
       +
                       uri: 'https://streamable.com/abc123',

     

       312
       +
                       thumb: 'https://example.com/thumb.jpg',

     

       313
       +
                       embedType: 'video',

     

       314
       +
                       provider: 'streamable',

     

       315
       +
                     ),

     

       316
       +
                     data: const {},

     

       317
       +
                   ),

     

       318
        
                 ),

     

       319
       +
               );

     

       320
       +
       

     

       321
       +
               await tester.pumpWidget(createTestWidget(post));

     

       322
       +
               await tester.pump();

     

       323
       +
       

     

       324
       +
               // Verify play button is displayed

     

       325
       +
               expect(find.byIcon(Icons.play_arrow), findsOneWidget);

     

       326
       +
             });

     

       327
       +
       

     

       328
       +
             testWidgets(

     

       329
       +
               'shows loading indicator when fetching video URL for Streamable',

     

       330
       +
               (tester) async {

     

       331
       +
                 final dio = Dio(BaseOptions(baseUrl: 'https://api.streamable.com'));

     

       332
       +
                 final dioAdapter = DioAdapter(dio: dio);

     

       333
       +
                 final streamableService = StreamableService(dio: dio);

     

       334
       +
       

     

       335
       +
                 // Delay the response to test loading state

     

       336
       +
                 dioAdapter.onGet(

     

       337
       +
                   '/videos/abc123',

     

       338
       +
                   (server) => server.reply(200, {

     

       339
       +
                     'files': {

     

       340
       +
                       'mp4': {'url': '//cdn.streamable.com/video.mp4'},

     

       341
       +
                     },

     

       342
       +
                   }, delay: const Duration(milliseconds: 500)),

     

       343
       +
                 );

     

       344
       +
       

     

       345
       +
                 final post = FeedViewPost(

     

       346
       +
                   post: PostView(

     

       347
       +
                     uri: 'at://did:example/post/123',

     

       348
       +
                     cid: 'cid123',

     

       349
       +
                     rkey: '123',

     

       350
       +
                     author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       351
       +
                     community: CommunityRef(

     

       352
       +
                       did: 'did:plc:community',

     

       353
       +
                       name: 'test-community',

     

       354
       +
                     ),

     

       355
       +
                     createdAt: DateTime(2024, 1, 1),

     

       356
       +
                     indexedAt: DateTime(2024, 1, 1),

     

       357
       +
                     text: '',

     

       358
       +
                     stats: PostStats(

     

       359
       +
                       upvotes: 0,

     

       360
       +
                       downvotes: 0,

     

       361
       +
                       score: 0,

     

       362
       +
                       commentCount: 0,

     

       363
       +
                     ),

     

       364
       +
                     embed: PostEmbed(

     

       365
       +
                       type: 'social.coves.embed.external',

     

       366
       +
                       external: ExternalEmbed(

     

       367
       +
                         uri: 'https://streamable.com/abc123',

     

       368
       +
                         thumb: 'https://example.com/thumb.jpg',

     

       369
       +
                         embedType: 'video',

     

       370
       +
                         provider: 'streamable',

     

       371
       +
                       ),

     

       372
       +
                       data: const {},

     

       373
       +
                     ),

     

       374
       +
                   ),

     

       375
       +
                 );

     

       376
       +
       

     

       377
       +
                 await tester.pumpWidget(

     

       378
       +
                   createTestWidget(post, streamableService: streamableService),

     

       379
       +
                 );

     

       380
       +
                 await tester.pump();

     

       381
       +
       

     

       382
       +
                 // Tap the play button

     

       383
       +
                 await tester.tap(find.byIcon(Icons.play_arrow));

     

       384
       +
                 await tester.pump();

     

       385
       +
       

     

       386
       +
                 // Verify loading indicator is displayed

     

       387
       +
                 expect(find.byType(CircularProgressIndicator), findsOneWidget);

     

       388
       +
               },

     

       389
        
             );

     

       390
        
       

     

       391
       +
             testWidgets('does not show play button for non-video embeds', (

     

       392
       +
               tester,

     

       393
       +
             ) async {

     

       394
       +
               final post = FeedViewPost(

     

       395
       +
                 post: PostView(

     

       396
       +
                   uri: 'at://did:example/post/123',

     

       397
       +
                   cid: 'cid123',

     

       398
       +
                   rkey: '123',

     

       399
       +
                   author: AuthorView(did: 'did:plc:author', handle: 'author.test'),

     

       400
       +
                   community: CommunityRef(

     

       401
       +
                     did: 'did:plc:community',

     

       402
       +
                     name: 'test-community',

     

       403
       +
                   ),

     

       404
       +
                   createdAt: DateTime(2024, 1, 1),

     

       405
       +
                   indexedAt: DateTime(2024, 1, 1),

     

       406
       +
                   text: '',

     

       407
       +
                   stats: PostStats(

     

       408
       +
                     upvotes: 0,

     

       409
       +
                     downvotes: 0,

     

       410
       +
                     score: 0,

     

       411
       +
                     commentCount: 0,

     

       412
       +
                   ),

     

       413
       +
                   embed: PostEmbed(

     

       414
       +
                     type: 'social.coves.embed.external',

     

       415
       +
                     external: ExternalEmbed(

     

       416
       +
                       uri: 'https://example.com/article',

     

       417
       +
                       thumb: 'https://example.com/thumb.jpg',

     

       418
       +
                     ),

     

       419
       +
                     data: const {},

     

       420
       +
                   ),

     

       421
       +
                 ),

     

       422
       +
               );

     

       423
        
       

     

       424
       +
               await tester.pumpWidget(createTestWidget(post));

     

       425
       +
               await tester.pump();

     

       426
       +
       

     

       427
       +
               // Verify play button is NOT displayed

     

       428
       +
               expect(find.byIcon(Icons.play_arrow), findsNothing);

     

       429
       +
             });

     

       430
       +
           },

     

       431
       +
         );

     

       432
        
       }