commit 084e1384b3f9385df4fe60ce9da93551a6e7a8ec · bretton.dev/coves-mobile

+30 -5

test/providers/feed_provider_test.dart

···

       38
       38
        
           });

     

       39
       39
        
       

     

       40
       40
        
           group('loadFeed', () {

     

       41
       41
       -
             test('should load timeline when authenticated', () async {

     

       41
       41
       +
             test('should load discover feed when authenticated by default', () async {

     

       42
       42
        
               when(mockAuthProvider.isAuthenticated).thenReturn(true);

     

       43
       43
        
       

     

       44
       44
        
               final mockResponse = TimelineResponse(

     
···

       47
       47
        
               );

     

       48
       48
        
       

     

       49
       49
        
               when(

     

       50
       50
       -
                 mockApiService.getTimeline(

     

       50
       50
       +
                 mockApiService.getDiscover(

     

       51
       51
        
                   sort: anyNamed('sort'),

     

       52
       52
        
                   timeframe: anyNamed('timeframe'),

     

       53
       53
        
                   limit: anyNamed('limit'),

     
···

       56
       56
        
               ).thenAnswer((_) async => mockResponse);

     

       57
       57
        
       

     

       58
       58
        
               await feedProvider.loadFeed(refresh: true);

     

       59
       59
       +
       

     

       60
       60
       +
               expect(feedProvider.posts.length, 1);

     

       61
       61
       +
               expect(feedProvider.error, null);

     

       62
       62
       +
               expect(feedProvider.isLoading, false);

     

       63
       63
       +
             });

     

       64
       64
       +
       

     

       65
       65
       +
             test('should load timeline when feed type is For You', () async {

     

       66
       66
       +
               when(mockAuthProvider.isAuthenticated).thenReturn(true);

     

       67
       67
       +
       

     

       68
       68
       +
               final mockResponse = TimelineResponse(

     

       69
       69
       +
                 feed: [_createMockPost()],

     

       70
       70
       +
                 cursor: 'next-cursor',

     

       71
       71
       +
               );

     

       72
       72
       +
       

     

       73
       73
       +
               when(

     

       74
       74
       +
                 mockApiService.getTimeline(

     

       75
       75
       +
                   sort: anyNamed('sort'),

     

       76
       76
       +
                   timeframe: anyNamed('timeframe'),

     

       77
       77
       +
                   limit: anyNamed('limit'),

     

       78
       78
       +
                   cursor: anyNamed('cursor'),

     

       79
       79
       +
                 ),

     

       80
       80
       +
               ).thenAnswer((_) async => mockResponse);

     

       81
       81
       +
       

     

       82
       82
       +
               await feedProvider.setFeedType(FeedType.forYou);

     

       59
       83
        
       

     

       60
       84
        
               expect(feedProvider.posts.length, 1);

     

       61
       85
        
               expect(feedProvider.error, null);

     
···

       274
       298
        
                   sort: anyNamed('sort'),

     

       275
       299
        
                   timeframe: anyNamed('timeframe'),

     

       276
       300
        
                   limit: anyNamed('limit'),

     

       301
       301
       +
                   cursor: anyNamed('cursor'),

     

       277
       302
        
                 ),

     

       278
       303
        
               ).thenAnswer((_) async => firstResponse);

     

       279
       304
        
       

     

       280
       280
       -
               await feedProvider.loadFeed(refresh: true);

     

       305
       305
       +
               await feedProvider.setFeedType(FeedType.forYou);

     

       281
       306
        
       

     

       282
       307
        
               // Load more

     

       283
       308
        
               final secondResponse = TimelineResponse(

     
···

       316
       341
        
                 ),

     

       317
       342
        
               ).thenAnswer((_) async => response);

     

       318
       343
        
       

     

       319
       319
       -
               await feedProvider.fetchTimeline(refresh: true);

     

       344
       344
       +
               await feedProvider.setFeedType(FeedType.forYou);

     

       320
       345
        
               await feedProvider.loadMore();

     

       321
       346
        
       

     

       322
       347
        
               // Should not make additional calls while loading

     
···

       356
       381
        
                 ),

     

       357
       382
        
               ).thenThrow(Exception('Network error'));

     

       358
       383
        
       

     

       359
       359
       -
               await feedProvider.loadFeed(refresh: true);

     

       384
       384
       +
               await feedProvider.setFeedType(FeedType.forYou);

     

       360
       385
        
               expect(feedProvider.error, isNotNull);

     

       361
       386
        
       

     

       362
       387
        
               // Retry

+6 -4

test/widgets/feed_screen_test.dart

···

       215
       215
        
             expect(find.text('Test Post 2'), findsOneWidget);

     

       216
       216
        
           });

     

       217
       217
        
       

     

       218
       218
       -
           testWidgets('should display "Feed" title when authenticated', (

     

       218
       218
       +
           testWidgets('should display feed type tabs when authenticated', (

     

       219
       219
        
             tester,

     

       220
       220
        
           ) async {

     

       221
       221
        
             fakeAuthProvider.setAuthenticated(value: true);

     

       222
       222
        
       

     

       223
       223
        
             await tester.pumpWidget(createTestWidget());

     

       224
       224
        
       

     

       225
       225
       -
             expect(find.text('Feed'), findsOneWidget);

     

       225
       225
       +
             expect(find.text('Discover'), findsOneWidget);

     

       226
       226
       +
             expect(find.text('For You'), findsOneWidget);

     

       226
       227
        
           });

     

       227
       228
        
       

     

       228
       228
       -
           testWidgets('should display "Explore" title when not authenticated', (

     

       229
       229
       +
           testWidgets('should display only Discover tab when not authenticated', (

     

       229
       230
        
             tester,

     

       230
       231
        
           ) async {

     

       231
       232
        
             fakeAuthProvider.setAuthenticated(value: false);

     

       232
       233
        
       

     

       233
       234
        
             await tester.pumpWidget(createTestWidget());

     

       234
       235
        
       

     

       235
       235
       -
             expect(find.text('Explore'), findsOneWidget);

     

       236
       236
       +
             expect(find.text('Discover'), findsOneWidget);

     

       237
       237
       +
             expect(find.text('For You'), findsNothing);

     

       236
       238
        
           });

     

       237
       239
        
       

     

       238
       240
        
           testWidgets('should handle pull-to-refresh', (tester) async {