···

       
38
       
 
       
    });

     

       
39
       
 
       


     

       
40
       
 
       
    group('loadFeed', () {

     

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

     

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

     

       
43
       
 
       


     

       
44
       
 
       
        final mockResponse = TimelineResponse(

     
···

       
47
       
 
       
        );

     

       
48
       
 
       


     

       
49
       
 
       
        when(

     

       
50
       
-
       
          mockApiService.getTimeline(

     

       
51
       
 
       
            sort: anyNamed('sort'),

     

       
52
       
 
       
            timeframe: anyNamed('timeframe'),

     

       
53
       
 
       
            limit: anyNamed('limit'),

     
···

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

     

       
57
       
 
       


     

       
58
       
 
       
        await feedProvider.loadFeed(refresh: true);

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
59
       
 
       


     

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

     

       
61
       
 
       
        expect(feedProvider.error, null);

     
···

       
274
       
 
       
            sort: anyNamed('sort'),

     

       
275
       
 
       
            timeframe: anyNamed('timeframe'),

     

       
276
       
 
       
            limit: anyNamed('limit'),

     

       
0
       
 
       

     

       
277
       
 
       
          ),

     

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

     

       
279
       
 
       


     

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

     

       
281
       
 
       


     

       
282
       
 
       
        // Load more

     

       
283
       
 
       
        final secondResponse = TimelineResponse(

     
···

       
316
       
 
       
          ),

     

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

     

       
318
       
 
       


     

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

     

       
320
       
 
       
        await feedProvider.loadMore();

     

       
321
       
 
       


     

       
322
       
 
       
        // Should not make additional calls while loading

     
···

       
356
       
 
       
          ),

     

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

     

       
358
       
 
       


     

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

     

       
360
       
 
       
        expect(feedProvider.error, isNotNull);

     

       
361
       
 
       


     

       
362
       
 
       
        // Retry

     

···

       
38
       
 
       
    });

     

       
39
       
 
       


     

       
40
       
 
       
    group('loadFeed', () {

     

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

     

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

     

       
43
       
 
       


     

       
44
       
 
       
        final mockResponse = TimelineResponse(

     
···

       
47
       
 
       
        );

     

       
48
       
 
       


     

       
49
       
 
       
        when(

     

       
50
       
+
       
          mockApiService.getDiscover(

     

       
51
       
 
       
            sort: anyNamed('sort'),

     

       
52
       
 
       
            timeframe: anyNamed('timeframe'),

     

       
53
       
 
       
            limit: anyNamed('limit'),

     
···

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

     

       
57
       
 
       


     

       
58
       
 
       
        await feedProvider.loadFeed(refresh: true);

     

       
59
       
+
       


     

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

     

       
61
       
+
       
        expect(feedProvider.error, null);

     

       
62
       
+
       
        expect(feedProvider.isLoading, false);

     

       
63
       
+
       
      });

     

       
64
       
+
       


     

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

     

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

     

       
67
       
+
       


     

       
68
       
+
       
        final mockResponse = TimelineResponse(

     

       
69
       
+
       
          feed: [_createMockPost()],

     

       
70
       
+
       
          cursor: 'next-cursor',

     

       
71
       
+
       
        );

     

       
72
       
+
       


     

       
73
       
+
       
        when(

     

       
74
       
+
       
          mockApiService.getTimeline(

     

       
75
       
+
       
            sort: anyNamed('sort'),

     

       
76
       
+
       
            timeframe: anyNamed('timeframe'),

     

       
77
       
+
       
            limit: anyNamed('limit'),

     

       
78
       
+
       
            cursor: anyNamed('cursor'),

     

       
79
       
+
       
          ),

     

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

     

       
81
       
+
       


     

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

     

       
83
       
 
       


     

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

     

       
85
       
 
       
        expect(feedProvider.error, null);

     
···

       
298
       
 
       
            sort: anyNamed('sort'),

     

       
299
       
 
       
            timeframe: anyNamed('timeframe'),

     

       
300
       
 
       
            limit: anyNamed('limit'),

     

       
301
       
+
       
            cursor: anyNamed('cursor'),

     

       
302
       
 
       
          ),

     

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

     

       
304
       
 
       


     

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

     

       
306
       
 
       


     

       
307
       
 
       
        // Load more

     

       
308
       
 
       
        final secondResponse = TimelineResponse(

     
···

       
341
       
 
       
          ),

     

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

     

       
343
       
 
       


     

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

     

       
345
       
 
       
        await feedProvider.loadMore();

     

       
346
       
 
       


     

       
347
       
 
       
        // Should not make additional calls while loading

     
···

       
381
       
 
       
          ),

     

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

     

       
383
       
 
       


     

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

     

       
385
       
 
       
        expect(feedProvider.error, isNotNull);

     

       
386
       
 
       


     

       
387
       
 
       
        // Retry

     

···

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

     

       
216
       
 
       
    });

     

       
217
       
 
       


     

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

     

       
219
       
 
       
      tester,

     

       
220
       
 
       
    ) async {

     

       
221
       
 
       
      fakeAuthProvider.setAuthenticated(value: true);

     

       
222
       
 
       


     

       
223
       
 
       
      await tester.pumpWidget(createTestWidget());

     

       
224
       
 
       


     

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

     

       
0
       
 
       

     

       
226
       
 
       
    });

     

       
227
       
 
       


     

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

     

       
229
       
 
       
      tester,

     

       
230
       
 
       
    ) async {

     

       
231
       
 
       
      fakeAuthProvider.setAuthenticated(value: false);

     

       
232
       
 
       


     

       
233
       
 
       
      await tester.pumpWidget(createTestWidget());

     

       
234
       
 
       


     

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

     

       
0
       
 
       

     

       
236
       
 
       
    });

     

       
237
       
 
       


     

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

     

···

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

     

       
216
       
 
       
    });

     

       
217
       
 
       


     

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

     

       
219
       
 
       
      tester,

     

       
220
       
 
       
    ) async {

     

       
221
       
 
       
      fakeAuthProvider.setAuthenticated(value: true);

     

       
222
       
 
       


     

       
223
       
 
       
      await tester.pumpWidget(createTestWidget());

     

       
224
       
 
       


     

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

     

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

     

       
227
       
 
       
    });

     

       
228
       
 
       


     

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

     

       
230
       
 
       
      tester,

     

       
231
       
 
       
    ) async {

     

       
232
       
 
       
      fakeAuthProvider.setAuthenticated(value: false);

     

       
233
       
 
       


     

       
234
       
 
       
      await tester.pumpWidget(createTestWidget());

     

       
235
       
 
       


     

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

     

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

     

       
238
       
 
       
    });

     

       
239
       
 
       


     

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