commit df203afbaa49e20dd69254304833fbd2f967fc6b · bretton.dev/coves-mobile

+49 -36

lib/services/vote_service.dart

···

       145
       145
        
         /// Find existing vote for a post

     

       146
       146
        
         ///

     

       147
       147
        
         /// Queries the user's PDS to check if they've already voted on this post.

     

       148
       148
       +
         /// Uses cursor-based pagination to search through all vote records, not just

     

       149
       149
       +
         /// the first 100. This prevents duplicate votes when users have voted on

     

       150
       150
       +
         /// more than 100 posts.

     

       148
       151
        
         ///

     

       149
       152
        
         /// Returns ExistingVote with direction and rkey if found, null otherwise.

     

       150
       153
        
         Future<ExistingVote?> _findExistingVote({

     
···

       157
       160
        
               return null;

     

       158
       161
        
             }

     

       159
       162
        
       

     

       160
       160
       -
             // Query listRecords to find votes using session's fetchHandler

     

       161
       161
       -
             final response = await session.fetchHandler(

     

       162
       162
       -
               '/xrpc/com.atproto.repo.listRecords?repo=$userDid&collection=$voteCollection&limit=100&reverse=true',

     

       163
       163
       -
               method: 'GET',

     

       164
       164
       -
             );

     

       163
       163
       +
             // Paginate through all vote records using cursor

     

       164
       164
       +
             String? cursor;

     

       165
       165
       +
             const pageSize = 100;

     

       165
       166
        
       

     

       166
       166
       -
             if (response.statusCode != 200) {

     

       167
       167
       -
               if (kDebugMode) {

     

       168
       168
       -
                 debugPrint('⚠️  Failed to list votes: ${response.statusCode}');

     

       167
       167
       +
             do {

     

       168
       168
       +
               // Build URL with cursor if available

     

       169
       169
       +
               final url = cursor == null

     

       170
       170
       +
                   ? '/xrpc/com.atproto.repo.listRecords?repo=$userDid&collection=$voteCollection&limit=$pageSize&reverse=true'

     

       171
       171
       +
                   : '/xrpc/com.atproto.repo.listRecords?repo=$userDid&collection=$voteCollection&limit=$pageSize&reverse=true&cursor=$cursor';

     

       172
       172
       +
       

     

       173
       173
       +
               final response = await session.fetchHandler(url, method: 'GET');

     

       174
       174
       +
       

     

       175
       175
       +
               if (response.statusCode != 200) {

     

       176
       176
       +
                 if (kDebugMode) {

     

       177
       177
       +
                   debugPrint('⚠️  Failed to list votes: ${response.statusCode}');

     

       178
       178
       +
                 }

     

       179
       179
       +
                 return null;

     

       169
       180
        
               }

     

       170
       170
       -
               return null;

     

       171
       171
       -
             }

     

       172
       181
        
       

     

       173
       173
       -
             final data = jsonDecode(response.body) as Map<String, dynamic>;

     

       174
       174
       -
             final records = data['records'] as List<dynamic>?;

     

       175
       175
       -
             if (records == null || records.isEmpty) {

     

       176
       176
       -
               return null;

     

       177
       177
       -
             }

     

       182
       182
       +
               final data = jsonDecode(response.body) as Map<String, dynamic>;

     

       183
       183
       +
               final records = data['records'] as List<dynamic>?;

     

       178
       184
        
       

     

       179
       179
       -
             // Find vote for this specific post

     

       180
       180
       -
             for (final record in records) {

     

       181
       181
       -
               final recordMap = record as Map<String, dynamic>;

     

       182
       182
       -
               final value = recordMap['value'] as Map<String, dynamic>?;

     

       185
       185
       +
               // Search current page for matching vote

     

       186
       186
       +
               if (records != null) {

     

       187
       187
       +
                 for (final record in records) {

     

       188
       188
       +
                   final recordMap = record as Map<String, dynamic>;

     

       189
       189
       +
                   final value = recordMap['value'] as Map<String, dynamic>?;

     

       183
       190
        
       

     

       184
       184
       -
               if (value == null) {

     

       185
       185
       -
                 continue;

     

       186
       186
       -
               }

     

       191
       191
       +
                   if (value == null) {

     

       192
       192
       +
                     continue;

     

       193
       193
       +
                   }

     

       187
       194
        
       

     

       188
       188
       -
               final subject = value['subject'] as Map<String, dynamic>?;

     

       189
       189
       -
               if (subject == null) {

     

       190
       190
       -
                 continue;

     

       191
       191
       -
               }

     

       195
       195
       +
                   final subject = value['subject'] as Map<String, dynamic>?;

     

       196
       196
       +
                   if (subject == null) {

     

       197
       197
       +
                     continue;

     

       198
       198
       +
                   }

     

       192
       199
        
       

     

       193
       193
       -
               final subjectUri = subject['uri'] as String?;

     

       194
       194
       -
               if (subjectUri == postUri) {

     

       195
       195
       -
                 // Found existing vote!

     

       196
       196
       -
                 final direction = value['direction'] as String;

     

       197
       197
       -
                 final uri = recordMap['uri'] as String;

     

       200
       200
       +
                   final subjectUri = subject['uri'] as String?;

     

       201
       201
       +
                   if (subjectUri == postUri) {

     

       202
       202
       +
                     // Found existing vote!

     

       203
       203
       +
                     final direction = value['direction'] as String;

     

       204
       204
       +
                     final uri = recordMap['uri'] as String;

     

       198
       205
        
       

     

       199
       199
       -
                 // Extract rkey from URI

     

       200
       200
       -
                 // Format: at://did:plc:xyz/social.coves.interaction.vote/3kby...

     

       201
       201
       -
                 final rkey = uri.split('/').last;

     

       206
       206
       +
                     // Extract rkey from URI

     

       207
       207
       +
                     // Format: at://did:plc:xyz/social.coves.interaction.vote/3kby...

     

       208
       208
       +
                     final rkey = uri.split('/').last;

     

       202
       209
        
       

     

       203
       203
       -
                 return ExistingVote(direction: direction, rkey: rkey);

     

       210
       210
       +
                     return ExistingVote(direction: direction, rkey: rkey);

     

       211
       211
       +
                   }

     

       212
       212
       +
                 }

     

       204
       213
        
               }

     

       205
       205
       -
             }

     

       206
       214
        
       

     

       215
       215
       +
               // Get cursor for next page

     

       216
       216
       +
               cursor = data['cursor'] as String?;

     

       217
       217
       +
             } while (cursor != null);

     

       218
       218
       +
       

     

       219
       219
       +
             // Vote not found after searching all pages

     

       207
       220
        
             return null;

     

       208
       221
        
           } catch (e) {

     

       209
       222
        
             if (kDebugMode) {

+256

test/services/vote_service_test.dart

···

       1
       1
       +
       import 'dart:convert';

     

       2
       2
       +
       

     

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

     

       1
       4
        
       import 'package:coves_flutter/services/api_exceptions.dart';

     

       2
       5
        
       import 'package:coves_flutter/services/vote_service.dart';

     

       3
       6
        
       import 'package:dio/dio.dart';

     

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

     

       8
       8
       +
       import 'package:http/http.dart' as http;

     

       9
       9
       +
       import 'package:mockito/annotations.dart';

     

       10
       10
       +
       import 'package:mockito/mockito.dart';

     

       11
       11
       +
       

     

       12
       12
       +
       import 'vote_service_test.mocks.dart';

     

       5
       13
        
       

     

       14
       14
       +
       // Generate mocks for OAuthSession

     

       15
       15
       +
       @GenerateMocks([OAuthSession])

     

       6
       16
        
       void main() {

     

       7
       17
        
         group('VoteService', () {

     

       18
       18
       +
           group('_findExistingVote pagination', () {

     

       19
       19
       +
             test('should find vote in first page', () async {

     

       20
       20
       +
               final mockSession = MockOAuthSession();

     

       21
       21
       +
               final service = VoteService(

     

       22
       22
       +
                 sessionGetter: () async => mockSession,

     

       23
       23
       +
                 didGetter: () => 'did:plc:test',

     

       24
       24
       +
                 pdsUrlGetter: () => 'https://test.pds',

     

       25
       25
       +
               );

     

       26
       26
       +
       

     

       27
       27
       +
               // Mock first page response with matching vote

     

       28
       28
       +
               final firstPageResponse = http.Response(

     

       29
       29
       +
                 jsonEncode({

     

       30
       30
       +
                   'records': [

     

       31
       31
       +
                     {

     

       32
       32
       +
                       'uri': 'at://did:plc:test/social.coves.interaction.vote/abc123',

     

       33
       33
       +
                       'value': {

     

       34
       34
       +
                         'subject': {

     

       35
       35
       +
                           'uri': 'at://did:plc:author/social.coves.post.record/post1',

     

       36
       36
       +
                           'cid': 'bafy123',

     

       37
       37
       +
                         },

     

       38
       38
       +
                         'direction': 'up',

     

       39
       39
       +
                         'createdAt': '2024-01-01T00:00:00Z',

     

       40
       40
       +
                       },

     

       41
       41
       +
                     },

     

       42
       42
       +
                   ],

     

       43
       43
       +
                   'cursor': null,

     

       44
       44
       +
                 }),

     

       45
       45
       +
                 200,

     

       46
       46
       +
               );

     

       47
       47
       +
       

     

       48
       48
       +
               when(

     

       49
       49
       +
                 mockSession.fetchHandler(

     

       50
       50
       +
                   argThat(contains('listRecords')),

     

       51
       51
       +
                   method: 'GET',

     

       52
       52
       +
                 ),

     

       53
       53
       +
               ).thenAnswer((_) async => firstPageResponse);

     

       54
       54
       +
       

     

       55
       55
       +
               // Mock deleteRecord for when existing vote is found

     

       56
       56
       +
               when(

     

       57
       57
       +
                 mockSession.fetchHandler(

     

       58
       58
       +
                   argThat(contains('deleteRecord')),

     

       59
       59
       +
                   method: 'POST',

     

       60
       60
       +
                   headers: anyNamed('headers'),

     

       61
       61
       +
                   body: anyNamed('body'),

     

       62
       62
       +
                 ),

     

       63
       63
       +
               ).thenAnswer(

     

       64
       64
       +
                 (_) async => http.Response(jsonEncode({}), 200),

     

       65
       65
       +
               );

     

       66
       66
       +
       

     

       67
       67
       +
               // Test that vote is found via reflection (private method)

     

       68
       68
       +
               // This is verified indirectly through createVote behavior

     

       69
       69
       +
               final response = await service.createVote(

     

       70
       70
       +
                 postUri: 'at://did:plc:author/social.coves.post.record/post1',

     

       71
       71
       +
                 postCid: 'bafy123',

     

       72
       72
       +
                 direction: 'up',

     

       73
       73
       +
               );

     

       74
       74
       +
       

     

       75
       75
       +
               // Should return deleted=true because existing vote with same direction

     

       76
       76
       +
               expect(response.deleted, true);

     

       77
       77
       +
               verify(

     

       78
       78
       +
                 mockSession.fetchHandler(

     

       79
       79
       +
                   argThat(contains('listRecords')),

     

       80
       80
       +
                   method: 'GET',

     

       81
       81
       +
                 ),

     

       82
       82
       +
               ).called(1);

     

       83
       83
       +
             });

     

       84
       84
       +
       

     

       85
       85
       +
             test('should paginate through multiple pages to find vote', () async {

     

       86
       86
       +
               final mockSession = MockOAuthSession();

     

       87
       87
       +
               final service = VoteService(

     

       88
       88
       +
                 sessionGetter: () async => mockSession,

     

       89
       89
       +
                 didGetter: () => 'did:plc:test',

     

       90
       90
       +
                 pdsUrlGetter: () => 'https://test.pds',

     

       91
       91
       +
               );

     

       92
       92
       +
       

     

       93
       93
       +
               // Mock first page without matching vote but with cursor

     

       94
       94
       +
               final firstPageResponse = http.Response(

     

       95
       95
       +
                 jsonEncode({

     

       96
       96
       +
                   'records': [

     

       97
       97
       +
                     {

     

       98
       98
       +
                       'uri': 'at://did:plc:test/social.coves.interaction.vote/abc1',

     

       99
       99
       +
                       'value': {

     

       100
       100
       +
                         'subject': {

     

       101
       101
       +
                           'uri': 'at://did:plc:author/social.coves.post.record/other1',

     

       102
       102
       +
                           'cid': 'bafy001',

     

       103
       103
       +
                         },

     

       104
       104
       +
                         'direction': 'up',

     

       105
       105
       +
                       },

     

       106
       106
       +
                     },

     

       107
       107
       +
                   ],

     

       108
       108
       +
                   'cursor': 'cursor123',

     

       109
       109
       +
                 }),

     

       110
       110
       +
                 200,

     

       111
       111
       +
               );

     

       112
       112
       +
       

     

       113
       113
       +
               // Mock second page with matching vote

     

       114
       114
       +
               final secondPageResponse = http.Response(

     

       115
       115
       +
                 jsonEncode({

     

       116
       116
       +
                   'records': [

     

       117
       117
       +
                     {

     

       118
       118
       +
                       'uri': 'at://did:plc:test/social.coves.interaction.vote/abc123',

     

       119
       119
       +
                       'value': {

     

       120
       120
       +
                         'subject': {

     

       121
       121
       +
                           'uri': 'at://did:plc:author/social.coves.post.record/target',

     

       122
       122
       +
                           'cid': 'bafy123',

     

       123
       123
       +
                         },

     

       124
       124
       +
                         'direction': 'up',

     

       125
       125
       +
                         'createdAt': '2024-01-01T00:00:00Z',

     

       126
       126
       +
                       },

     

       127
       127
       +
                     },

     

       128
       128
       +
                   ],

     

       129
       129
       +
                   'cursor': null,

     

       130
       130
       +
                 }),

     

       131
       131
       +
                 200,

     

       132
       132
       +
               );

     

       133
       133
       +
       

     

       134
       134
       +
               // Setup mock responses based on URL

     

       135
       135
       +
               when(

     

       136
       136
       +
                 mockSession.fetchHandler(

     

       137
       137
       +
                   argThat(allOf(contains('listRecords'), isNot(contains('cursor')))),

     

       138
       138
       +
                   method: 'GET',

     

       139
       139
       +
                 ),

     

       140
       140
       +
               ).thenAnswer((_) async => firstPageResponse);

     

       141
       141
       +
       

     

       142
       142
       +
               when(

     

       143
       143
       +
                 mockSession.fetchHandler(

     

       144
       144
       +
                   argThat(allOf(contains('listRecords'), contains('cursor=cursor123'))),

     

       145
       145
       +
                   method: 'GET',

     

       146
       146
       +
                 ),

     

       147
       147
       +
               ).thenAnswer((_) async => secondPageResponse);

     

       148
       148
       +
       

     

       149
       149
       +
               // Mock deleteRecord for when existing vote is found

     

       150
       150
       +
               when(

     

       151
       151
       +
                 mockSession.fetchHandler(

     

       152
       152
       +
                   argThat(contains('deleteRecord')),

     

       153
       153
       +
                   method: 'POST',

     

       154
       154
       +
                   headers: anyNamed('headers'),

     

       155
       155
       +
                   body: anyNamed('body'),

     

       156
       156
       +
                 ),

     

       157
       157
       +
               ).thenAnswer(

     

       158
       158
       +
                 (_) async => http.Response(jsonEncode({}), 200),

     

       159
       159
       +
               );

     

       160
       160
       +
       

     

       161
       161
       +
               // Test that pagination works by creating vote that exists on page 2

     

       162
       162
       +
               final response = await service.createVote(

     

       163
       163
       +
                 postUri: 'at://did:plc:author/social.coves.post.record/target',

     

       164
       164
       +
                 postCid: 'bafy123',

     

       165
       165
       +
                 direction: 'up',

     

       166
       166
       +
               );

     

       167
       167
       +
       

     

       168
       168
       +
               // Should return deleted=true because existing vote was found on page 2

     

       169
       169
       +
               expect(response.deleted, true);

     

       170
       170
       +
       

     

       171
       171
       +
               // Verify both pages were fetched

     

       172
       172
       +
               verify(

     

       173
       173
       +
                 mockSession.fetchHandler(

     

       174
       174
       +
                   argThat(allOf(contains('listRecords'), isNot(contains('cursor')))),

     

       175
       175
       +
                   method: 'GET',

     

       176
       176
       +
                 ),

     

       177
       177
       +
               ).called(1);

     

       178
       178
       +
       

     

       179
       179
       +
               verify(

     

       180
       180
       +
                 mockSession.fetchHandler(

     

       181
       181
       +
                   argThat(allOf(contains('listRecords'), contains('cursor=cursor123'))),

     

       182
       182
       +
                   method: 'GET',

     

       183
       183
       +
                 ),

     

       184
       184
       +
               ).called(1);

     

       185
       185
       +
             });

     

       186
       186
       +
       

     

       187
       187
       +
             test('should handle vote not found after pagination', () async {

     

       188
       188
       +
               final mockSession = MockOAuthSession();

     

       189
       189
       +
               final service = VoteService(

     

       190
       190
       +
                 sessionGetter: () async => mockSession,

     

       191
       191
       +
                 didGetter: () => 'did:plc:test',

     

       192
       192
       +
                 pdsUrlGetter: () => 'https://test.pds',

     

       193
       193
       +
               );

     

       194
       194
       +
       

     

       195
       195
       +
               // Mock response with no matching votes

     

       196
       196
       +
               final response = http.Response(

     

       197
       197
       +
                 jsonEncode({

     

       198
       198
       +
                   'records': [

     

       199
       199
       +
                     {

     

       200
       200
       +
                       'uri': 'at://did:plc:test/social.coves.interaction.vote/abc1',

     

       201
       201
       +
                       'value': {

     

       202
       202
       +
                         'subject': {

     

       203
       203
       +
                           'uri': 'at://did:plc:author/social.coves.post.record/other',

     

       204
       204
       +
                           'cid': 'bafy001',

     

       205
       205
       +
                         },

     

       206
       206
       +
                         'direction': 'up',

     

       207
       207
       +
                       },

     

       208
       208
       +
                     },

     

       209
       209
       +
                   ],

     

       210
       210
       +
                   'cursor': null,

     

       211
       211
       +
                 }),

     

       212
       212
       +
                 200,

     

       213
       213
       +
               );

     

       214
       214
       +
       

     

       215
       215
       +
               when(

     

       216
       216
       +
                 mockSession.fetchHandler(

     

       217
       217
       +
                   argThat(contains('listRecords')),

     

       218
       218
       +
                   method: 'GET',

     

       219
       219
       +
                 ),

     

       220
       220
       +
               ).thenAnswer((_) async => response);

     

       221
       221
       +
       

     

       222
       222
       +
               // Mock createRecord for new vote

     

       223
       223
       +
               when(

     

       224
       224
       +
                 mockSession.fetchHandler(

     

       225
       225
       +
                   argThat(contains('createRecord')),

     

       226
       226
       +
                   method: 'POST',

     

       227
       227
       +
                   headers: anyNamed('headers'),

     

       228
       228
       +
                   body: anyNamed('body'),

     

       229
       229
       +
                 ),

     

       230
       230
       +
               ).thenAnswer(

     

       231
       231
       +
                 (_) async => http.Response(

     

       232
       232
       +
                   jsonEncode({

     

       233
       233
       +
                     'uri': 'at://did:plc:test/social.coves.interaction.vote/new123',

     

       234
       234
       +
                     'cid': 'bafy456',

     

       235
       235
       +
                   }),

     

       236
       236
       +
                   200,

     

       237
       237
       +
                 ),

     

       238
       238
       +
               );

     

       239
       239
       +
       

     

       240
       240
       +
               // Test creating vote for post not in vote history

     

       241
       241
       +
               final voteResponse = await service.createVote(

     

       242
       242
       +
                 postUri: 'at://did:plc:author/social.coves.post.record/newpost',

     

       243
       243
       +
                 postCid: 'bafy123',

     

       244
       244
       +
                 direction: 'up',

     

       245
       245
       +
               );

     

       246
       246
       +
       

     

       247
       247
       +
               // Should create new vote

     

       248
       248
       +
               expect(voteResponse.deleted, false);

     

       249
       249
       +
               expect(voteResponse.uri, isNotNull);

     

       250
       250
       +
               expect(voteResponse.cid, 'bafy456');

     

       251
       251
       +
       

     

       252
       252
       +
               // Verify createRecord was called

     

       253
       253
       +
               verify(

     

       254
       254
       +
                 mockSession.fetchHandler(

     

       255
       255
       +
                   argThat(contains('createRecord')),

     

       256
       256
       +
                   method: 'POST',

     

       257
       257
       +
                   headers: anyNamed('headers'),

     

       258
       258
       +
                   body: anyNamed('body'),

     

       259
       259
       +
                 ),

     

       260
       260
       +
               ).called(1);

     

       261
       261
       +
             });

     

       262
       262
       +
           });

     

       263
       263
       +
       

     

       8
       264
        
           group('createVote', () {

     

       9
       265
        
       

     

       10
       266
        
             test('should create vote successfully', () async {

+158

test/services/vote_service_test.mocks.dart

···

       1
       1
       +
       // Mocks generated by Mockito 5.4.6 from annotations

     

       2
       2
       +
       // in coves_flutter/test/services/vote_service_test.dart.

     

       3
       3
       +
       // Do not manually edit this file.

     

       4
       4
       +
       

     

       5
       5
       +
       // ignore_for_file: no_leading_underscores_for_library_prefixes

     

       6
       6
       +
       import 'dart:async' as _i6;

     

       7
       7
       +
       

     

       8
       8
       +
       import 'package:atproto_oauth_flutter/src/oauth/oauth_server_agent.dart' as _i2;

     

       9
       9
       +
       import 'package:atproto_oauth_flutter/src/session/oauth_session.dart' as _i3;

     

       10
       10
       +
       import 'package:http/http.dart' as _i4;

     

       11
       11
       +
       import 'package:mockito/mockito.dart' as _i1;

     

       12
       12
       +
       import 'package:mockito/src/dummies.dart' as _i5;

     

       13
       13
       +
       

     

       14
       14
       +
       // ignore_for_file: type=lint

     

       15
       15
       +
       // ignore_for_file: avoid_redundant_argument_values

     

       16
       16
       +
       // ignore_for_file: avoid_setters_without_getters

     

       17
       17
       +
       // ignore_for_file: comment_references

     

       18
       18
       +
       // ignore_for_file: deprecated_member_use

     

       19
       19
       +
       // ignore_for_file: deprecated_member_use_from_same_package

     

       20
       20
       +
       // ignore_for_file: implementation_imports

     

       21
       21
       +
       // ignore_for_file: invalid_use_of_visible_for_testing_member

     

       22
       22
       +
       // ignore_for_file: must_be_immutable

     

       23
       23
       +
       // ignore_for_file: prefer_const_constructors

     

       24
       24
       +
       // ignore_for_file: unnecessary_parenthesis

     

       25
       25
       +
       // ignore_for_file: camel_case_types

     

       26
       26
       +
       // ignore_for_file: subtype_of_sealed_class

     

       27
       27
       +
       // ignore_for_file: invalid_use_of_internal_member

     

       28
       28
       +
       

     

       29
       29
       +
       class _FakeOAuthServerAgent_0 extends _i1.SmartFake

     

       30
       30
       +
           implements _i2.OAuthServerAgent {

     

       31
       31
       +
         _FakeOAuthServerAgent_0(Object parent, Invocation parentInvocation)

     

       32
       32
       +
           : super(parent, parentInvocation);

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       class _FakeSessionGetterInterface_1 extends _i1.SmartFake

     

       36
       36
       +
           implements _i3.SessionGetterInterface {

     

       37
       37
       +
         _FakeSessionGetterInterface_1(Object parent, Invocation parentInvocation)

     

       38
       38
       +
           : super(parent, parentInvocation);

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       class _FakeTokenInfo_2 extends _i1.SmartFake implements _i3.TokenInfo {

     

       42
       42
       +
         _FakeTokenInfo_2(Object parent, Invocation parentInvocation)

     

       43
       43
       +
           : super(parent, parentInvocation);

     

       44
       44
       +
       }

     

       45
       45
       +
       

     

       46
       46
       +
       class _FakeResponse_3 extends _i1.SmartFake implements _i4.Response {

     

       47
       47
       +
         _FakeResponse_3(Object parent, Invocation parentInvocation)

     

       48
       48
       +
           : super(parent, parentInvocation);

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       /// A class which mocks [OAuthSession].

     

       52
       52
       +
       ///

     

       53
       53
       +
       /// See the documentation for Mockito's code generation for more information.

     

       54
       54
       +
       class MockOAuthSession extends _i1.Mock implements _i3.OAuthSession {

     

       55
       55
       +
         MockOAuthSession() {

     

       56
       56
       +
           _i1.throwOnMissingStub(this);

     

       57
       57
       +
         }

     

       58
       58
       +
       

     

       59
       59
       +
         @override

     

       60
       60
       +
         _i2.OAuthServerAgent get server =>

     

       61
       61
       +
             (super.noSuchMethod(

     

       62
       62
       +
                   Invocation.getter(#server),

     

       63
       63
       +
                   returnValue: _FakeOAuthServerAgent_0(

     

       64
       64
       +
                     this,

     

       65
       65
       +
                     Invocation.getter(#server),

     

       66
       66
       +
                   ),

     

       67
       67
       +
                 )

     

       68
       68
       +
                 as _i2.OAuthServerAgent);

     

       69
       69
       +
       

     

       70
       70
       +
         @override

     

       71
       71
       +
         String get sub =>

     

       72
       72
       +
             (super.noSuchMethod(

     

       73
       73
       +
                   Invocation.getter(#sub),

     

       74
       74
       +
                   returnValue: _i5.dummyValue<String>(this, Invocation.getter(#sub)),

     

       75
       75
       +
                 )

     

       76
       76
       +
                 as String);

     

       77
       77
       +
       

     

       78
       78
       +
         @override

     

       79
       79
       +
         _i3.SessionGetterInterface get sessionGetter =>

     

       80
       80
       +
             (super.noSuchMethod(

     

       81
       81
       +
                   Invocation.getter(#sessionGetter),

     

       82
       82
       +
                   returnValue: _FakeSessionGetterInterface_1(

     

       83
       83
       +
                     this,

     

       84
       84
       +
                     Invocation.getter(#sessionGetter),

     

       85
       85
       +
                   ),

     

       86
       86
       +
                 )

     

       87
       87
       +
                 as _i3.SessionGetterInterface);

     

       88
       88
       +
       

     

       89
       89
       +
         @override

     

       90
       90
       +
         String get did =>

     

       91
       91
       +
             (super.noSuchMethod(

     

       92
       92
       +
                   Invocation.getter(#did),

     

       93
       93
       +
                   returnValue: _i5.dummyValue<String>(this, Invocation.getter(#did)),

     

       94
       94
       +
                 )

     

       95
       95
       +
                 as String);

     

       96
       96
       +
       

     

       97
       97
       +
         @override

     

       98
       98
       +
         Map<String, dynamic> get serverMetadata =>

     

       99
       99
       +
             (super.noSuchMethod(

     

       100
       100
       +
                   Invocation.getter(#serverMetadata),

     

       101
       101
       +
                   returnValue: <String, dynamic>{},

     

       102
       102
       +
                 )

     

       103
       103
       +
                 as Map<String, dynamic>);

     

       104
       104
       +
       

     

       105
       105
       +
         @override

     

       106
       106
       +
         _i6.Future<_i3.TokenInfo> getTokenInfo([dynamic refresh = 'auto']) =>

     

       107
       107
       +
             (super.noSuchMethod(

     

       108
       108
       +
                   Invocation.method(#getTokenInfo, [refresh]),

     

       109
       109
       +
                   returnValue: _i6.Future<_i3.TokenInfo>.value(

     

       110
       110
       +
                     _FakeTokenInfo_2(

     

       111
       111
       +
                       this,

     

       112
       112
       +
                       Invocation.method(#getTokenInfo, [refresh]),

     

       113
       113
       +
                     ),

     

       114
       114
       +
                   ),

     

       115
       115
       +
                 )

     

       116
       116
       +
                 as _i6.Future<_i3.TokenInfo>);

     

       117
       117
       +
       

     

       118
       118
       +
         @override

     

       119
       119
       +
         _i6.Future<void> signOut() =>

     

       120
       120
       +
             (super.noSuchMethod(

     

       121
       121
       +
                   Invocation.method(#signOut, []),

     

       122
       122
       +
                   returnValue: _i6.Future<void>.value(),

     

       123
       123
       +
                   returnValueForMissingStub: _i6.Future<void>.value(),

     

       124
       124
       +
                 )

     

       125
       125
       +
                 as _i6.Future<void>);

     

       126
       126
       +
       

     

       127
       127
       +
         @override

     

       128
       128
       +
         _i6.Future<_i4.Response> fetchHandler(

     

       129
       129
       +
           String? pathname, {

     

       130
       130
       +
           String? method = 'GET',

     

       131
       131
       +
           Map<String, String>? headers,

     

       132
       132
       +
           dynamic body,

     

       133
       133
       +
         }) =>

     

       134
       134
       +
             (super.noSuchMethod(

     

       135
       135
       +
                   Invocation.method(

     

       136
       136
       +
                     #fetchHandler,

     

       137
       137
       +
                     [pathname],

     

       138
       138
       +
                     {#method: method, #headers: headers, #body: body},

     

       139
       139
       +
                   ),

     

       140
       140
       +
                   returnValue: _i6.Future<_i4.Response>.value(

     

       141
       141
       +
                     _FakeResponse_3(

     

       142
       142
       +
                       this,

     

       143
       143
       +
                       Invocation.method(

     

       144
       144
       +
                         #fetchHandler,

     

       145
       145
       +
                         [pathname],

     

       146
       146
       +
                         {#method: method, #headers: headers, #body: body},

     

       147
       147
       +
                       ),

     

       148
       148
       +
                     ),

     

       149
       149
       +
                   ),

     

       150
       150
       +
                 )

     

       151
       151
       +
                 as _i6.Future<_i4.Response>);

     

       152
       152
       +
       

     

       153
       153
       +
         @override

     

       154
       154
       +
         void dispose() => super.noSuchMethod(

     

       155
       155
       +
           Invocation.method(#dispose, []),

     

       156
       156
       +
           returnValueForMissingStub: null,

     

       157
       157
       +
         );

     

       158
       158
       +
       }