commit f4f89f516779c5347c8dd4cf72420e364f3c2000 · bretton.dev/coves-mobile

+535

DEVELOPMENT_SUMMARY.md

···

       1
       1
       +
       # Development Summary: Direct-to-PDS Voting Architecture

     

       2
       2
       +
       

     

       3
       3
       +
       ## Overview

     

       4
       4
       +
       

     

       5
       5
       +
       This document summarizes the complete voting/like feature implementation with **proper atProto architecture**, where the mobile client writes directly to the user's Personal Data Server (PDS) instead of through a backend proxy.

     

       6
       6
       +
       

     

       7
       7
       +
       **Total Changes:**

     

       8
       8
       +
       - **8 files modified** (core implementation)

     

       9
       9
       +
       - **3 test files updated**

     

       10
       10
       +
       - **109 tests passing** (107 passing, 2 intentionally skipped)

     

       11
       11
       +
       - **0 warnings, 0 errors** from flutter analyze

     

       12
       12
       +
       - **7 info-level style suggestions** (test files only)

     

       13
       13
       +
       

     

       14
       14
       +
       ---

     

       15
       15
       +
       

     

       16
       16
       +
       ## Architecture: The Right Way ✅

     

       17
       17
       +
       

     

       18
       18
       +
       ### Before (INCORRECT ❌)

     

       19
       19
       +
       ```

     

       20
       20
       +
       Mobile Client → Backend API (/xrpc/social.coves.interaction.createVote)

     

       21
       21
       +
                            ↓

     

       22
       22
       +
                     Backend writes to User's PDS

     

       23
       23
       +
                            ↓

     

       24
       24
       +
                        Jetstream

     

       25
       25
       +
                            ↓

     

       26
       26
       +
               Backend AppView (indexes records)

     

       27
       27
       +
       ```

     

       28
       28
       +
       

     

       29
       29
       +
       **Problems:**

     

       30
       30
       +
       - ❌ Backend acts as write proxy (violates atProto principles)

     

       31
       31
       +
       - ❌ AppView writes to PDSs on behalf of users

     

       32
       32
       +
       - ❌ Doesn't scale across federated network

     

       33
       33
       +
       - ❌ Creates unnecessary coupling

     

       34
       34
       +
       

     

       35
       35
       +
       ### After (CORRECT ✅)

     

       36
       36
       +
       ```

     

       37
       37
       +
       Mobile Client → User's PDS (com.atproto.repo.createRecord)

     

       38
       38
       +
                            ↓

     

       39
       39
       +
                        Jetstream (broadcasts events)

     

       40
       40
       +
                            ↓

     

       41
       41
       +
               Backend AppView (indexes vote events, read-only)

     

       42
       42
       +
                            ↓

     

       43
       43
       +
               Feed endpoint returns aggregated stats

     

       44
       44
       +
       ```

     

       45
       45
       +
       

     

       46
       46
       +
       **Benefits:**

     

       47
       47
       +
       - ✅ Client owns their data on their PDS

     

       48
       48
       +
       - ✅ Backend only indexes public data (read-only)

     

       49
       49
       +
       - ✅ Works across entire atProto federation

     

       50
       50
       +
       - ✅ Follows Bluesky architecture pattern

     

       51
       51
       +
       - ✅ User's PDS is source of truth

     

       52
       52
       +
       

     

       53
       53
       +
       ---

     

       54
       54
       +
       

     

       55
       55
       +
       ## 1. Core Voting Implementation

     

       56
       56
       +
       

     

       57
       57
       +
       ### Vote Record Schema

     

       58
       58
       +
       

     

       59
       59
       +
       **Collection Name**: `social.coves.interaction.vote`

     

       60
       60
       +
       

     

       61
       61
       +
       **Record Structure** (from backend lexicon):

     

       62
       62
       +
       ```json

     

       63
       63
       +
       {

     

       64
       64
       +
         "$type": "social.coves.interaction.vote",

     

       65
       65
       +
         "subject": {

     

       66
       66
       +
           "uri": "at://did:plc:community123/social.coves.post.record/3kbx...",

     

       67
       67
       +
           "cid": "bafy2bzacepostcid123"

     

       68
       68
       +
         },

     

       69
       69
       +
         "direction": "up",

     

       70
       70
       +
         "createdAt": "2025-11-02T12:00:00Z"

     

       71
       71
       +
       }

     

       72
       72
       +
       ```

     

       73
       73
       +
       

     

       74
       74
       +
       **Strong Reference**: The `subject` field includes both URI and CID to create a strong reference to a specific version of the post.

     

       75
       75
       +
       

     

       76
       76
       +
       ---

     

       77
       77
       +
       

     

       78
       78
       +
       ## 2. Implementation Details

     

       79
       79
       +
       

     

       80
       80
       +
       ### `lib/services/vote_service.dart` (COMPLETE REWRITE - 349 lines)

     

       81
       81
       +
       

     

       82
       82
       +
       **New Architecture**: Direct PDS XRPC calls instead of backend API

     

       83
       83
       +
       

     

       84
       84
       +
       **XRPC Endpoints Used**:

     

       85
       85
       +
       - `com.atproto.repo.createRecord` - Create vote record

     

       86
       86
       +
       - `com.atproto.repo.deleteRecord` - Delete vote record

     

       87
       87
       +
       - `com.atproto.repo.listRecords` - Find existing votes

     

       88
       88
       +
       

     

       89
       89
       +
       **Key Features**:

     

       90
       90
       +
       - ✅ Smart toggle logic (query PDS → decide create/delete/switch)

     

       91
       91
       +
       - ✅ Requires `userDid`, `pdsUrl`, and `postCid` parameters

     

       92
       92
       +
       - ✅ Returns `rkey` (record key) for deletion

     

       93
       93
       +
       - ✅ Handles authentication via token callback

     

       94
       94
       +
       - ✅ Proper error handling with ApiException

     

       95
       95
       +
       

     

       96
       96
       +
       **Toggle Logic**:

     

       97
       97
       +
       1. Query PDS for existing vote on this post

     

       98
       98
       +
       2. If exists with same direction → Delete (toggle off)

     

       99
       99
       +
       3. If exists with different direction → Delete old + Create new

     

       100
       100
       +
       4. If no existing vote → Create new

     

       101
       101
       +
       

     

       102
       102
       +
       **API**:

     

       103
       103
       +
       ```dart

     

       104
       104
       +
       VoteService({

     

       105
       105
       +
         Future<String?> Function()? tokenGetter,

     

       106
       106
       +
         String? Function()? didGetter,

     

       107
       107
       +
         String? Function()? pdsUrlGetter,

     

       108
       108
       +
       })

     

       109
       109
       +
       

     

       110
       110
       +
       Future<VoteResponse> createVote({

     

       111
       111
       +
         required String postUri,

     

       112
       112
       +
         required String postCid,  // NEW: Required for strong reference

     

       113
       113
       +
         String direction = 'up',

     

       114
       114
       +
       })

     

       115
       115
       +
       ```

     

       116
       116
       +
       

     

       117
       117
       +
       **VoteResponse** (Updated):

     

       118
       118
       +
       ```dart

     

       119
       119
       +
       class VoteResponse {

     

       120
       120
       +
         final String? uri;    // Vote record AT-URI

     

       121
       121
       +
         final String? cid;    // Vote record content ID

     

       122
       122
       +
         final String? rkey;   // NEW: Record key for deletion

     

       123
       123
       +
         final bool deleted;   // True if vote was toggled off

     

       124
       124
       +
       }

     

       125
       125
       +
       ```

     

       126
       126
       +
       

     

       127
       127
       +
       ---

     

       128
       128
       +
       

     

       129
       129
       +
       ### `lib/providers/vote_provider.dart` (MODIFIED)

     

       130
       130
       +
       

     

       131
       131
       +
       **Changes**:

     

       132
       132
       +
       - ✅ Added `postCid` parameter to `toggleVote()`

     

       133
       133
       +
       - ✅ Updated `VoteState` to include `rkey` field

     

       134
       134
       +
       - ✅ Extracts `rkey` from vote URI for deletion

     

       135
       135
       +
       

     

       136
       136
       +
       **Updated API**:

     

       137
       137
       +
       ```dart

     

       138
       138
       +
       Future<bool> toggleVote({

     

       139
       139
       +
         required String postUri,

     

       140
       140
       +
         required String postCid,  // NEW: Pass post CID

     

       141
       141
       +
         String direction = 'up',

     

       142
       142
       +
       })

     

       143
       143
       +
       ```

     

       144
       144
       +
       

     

       145
       145
       +
       **VoteState** (Enhanced):

     

       146
       146
       +
       ```dart

     

       147
       147
       +
       class VoteState {

     

       148
       148
       +
         final String direction;    // "up" or "down"

     

       149
       149
       +
         final String? uri;         // Vote record URI

     

       150
       150
       +
         final String? rkey;        // NEW: Record key for deletion

     

       151
       151
       +
         final bool deleted;

     

       152
       152
       +
       }

     

       153
       153
       +
       ```

     

       154
       154
       +
       

     

       155
       155
       +
       **rkey Extraction**:

     

       156
       156
       +
       ```dart

     

       157
       157
       +
       // Extract rkey from URI: at://did:plc:xyz/social.coves.interaction.vote/3kby...

     

       158
       158
       +
       // Result: "3kby..."

     

       159
       159
       +
       final rkey = voteUri.split('/').last;

     

       160
       160
       +
       ```

     

       161
       161
       +
       

     

       162
       162
       +
       ---

     

       163
       163
       +
       

     

       164
       164
       +
       ### `lib/providers/auth_provider.dart` (NEW METHOD)

     

       165
       165
       +
       

     

       166
       166
       +
       **Added PDS URL Helper**:

     

       167
       167
       +
       ```dart

     

       168
       168
       +
       /// Get the user's PDS URL from OAuth session

     

       169
       169
       +
       String? getPdsUrl() {

     

       170
       170
       +
         if (_session == null) return null;

     

       171
       171
       +
         return _session!.serverMetadata['issuer'] as String?;

     

       172
       172
       +
       }

     

       173
       173
       +
       ```

     

       174
       174
       +
       

     

       175
       175
       +
       This extracts the PDS URL from the OAuth session metadata, enabling direct writes to the user's PDS.

     

       176
       176
       +
       

     

       177
       177
       +
       ---

     

       178
       178
       +
       

     

       179
       179
       +
       ### `lib/widgets/post_card.dart` (MODIFIED)

     

       180
       180
       +
       

     

       181
       181
       +
       **Updated Vote Call**:

     

       182
       182
       +
       ```dart

     

       183
       183
       +
       // Before

     

       184
       184
       +
       await voteProvider.toggleVote(postUri: post.post.uri);

     

       185
       185
       +
       

     

       186
       186
       +
       // After

     

       187
       187
       +
       await voteProvider.toggleVote(

     

       188
       188
       +
         postUri: post.post.uri,

     

       189
       189
       +
         postCid: post.post.cid,  // NEW: Pass CID for strong reference

     

       190
       190
       +
       );

     

       191
       191
       +
       ```

     

       192
       192
       +
       

     

       193
       193
       +
       ---

     

       194
       194
       +
       

     

       195
       195
       +
       ### `lib/main.dart` (MODIFIED)

     

       196
       196
       +
       

     

       197
       197
       +
       **Updated VoteService Initialization**:

     

       198
       198
       +
       ```dart

     

       199
       199
       +
       // Initialize vote service with auth callbacks for direct PDS writes

     

       200
       200
       +
       final voteService = VoteService(

     

       201
       201
       +
         tokenGetter: authProvider.getAccessToken,

     

       202
       202
       +
         didGetter: () => authProvider.did,        // NEW

     

       203
       203
       +
         pdsUrlGetter: authProvider.getPdsUrl,     // NEW

     

       204
       204
       +
       );

     

       205
       205
       +
       ```

     

       206
       206
       +
       

     

       207
       207
       +
       ---

     

       208
       208
       +
       

     

       209
       209
       +
       ## 3. UI Components (Unchanged)

     

       210
       210
       +
       

     

       211
       211
       +
       ### `lib/widgets/sign_in_dialog.dart`

     

       212
       212
       +
       Reusable dialog for prompting authentication when unauthenticated users try to interact.

     

       213
       213
       +
       

     

       214
       214
       +
       ### `lib/widgets/icons/animated_heart_icon.dart`

     

       215
       215
       +
       Bluesky-inspired animated heart icon with burst effect.

     

       216
       216
       +
       

     

       217
       217
       +
       **Animation Phases**:

     

       218
       218
       +
       1. Shrink to 0.8x (150ms)

     

       219
       219
       +
       2. Expand to 1.3x (250ms)

     

       220
       220
       +
       3. Settle back to 1.0x (400ms)

     

       221
       221
       +
       4. Particle burst at peak expansion

     

       222
       222
       +
       

     

       223
       223
       +
       ### Other Icons

     

       224
       224
       +
       - `reply_icon.dart` - Reply icon with filled/outline states

     

       225
       225
       +
       - `share_icon.dart` - Share/upload icon with Bluesky styling

     

       226
       226
       +
       

     

       227
       227
       +
       ---

     

       228
       228
       +
       

     

       229
       229
       +
       ## 4. Test Coverage

     

       230
       230
       +
       

     

       231
       231
       +
       ### Tests Updated

     

       232
       232
       +
       

     

       233
       233
       +
       **`test/providers/vote_provider_test.dart`** (24 tests)

     

       234
       234
       +
       - ✅ Updated all mocks to include `postCid` parameter

     

       235
       235
       +
       - ✅ Updated `VoteResponse` assertions to check `rkey`

     

       236
       236
       +
       - ✅ All tests passing

     

       237
       237
       +
       

     

       238
       238
       +
       **`test/services/vote_service_test.dart`** (19 tests)

     

       239
       239
       +
       - ✅ Updated `VoteResponse` creation to include `rkey`

     

       240
       240
       +
       - ✅ Removed obsolete `existing` field tests

     

       241
       241
       +
       - ✅ All tests passing

     

       242
       242
       +
       

     

       243
       243
       +
       **`test/widgets/feed_screen_test.dart`** (6 tests)

     

       244
       244
       +
       - ✅ Updated `FakeVoteProvider` to pass new VoteService parameters

     

       245
       245
       +
       - ✅ All tests passing

     

       246
       246
       +
       

     

       247
       247
       +
       ### Test Results

     

       248
       248
       +
       ```bash

     

       249
       249
       +
       $ flutter test

     

       250
       250
       +
       109 tests: 107 passing, 2 skipped

     

       251
       251
       +
       All tests passed! ✅

     

       252
       252
       +
       ```

     

       253
       253
       +
       

     

       254
       254
       +
       ### Analyzer Results

     

       255
       255
       +
       ```bash

     

       256
       256
       +
       $ flutter analyze

     

       257
       257
       +
       7 issues found (all info-level style suggestions in test files)

     

       258
       258
       +
       0 warnings, 0 errors ✅

     

       259
       259
       +
       ```

     

       260
       260
       +
       

     

       261
       261
       +
       ---

     

       262
       262
       +
       

     

       263
       263
       +
       ## 5. Key Architectural Patterns

     

       264
       264
       +
       

     

       265
       265
       +
       ### Client-Side Direct Writes

     

       266
       266
       +
       The mobile client writes vote records directly to the user's PDS using atProto XRPC calls, not through a backend proxy.

     

       267
       267
       +
       

     

       268
       268
       +
       ### AppView Read-Only Indexing

     

       269
       269
       +
       The backend listens to Jetstream events and indexes vote records for aggregated stats in feeds. It never writes to PDSs on behalf of users.

     

       270
       270
       +
       

     

       271
       271
       +
       ### Source of Truth

     

       272
       272
       +
       The user's PDS is the source of truth for their votes. The client queries the PDS to find existing votes, ensuring consistency.

     

       273
       273
       +
       

     

       274
       274
       +
       ### Optimistic UI Updates (Preserved)

     

       275
       275
       +
       1. Immediately update local state

     

       276
       276
       +
       2. Trigger PDS API call

     

       277
       277
       +
       3. On success: keep optimistic state

     

       278
       278
       +
       4. On error: rollback to previous state + rethrow

     

       279
       279
       +
       

     

       280
       280
       +
       ### Token Management

     

       281
       281
       +
       Services receive callbacks from `AuthProvider`:

     

       282
       282
       +
       ```dart

     

       283
       283
       +
       tokenGetter: authProvider.getAccessToken    // Fresh token on every request

     

       284
       284
       +
       didGetter: () => authProvider.did           // User's DID

     

       285
       285
       +
       pdsUrlGetter: authProvider.getPdsUrl        // User's PDS URL

     

       286
       286
       +
       ```

     

       287
       287
       +
       

     

       288
       288
       +
       ---

     

       289
       289
       +
       

     

       290
       290
       +
       ## 6. Exception Handling

     

       291
       291
       +
       

     

       292
       292
       +
       ### `lib/services/api_exceptions.dart`

     

       293
       293
       +
       Enhanced exception hierarchy with Dio integration.

     

       294
       294
       +
       

     

       295
       295
       +
       **Exception Types**:

     

       296
       296
       +
       - `ApiException` (base)

     

       297
       297
       +
       - `NetworkException` (connection/timeout errors)

     

       298
       298
       +
       - `AuthenticationException` (401)

     

       299
       299
       +
       - `NotFoundException` (404)

     

       300
       300
       +
       - `ServerException` (500+)

     

       301
       301
       +
       - `FederationException` (atProto federation errors)

     

       302
       302
       +
       

     

       303
       303
       +
       ---

     

       304
       304
       +
       

     

       305
       305
       +
       ## 7. Bug Fixes (Previous Work)

     

       306
       306
       +
       

     

       307
       307
       +
       ### Feed Provider - Duplicate API Calls on Failed Sign-In

     

       308
       308
       +
       

     

       309
       309
       +
       **Fix**: Track auth state transitions instead of current state

     

       310
       310
       +
       ```dart

     

       311
       311
       +
       bool _wasAuthenticated = false;

     

       312
       312
       +
       

     

       313
       313
       +
       void _onAuthChanged() {

     

       314
       314
       +
         final isAuthenticated = _authProvider.isAuthenticated;

     

       315
       315
       +
       

     

       316
       316
       +
         // Only reload if transitioning from authenticated → unauthenticated

     

       317
       317
       +
         if (_wasAuthenticated && !isAuthenticated && _posts.isNotEmpty) {

     

       318
       318
       +
           reset();

     

       319
       319
       +
           loadFeed(refresh: true);

     

       320
       320
       +
         }

     

       321
       321
       +
       

     

       322
       322
       +
         _wasAuthenticated = isAuthenticated;

     

       323
       323
       +
       }

     

       324
       324
       +
       ```

     

       325
       325
       +
       

     

       326
       326
       +
       ---

     

       327
       327
       +
       

     

       328
       328
       +
       ## 8. Files Summary

     

       329
       329
       +
       

     

       330
       330
       +
       ### Modified Files (8)

     

       331
       331
       +
       | File | Purpose |

     

       332
       332
       +
       |------|---------|

     

       333
       333
       +
       | [lib/providers/auth_provider.dart](lib/providers/auth_provider.dart#L74-L86) | Added `getPdsUrl()` method |

     

       334
       334
       +
       | [lib/services/vote_service.dart](lib/services/vote_service.dart) | Complete rewrite for direct PDS calls |

     

       335
       335
       +
       | [lib/providers/vote_provider.dart](lib/providers/vote_provider.dart) | Updated to pass `postCid`, track `rkey` |

     

       336
       336
       +
       | [lib/widgets/post_card.dart](lib/widgets/post_card.dart#L247-L250) | Updated vote call with `postCid` |

     

       337
       337
       +
       | [lib/main.dart](lib/main.dart#L31-L36) | Updated VoteService initialization |

     

       338
       338
       +
       | test/providers/vote_provider_test.dart | Updated mocks and assertions |

     

       339
       339
       +
       | test/services/vote_service_test.dart | Updated VoteResponse tests |

     

       340
       340
       +
       | test/widgets/feed_screen_test.dart | Updated FakeVoteProvider |

     

       341
       341
       +
       

     

       342
       342
       +
       ### Unchanged Files (Still Relevant)

     

       343
       343
       +
       | File | Purpose |

     

       344
       344
       +
       |------|---------|

     

       345
       345
       +
       | lib/widgets/sign_in_dialog.dart | Auth prompt dialog |

     

       346
       346
       +
       | lib/widgets/icons/animated_heart_icon.dart | Animated heart with burst effect |

     

       347
       347
       +
       | lib/widgets/icons/reply_icon.dart | Reply icon |

     

       348
       348
       +
       | lib/widgets/icons/share_icon.dart | Share icon |

     

       349
       349
       +
       | lib/config/environment_config.dart | Environment configuration |

     

       350
       350
       +
       

     

       351
       351
       +
       ---

     

       352
       352
       +
       

     

       353
       353
       +
       ## 9. Backend Integration Requirements

     

       354
       354
       +
       

     

       355
       355
       +
       ### Jetstream Listener

     

       356
       356
       +
       The backend must listen for `social.coves.interaction.vote` records from Jetstream:

     

       357
       357
       +
       

     

       358
       358
       +
       ```json

     

       359
       359
       +
       {

     

       360
       360
       +
         "did": "did:plc:user123",

     

       361
       361
       +
         "kind": "commit",

     

       362
       362
       +
         "commit": {

     

       363
       363
       +
           "operation": "create",

     

       364
       364
       +
           "collection": "social.coves.interaction.vote",

     

       365
       365
       +
           "rkey": "3kby...",

     

       366
       366
       +
           "cid": "bafy2bzacevotecid123",

     

       367
       367
       +
           "record": {

     

       368
       368
       +
             "$type": "social.coves.interaction.vote",

     

       369
       369
       +
             "subject": {

     

       370
       370
       +
               "uri": "at://did:plc:community/social.coves.post.record/abc",

     

       371
       371
       +
               "cid": "bafy2bzacepostcid123"

     

       372
       372
       +
             },

     

       373
       373
       +
             "direction": "up",

     

       374
       374
       +
             "createdAt": "2025-11-02T12:00:00Z"

     

       375
       375
       +
           }

     

       376
       376
       +
         }

     

       377
       377
       +
       }

     

       378
       378
       +
       ```

     

       379
       379
       +
       

     

       380
       380
       +
       ### AppView Indexing

     

       381
       381
       +
       1. Listen to Jetstream for vote events

     

       382
       382
       +
       2. Index vote records in database

     

       383
       383
       +
       3. Update vote counts on posts

     

       384
       384
       +
       4. Return aggregated stats in feed responses

     

       385
       385
       +
       

     

       386
       386
       +
       ### Feed Responses

     

       387
       387
       +
       Feed endpoints should include viewer state:

     

       388
       388
       +
       ```json

     

       389
       389
       +
       {

     

       390
       390
       +
         "post": {

     

       391
       391
       +
           "uri": "at://did:plc:community/social.coves.post.record/abc",

     

       392
       392
       +
           "stats": {

     

       393
       393
       +
             "upvotes": 42,

     

       394
       394
       +
             "downvotes": 3,

     

       395
       395
       +
             "score": 39

     

       396
       396
       +
           },

     

       397
       397
       +
           "viewer": {

     

       398
       398
       +
             "vote": {

     

       399
       399
       +
               "direction": "up",

     

       400
       400
       +
               "uri": "at://did:plc:user/social.coves.interaction.vote/3kby..."

     

       401
       401
       +
             }

     

       402
       402
       +
           }

     

       403
       403
       +
         }

     

       404
       404
       +
       }

     

       405
       405
       +
       ```

     

       406
       406
       +
       

     

       407
       407
       +
       ---

     

       408
       408
       +
       

     

       409
       409
       +
       ## 10. Testing Checklist

     

       410
       410
       +
       

     

       411
       411
       +
       ### Unit Tests ✅

     

       412
       412
       +
       - [x] VoteService creates proper record structure

     

       413
       413
       +
       - [x] VoteService finds existing votes correctly

     

       414
       414
       +
       - [x] VoteService implements toggle logic correctly

     

       415
       415
       +
       - [x] VoteProvider passes correct parameters

     

       416
       416
       +
       - [x] Error handling (network failures, auth errors)

     

       417
       417
       +
       

     

       418
       418
       +
       ### Integration Tests (Manual)

     

       419
       419
       +
       - [ ] Create vote on real PDS

     

       420
       420
       +
       - [ ] Toggle vote off (delete)

     

       421
       421
       +
       - [ ] Switch vote direction (delete + create)

     

       422
       422
       +
       - [ ] Verify Jetstream receives events

     

       423
       423
       +
       - [ ] Verify backend indexes votes correctly

     

       424
       424
       +
       - [ ] Check optimistic UI works

     

       425
       425
       +
       - [ ] Test rollback on error

     

       426
       426
       +
       

     

       427
       427
       +
       ### Backend Verification

     

       428
       428
       +
       - [ ] Jetstream listener receives vote events

     

       429
       429
       +
       - [ ] AppView indexes votes in database

     

       430
       430
       +
       - [ ] Feed endpoints return correct vote counts

     

       431
       431
       +
       - [ ] Viewer state includes user's vote

     

       432
       432
       +
       

     

       433
       433
       +
       ---

     

       434
       434
       +
       

     

       435
       435
       +
       ## 11. Performance Considerations

     

       436
       436
       +
       

     

       437
       437
       +
       ### Optimizations

     

       438
       438
       +
       - **Optimistic Updates**: Instant UI feedback without waiting for PDS

     

       439
       439
       +
       - **Concurrent Request Prevention**: Debouncing prevents duplicate API calls

     

       440
       440
       +
       - **Auth Transition Detection**: Eliminates unnecessary feed reloads

     

       441
       441
       +
       - **Direct PDS Writes**: Removes backend proxy hop

     

       442
       442
       +
       

     

       443
       443
       +
       ### Potential Issues & Solutions

     

       444
       444
       +
       

     

       445
       445
       +
       **Issue 1**: Finding existing votes is slow (100 records to scan)

     

       446
       446
       +
       - **Solution**: Cache vote URIs locally, or use backend's viewer state as hint

     

       447
       447
       +
       

     

       448
       448
       +
       **Issue 2**: User might have voted from another client

     

       449
       449
       +
       - **Solution**: Always query PDS listRecords to get source of truth

     

       450
       450
       +
       

     

       451
       451
       +
       **Issue 3**: Network latency for PDS calls

     

       452
       452
       +
       - **Solution**: Keep optimistic UI updates for instant feedback

     

       453
       453
       +
       

     

       454
       454
       +
       **Issue 4**: Vote count updates

     

       455
       455
       +
       - **Solution**: Backend AppView indexes Jetstream events and updates counts in feed

     

       456
       456
       +
       

     

       457
       457
       +
       ---

     

       458
       458
       +
       

     

       459
       459
       +
       ## 12. Dependencies

     

       460
       460
       +
       

     

       461
       461
       +
       ### Production Dependencies

     

       462
       462
       +
       - `provider` - State management

     

       463
       463
       +
       - `dio` - HTTP client

     

       464
       464
       +
       - `atproto_oauth_flutter` - OAuth authentication

     

       465
       465
       +
       - `flutter/material.dart` - UI framework

     

       466
       466
       +
       

     

       467
       467
       +
       ### Test Dependencies

     

       468
       468
       +
       - `mockito` - Mocking framework

     

       469
       469
       +
       - `build_runner` - Code generation

     

       470
       470
       +
       - `flutter_test` - Testing framework

     

       471
       471
       +
       

     

       472
       472
       +
       ---

     

       473
       473
       +
       

     

       474
       474
       +
       ## 13. Future Enhancements

     

       475
       475
       +
       

     

       476
       476
       +
       ### Potential Improvements

     

       477
       477
       +
       1. **Persistent Vote Cache** - Store votes locally for offline support

     

       478
       478
       +
       2. **Vote Animations** - More sophisticated animations (number counter)

     

       479
       479
       +
       3. **Downvote UI** - Currently only upvote shown in UI

     

       480
       480
       +
       4. **Error Snackbars** - User-friendly error messages

     

       481
       481
       +
       5. **Real-time Updates** - WebSocket for live vote count updates

     

       482
       482
       +
       6. **Vote History** - View vote history in user profile

     

       483
       483
       +
       

     

       484
       484
       +
       ---

     

       485
       485
       +
       

     

       486
       486
       +
       ## 14. Migration Notes

     

       487
       487
       +
       

     

       488
       488
       +
       ### Breaking Changes

     

       489
       489
       +
       - `VoteService` constructor signature changed (added `didGetter`, `pdsUrlGetter`)

     

       490
       490
       +
       - `toggleVote()` now requires `postCid` parameter

     

       491
       491
       +
       - `VoteResponse` added `rkey` field (removed `existing` field)

     

       492
       492
       +
       - Backend must implement Jetstream listener (no longer receives vote API calls)

     

       493
       493
       +
       

     

       494
       494
       +
       ### Backward Compatibility

     

       495
       495
       +
       - Feed reading logic unchanged

     

       496
       496
       +
       - UI components unchanged (except `PostCard` vote call)

     

       497
       497
       +
       - Test infrastructure preserved

     

       498
       498
       +
       - Optimistic UI behavior preserved

     

       499
       499
       +
       

     

       500
       500
       +
       ---

     

       501
       501
       +
       

     

       502
       502
       +
       ## Conclusion

     

       503
       503
       +
       

     

       504
       504
       +
       This refactoring represents a **fundamental architectural improvement** that aligns with atProto principles:

     

       505
       505
       +
       

     

       506
       506
       +
       ### Key Achievements

     

       507
       507
       +
       - ✅ **Proper atProto Architecture** - Clients write to PDSs, AppViews index

     

       508
       508
       +
       - ✅ **Federation Ready** - Works with any PDS in the atProto network

     

       509
       509
       +
       - ✅ **User Data Ownership** - Votes stored on user's PDS

     

       510
       510
       +
       - ✅ **Scalable Backend** - AppView only indexes, doesn't proxy writes

     

       511
       511
       +
       - ✅ **Comprehensive Testing** - 109 tests passing, 0 warnings/errors

     

       512
       512
       +
       - ✅ **Preserved UX** - Optimistic UI updates maintained

     

       513
       513
       +
       - ✅ **Production Ready** - Full error handling and rollback

     

       514
       514
       +
       

     

       515
       515
       +
       ### Architecture Benefits

     

       516
       516
       +
       The new architecture is simpler, more scalable, and follows the atProto specification correctly. The mobile client now operates as a first-class atProto client, writing directly to the user's PDS and reading from the AppView's aggregated feeds.

     

       517
       517
       +
       

     

       518
       518
       +
       ---

     

       519
       519
       +
       

     

       520
       520
       +
       **Generated**: 2025-11-02

     

       521
       521
       +
       **Branch**: `feature/bluesky-icons-and-heart-animation`

     

       522
       522
       +
       **Status**: ✅ **Complete and Ready for Production Testing**

     

       523
       523
       +
       

     

       524
       524
       +
       **DPoP Authentication**: ✅ Fully implemented using OAuthSession.fetchHandler

     

       525
       525
       +
       - Uses local atproto_oauth_flutter package's built-in DPoP support

     

       526
       526
       +
       - Automatic token refresh on expiry

     

       527
       527
       +
       - Nonce management for replay protection

     

       528
       528
       +
       - Authorization: DPoP <access_token> headers

     

       529
       529
       +
       - DPoP: <proof> signed JWT headers

     

       530
       530
       +
       

     

       531
       531
       +
       **Next Steps**:

     

       532
       532
       +
       1. ✅ Commit architectural changes

     

       533
       533
       +
       2. ✅ Implement DPoP authentication

     

       534
       534
       +
       3. 🧪 Test with real PDS and verify Jetstream integration

     

       535
       535
       +
       4. 🚀 Deploy to production

+67

lib/config/environment_config.dart

···

       1
       1
       +
       /// Environment Configuration for Coves Mobile

     

       2
       2
       +
       ///

     

       3
       3
       +
       /// Supports multiple environments:

     

       4
       4
       +
       /// - Production: Real Bluesky infrastructure

     

       5
       5
       +
       /// - Local: Local PDS + PLC for development/testing

     

       6
       6
       +
       ///

     

       7
       7
       +
       /// Set via ENVIRONMENT environment variable or flutter run --dart-define

     

       8
       8
       +
       enum Environment {

     

       9
       9
       +
         production,

     

       10
       10
       +
         local,

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       class EnvironmentConfig {

     

       14
       14
       +
       

     

       15
       15
       +
         const EnvironmentConfig({

     

       16
       16
       +
           required this.environment,

     

       17
       17
       +
           required this.apiUrl,

     

       18
       18
       +
           required this.handleResolverUrl,

     

       19
       19
       +
           required this.plcDirectoryUrl,

     

       20
       20
       +
         });

     

       21
       21
       +
         final Environment environment;

     

       22
       22
       +
         final String apiUrl;

     

       23
       23
       +
         final String handleResolverUrl;

     

       24
       24
       +
         final String plcDirectoryUrl;

     

       25
       25
       +
       

     

       26
       26
       +
         /// Production configuration (default)

     

       27
       27
       +
         /// Uses real Bluesky infrastructure

     

       28
       28
       +
         static const production = EnvironmentConfig(

     

       29
       29
       +
           environment: Environment.production,

     

       30
       30
       +
           apiUrl: 'https://coves.social', // TODO: Update when production is live

     

       31
       31
       +
           handleResolverUrl: 'https://bsky.social/xrpc/com.atproto.identity.resolveHandle',

     

       32
       32
       +
           plcDirectoryUrl: 'https://plc.directory',

     

       33
       33
       +
         );

     

       34
       34
       +
       

     

       35
       35
       +
         /// Local development configuration

     

       36
       36
       +
         /// Uses localhost via adb reverse port forwarding

     

       37
       37
       +
         ///

     

       38
       38
       +
         /// IMPORTANT: Before testing, run these commands to forward ports:

     

       39
       39
       +
         ///   adb reverse tcp:3001 tcp:3001  # PDS

     

       40
       40
       +
         ///   adb reverse tcp:3002 tcp:3002  # PLC

     

       41
       41
       +
         ///   adb reverse tcp:8081 tcp:8081  # AppView

     

       42
       42
       +
         ///

     

       43
       43
       +
         /// Note: For physical devices not connected via USB, use ngrok URLs instead

     

       44
       44
       +
         static const local = EnvironmentConfig(

     

       45
       45
       +
           environment: Environment.local,

     

       46
       46
       +
           apiUrl: 'http://localhost:8081',

     

       47
       47
       +
           handleResolverUrl: 'http://localhost:3001/xrpc/com.atproto.identity.resolveHandle',

     

       48
       48
       +
           plcDirectoryUrl: 'http://localhost:3002',

     

       49
       49
       +
         );

     

       50
       50
       +
       

     

       51
       51
       +
         /// Get current environment based on build configuration

     

       52
       52
       +
         static EnvironmentConfig get current {

     

       53
       53
       +
           // Read from --dart-define=ENVIRONMENT=local

     

       54
       54
       +
           const envString = String.fromEnvironment('ENVIRONMENT', defaultValue: 'production');

     

       55
       55
       +
       

     

       56
       56
       +
           switch (envString) {

     

       57
       57
       +
             case 'local':

     

       58
       58
       +
               return local;

     

       59
       59
       +
             case 'production':

     

       60
       60
       +
             default:

     

       61
       61
       +
               return production;

     

       62
       62
       +
           }

     

       63
       63
       +
         }

     

       64
       64
       +
       

     

       65
       65
       +
         bool get isProduction => environment == Environment.production;

     

       66
       66
       +
         bool get isLocal => environment == Environment.local;

     

       67
       67
       +
       }

+4 -3

lib/config/oauth_config.dart

···

       1
       1
        
       import 'package:atproto_oauth_flutter/atproto_oauth_flutter.dart';

     

       2
       2
        
       

     

       3
       3
       +
       import 'environment_config.dart';

     

       4
       4
       +
       

     

       3
       5
        
       /// OAuth Configuration for atProto

     

       4
       6
        
       ///

     

       5
       7
        
       /// This configuration provides ClientMetadata for the new

     
···

       19
       21
        
             'dev.workers.brettmay0212.lingering-darkness-50a6';

     

       20
       22
        
       

     

       21
       23
        
         // API Configuration

     

       22
       22
       -
         // Using adb reverse port forwarding, phone can access via localhost

     

       23
       23
       -
         // Setup: adb reverse tcp:8081 tcp:8081

     

       24
       24
       -
         static const String apiUrl = 'http://localhost:8081';

     

       24
       24
       +
         // Environment-aware API URL

     

       25
       25
       +
         static String get apiUrl => EnvironmentConfig.current.apiUrl;

     

       25
       26
        
       

     

       26
       27
        
         // Derived OAuth URLs

     

       27
       28
        
         static const String clientId = '$oauthServerUrl/client-metadata.json';

+16

lib/main.dart

···

       7
       7
        
       import 'config/oauth_config.dart';

     

       8
       8
        
       import 'providers/auth_provider.dart';

     

       9
       9
        
       import 'providers/feed_provider.dart';

     

       10
       10
       +
       import 'providers/vote_provider.dart';

     

       10
       11
        
       import 'screens/auth/login_screen.dart';

     

       11
       12
        
       import 'screens/home/main_shell_screen.dart';

     

       12
       13
        
       import 'screens/landing_screen.dart';

     

       14
       14
       +
       import 'services/vote_service.dart';

     

       13
       15
        
       

     

       14
       16
        
       void main() async {

     

       15
       17
        
         WidgetsFlutterBinding.ensureInitialized();

     
···

       26
       28
        
         final authProvider = AuthProvider();

     

       27
       29
        
         await authProvider.initialize();

     

       28
       30
        
       

     

       31
       31
       +
         // Initialize vote service with auth callbacks for direct PDS writes

     

       32
       32
       +
         // Uses DPoP authentication (not Bearer tokens!)

     

       33
       33
       +
         final voteService = VoteService(

     

       34
       34
       +
           sessionGetter: () async => authProvider.session,

     

       35
       35
       +
           didGetter: () => authProvider.did,

     

       36
       36
       +
           pdsUrlGetter: authProvider.getPdsUrl,

     

       37
       37
       +
         );

     

       38
       38
       +
       

     

       29
       39
        
         runApp(

     

       30
       40
        
           MultiProvider(

     

       31
       41
        
             providers: [

     

       32
       42
        
               ChangeNotifierProvider.value(value: authProvider),

     

       33
       43
        
               ChangeNotifierProvider(create: (_) => FeedProvider(authProvider)),

     

       44
       44
       +
               ChangeNotifierProvider(

     

       45
       45
       +
                 create: (_) => VoteProvider(

     

       46
       46
       +
                   voteService: voteService,

     

       47
       47
       +
                   authProvider: authProvider,

     

       48
       48
       +
                 ),

     

       49
       49
       +
               ),

     

       34
       50
        
             ],

     

       35
       51
        
             child: const CovesApp(),

     

       36
       52
        
           ),

+14

lib/providers/auth_provider.dart

···

       71
       71
        
           }

     

       72
       72
        
         }

     

       73
       73
        
       

     

       74
       74
       +
         /// Get the user's PDS URL

     

       75
       75
       +
         ///

     

       76
       76
       +
         /// Returns the URL of the user's Personal Data Server from the OAuth session.

     

       77
       77
       +
         /// This is needed for direct XRPC calls to the PDS (e.g., createRecord).

     

       78
       78
       +
         ///

     

       79
       79
       +
         /// The PDS URL is stored in serverMetadata['issuer'] from the OAuth session.

     

       80
       80
       +
         String? getPdsUrl() {

     

       81
       81
       +
           if (_session == null) {

     

       82
       82
       +
             return null;

     

       83
       83
       +
           }

     

       84
       84
       +
       

     

       85
       85
       +
           return _session!.serverMetadata['issuer'] as String?;

     

       86
       86
       +
         }

     

       87
       87
       +
       

     

       74
       88
        
         /// Initialize the provider and restore any existing session

     

       75
       89
        
         ///

     

       76
       90
        
         /// This is called on app startup to:

+17 -7

lib/providers/feed_provider.dart

···

       21
       21
        
               apiService ??

     

       22
       22
        
               CovesApiService(tokenGetter: _authProvider.getAccessToken);

     

       23
       23
        
       

     

       24
       24
       +
           // Track initial auth state

     

       25
       25
       +
           _wasAuthenticated = _authProvider.isAuthenticated;

     

       26
       26
       +
       

     

       24
       27
        
           // [P0 FIX] Listen to auth state changes and clear feed on sign-out

     

       25
       28
        
           // This prevents privacy bug where logged-out users see their private

     

       26
       29
        
           // timeline until they manually refresh.

     
···

       29
       32
        
       

     

       30
       33
        
         /// Handle authentication state changes

     

       31
       34
        
         ///

     

       32
       32
       -
         /// When the user signs out (isAuthenticated becomes false),

     

       33
       33
       -
         /// immediately clear the feed to prevent showing personalized content

     

       34
       34
       -
         /// to logged-out users. This fixes a privacy bug where token refresh

     

       35
       35
       -
         /// failures would sign out the user but leave their private timeline

     

       36
       36
       -
         /// visible until manual refresh.

     

       35
       35
       +
         /// Only clears and reloads feed when transitioning from authenticated

     

       36
       36
       +
         /// to unauthenticated (actual sign-out), not when staying unauthenticated

     

       37
       37
       +
         /// (e.g., failed sign-in attempt). This prevents unnecessary API calls.

     

       37
       38
        
         void _onAuthChanged() {

     

       38
       38
       -
           if (!_authProvider.isAuthenticated && _posts.isNotEmpty) {

     

       39
       39
       +
           final isAuthenticated = _authProvider.isAuthenticated;

     

       40
       40
       +
       

     

       41
       41
       +
           // Only reload if transitioning from authenticated → unauthenticated

     

       42
       42
       +
           if (_wasAuthenticated && !isAuthenticated && _posts.isNotEmpty) {

     

       39
       43
        
             if (kDebugMode) {

     

       40
       40
       -
               debugPrint('🔒 Auth state changed to unauthenticated - clearing feed');

     

       44
       44
       +
               debugPrint('🔒 User signed out - clearing feed');

     

       41
       45
        
             }

     

       42
       46
        
             reset();

     

       43
       47
        
             // Automatically load the public discover feed

     

       44
       48
        
             loadFeed(refresh: true);

     

       45
       49
        
           }

     

       50
       50
       +
       

     

       51
       51
       +
           // Update tracked state

     

       52
       52
       +
           _wasAuthenticated = isAuthenticated;

     

       46
       53
        
         }

     

       47
       54
        
       

     

       48
       55
        
         final AuthProvider _authProvider;

     

       49
       56
        
         late final CovesApiService _apiService;

     

       57
       57
       +
       

     

       58
       58
       +
         // Track previous auth state to detect transitions

     

       59
       59
       +
         bool _wasAuthenticated = false;

     

       50
       60
        
       

     

       51
       61
        
         // Feed state

     

       52
       62
        
         List<FeedViewPost> _posts = [];

+232

lib/providers/vote_provider.dart

···

       1
       1
       +
       import 'package:flutter/foundation.dart';

     

       2
       2
       +
       

     

       3
       3
       +
       import '../services/api_exceptions.dart';

     

       4
       4
       +
       import '../services/vote_service.dart';

     

       5
       5
       +
       import 'auth_provider.dart';

     

       6
       6
       +
       

     

       7
       7
       +
       /// Vote Provider

     

       8
       8
       +
       ///

     

       9
       9
       +
       /// Manages vote state with optimistic UI updates.

     

       10
       10
       +
       /// Tracks local vote state keyed by post URI for instant feedback.

     

       11
       11
       +
       /// Automatically clears state when user signs out.

     

       12
       12
       +
       class VoteProvider with ChangeNotifier {

     

       13
       13
       +
         VoteProvider({

     

       14
       14
       +
           required VoteService voteService,

     

       15
       15
       +
           required AuthProvider authProvider,

     

       16
       16
       +
         })  : _voteService = voteService,

     

       17
       17
       +
               _authProvider = authProvider {

     

       18
       18
       +
           // Listen to auth state changes and clear votes on sign-out

     

       19
       19
       +
           _authProvider.addListener(_onAuthChanged);

     

       20
       20
       +
         }

     

       21
       21
       +
       

     

       22
       22
       +
         @override

     

       23
       23
       +
         void dispose() {

     

       24
       24
       +
           _authProvider.removeListener(_onAuthChanged);

     

       25
       25
       +
           super.dispose();

     

       26
       26
       +
         }

     

       27
       27
       +
       

     

       28
       28
       +
         void _onAuthChanged() {

     

       29
       29
       +
           // Clear vote state when user signs out

     

       30
       30
       +
           if (!_authProvider.isAuthenticated) {

     

       31
       31
       +
             if (_votes.isNotEmpty) {

     

       32
       32
       +
               clear();

     

       33
       33
       +
               if (kDebugMode) {

     

       34
       34
       +
                 debugPrint('🧹 Cleared vote state on sign-out');

     

       35
       35
       +
               }

     

       36
       36
       +
             }

     

       37
       37
       +
           }

     

       38
       38
       +
         }

     

       39
       39
       +
       

     

       40
       40
       +
         final VoteService _voteService;

     

       41
       41
       +
         final AuthProvider _authProvider;

     

       42
       42
       +
       

     

       43
       43
       +
         // Map of post URI -> vote state

     

       44
       44
       +
         final Map<String, VoteState> _votes = {};

     

       45
       45
       +
       

     

       46
       46
       +
         // Map of post URI -> in-flight request flag

     

       47
       47
       +
         final Map<String, bool> _pendingRequests = {};

     

       48
       48
       +
       

     

       49
       49
       +
         /// Get vote state for a post

     

       50
       50
       +
         VoteState? getVoteState(String postUri) => _votes[postUri];

     

       51
       51
       +
       

     

       52
       52
       +
         /// Check if a post is liked/upvoted

     

       53
       53
       +
         bool isLiked(String postUri) =>

     

       54
       54
       +
             _votes[postUri]?.direction == 'up' &&

     

       55
       55
       +
             !(_votes[postUri]?.deleted ?? false);

     

       56
       56
       +
       

     

       57
       57
       +
         /// Check if a request is pending for a post

     

       58
       58
       +
         bool isPending(String postUri) => _pendingRequests[postUri] ?? false;

     

       59
       59
       +
       

     

       60
       60
       +
         /// Toggle vote (like/unlike)

     

       61
       61
       +
         ///

     

       62
       62
       +
         /// Uses optimistic updates:

     

       63
       63
       +
         /// 1. Immediately updates local state

     

       64
       64
       +
         /// 2. Makes API call

     

       65
       65
       +
         /// 3. Reverts on error

     

       66
       66
       +
         ///

     

       67
       67
       +
         /// Parameters:

     

       68
       68
       +
         /// - [postUri]: AT-URI of the post

     

       69
       69
       +
         /// - [postCid]: Content ID of the post (for strong reference)

     

       70
       70
       +
         /// - [direction]: Vote direction (defaults to "up" for like)

     

       71
       71
       +
         ///

     

       72
       72
       +
         /// Returns:

     

       73
       73
       +
         /// - true if vote was created

     

       74
       74
       +
         /// - false if vote was removed (toggled off)

     

       75
       75
       +
         ///

     

       76
       76
       +
         /// Throws:

     

       77
       77
       +
         /// - ApiException if the request fails

     

       78
       78
       +
         Future<bool> toggleVote({

     

       79
       79
       +
           required String postUri,

     

       80
       80
       +
           required String postCid,

     

       81
       81
       +
           String direction = 'up',

     

       82
       82
       +
         }) async {

     

       83
       83
       +
           // Prevent concurrent requests for the same post

     

       84
       84
       +
           if (_pendingRequests[postUri] ?? false) {

     

       85
       85
       +
             if (kDebugMode) {

     

       86
       86
       +
               debugPrint('⚠️ Vote request already in progress for $postUri');

     

       87
       87
       +
             }

     

       88
       88
       +
             return false;

     

       89
       89
       +
           }

     

       90
       90
       +
       

     

       91
       91
       +
           // Save current state for rollback on error

     

       92
       92
       +
           final previousState = _votes[postUri];

     

       93
       93
       +
           final currentState = previousState;

     

       94
       94
       +
       

     

       95
       95
       +
           // Optimistic update

     

       96
       96
       +
           if (currentState?.direction == direction &&

     

       97
       97
       +
               !(currentState?.deleted ?? false)) {

     

       98
       98
       +
             // Toggle off - mark as deleted

     

       99
       99
       +
             _votes[postUri] = VoteState(

     

       100
       100
       +
               direction: direction,

     

       101
       101
       +
               uri: currentState?.uri,

     

       102
       102
       +
               rkey: currentState?.rkey,

     

       103
       103
       +
               deleted: true,

     

       104
       104
       +
             );

     

       105
       105
       +
           } else {

     

       106
       106
       +
             // Create or switch direction

     

       107
       107
       +
             _votes[postUri] = VoteState(

     

       108
       108
       +
               direction: direction,

     

       109
       109
       +
               deleted: false,

     

       110
       110
       +
             );

     

       111
       111
       +
           }

     

       112
       112
       +
           notifyListeners();

     

       113
       113
       +
       

     

       114
       114
       +
           // Mark request as pending

     

       115
       115
       +
           _pendingRequests[postUri] = true;

     

       116
       116
       +
       

     

       117
       117
       +
           try {

     

       118
       118
       +
             // Make API call

     

       119
       119
       +
             final response = await _voteService.createVote(

     

       120
       120
       +
               postUri: postUri,

     

       121
       121
       +
               postCid: postCid,

     

       122
       122
       +
               direction: direction,

     

       123
       123
       +
             );

     

       124
       124
       +
       

     

       125
       125
       +
             // Update with server response

     

       126
       126
       +
             if (response.deleted) {

     

       127
       127
       +
               // Vote was removed

     

       128
       128
       +
               _votes[postUri] = VoteState(

     

       129
       129
       +
                 direction: direction,

     

       130
       130
       +
                 deleted: true,

     

       131
       131
       +
               );

     

       132
       132
       +
             } else {

     

       133
       133
       +
               // Vote was created or updated

     

       134
       134
       +
               _votes[postUri] = VoteState(

     

       135
       135
       +
                 direction: direction,

     

       136
       136
       +
                 uri: response.uri,

     

       137
       137
       +
                 rkey: response.rkey,

     

       138
       138
       +
                 deleted: false,

     

       139
       139
       +
               );

     

       140
       140
       +
             }

     

       141
       141
       +
       

     

       142
       142
       +
             notifyListeners();

     

       143
       143
       +
             return !response.deleted;

     

       144
       144
       +
           } on ApiException catch (e) {

     

       145
       145
       +
             if (kDebugMode) {

     

       146
       146
       +
               debugPrint('❌ Failed to toggle vote: ${e.message}');

     

       147
       147
       +
             }

     

       148
       148
       +
       

     

       149
       149
       +
             // Rollback optimistic update

     

       150
       150
       +
             if (previousState != null) {

     

       151
       151
       +
               _votes[postUri] = previousState;

     

       152
       152
       +
             } else {

     

       153
       153
       +
               _votes.remove(postUri);

     

       154
       154
       +
             }

     

       155
       155
       +
             notifyListeners();

     

       156
       156
       +
       

     

       157
       157
       +
             rethrow;

     

       158
       158
       +
           } finally {

     

       159
       159
       +
             _pendingRequests.remove(postUri);

     

       160
       160
       +
           }

     

       161
       161
       +
         }

     

       162
       162
       +
       

     

       163
       163
       +
         /// Initialize vote state from post data

     

       164
       164
       +
         ///

     

       165
       165
       +
         /// Call this when loading posts to populate initial vote state

     

       166
       166
       +
         /// from the backend's viewer state.

     

       167
       167
       +
         ///

     

       168
       168
       +
         /// Parameters:

     

       169
       169
       +
         /// - [postUri]: AT-URI of the post

     

       170
       170
       +
         /// - [voteDirection]: Current vote direction ("up", "down", or null)

     

       171
       171
       +
         /// - [voteUri]: AT-URI of the vote record

     

       172
       172
       +
         void setInitialVoteState({

     

       173
       173
       +
           required String postUri,

     

       174
       174
       +
           String? voteDirection,

     

       175
       175
       +
           String? voteUri,

     

       176
       176
       +
         }) {

     

       177
       177
       +
           if (voteDirection != null) {

     

       178
       178
       +
             // Extract rkey from vote URI if available

     

       179
       179
       +
             // URI format: at://did:plc:xyz/social.coves.interaction.vote/3kby...

     

       180
       180
       +
             String? rkey;

     

       181
       181
       +
             if (voteUri != null) {

     

       182
       182
       +
               final parts = voteUri.split('/');

     

       183
       183
       +
               if (parts.isNotEmpty) {

     

       184
       184
       +
                 rkey = parts.last;

     

       185
       185
       +
               }

     

       186
       186
       +
             }

     

       187
       187
       +
       

     

       188
       188
       +
             _votes[postUri] = VoteState(

     

       189
       189
       +
               direction: voteDirection,

     

       190
       190
       +
               uri: voteUri,

     

       191
       191
       +
               rkey: rkey,

     

       192
       192
       +
               deleted: false,

     

       193
       193
       +
             );

     

       194
       194
       +
           } else {

     

       195
       195
       +
             _votes.remove(postUri);

     

       196
       196
       +
           }

     

       197
       197
       +
           // Don't notify listeners - this is just initial state

     

       198
       198
       +
         }

     

       199
       199
       +
       

     

       200
       200
       +
         /// Clear all vote state (e.g., on sign out)

     

       201
       201
       +
         void clear() {

     

       202
       202
       +
           _votes.clear();

     

       203
       203
       +
           _pendingRequests.clear();

     

       204
       204
       +
           notifyListeners();

     

       205
       205
       +
         }

     

       206
       206
       +
       }

     

       207
       207
       +
       

     

       208
       208
       +
       /// Vote State

     

       209
       209
       +
       ///

     

       210
       210
       +
       /// Represents the current vote state for a post.

     

       211
       211
       +
       class VoteState {

     

       212
       212
       +
         const VoteState({

     

       213
       213
       +
           required this.direction,

     

       214
       214
       +
           this.uri,

     

       215
       215
       +
           this.rkey,

     

       216
       216
       +
           required this.deleted,

     

       217
       217
       +
         });

     

       218
       218
       +
       

     

       219
       219
       +
         /// Vote direction ("up" or "down")

     

       220
       220
       +
         final String direction;

     

       221
       221
       +
       

     

       222
       222
       +
         /// AT-URI of the vote record (null if not yet created)

     

       223
       223
       +
         final String? uri;

     

       224
       224
       +
       

     

       225
       225
       +
         /// Record key (rkey) of the vote - needed for deletion

     

       226
       226
       +
         /// This is the last segment of the AT-URI (e.g., "3kby..." from

     

       227
       227
       +
         /// "at://did:plc:xyz/social.coves.interaction.vote/3kby...")

     

       228
       228
       +
         final String? rkey;

     

       229
       229
       +
       

     

       230
       230
       +
         /// Whether the vote has been deleted

     

       231
       231
       +
         final bool deleted;

     

       232
       232
       +
       }

+49

lib/services/api_exceptions.dart

···

       4
       4
        
       /// This allows better error handling and user-friendly error messages.

     

       5
       5
        
       library;

     

       6
       6
        
       

     

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

     

       8
       8
       +
       

     

       7
       9
        
       /// Base class for all API exceptions

     

       8
       10
        
       class ApiException implements Exception {

     

       9
       11
        
         ApiException(this.message, {this.statusCode, this.originalError});

     

       12
       12
       +
       

     

       13
       13
       +
         /// Create ApiException from DioException

     

       14
       14
       +
         factory ApiException.fromDioError(DioException error) {

     

       15
       15
       +
           switch (error.type) {

     

       16
       16
       +
             case DioExceptionType.connectionTimeout:

     

       17
       17
       +
             case DioExceptionType.sendTimeout:

     

       18
       18
       +
             case DioExceptionType.receiveTimeout:

     

       19
       19
       +
               return NetworkException(

     

       20
       20
       +
                 'Request timeout. Please check your connection.',

     

       21
       21
       +
                 originalError: error,

     

       22
       22
       +
               );

     

       23
       23
       +
             case DioExceptionType.badResponse:

     

       24
       24
       +
               final statusCode = error.response?.statusCode;

     

       25
       25
       +
               final message =

     

       26
       26
       +
                   error.response?.data?['message'] as String? ??

     

       27
       27
       +
                   error.response?.data?['error'] as String? ??

     

       28
       28
       +
                   'Server error';

     

       29
       29
       +
       

     

       30
       30
       +
               if (statusCode == 401) {

     

       31
       31
       +
                 return AuthenticationException(message, originalError: error);

     

       32
       32
       +
               } else if (statusCode == 404) {

     

       33
       33
       +
                 return NotFoundException(message, originalError: error);

     

       34
       34
       +
               } else if (statusCode != null && statusCode >= 500) {

     

       35
       35
       +
                 return ServerException(

     

       36
       36
       +
                   message,

     

       37
       37
       +
                   statusCode: statusCode,

     

       38
       38
       +
                   originalError: error,

     

       39
       39
       +
                 );

     

       40
       40
       +
               }

     

       41
       41
       +
               return ApiException(

     

       42
       42
       +
                 message,

     

       43
       43
       +
                 statusCode: statusCode,

     

       44
       44
       +
                 originalError: error,

     

       45
       45
       +
               );

     

       46
       46
       +
             case DioExceptionType.cancel:

     

       47
       47
       +
               return ApiException('Request was cancelled', originalError: error);

     

       48
       48
       +
             case DioExceptionType.connectionError:

     

       49
       49
       +
               return NetworkException(

     

       50
       50
       +
                 'Connection failed. Please check your internet.',

     

       51
       51
       +
                 originalError: error,

     

       52
       52
       +
               );

     

       53
       53
       +
             case DioExceptionType.badCertificate:

     

       54
       54
       +
               return NetworkException('SSL certificate error', originalError: error);

     

       55
       55
       +
             case DioExceptionType.unknown:

     

       56
       56
       +
               return NetworkException('Network error occurred', originalError: error);

     

       57
       57
       +
           }

     

       58
       58
       +
         }

     

       10
       59
        
         final String message;

     

       11
       60
        
         final int? statusCode;

     

       12
       61
        
         final dynamic originalError;

+12

lib/services/oauth_service.dart

···

       1
       1
        
       import 'dart:async';

     

       2
       2
        
       import 'package:atproto_oauth_flutter/atproto_oauth_flutter.dart';

     

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

     

       4
       4
       +
       import '../config/environment_config.dart';

     

       4
       5
        
       import '../config/oauth_config.dart';

     

       5
       6
        
       

     

       6
       7
        
       /// OAuth Service for atProto authentication using the new

     
···

       43
       44
        
         /// - Automatic session management

     

       44
       45
        
         Future<void> initialize() async {

     

       45
       46
        
           try {

     

       47
       47
       +
             // Get environment configuration

     

       48
       48
       +
             final config = EnvironmentConfig.current;

     

       49
       49
       +
       

     

       46
       50
        
             // Create client with metadata from config

     

       51
       51
       +
             // For local development, use custom resolvers

     

       47
       52
        
             _client = FlutterOAuthClient(

     

       48
       53
        
               clientMetadata: OAuthConfig.createClientMetadata(),

     

       54
       54
       +
               plcDirectoryUrl: config.plcDirectoryUrl,

     

       55
       55
       +
               handleResolverUrl: config.handleResolverUrl,

     

       56
       56
       +
               allowHttp: config.isLocal, // Allow HTTP for local development

     

       49
       57
        
             );

     

       50
       58
        
       

     

       51
       59
        
             // Set up session event listeners

     
···

       53
       61
        
       

     

       54
       62
        
             if (kDebugMode) {

     

       55
       63
        
               print('✅ FlutterOAuthClient initialized');

     

       64
       64
       +
               print('   Environment: ${config.environment}');

     

       56
       65
        
               print('   Client ID: ${OAuthConfig.clientId}');

     

       57
       66
        
               print('   Redirect URI: ${OAuthConfig.customSchemeCallback}');

     

       58
       67
        
               print('   Scope: ${OAuthConfig.scope}');

     

       68
       68
       +
               print('   Handle Resolver: ${config.handleResolverUrl}');

     

       69
       69
       +
               print('   PLC Directory: ${config.plcDirectoryUrl}');

     

       70
       70
       +
               print('   Allow HTTP: ${config.isLocal}');

     

       59
       71
        
             }

     

       60
       72
        
           } catch (e) {

     

       61
       73
        
             if (kDebugMode) {

+10 -5

lib/services/pds_discovery_service.dart

···

       1
       1
        
       import 'package:dio/dio.dart';

     

       2
       2
        
       

     

       3
       3
       +
       import '../config/environment_config.dart';

     

       4
       4
       +
       

     

       3
       5
        
       /// PDS Discovery Service

     

       4
       6
        
       ///

     

       5
       7
        
       /// Handles the resolution of atProto handles to their Personal Data

     
···

       8
       10
        
       /// redirect them to THEIR PDS's OAuth server.

     

       9
       11
        
       ///

     

       10
       12
        
       /// Flow:

     

       11
       11
       -
       /// 1. Resolve handle to DID using a handle resolver (bsky.social)

     

       13
       13
       +
       /// 1. Resolve handle to DID using a handle resolver

     

       12
       14
        
       /// 2. Fetch the DID document from the PLC directory

     

       13
       15
        
       /// 3. Extract the PDS endpoint from the service array

     

       14
       16
        
       /// 4. Return the PDS URL for OAuth discovery

     

       15
       17
        
       class PDSDiscoveryService {

     

       18
       18
       +
         PDSDiscoveryService({EnvironmentConfig? config})

     

       19
       19
       +
             : _config = config ?? EnvironmentConfig.current;

     

       20
       20
       +
       

     

       16
       21
        
         final Dio _dio = Dio();

     

       22
       22
       +
         final EnvironmentConfig _config;

     

       17
       23
        
       

     

       18
       24
        
         /// Discover the PDS URL for a given atProto handle

     

       19
       25
        
         ///

     
···

       41
       47
        
       

     

       42
       48
        
         /// Resolve an atProto handle to a DID

     

       43
       49
        
         ///

     

       44
       44
       -
         /// Uses Bluesky's public resolver which can resolve ANY atProto handle,

     

       45
       45
       -
         /// not just bsky.social handles.

     

       50
       50
       +
         /// Uses configured handle resolver (production: Bluesky, local: your PDS)

     

       46
       51
        
         Future<String> _resolveHandle(String handle) async {

     

       47
       52
        
           try {

     

       48
       53
        
             final response = await _dio.get(

     

       49
       49
       -
               'https://bsky.social/xrpc/com.atproto.identity.resolveHandle',

     

       54
       54
       +
               _config.handleResolverUrl,

     

       50
       55
        
               queryParameters: {'handle': handle},

     

       51
       56
        
             );

     

       52
       57
        
       

     
···

       68
       73
        
         /// Fetch a DID document from the PLC directory

     

       69
       74
        
         Future<Map<String, dynamic>> _fetchDIDDocument(String did) async {

     

       70
       75
        
           try {

     

       71
       71
       -
             final response = await _dio.get('https://plc.directory/$did');

     

       76
       76
       +
             final response = await _dio.get('${_config.plcDirectoryUrl}/$did');

     

       72
       77
        
       

     

       73
       78
        
             if (response.statusCode != 200) {

     

       74
       79
        
               throw Exception('Failed to fetch DID document: ${response.statusCode}');

+365

lib/services/vote_service.dart

···

       1
       1
       +
       import 'dart:convert';

     

       2
       2
       +
       

     

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

     

       4
       4
       +
       import 'package:flutter/foundation.dart';

     

       5
       5
       +
       

     

       6
       6
       +
       import 'api_exceptions.dart';

     

       7
       7
       +
       

     

       8
       8
       +
       /// Vote Service

     

       9
       9
       +
       ///

     

       10
       10
       +
       /// Handles vote/like interactions by writing directly to the user's PDS.

     

       11
       11
       +
       /// This follows the atProto architecture where clients write to PDSs and

     

       12
       12
       +
       /// AppViews only index public data.

     

       13
       13
       +
       ///

     

       14
       14
       +
       /// **Correct Architecture**:

     

       15
       15
       +
       /// Mobile Client → User's PDS (com.atproto.repo.createRecord)

     

       16
       16
       +
       ///              ↓

     

       17
       17
       +
       ///          Jetstream

     

       18
       18
       +
       ///              ↓

     

       19
       19
       +
       /// Backend AppView (indexes vote events)

     

       20
       20
       +
       ///

     

       21
       21
       +
       /// Uses these XRPC endpoints:

     

       22
       22
       +
       /// - com.atproto.repo.createRecord (create vote)

     

       23
       23
       +
       /// - com.atproto.repo.deleteRecord (delete vote)

     

       24
       24
       +
       /// - com.atproto.repo.listRecords (find existing votes)

     

       25
       25
       +
       ///

     

       26
       26
       +
       /// **DPoP Authentication**:

     

       27
       27
       +
       /// atProto PDSs require DPoP (Demonstrating Proof of Possession) authentication.

     

       28
       28
       +
       /// Uses OAuthSession.fetchHandler which automatically handles:

     

       29
       29
       +
       /// - Authorization: DPoP <access_token>

     

       30
       30
       +
       /// - DPoP: <proof> (signed JWT proving key possession)

     

       31
       31
       +
       /// - Automatic token refresh on expiry

     

       32
       32
       +
       /// - Nonce management for replay protection

     

       33
       33
       +
       class VoteService {

     

       34
       34
       +
         VoteService({

     

       35
       35
       +
           Future<OAuthSession?> Function()? sessionGetter,

     

       36
       36
       +
           String? Function()? didGetter,

     

       37
       37
       +
           String? Function()? pdsUrlGetter,

     

       38
       38
       +
         })  : _sessionGetter = sessionGetter,

     

       39
       39
       +
               _didGetter = didGetter,

     

       40
       40
       +
               _pdsUrlGetter = pdsUrlGetter;

     

       41
       41
       +
       

     

       42
       42
       +
         final Future<OAuthSession?> Function()? _sessionGetter;

     

       43
       43
       +
         final String? Function()? _didGetter;

     

       44
       44
       +
         final String? Function()? _pdsUrlGetter;

     

       45
       45
       +
       

     

       46
       46
       +
         /// Collection name for vote records

     

       47
       47
       +
         static const String voteCollection = 'social.coves.interaction.vote';

     

       48
       48
       +
       

     

       49
       49
       +
         /// Create or toggle vote

     

       50
       50
       +
         ///

     

       51
       51
       +
         /// Implements smart toggle logic:

     

       52
       52
       +
         /// 1. Query PDS for existing vote on this post

     

       53
       53
       +
         /// 2. If exists with same direction → Delete (toggle off)

     

       54
       54
       +
         /// 3. If exists with different direction → Delete old + Create new

     

       55
       55
       +
         /// 4. If no existing vote → Create new

     

       56
       56
       +
         ///

     

       57
       57
       +
         /// Parameters:

     

       58
       58
       +
         /// - [postUri]: AT-URI of the post (e.g.,

     

       59
       59
       +
         ///   "at://did:plc:xyz/social.coves.post.record/abc123")

     

       60
       60
       +
         /// - [postCid]: Content ID of the post (for strong reference)

     

       61
       61
       +
         /// - [direction]: Vote direction - "up" for like/upvote, "down" for downvote

     

       62
       62
       +
         ///

     

       63
       63
       +
         /// Returns:

     

       64
       64
       +
         /// - VoteResponse with uri/cid/rkey if created

     

       65
       65
       +
         /// - VoteResponse with deleted=true if toggled off

     

       66
       66
       +
         ///

     

       67
       67
       +
         /// Throws:

     

       68
       68
       +
         /// - ApiException for API errors

     

       69
       69
       +
         Future<VoteResponse> createVote({

     

       70
       70
       +
           required String postUri,

     

       71
       71
       +
           required String postCid,

     

       72
       72
       +
           String direction = 'up',

     

       73
       73
       +
         }) async {

     

       74
       74
       +
           try {

     

       75
       75
       +
             // Get user's DID and PDS URL

     

       76
       76
       +
             final userDid = _didGetter?.call();

     

       77
       77
       +
             final pdsUrl = _pdsUrlGetter?.call();

     

       78
       78
       +
       

     

       79
       79
       +
             if (userDid == null || userDid.isEmpty) {

     

       80
       80
       +
               throw ApiException('User not authenticated - no DID available');

     

       81
       81
       +
             }

     

       82
       82
       +
       

     

       83
       83
       +
             if (pdsUrl == null || pdsUrl.isEmpty) {

     

       84
       84
       +
               throw ApiException('PDS URL not available');

     

       85
       85
       +
             }

     

       86
       86
       +
       

     

       87
       87
       +
             if (kDebugMode) {

     

       88
       88
       +
               debugPrint('🗳️  Creating vote on PDS');

     

       89
       89
       +
               debugPrint('   Post: $postUri');

     

       90
       90
       +
               debugPrint('   Direction: $direction');

     

       91
       91
       +
               debugPrint('   PDS: $pdsUrl');

     

       92
       92
       +
             }

     

       93
       93
       +
       

     

       94
       94
       +
             // Step 1: Check for existing vote

     

       95
       95
       +
             final existingVote = await _findExistingVote(

     

       96
       96
       +
               userDid: userDid,

     

       97
       97
       +
               postUri: postUri,

     

       98
       98
       +
             );

     

       99
       99
       +
       

     

       100
       100
       +
             if (existingVote != null) {

     

       101
       101
       +
               if (kDebugMode) {

     

       102
       102
       +
                 debugPrint('   Found existing vote: ${existingVote.direction}');

     

       103
       103
       +
               }

     

       104
       104
       +
       

     

       105
       105
       +
               // If same direction, toggle off (delete)

     

       106
       106
       +
               if (existingVote.direction == direction) {

     

       107
       107
       +
                 if (kDebugMode) {

     

       108
       108
       +
                   debugPrint('   Same direction - deleting vote');

     

       109
       109
       +
                 }

     

       110
       110
       +
                 await _deleteVote(

     

       111
       111
       +
                   userDid: userDid,

     

       112
       112
       +
                   rkey: existingVote.rkey,

     

       113
       113
       +
                 );

     

       114
       114
       +
                 return const VoteResponse(deleted: true);

     

       115
       115
       +
               }

     

       116
       116
       +
       

     

       117
       117
       +
               // Different direction - delete old vote first

     

       118
       118
       +
               if (kDebugMode) {

     

       119
       119
       +
                 debugPrint('   Different direction - switching vote');

     

       120
       120
       +
               }

     

       121
       121
       +
               await _deleteVote(

     

       122
       122
       +
                 userDid: userDid,

     

       123
       123
       +
                 rkey: existingVote.rkey,

     

       124
       124
       +
               );

     

       125
       125
       +
             }

     

       126
       126
       +
       

     

       127
       127
       +
             // Step 2: Create new vote

     

       128
       128
       +
             final response = await _createVote(

     

       129
       129
       +
               userDid: userDid,

     

       130
       130
       +
               postUri: postUri,

     

       131
       131
       +
               postCid: postCid,

     

       132
       132
       +
               direction: direction,

     

       133
       133
       +
             );

     

       134
       134
       +
       

     

       135
       135
       +
             if (kDebugMode) {

     

       136
       136
       +
               debugPrint('✅ Vote created: ${response.uri}');

     

       137
       137
       +
             }

     

       138
       138
       +
       

     

       139
       139
       +
             return response;

     

       140
       140
       +
           } catch (e) {

     

       141
       141
       +
             throw ApiException('Failed to create vote: $e');

     

       142
       142
       +
           }

     

       143
       143
       +
         }

     

       144
       144
       +
       

     

       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.

     

       151
       151
       +
         ///

     

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

     

       153
       153
       +
         Future<ExistingVote?> _findExistingVote({

     

       154
       154
       +
           required String userDid,

     

       155
       155
       +
           required String postUri,

     

       156
       156
       +
         }) async {

     

       157
       157
       +
           try {

     

       158
       158
       +
             final session = await _sessionGetter?.call();

     

       159
       159
       +
             if (session == null) {

     

       160
       160
       +
               return null;

     

       161
       161
       +
             }

     

       162
       162
       +
       

     

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

     

       164
       164
       +
             String? cursor;

     

       165
       165
       +
             const pageSize = 100;

     

       166
       166
       +
       

     

       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;

     

       180
       180
       +
               }

     

       181
       181
       +
       

     

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

     

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

     

       184
       184
       +
       

     

       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>?;

     

       190
       190
       +
       

     

       191
       191
       +
                   if (value == null) {

     

       192
       192
       +
                     continue;

     

       193
       193
       +
                   }

     

       194
       194
       +
       

     

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

     

       196
       196
       +
                   if (subject == null) {

     

       197
       197
       +
                     continue;

     

       198
       198
       +
                   }

     

       199
       199
       +
       

     

       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;

     

       205
       205
       +
       

     

       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;

     

       209
       209
       +
       

     

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

     

       211
       211
       +
                   }

     

       212
       212
       +
                 }

     

       213
       213
       +
               }

     

       214
       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

     

       220
       220
       +
             return null;

     

       221
       221
       +
           } catch (e) {

     

       222
       222
       +
             if (kDebugMode) {

     

       223
       223
       +
               debugPrint('⚠️  Failed to list votes: $e');

     

       224
       224
       +
             }

     

       225
       225
       +
             // Return null on error - assume no existing vote

     

       226
       226
       +
             return null;

     

       227
       227
       +
           }

     

       228
       228
       +
         }

     

       229
       229
       +
       

     

       230
       230
       +
         /// Create vote record on PDS

     

       231
       231
       +
         ///

     

       232
       232
       +
         /// Calls com.atproto.repo.createRecord with the vote record.

     

       233
       233
       +
         Future<VoteResponse> _createVote({

     

       234
       234
       +
           required String userDid,

     

       235
       235
       +
           required String postUri,

     

       236
       236
       +
           required String postCid,

     

       237
       237
       +
           required String direction,

     

       238
       238
       +
         }) async {

     

       239
       239
       +
           final session = await _sessionGetter?.call();

     

       240
       240
       +
           if (session == null) {

     

       241
       241
       +
             throw ApiException('User not authenticated - no session available');

     

       242
       242
       +
           }

     

       243
       243
       +
       

     

       244
       244
       +
           // Build the vote record according to the lexicon

     

       245
       245
       +
           final record = {

     

       246
       246
       +
             r'$type': voteCollection,

     

       247
       247
       +
             'subject': {

     

       248
       248
       +
               'uri': postUri,

     

       249
       249
       +
               'cid': postCid,

     

       250
       250
       +
             },

     

       251
       251
       +
             'direction': direction,

     

       252
       252
       +
             'createdAt': DateTime.now().toUtc().toIso8601String(),

     

       253
       253
       +
           };

     

       254
       254
       +
       

     

       255
       255
       +
           final requestBody = jsonEncode({

     

       256
       256
       +
             'repo': userDid,

     

       257
       257
       +
             'collection': voteCollection,

     

       258
       258
       +
             'record': record,

     

       259
       259
       +
           });

     

       260
       260
       +
       

     

       261
       261
       +
           // Use session's fetchHandler for DPoP-authenticated request

     

       262
       262
       +
           final response = await session.fetchHandler(

     

       263
       263
       +
             '/xrpc/com.atproto.repo.createRecord',

     

       264
       264
       +
             method: 'POST',

     

       265
       265
       +
             headers: {'Content-Type': 'application/json'},

     

       266
       266
       +
             body: requestBody,

     

       267
       267
       +
           );

     

       268
       268
       +
       

     

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

     

       270
       270
       +
             throw ApiException(

     

       271
       271
       +
               'Failed to create vote: ${response.statusCode} - ${response.body}',

     

       272
       272
       +
               statusCode: response.statusCode,

     

       273
       273
       +
             );

     

       274
       274
       +
           }

     

       275
       275
       +
       

     

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

     

       277
       277
       +
           final uri = data['uri'] as String?;

     

       278
       278
       +
           final cid = data['cid'] as String?;

     

       279
       279
       +
       

     

       280
       280
       +
           if (uri == null || cid == null) {

     

       281
       281
       +
             throw ApiException('Invalid response from PDS - missing uri or cid');

     

       282
       282
       +
           }

     

       283
       283
       +
       

     

       284
       284
       +
           // Extract rkey from URI

     

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

     

       286
       286
       +
       

     

       287
       287
       +
           return VoteResponse(

     

       288
       288
       +
             uri: uri,

     

       289
       289
       +
             cid: cid,

     

       290
       290
       +
             rkey: rkey,

     

       291
       291
       +
             deleted: false,

     

       292
       292
       +
           );

     

       293
       293
       +
         }

     

       294
       294
       +
       

     

       295
       295
       +
         /// Delete vote record from PDS

     

       296
       296
       +
         ///

     

       297
       297
       +
         /// Calls com.atproto.repo.deleteRecord to remove the vote.

     

       298
       298
       +
         Future<void> _deleteVote({

     

       299
       299
       +
           required String userDid,

     

       300
       300
       +
           required String rkey,

     

       301
       301
       +
         }) async {

     

       302
       302
       +
           final session = await _sessionGetter?.call();

     

       303
       303
       +
           if (session == null) {

     

       304
       304
       +
             throw ApiException('User not authenticated - no session available');

     

       305
       305
       +
           }

     

       306
       306
       +
       

     

       307
       307
       +
           final requestBody = jsonEncode({

     

       308
       308
       +
             'repo': userDid,

     

       309
       309
       +
             'collection': voteCollection,

     

       310
       310
       +
             'rkey': rkey,

     

       311
       311
       +
           });

     

       312
       312
       +
       

     

       313
       313
       +
           // Use session's fetchHandler for DPoP-authenticated request

     

       314
       314
       +
           final response = await session.fetchHandler(

     

       315
       315
       +
             '/xrpc/com.atproto.repo.deleteRecord',

     

       316
       316
       +
             method: 'POST',

     

       317
       317
       +
             headers: {'Content-Type': 'application/json'},

     

       318
       318
       +
             body: requestBody,

     

       319
       319
       +
           );

     

       320
       320
       +
       

     

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

     

       322
       322
       +
             throw ApiException(

     

       323
       323
       +
               'Failed to delete vote: ${response.statusCode} - ${response.body}',

     

       324
       324
       +
               statusCode: response.statusCode,

     

       325
       325
       +
             );

     

       326
       326
       +
           }

     

       327
       327
       +
         }

     

       328
       328
       +
       }

     

       329
       329
       +
       

     

       330
       330
       +
       /// Vote Response

     

       331
       331
       +
       ///

     

       332
       332
       +
       /// Response from createVote operation.

     

       333
       333
       +
       class VoteResponse {

     

       334
       334
       +
         const VoteResponse({

     

       335
       335
       +
           this.uri,

     

       336
       336
       +
           this.cid,

     

       337
       337
       +
           this.rkey,

     

       338
       338
       +
           required this.deleted,

     

       339
       339
       +
         });

     

       340
       340
       +
       

     

       341
       341
       +
         /// AT-URI of the created vote record

     

       342
       342
       +
         final String? uri;

     

       343
       343
       +
       

     

       344
       344
       +
         /// Content ID of the vote record

     

       345
       345
       +
         final String? cid;

     

       346
       346
       +
       

     

       347
       347
       +
         /// Record key (rkey) of the vote - last segment of URI

     

       348
       348
       +
         final String? rkey;

     

       349
       349
       +
       

     

       350
       350
       +
         /// Whether the vote was deleted (toggled off)

     

       351
       351
       +
         final bool deleted;

     

       352
       352
       +
       }

     

       353
       353
       +
       

     

       354
       354
       +
       /// Existing Vote

     

       355
       355
       +
       ///

     

       356
       356
       +
       /// Represents a vote that already exists on the PDS.

     

       357
       357
       +
       class ExistingVote {

     

       358
       358
       +
         const ExistingVote({required this.direction, required this.rkey});

     

       359
       359
       +
       

     

       360
       360
       +
         /// Vote direction ("up" or "down")

     

       361
       361
       +
         final String direction;

     

       362
       362
       +
       

     

       363
       363
       +
         /// Record key for deletion

     

       364
       364
       +
         final String rkey;

     

       365
       365
       +
       }

+328

lib/widgets/icons/animated_heart_icon.dart

···

       1
       1
       +
       import 'dart:math' as math;

     

       2
       2
       +
       

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       /// Animated heart icon with outline and filled states

     

       6
       6
       +
       ///

     

       7
       7
       +
       /// Features a dramatic animation sequence:

     

       8
       8
       +
       /// 1. Heart shrinks to nothing

     

       9
       9
       +
       /// 2. Red hollow circle expands outwards

     

       10
       10
       +
       /// 3. Small heart grows from center

     

       11
       11
       +
       /// 4. Heart pops to 1.3x with 7 particle dots

     

       12
       12
       +
       /// 5. Heart settles back to 1x filled

     

       13
       13
       +
       class AnimatedHeartIcon extends StatefulWidget {

     

       14
       14
       +
         const AnimatedHeartIcon({

     

       15
       15
       +
           required this.isLiked,

     

       16
       16
       +
           this.size = 18,

     

       17
       17
       +
           this.color,

     

       18
       18
       +
           this.likedColor,

     

       19
       19
       +
           super.key,

     

       20
       20
       +
         });

     

       21
       21
       +
       

     

       22
       22
       +
         final bool isLiked;

     

       23
       23
       +
         final double size;

     

       24
       24
       +
         final Color? color;

     

       25
       25
       +
         final Color? likedColor;

     

       26
       26
       +
       

     

       27
       27
       +
         @override

     

       28
       28
       +
         State<AnimatedHeartIcon> createState() => _AnimatedHeartIconState();

     

       29
       29
       +
       }

     

       30
       30
       +
       

     

       31
       31
       +
       class _AnimatedHeartIconState extends State<AnimatedHeartIcon>

     

       32
       32
       +
           with SingleTickerProviderStateMixin {

     

       33
       33
       +
         late AnimationController _controller;

     

       34
       34
       +
       

     

       35
       35
       +
         // Heart scale animations

     

       36
       36
       +
         late Animation<double> _heartShrinkAnimation;

     

       37
       37
       +
         late Animation<double> _heartGrowAnimation;

     

       38
       38
       +
         late Animation<double> _heartPopAnimation;

     

       39
       39
       +
       

     

       40
       40
       +
         // Hollow circle animation

     

       41
       41
       +
         late Animation<double> _circleScaleAnimation;

     

       42
       42
       +
         late Animation<double> _circleOpacityAnimation;

     

       43
       43
       +
       

     

       44
       44
       +
         // Particle burst animations

     

       45
       45
       +
         late Animation<double> _particleScaleAnimation;

     

       46
       46
       +
         late Animation<double> _particleOpacityAnimation;

     

       47
       47
       +
       

     

       48
       48
       +
         bool _hasBeenToggled = false;

     

       49
       49
       +
         bool _previousIsLiked = false;

     

       50
       50
       +
       

     

       51
       51
       +
         @override

     

       52
       52
       +
         void initState() {

     

       53
       53
       +
           super.initState();

     

       54
       54
       +
           _previousIsLiked = widget.isLiked;

     

       55
       55
       +
       

     

       56
       56
       +
           _controller = AnimationController(

     

       57
       57
       +
             duration: const Duration(milliseconds: 800),

     

       58
       58
       +
             vsync: this,

     

       59
       59
       +
           );

     

       60
       60
       +
       

     

       61
       61
       +
           // Phase 1 (0-15%): Heart shrinks to nothing

     

       62
       62
       +
           _heartShrinkAnimation = Tween<double>(begin: 1, end: 0).animate(

     

       63
       63
       +
             CurvedAnimation(

     

       64
       64
       +
               parent: _controller,

     

       65
       65
       +
               curve: const Interval(0, 0.15, curve: Curves.easeIn),

     

       66
       66
       +
             ),

     

       67
       67
       +
           );

     

       68
       68
       +
       

     

       69
       69
       +
           // Phase 2 (15-40%): Hollow circle expands

     

       70
       70
       +
           _circleScaleAnimation = Tween<double>(begin: 0, end: 2).animate(

     

       71
       71
       +
             CurvedAnimation(

     

       72
       72
       +
               parent: _controller,

     

       73
       73
       +
               curve: const Interval(0.15, 0.4, curve: Curves.easeOut),

     

       74
       74
       +
             ),

     

       75
       75
       +
           );

     

       76
       76
       +
       

     

       77
       77
       +
           _circleOpacityAnimation = TweenSequence<double>([

     

       78
       78
       +
             TweenSequenceItem(tween: Tween(begin: 0, end: 0.8), weight: 50),

     

       79
       79
       +
             TweenSequenceItem(tween: Tween(begin: 0.8, end: 0), weight: 50),

     

       80
       80
       +
           ]).animate(

     

       81
       81
       +
             CurvedAnimation(parent: _controller, curve: const Interval(0.15, 0.4)),

     

       82
       82
       +
           );

     

       83
       83
       +
       

     

       84
       84
       +
           // Phase 3 (25-55%): Heart grows from small in center

     

       85
       85
       +
           _heartGrowAnimation = Tween<double>(begin: 0.2, end: 1.3).animate(

     

       86
       86
       +
             CurvedAnimation(

     

       87
       87
       +
               parent: _controller,

     

       88
       88
       +
               curve: const Interval(0.25, 0.55, curve: Curves.easeOut),

     

       89
       89
       +
             ),

     

       90
       90
       +
           );

     

       91
       91
       +
       

     

       92
       92
       +
           // Phase 4 (55-65%): Particle burst at peak

     

       93
       93
       +
           _particleScaleAnimation = Tween<double>(begin: 0, end: 1).animate(

     

       94
       94
       +
             CurvedAnimation(

     

       95
       95
       +
               parent: _controller,

     

       96
       96
       +
               curve: const Interval(0.55, 0.65, curve: Curves.easeOut),

     

       97
       97
       +
             ),

     

       98
       98
       +
           );

     

       99
       99
       +
       

     

       100
       100
       +
           _particleOpacityAnimation = TweenSequence<double>([

     

       101
       101
       +
             TweenSequenceItem(tween: Tween(begin: 0, end: 1), weight: 30),

     

       102
       102
       +
             TweenSequenceItem(tween: Tween(begin: 1, end: 0), weight: 70),

     

       103
       103
       +
           ]).animate(

     

       104
       104
       +
             CurvedAnimation(parent: _controller, curve: const Interval(0.55, 0.75)),

     

       105
       105
       +
           );

     

       106
       106
       +
       

     

       107
       107
       +
           // Phase 5 (65-100%): Heart settles to 1x

     

       108
       108
       +
           _heartPopAnimation = Tween<double>(begin: 1.3, end: 1).animate(

     

       109
       109
       +
             CurvedAnimation(

     

       110
       110
       +
               parent: _controller,

     

       111
       111
       +
               curve: const Interval(0.65, 1, curve: Curves.elasticOut),

     

       112
       112
       +
             ),

     

       113
       113
       +
           );

     

       114
       114
       +
         }

     

       115
       115
       +
       

     

       116
       116
       +
         @override

     

       117
       117
       +
         void didUpdateWidget(AnimatedHeartIcon oldWidget) {

     

       118
       118
       +
           super.didUpdateWidget(oldWidget);

     

       119
       119
       +
       

     

       120
       120
       +
           if (widget.isLiked != _previousIsLiked) {

     

       121
       121
       +
             _hasBeenToggled = true;

     

       122
       122
       +
             _previousIsLiked = widget.isLiked;

     

       123
       123
       +
       

     

       124
       124
       +
             if (widget.isLiked && mounted) {

     

       125
       125
       +
               _controller.forward(from: 0);

     

       126
       126
       +
             }

     

       127
       127
       +
           }

     

       128
       128
       +
         }

     

       129
       129
       +
       

     

       130
       130
       +
         @override

     

       131
       131
       +
         void dispose() {

     

       132
       132
       +
           _controller.dispose();

     

       133
       133
       +
           super.dispose();

     

       134
       134
       +
         }

     

       135
       135
       +
       

     

       136
       136
       +
         double _getHeartScale() {

     

       137
       137
       +
           if (!widget.isLiked || !_hasBeenToggled) {

     

       138
       138
       +
             return 1;

     

       139
       139
       +
           }

     

       140
       140
       +
       

     

       141
       141
       +
           final progress = _controller.value;

     

       142
       142
       +
           if (progress < 0.15) {

     

       143
       143
       +
             // Phase 1: Shrinking

     

       144
       144
       +
             return _heartShrinkAnimation.value;

     

       145
       145
       +
           } else if (progress < 0.55) {

     

       146
       146
       +
             // Phase 3: Growing from center

     

       147
       147
       +
             return _heartGrowAnimation.value;

     

       148
       148
       +
           } else {

     

       149
       149
       +
             // Phase 5: Settling back

     

       150
       150
       +
             return _heartPopAnimation.value;

     

       151
       151
       +
           }

     

       152
       152
       +
         }

     

       153
       153
       +
       

     

       154
       154
       +
         @override

     

       155
       155
       +
         Widget build(BuildContext context) {

     

       156
       156
       +
           final effectiveColor =

     

       157
       157
       +
               widget.color ?? Theme.of(context).iconTheme.color ?? Colors.grey;

     

       158
       158
       +
           final effectiveLikedColor = widget.likedColor ?? Colors.red;

     

       159
       159
       +
       

     

       160
       160
       +
           // Use 2.5x size for animation overflow space (for 1.3x scale + particles)

     

       161
       161
       +
           final containerSize = widget.size * 2.5;

     

       162
       162
       +
       

     

       163
       163
       +
           return SizedBox(

     

       164
       164
       +
             width: widget.size,

     

       165
       165
       +
             height: widget.size,

     

       166
       166
       +
             child: OverflowBox(

     

       167
       167
       +
               maxWidth: containerSize,

     

       168
       168
       +
               maxHeight: containerSize,

     

       169
       169
       +
               child: SizedBox(

     

       170
       170
       +
                 width: containerSize,

     

       171
       171
       +
                 height: containerSize,

     

       172
       172
       +
                 child: AnimatedBuilder(

     

       173
       173
       +
                   animation: _controller,

     

       174
       174
       +
                   builder: (context, child) {

     

       175
       175
       +
                     return Stack(

     

       176
       176
       +
                       clipBehavior: Clip.none,

     

       177
       177
       +
                       alignment: Alignment.center,

     

       178
       178
       +
                       children: [

     

       179
       179
       +
                         // Phase 2: Expanding hollow circle

     

       180
       180
       +
                         if (widget.isLiked &&

     

       181
       181
       +
                             _hasBeenToggled &&

     

       182
       182
       +
                             _controller.value >= 0.15 &&

     

       183
       183
       +
                             _controller.value <= 0.4) ...[

     

       184
       184
       +
                           Opacity(

     

       185
       185
       +
                             opacity: _circleOpacityAnimation.value,

     

       186
       186
       +
                             child: Transform.scale(

     

       187
       187
       +
                               scale: _circleScaleAnimation.value,

     

       188
       188
       +
                               child: Container(

     

       189
       189
       +
                                 width: widget.size,

     

       190
       190
       +
                                 height: widget.size,

     

       191
       191
       +
                                 decoration: BoxDecoration(

     

       192
       192
       +
                                   shape: BoxShape.circle,

     

       193
       193
       +
                                   border: Border.all(

     

       194
       194
       +
                                     color: effectiveLikedColor,

     

       195
       195
       +
                                     width: 2,

     

       196
       196
       +
                                   ),

     

       197
       197
       +
                                 ),

     

       198
       198
       +
                               ),

     

       199
       199
       +
                             ),

     

       200
       200
       +
                           ),

     

       201
       201
       +
                         ],

     

       202
       202
       +
       

     

       203
       203
       +
                         // Phase 4: Particle burst (7 dots)

     

       204
       204
       +
                         if (widget.isLiked &&

     

       205
       205
       +
                             _hasBeenToggled &&

     

       206
       206
       +
                             _controller.value >= 0.55 &&

     

       207
       207
       +
                             _controller.value <= 0.75)

     

       208
       208
       +
                           ..._buildParticleBurst(effectiveLikedColor),

     

       209
       209
       +
       

     

       210
       210
       +
                         // Heart icon (all phases)

     

       211
       211
       +
                         Transform.scale(

     

       212
       212
       +
                           scale: _getHeartScale(),

     

       213
       213
       +
                           child: CustomPaint(

     

       214
       214
       +
                             size: Size(widget.size, widget.size),

     

       215
       215
       +
                             painter: _HeartIconPainter(

     

       216
       216
       +
                               color:

     

       217
       217
       +
                                   widget.isLiked

     

       218
       218
       +
                                       ? effectiveLikedColor

     

       219
       219
       +
                                       : effectiveColor,

     

       220
       220
       +
                               filled: widget.isLiked,

     

       221
       221
       +
                             ),

     

       222
       222
       +
                           ),

     

       223
       223
       +
                         ),

     

       224
       224
       +
                       ],

     

       225
       225
       +
                     );

     

       226
       226
       +
                   },

     

       227
       227
       +
                 ),

     

       228
       228
       +
               ),

     

       229
       229
       +
             ),

     

       230
       230
       +
           );

     

       231
       231
       +
         }

     

       232
       232
       +
       

     

       233
       233
       +
         List<Widget> _buildParticleBurst(Color color) {

     

       234
       234
       +
           const particleCount = 7;

     

       235
       235
       +
           final particles = <Widget>[];

     

       236
       236
       +
           final containerSize = widget.size * 2.5;

     

       237
       237
       +
       

     

       238
       238
       +
           for (var i = 0; i < particleCount; i++) {

     

       239
       239
       +
             final angle = (2 * math.pi * i) / particleCount;

     

       240
       240
       +
             final distance = widget.size * 1 * _particleScaleAnimation.value;

     

       241
       241
       +
             final dx = math.cos(angle) * distance;

     

       242
       242
       +
             final dy = math.sin(angle) * distance;

     

       243
       243
       +
       

     

       244
       244
       +
             particles.add(

     

       245
       245
       +
               Positioned(

     

       246
       246
       +
                 left: containerSize / 2 + dx - 2,

     

       247
       247
       +
                 top: containerSize / 2 + dy - 2,

     

       248
       248
       +
                 child: Opacity(

     

       249
       249
       +
                   opacity: _particleOpacityAnimation.value,

     

       250
       250
       +
                   child: Container(

     

       251
       251
       +
                     width: 2,

     

       252
       252
       +
                     height: 2,

     

       253
       253
       +
                     decoration: BoxDecoration(color: color, shape: BoxShape.circle),

     

       254
       254
       +
                   ),

     

       255
       255
       +
                 ),

     

       256
       256
       +
               ),

     

       257
       257
       +
             );

     

       258
       258
       +
           }

     

       259
       259
       +
       

     

       260
       260
       +
           return particles;

     

       261
       261
       +
         }

     

       262
       262
       +
       }

     

       263
       263
       +
       

     

       264
       264
       +
       /// Custom painter for heart icon

     

       265
       265
       +
       ///

     

       266
       266
       +
       /// SVG path data from Bluesky's Heart2 icon component

     

       267
       267
       +
       class _HeartIconPainter extends CustomPainter {

     

       268
       268
       +
         _HeartIconPainter({required this.color, required this.filled});

     

       269
       269
       +
       

     

       270
       270
       +
         final Color color;

     

       271
       271
       +
         final bool filled;

     

       272
       272
       +
       

     

       273
       273
       +
         @override

     

       274
       274
       +
         void paint(Canvas canvas, Size size) {

     

       275
       275
       +
           final paint =

     

       276
       276
       +
               Paint()

     

       277
       277
       +
                 ..color = color

     

       278
       278
       +
                 ..style = PaintingStyle.fill;

     

       279
       279
       +
       

     

       280
       280
       +
           // Scale factor to fit 24x24 viewBox into widget size

     

       281
       281
       +
           final scale = size.width / 24;

     

       282
       282
       +
           canvas.scale(scale);

     

       283
       283
       +
       

     

       284
       284
       +
           final path = Path();

     

       285
       285
       +
       

     

       286
       286
       +
           if (filled) {

     

       287
       287
       +
             // Filled heart path from Bluesky

     

       288
       288
       +
             path

     

       289
       289
       +
               ..moveTo(12.489, 21.372)

     

       290
       290
       +
               ..cubicTo(21.017, 16.592, 23.115, 10.902, 21.511, 6.902)

     

       291
       291
       +
               ..cubicTo(20.732, 4.961, 19.097, 3.569, 17.169, 3.139)

     

       292
       292
       +
               ..cubicTo(15.472, 2.761, 13.617, 3.142, 12, 4.426)

     

       293
       293
       +
               ..cubicTo(10.383, 3.142, 8.528, 2.761, 6.83, 3.139)

     

       294
       294
       +
               ..cubicTo(4.903, 3.569, 3.268, 4.961, 2.49, 6.903)

     

       295
       295
       +
               ..cubicTo(0.885, 10.903, 2.983, 16.593, 11.511, 21.373)

     

       296
       296
       +
               ..cubicTo(11.826, 21.558, 12.174, 21.558, 12.489, 21.372)

     

       297
       297
       +
               ..close();

     

       298
       298
       +
           } else {

     

       299
       299
       +
             // Outline heart path from Bluesky

     

       300
       300
       +
             path

     

       301
       301
       +
               ..moveTo(16.734, 5.091)

     

       302
       302
       +
               ..cubicTo(15.496, 4.815, 14.026, 5.138, 12.712, 6.471)

     

       303
       303
       +
               ..cubicTo(12.318, 6.865, 11.682, 6.865, 11.288, 6.471)

     

       304
       304
       +
               ..cubicTo(9.974, 5.137, 8.504, 4.814, 7.266, 5.09)

     

       305
       305
       +
               ..cubicTo(6.003, 5.372, 4.887, 6.296, 4.346, 7.646)

     

       306
       306
       +
               ..cubicTo(3.33, 10.18, 4.252, 14.84, 12, 19.348)

     

       307
       307
       +
               ..cubicTo(19.747, 14.84, 20.67, 10.18, 19.654, 7.648)

     

       308
       308
       +
               ..cubicTo(19.113, 6.297, 17.997, 5.373, 16.734, 5.091)

     

       309
       309
       +
               ..close()

     

       310
       310
       +
               ..moveTo(21.511, 6.903)

     

       311
       311
       +
               ..cubicTo(23.115, 10.903, 21.017, 16.593, 12.489, 21.373)

     

       312
       312
       +
               ..cubicTo(12.174, 21.558, 11.826, 21.558, 11.511, 21.373)

     

       313
       313
       +
               ..cubicTo(2.983, 16.592, 0.885, 10.902, 2.49, 6.902)

     

       314
       314
       +
               ..cubicTo(3.269, 4.96, 4.904, 3.568, 6.832, 3.138)

     

       315
       315
       +
               ..cubicTo(8.529, 2.76, 10.384, 3.141, 12.001, 4.424)

     

       316
       316
       +
               ..cubicTo(13.618, 3.141, 15.473, 2.76, 17.171, 3.138)

     

       317
       317
       +
               ..cubicTo(19.098, 3.568, 20.733, 4.96, 21.511, 6.903)

     

       318
       318
       +
               ..close();

     

       319
       319
       +
           }

     

       320
       320
       +
       

     

       321
       321
       +
           canvas.drawPath(path, paint);

     

       322
       322
       +
         }

     

       323
       323
       +
       

     

       324
       324
       +
         @override

     

       325
       325
       +
         bool shouldRepaint(_HeartIconPainter oldDelegate) {

     

       326
       326
       +
           return oldDelegate.color != color || oldDelegate.filled != filled;

     

       327
       327
       +
         }

     

       328
       328
       +
       }

+117

lib/widgets/icons/reply_icon.dart

···

       1
       1
       +
       import 'package:flutter/material.dart';

     

       2
       2
       +
       

     

       3
       3
       +
       /// Reply/comment icon widget

     

       4
       4
       +
       ///

     

       5
       5
       +
       /// Speech bubble icon from Bluesky's design system.

     

       6
       6
       +
       /// Supports both outline and filled states.

     

       7
       7
       +
       class ReplyIcon extends StatelessWidget {

     

       8
       8
       +
         const ReplyIcon({this.size = 18, this.color, this.filled = false, super.key});

     

       9
       9
       +
       

     

       10
       10
       +
         final double size;

     

       11
       11
       +
         final Color? color;

     

       12
       12
       +
         final bool filled;

     

       13
       13
       +
       

     

       14
       14
       +
         @override

     

       15
       15
       +
         Widget build(BuildContext context) {

     

       16
       16
       +
           final effectiveColor =

     

       17
       17
       +
               color ?? Theme.of(context).iconTheme.color ?? Colors.grey;

     

       18
       18
       +
       

     

       19
       19
       +
           return CustomPaint(

     

       20
       20
       +
             size: Size(size, size),

     

       21
       21
       +
             painter: _ReplyIconPainter(color: effectiveColor, filled: filled),

     

       22
       22
       +
           );

     

       23
       23
       +
         }

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       /// Custom painter for reply/comment icon

     

       27
       27
       +
       ///

     

       28
       28
       +
       /// SVG path data from Bluesky's Reply icon component

     

       29
       29
       +
       class _ReplyIconPainter extends CustomPainter {

     

       30
       30
       +
         _ReplyIconPainter({required this.color, required this.filled});

     

       31
       31
       +
       

     

       32
       32
       +
         final Color color;

     

       33
       33
       +
         final bool filled;

     

       34
       34
       +
       

     

       35
       35
       +
         @override

     

       36
       36
       +
         void paint(Canvas canvas, Size size) {

     

       37
       37
       +
           final paint = Paint()

     

       38
       38
       +
             ..color = color

     

       39
       39
       +
             ..style = PaintingStyle.fill; // Always fill - paths are pre-stroked

     

       40
       40
       +
       

     

       41
       41
       +
           // Scale factor to fit 24x24 viewBox into widget size

     

       42
       42
       +
           final scale = size.width / 24.0;

     

       43
       43
       +
           canvas.scale(scale);

     

       44
       44
       +
       

     

       45
       45
       +
           final path = Path();

     

       46
       46
       +
       

     

       47
       47
       +
           if (filled) {

     

       48
       48
       +
             // Filled reply icon path from Bluesky

     

       49
       49
       +
             // M22.002 15a4 4 0 0 1-4 4h-4.648l-4.727 3.781A1.001 1.001 0 0 1 7.002 22

     

       50
       50
       +
             // v-3h-1a4 4 0 0 1-4-4V7a4 4 0 0 1 4-4h12a4 4 0 0 1 4 4v8Z

     

       51
       51
       +
             path

     

       52
       52
       +
               ..moveTo(22.002, 15)

     

       53
       53
       +
               ..cubicTo(22.002, 17.209, 20.211, 19, 18.002, 19)

     

       54
       54
       +
               ..lineTo(13.354, 19)

     

       55
       55
       +
               ..lineTo(8.627, 22.781)

     

       56
       56
       +
               ..cubicTo(8.243, 23.074, 7.683, 22.808, 7.627, 22.318)

     

       57
       57
       +
               ..lineTo(7.002, 22)

     

       58
       58
       +
               ..lineTo(7.002, 19)

     

       59
       59
       +
               ..lineTo(6.002, 19)

     

       60
       60
       +
               ..cubicTo(3.793, 19, 2.002, 17.209, 2.002, 15)

     

       61
       61
       +
               ..lineTo(2.002, 7)

     

       62
       62
       +
               ..cubicTo(2.002, 4.791, 3.793, 3, 6.002, 3)

     

       63
       63
       +
               ..lineTo(18.002, 3)

     

       64
       64
       +
               ..cubicTo(20.211, 3, 22.002, 4.791, 22.002, 7)

     

       65
       65
       +
               ..lineTo(22.002, 15)

     

       66
       66
       +
               ..close();

     

       67
       67
       +
           } else {

     

       68
       68
       +
             // Outline reply icon path from Bluesky

     

       69
       69
       +
             // M20.002 7a2 2 0 0 0-2-2h-12a2 2 0 0 0-2 2v8a2 2 0 0 0 2 2h2

     

       70
       70
       +
             // a1 1 0 0 1 1 1 v1.918l3.375-2.7a1 1 0 0 1 .625-.218h5

     

       71
       71
       +
             // a2 2 0 0 0 2-2V7Zm2 8a4 4 0 0 1-4 4 h-4.648l-4.727 3.781

     

       72
       72
       +
             // A1.001 1.001 0 0 1 7.002 22v-3h-1a4 4 0 0 1-4-4V7

     

       73
       73
       +
             // a4 4 0 0 1 4-4h12a4 4 0 0 1 4 4v8Z

     

       74
       74
       +
       

     

       75
       75
       +
             // Inner shape

     

       76
       76
       +
             path

     

       77
       77
       +
               ..moveTo(20.002, 7)

     

       78
       78
       +
               ..cubicTo(20.002, 5.895, 19.107, 5, 18.002, 5)

     

       79
       79
       +
               ..lineTo(6.002, 5)

     

       80
       80
       +
               ..cubicTo(4.897, 5, 4.002, 5.895, 4.002, 7)

     

       81
       81
       +
               ..lineTo(4.002, 15)

     

       82
       82
       +
               ..cubicTo(4.002, 16.105, 4.897, 17, 6.002, 17)

     

       83
       83
       +
               ..lineTo(8.002, 17)

     

       84
       84
       +
               ..cubicTo(8.554, 17, 9.002, 17.448, 9.002, 18)

     

       85
       85
       +
               ..lineTo(9.002, 19.918)

     

       86
       86
       +
               ..lineTo(12.377, 17.218)

     

       87
       87
       +
               ..cubicTo(12.574, 17.073, 12.813, 17, 13.002, 17)

     

       88
       88
       +
               ..lineTo(18.002, 17)

     

       89
       89
       +
               ..cubicTo(19.107, 17, 20.002, 16.105, 20.002, 15)

     

       90
       90
       +
               ..lineTo(20.002, 7)

     

       91
       91
       +
               ..close()

     

       92
       92
       +
               // Outer shape

     

       93
       93
       +
               ..moveTo(22.002, 15)

     

       94
       94
       +
               ..cubicTo(22.002, 17.209, 20.211, 19, 18.002, 19)

     

       95
       95
       +
               ..lineTo(13.354, 19)

     

       96
       96
       +
               ..lineTo(8.627, 22.781)

     

       97
       97
       +
               ..cubicTo(8.243, 23.074, 7.683, 22.808, 7.627, 22.318)

     

       98
       98
       +
               ..lineTo(7.002, 22)

     

       99
       99
       +
               ..lineTo(7.002, 19)

     

       100
       100
       +
               ..lineTo(6.002, 19)

     

       101
       101
       +
               ..cubicTo(3.793, 19, 2.002, 17.209, 2.002, 15)

     

       102
       102
       +
               ..lineTo(2.002, 7)

     

       103
       103
       +
               ..cubicTo(2.002, 4.791, 3.793, 3, 6.002, 3)

     

       104
       104
       +
               ..lineTo(18.002, 3)

     

       105
       105
       +
               ..cubicTo(20.211, 3, 22.002, 4.791, 22.002, 7)

     

       106
       106
       +
               ..lineTo(22.002, 15)

     

       107
       107
       +
               ..close();

     

       108
       108
       +
           }

     

       109
       109
       +
       

     

       110
       110
       +
           canvas.drawPath(path, paint);

     

       111
       111
       +
         }

     

       112
       112
       +
       

     

       113
       113
       +
         @override

     

       114
       114
       +
         bool shouldRepaint(_ReplyIconPainter oldDelegate) {

     

       115
       115
       +
           return oldDelegate.color != color || oldDelegate.filled != filled;

     

       116
       116
       +
         }

     

       117
       117
       +
       }

+93

lib/widgets/icons/share_icon.dart

···

       1
       1
       +
       import 'package:flutter/material.dart';

     

       2
       2
       +
       

     

       3
       3
       +
       /// Share icon widget (arrow out of box)

     

       4
       4
       +
       ///

     

       5
       5
       +
       /// Arrow-out-of-box icon from Bluesky's design system.

     

       6
       6
       +
       /// Uses the modified version with rounded corners for a friendlier look.

     

       7
       7
       +
       class ShareIcon extends StatelessWidget {

     

       8
       8
       +
         const ShareIcon({this.size = 18, this.color, super.key});

     

       9
       9
       +
       

     

       10
       10
       +
         final double size;

     

       11
       11
       +
         final Color? color;

     

       12
       12
       +
       

     

       13
       13
       +
         @override

     

       14
       14
       +
         Widget build(BuildContext context) {

     

       15
       15
       +
           final effectiveColor =

     

       16
       16
       +
               color ?? Theme.of(context).iconTheme.color ?? Colors.grey;

     

       17
       17
       +
       

     

       18
       18
       +
           return CustomPaint(

     

       19
       19
       +
             size: Size(size, size),

     

       20
       20
       +
             painter: _ShareIconPainter(color: effectiveColor),

     

       21
       21
       +
           );

     

       22
       22
       +
         }

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       /// Custom painter for share icon

     

       26
       26
       +
       ///

     

       27
       27
       +
       /// SVG path data from Bluesky's ArrowOutOfBoxModified icon component

     

       28
       28
       +
       class _ShareIconPainter extends CustomPainter {

     

       29
       29
       +
         _ShareIconPainter({required this.color});

     

       30
       30
       +
       

     

       31
       31
       +
         final Color color;

     

       32
       32
       +
       

     

       33
       33
       +
         @override

     

       34
       34
       +
         void paint(Canvas canvas, Size size) {

     

       35
       35
       +
           final paint = Paint()

     

       36
       36
       +
             ..color = color

     

       37
       37
       +
             ..style = PaintingStyle.fill; // Always fill - paths are pre-stroked

     

       38
       38
       +
       

     

       39
       39
       +
           // Scale factor to fit 24x24 viewBox into widget size

     

       40
       40
       +
           final scale = size.width / 24.0;

     

       41
       41
       +
           canvas.scale(scale);

     

       42
       42
       +
       

     

       43
       43
       +
           // ArrowOutOfBoxModified_Stroke2_Corner2_Rounded path from Bluesky

     

       44
       44
       +
           // M20 13.75a1 1 0 0 1 1 1V18a3 3 0 0 1-3 3H6a3 3 0 0 1-3-3v-3.25

     

       45
       45
       +
           // a1 1 0 1 1 2 0V18 a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-3.25

     

       46
       46
       +
           // a1 1 0 0 1 1-1ZM12 3a1 1 0 0 1 .707.293 l4.5 4.5

     

       47
       47
       +
           // a1 1 0 1 1-1.414 1.414L13 6.414v8.836a1 1 0 1 1-2 0V6.414

     

       48
       48
       +
           // L8.207 9.207a1 1 0 1 1-1.414-1.414l4.5-4.5A1 1 0 0 1 12 3Z

     

       49
       49
       +
       

     

       50
       50
       +
           // Box bottom part

     

       51
       51
       +
           final path = Path()

     

       52
       52
       +
             ..moveTo(20, 13.75)

     

       53
       53
       +
             ..cubicTo(20.552, 13.75, 21, 14.198, 21, 14.75)

     

       54
       54
       +
             ..lineTo(21, 18)

     

       55
       55
       +
             ..cubicTo(21, 19.657, 19.657, 21, 18, 21)

     

       56
       56
       +
             ..lineTo(6, 21)

     

       57
       57
       +
             ..cubicTo(4.343, 21, 3, 19.657, 3, 18)

     

       58
       58
       +
             ..lineTo(3, 14.75)

     

       59
       59
       +
             ..cubicTo(3, 14.198, 3.448, 13.75, 4, 13.75)

     

       60
       60
       +
             ..cubicTo(4.552, 13.75, 5, 14.198, 5, 14.75)

     

       61
       61
       +
             ..lineTo(5, 18)

     

       62
       62
       +
             ..cubicTo(5, 18.552, 5.448, 19, 6, 19)

     

       63
       63
       +
             ..lineTo(18, 19)

     

       64
       64
       +
             ..cubicTo(18.552, 19, 19, 18.552, 19, 18)

     

       65
       65
       +
             ..lineTo(19, 14.75)

     

       66
       66
       +
             ..cubicTo(19, 14.198, 19.448, 13.75, 20, 13.75)

     

       67
       67
       +
             ..close()

     

       68
       68
       +
             // Arrow

     

       69
       69
       +
             ..moveTo(12, 3)

     

       70
       70
       +
             ..cubicTo(12.265, 3, 12.52, 3.105, 12.707, 3.293)

     

       71
       71
       +
             ..lineTo(17.207, 7.793)

     

       72
       72
       +
             ..cubicTo(17.598, 8.184, 17.598, 8.817, 17.207, 9.207)

     

       73
       73
       +
             ..cubicTo(16.816, 9.598, 16.183, 9.598, 15.793, 9.207)

     

       74
       74
       +
             ..lineTo(13, 6.414)

     

       75
       75
       +
             ..lineTo(13, 15.25)

     

       76
       76
       +
             ..cubicTo(13, 15.802, 12.552, 16.25, 12, 16.25)

     

       77
       77
       +
             ..cubicTo(11.448, 16.25, 11, 15.802, 11, 15.25)

     

       78
       78
       +
             ..lineTo(11, 6.414)

     

       79
       79
       +
             ..lineTo(8.207, 9.207)

     

       80
       80
       +
             ..cubicTo(7.816, 9.598, 7.183, 9.598, 6.793, 9.207)

     

       81
       81
       +
             ..cubicTo(6.402, 8.816, 6.402, 8.183, 6.793, 7.793)

     

       82
       82
       +
             ..lineTo(11.293, 3.293)

     

       83
       83
       +
             ..cubicTo(11.48, 3.105, 11.735, 3, 12, 3)

     

       84
       84
       +
             ..close();

     

       85
       85
       +
       

     

       86
       86
       +
           canvas.drawPath(path, paint);

     

       87
       87
       +
         }

     

       88
       88
       +
       

     

       89
       89
       +
         @override

     

       90
       90
       +
         bool shouldRepaint(_ShareIconPainter oldDelegate) {

     

       91
       91
       +
           return oldDelegate.color != color;

     

       92
       92
       +
         }

     

       93
       93
       +
       }

+77 -36

lib/widgets/post_card.dart

···

       1
       1
        
       import 'package:cached_network_image/cached_network_image.dart';

     

       2
       2
        
       import 'package:flutter/foundation.dart';

     

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

     

       4
       4
       +
       import 'package:flutter/services.dart';

     

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

     

       4
       6
        
       

     

       5
       7
        
       import '../constants/app_colors.dart';

     

       6
       8
        
       import '../models/post.dart';

     

       9
       9
       +
       import '../providers/auth_provider.dart';

     

       10
       10
       +
       import '../providers/vote_provider.dart';

     

       7
       11
        
       import '../utils/date_time_utils.dart';

     

       12
       12
       +
       import 'icons/animated_heart_icon.dart';

     

       13
       13
       +
       import 'icons/reply_icon.dart';

     

       14
       14
       +
       import 'icons/share_icon.dart';

     

       15
       15
       +
       import 'sign_in_dialog.dart';

     

       8
       16
        
       

     

       9
       17
        
       /// Post card widget for displaying feed posts

     

       10
       18
        
       ///

     
···

       163
       171
        
                             horizontal: 12,

     

       164
       172
        
                             vertical: 10,

     

       165
       173
        
                           ),

     

       166
       166
       -
                           child: Icon(

     

       167
       167
       -
                             Icons.ios_share,

     

       168
       168
       -
                             size: 18,

     

       174
       174
       +
                           child: ShareIcon(

     

       169
       175
        
                             color: AppColors.textPrimary.withValues(alpha: 0.6),

     

       170
       176
        
                           ),

     

       171
       177
        
                         ),

     
···

       189
       195
        
                           child: Row(

     

       190
       196
        
                             mainAxisSize: MainAxisSize.min,

     

       191
       197
        
                             children: [

     

       192
       192
       -
                               Icon(

     

       193
       193
       -
                                 Icons.chat_bubble_outline,

     

       194
       194
       -
                                 size: 18,

     

       198
       198
       +
                               ReplyIcon(

     

       195
       199
        
                                 color: AppColors.textPrimary.withValues(alpha: 0.6),

     

       196
       200
        
                               ),

     

       197
       201
        
                               const SizedBox(width: 5),

     
···

       211
       215
        
                       const SizedBox(width: 8),

     

       212
       216
        
       

     

       213
       217
        
                       // Heart button

     

       214
       214
       -
                       InkWell(

     

       215
       215
       -
                         onTap: () {

     

       216
       216
       -
                           // TODO: Handle upvote/like interaction with backend

     

       217
       217
       -
                           if (kDebugMode) {

     

       218
       218
       -
                             debugPrint('Heart button tapped for post');

     

       219
       219
       -
                           }

     

       220
       220
       -
                         },

     

       221
       221
       -
                         child: Padding(

     

       222
       222
       -
                           // Increased padding for better touch targets

     

       223
       223
       -
                           padding: const EdgeInsets.symmetric(

     

       224
       224
       -
                             horizontal: 12,

     

       225
       225
       -
                             vertical: 10,

     

       226
       226
       -
                           ),

     

       227
       227
       -
                           child: Row(

     

       228
       228
       -
                             mainAxisSize: MainAxisSize.min,

     

       229
       229
       -
                             children: [

     

       230
       230
       -
                               Icon(

     

       231
       231
       -
                                 Icons.favorite_border,

     

       232
       232
       -
                                 size: 18,

     

       233
       233
       -
                                 color: AppColors.textPrimary.withValues(alpha: 0.6),

     

       218
       218
       +
                       Consumer<VoteProvider>(

     

       219
       219
       +
                         builder: (context, voteProvider, child) {

     

       220
       220
       +
                           final isLiked = voteProvider.isLiked(post.post.uri);

     

       221
       221
       +
       

     

       222
       222
       +
                           return InkWell(

     

       223
       223
       +
                             onTap: () async {

     

       224
       224
       +
                               // Check authentication

     

       225
       225
       +
                               final authProvider = context.read<AuthProvider>();

     

       226
       226
       +
                               if (!authProvider.isAuthenticated) {

     

       227
       227
       +
                                 // Show sign-in dialog

     

       228
       228
       +
                                 final shouldSignIn = await SignInDialog.show(

     

       229
       229
       +
                                   context,

     

       230
       230
       +
                                   message: 'You need to sign in to like posts.',

     

       231
       231
       +
                                 );

     

       232
       232
       +
       

     

       233
       233
       +
                                 if ((shouldSignIn ?? false) && context.mounted) {

     

       234
       234
       +
                                   // TODO: Navigate to sign-in screen

     

       235
       235
       +
                                   if (kDebugMode) {

     

       236
       236
       +
                                     debugPrint('Navigate to sign-in screen');

     

       237
       237
       +
                                   }

     

       238
       238
       +
                                 }

     

       239
       239
       +
                                 return;

     

       240
       240
       +
                               }

     

       241
       241
       +
       

     

       242
       242
       +
                               // Light haptic feedback on both like and unlike

     

       243
       243
       +
                               await HapticFeedback.lightImpact();

     

       244
       244
       +
       

     

       245
       245
       +
                               // Toggle vote with optimistic update

     

       246
       246
       +
                               try {

     

       247
       247
       +
                                 await voteProvider.toggleVote(

     

       248
       248
       +
                                   postUri: post.post.uri,

     

       249
       249
       +
                                   postCid: post.post.cid,

     

       250
       250
       +
                                 );

     

       251
       251
       +
                               } on Exception catch (e) {

     

       252
       252
       +
                                 if (kDebugMode) {

     

       253
       253
       +
                                   debugPrint('Failed to toggle vote: $e');

     

       254
       254
       +
                                 }

     

       255
       255
       +
                                 // TODO: Show error snackbar

     

       256
       256
       +
                               }

     

       257
       257
       +
                             },

     

       258
       258
       +
                             child: Padding(

     

       259
       259
       +
                               // Increased padding for better touch targets

     

       260
       260
       +
                               padding: const EdgeInsets.symmetric(

     

       261
       261
       +
                                 horizontal: 12,

     

       262
       262
       +
                                 vertical: 10,

     

       234
       263
        
                               ),

     

       235
       235
       -
                               const SizedBox(width: 5),

     

       236
       236
       -
                               Text(

     

       237
       237
       -
                                 DateTimeUtils.formatCount(post.post.stats.score),

     

       238
       238
       -
                                 style: TextStyle(

     

       239
       239
       -
                                   color: AppColors.textPrimary.withValues(alpha: 0.6),

     

       240
       240
       -
                                   fontSize: 13,

     

       241
       241
       -
                                 ),

     

       264
       264
       +
                               child: Row(

     

       265
       265
       +
                                 mainAxisSize: MainAxisSize.min,

     

       266
       266
       +
                                 children: [

     

       267
       267
       +
                                   AnimatedHeartIcon(

     

       268
       268
       +
                                     isLiked: isLiked,

     

       269
       269
       +
                                     color: AppColors.textPrimary

     

       270
       270
       +
                                         .withValues(alpha: 0.6),

     

       271
       271
       +
                                     likedColor: const Color(0xFFFF0033),

     

       272
       272
       +
                                   ),

     

       273
       273
       +
                                   const SizedBox(width: 5),

     

       274
       274
       +
                                   Text(

     

       275
       275
       +
                                     DateTimeUtils.formatCount(post.post.stats.score),

     

       276
       276
       +
                                     style: TextStyle(

     

       277
       277
       +
                                       color: AppColors.textPrimary

     

       278
       278
       +
                                           .withValues(alpha: 0.6),

     

       279
       279
       +
                                       fontSize: 13,

     

       280
       280
       +
                                     ),

     

       281
       281
       +
                                   ),

     

       282
       282
       +
                                 ],

     

       242
       283
        
                               ),

     

       243
       243
       -
                             ],

     

       244
       244
       -
                           ),

     

       245
       245
       -
                         ),

     

       284
       284
       +
                             ),

     

       285
       285
       +
                           );

     

       286
       286
       +
                         },

     

       246
       287
        
                       ),

     

       247
       288
        
                     ],

     

       248
       289
        
                   ),

+70

lib/widgets/sign_in_dialog.dart

···

       1
       1
       +
       import 'package:flutter/material.dart';

     

       2
       2
       +
       

     

       3
       3
       +
       import '../constants/app_colors.dart';

     

       4
       4
       +
       

     

       5
       5
       +
       /// Sign In Dialog

     

       6
       6
       +
       ///

     

       7
       7
       +
       /// Shows a dialog prompting users to sign in before performing actions

     

       8
       8
       +
       /// that require authentication (like voting, commenting, etc.)

     

       9
       9
       +
       class SignInDialog extends StatelessWidget {

     

       10
       10
       +
         const SignInDialog({

     

       11
       11
       +
           this.title = 'Sign in required',

     

       12
       12
       +
           this.message = 'You need to sign in to interact with posts.',

     

       13
       13
       +
           super.key,

     

       14
       14
       +
         });

     

       15
       15
       +
       

     

       16
       16
       +
         final String title;

     

       17
       17
       +
         final String message;

     

       18
       18
       +
       

     

       19
       19
       +
         /// Show the dialog

     

       20
       20
       +
         static Future<bool?> show(

     

       21
       21
       +
           BuildContext context, {

     

       22
       22
       +
           String? title,

     

       23
       23
       +
           String? message,

     

       24
       24
       +
         }) {

     

       25
       25
       +
           return showDialog<bool>(

     

       26
       26
       +
             context: context,

     

       27
       27
       +
             builder:

     

       28
       28
       +
                 (context) => SignInDialog(

     

       29
       29
       +
                   title: title ?? 'Sign in required',

     

       30
       30
       +
                   message: message ?? 'You need to sign in to interact with posts.',

     

       31
       31
       +
                 ),

     

       32
       32
       +
           );

     

       33
       33
       +
         }

     

       34
       34
       +
       

     

       35
       35
       +
         @override

     

       36
       36
       +
         Widget build(BuildContext context) {

     

       37
       37
       +
           return AlertDialog(

     

       38
       38
       +
             backgroundColor: AppColors.background,

     

       39
       39
       +
             title: Text(

     

       40
       40
       +
               title,

     

       41
       41
       +
               style: const TextStyle(

     

       42
       42
       +
                 color: AppColors.textPrimary,

     

       43
       43
       +
                 fontSize: 18,

     

       44
       44
       +
                 fontWeight: FontWeight.bold,

     

       45
       45
       +
               ),

     

       46
       46
       +
             ),

     

       47
       47
       +
             content: Text(

     

       48
       48
       +
               message,

     

       49
       49
       +
               style: const TextStyle(color: AppColors.textSecondary, fontSize: 14),

     

       50
       50
       +
             ),

     

       51
       51
       +
             actions: [

     

       52
       52
       +
               TextButton(

     

       53
       53
       +
                 onPressed: () => Navigator.of(context).pop(false),

     

       54
       54
       +
                 child: const Text(

     

       55
       55
       +
                   'Cancel',

     

       56
       56
       +
                   style: TextStyle(color: AppColors.textSecondary),

     

       57
       57
       +
                 ),

     

       58
       58
       +
               ),

     

       59
       59
       +
               ElevatedButton(

     

       60
       60
       +
                 onPressed: () => Navigator.of(context).pop(true),

     

       61
       61
       +
                 style: ElevatedButton.styleFrom(

     

       62
       62
       +
                   backgroundColor: AppColors.primary,

     

       63
       63
       +
                   foregroundColor: AppColors.textPrimary,

     

       64
       64
       +
                 ),

     

       65
       65
       +
                 child: const Text('Sign In'),

     

       66
       66
       +
               ),

     

       67
       67
       +
             ],

     

       68
       68
       +
           );

     

       69
       69
       +
         }

     

       70
       70
       +
       }

+1 -1

test/providers/auth_provider_test.mocks.dart

···

       84
       84
        
         @override

     

       85
       85
        
         _i6.Future<_i2.OAuthSession?> restoreSession(

     

       86
       86
        
           String? did, {

     

       87
       87
       -
           dynamic refresh = 'auto',

     

       87
       87
       +
           String? refresh = 'auto',

     

       88
       88
        
         }) =>

     

       89
       89
        
             (super.noSuchMethod(

     

       90
       90
        
                   Invocation.method(#restoreSession, [did], {#refresh: refresh}),

+16

test/providers/feed_provider_test.dart

···

       299
       299
        
             });

     

       300
       300
        
       

     

       301
       301
        
             test('should not load more if already loading', () async {

     

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

     

       303
       303
       +
       

     

       304
       304
       +
               final response = TimelineResponse(

     

       305
       305
       +
                 feed: [_createMockPost()],

     

       306
       306
       +
                 cursor: 'cursor-1',

     

       307
       307
       +
               );

     

       308
       308
       +
       

     

       309
       309
       +
               when(

     

       310
       310
       +
                 mockApiService.getTimeline(

     

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

     

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

     

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

     

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

     

       315
       315
       +
                 ),

     

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

     

       317
       317
       +
       

     

       302
       318
        
               await feedProvider.fetchTimeline(refresh: true);

     

       303
       319
        
               await feedProvider.loadMore();

     

       304
       320

+467

test/providers/vote_provider_test.dart

···

       1
       1
       +
       import 'package:coves_flutter/providers/auth_provider.dart';

     

       2
       2
       +
       import 'package:coves_flutter/providers/vote_provider.dart';

     

       3
       3
       +
       import 'package:coves_flutter/services/api_exceptions.dart';

     

       4
       4
       +
       import 'package:coves_flutter/services/vote_service.dart';

     

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

     

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

     

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

     

       8
       8
       +
       

     

       9
       9
       +
       import 'vote_provider_test.mocks.dart';

     

       10
       10
       +
       

     

       11
       11
       +
       // Generate mocks for VoteService and AuthProvider

     

       12
       12
       +
       @GenerateMocks([VoteService, AuthProvider])

     

       13
       13
       +
       void main() {

     

       14
       14
       +
         TestWidgetsFlutterBinding.ensureInitialized();

     

       15
       15
       +
       

     

       16
       16
       +
         group('VoteProvider', () {

     

       17
       17
       +
           late VoteProvider voteProvider;

     

       18
       18
       +
           late MockVoteService mockVoteService;

     

       19
       19
       +
           late MockAuthProvider mockAuthProvider;

     

       20
       20
       +
       

     

       21
       21
       +
           setUp(() {

     

       22
       22
       +
             mockVoteService = MockVoteService();

     

       23
       23
       +
             mockAuthProvider = MockAuthProvider();

     

       24
       24
       +
       

     

       25
       25
       +
             // Default: user is authenticated

     

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

     

       27
       27
       +
       

     

       28
       28
       +
             voteProvider = VoteProvider(

     

       29
       29
       +
               voteService: mockVoteService,

     

       30
       30
       +
               authProvider: mockAuthProvider,

     

       31
       31
       +
             );

     

       32
       32
       +
           });

     

       33
       33
       +
       

     

       34
       34
       +
           tearDown(() {

     

       35
       35
       +
             voteProvider.dispose();

     

       36
       36
       +
           });

     

       37
       37
       +
       

     

       38
       38
       +
           group('toggleVote', () {

     

       39
       39
       +
             const testPostUri = 'at://did:plc:test/social.coves.post.record/123';

     

       40
       40
       +
             const testPostCid = 'bafy2bzacepostcid123';

     

       41
       41
       +
       

     

       42
       42
       +
             test('should create vote with optimistic update', () async {

     

       43
       43
       +
               // Mock successful API response

     

       44
       44
       +
               when(

     

       45
       45
       +
                 mockVoteService.createVote(

     

       46
       46
       +
                   postUri: testPostUri,

     

       47
       47
       +
                   postCid: testPostCid,

     

       48
       48
       +
                 ),

     

       49
       49
       +
               ).thenAnswer(

     

       50
       50
       +
                 (_) async => const VoteResponse(

     

       51
       51
       +
                   uri: 'at://did:plc:test/social.coves.interaction.vote/456',

     

       52
       52
       +
                   cid: 'bafy123',

     

       53
       53
       +
                   rkey: '456',

     

       54
       54
       +
                   deleted: false,

     

       55
       55
       +
                 ),

     

       56
       56
       +
               );

     

       57
       57
       +
       

     

       58
       58
       +
               var notificationCount = 0;

     

       59
       59
       +
               voteProvider.addListener(() {

     

       60
       60
       +
                 notificationCount++;

     

       61
       61
       +
               });

     

       62
       62
       +
       

     

       63
       63
       +
               // Initially not liked

     

       64
       64
       +
               expect(voteProvider.isLiked(testPostUri), false);

     

       65
       65
       +
       

     

       66
       66
       +
               // Toggle vote

     

       67
       67
       +
               final wasLiked = await voteProvider.toggleVote(

     

       68
       68
       +
                 postUri: testPostUri,

     

       69
       69
       +
                 postCid: testPostCid,

     

       70
       70
       +
               );

     

       71
       71
       +
       

     

       72
       72
       +
               // Should return true (vote created)

     

       73
       73
       +
               expect(wasLiked, true);

     

       74
       74
       +
       

     

       75
       75
       +
               // Should be liked now

     

       76
       76
       +
               expect(voteProvider.isLiked(testPostUri), true);

     

       77
       77
       +
       

     

       78
       78
       +
               // Should have notified listeners twice (optimistic + server response)

     

       79
       79
       +
               expect(notificationCount, greaterThanOrEqualTo(2));

     

       80
       80
       +
       

     

       81
       81
       +
               // Vote state should be correct

     

       82
       82
       +
               final voteState = voteProvider.getVoteState(testPostUri);

     

       83
       83
       +
               expect(voteState?.direction, 'up');

     

       84
       84
       +
               expect(voteState?.uri, 'at://did:plc:test/social.coves.interaction.vote/456');

     

       85
       85
       +
               expect(voteState?.deleted, false);

     

       86
       86
       +
             });

     

       87
       87
       +
       

     

       88
       88
       +
             test('should remove vote when toggled off', () async {

     

       89
       89
       +
               // First, set up initial vote state

     

       90
       90
       +
               voteProvider.setInitialVoteState(

     

       91
       91
       +
                 postUri: testPostUri,

     

       92
       92
       +
                 voteDirection: 'up',

     

       93
       93
       +
                 voteUri: 'at://did:plc:test/social.coves.interaction.vote/456',

     

       94
       94
       +
               );

     

       95
       95
       +
       

     

       96
       96
       +
               expect(voteProvider.isLiked(testPostUri), true);

     

       97
       97
       +
       

     

       98
       98
       +
               // Mock API response for toggling off

     

       99
       99
       +
               when(

     

       100
       100
       +
                 mockVoteService.createVote(

     

       101
       101
       +
                   postUri: testPostUri,

     

       102
       102
       +
                   postCid: testPostCid,

     

       103
       103
       +
                 ),

     

       104
       104
       +
               ).thenAnswer(

     

       105
       105
       +
                 (_) async => const VoteResponse(deleted: true),

     

       106
       106
       +
               );

     

       107
       107
       +
       

     

       108
       108
       +
               // Toggle vote off

     

       109
       109
       +
               final wasLiked = await voteProvider.toggleVote(

     

       110
       110
       +
                 postUri: testPostUri,

     

       111
       111
       +
                 postCid: testPostCid,

     

       112
       112
       +
               );

     

       113
       113
       +
       

     

       114
       114
       +
               // Should return false (vote removed)

     

       115
       115
       +
               expect(wasLiked, false);

     

       116
       116
       +
       

     

       117
       117
       +
               // Should not be liked anymore

     

       118
       118
       +
               expect(voteProvider.isLiked(testPostUri), false);

     

       119
       119
       +
       

     

       120
       120
       +
               // Vote state should be marked as deleted

     

       121
       121
       +
               final voteState = voteProvider.getVoteState(testPostUri);

     

       122
       122
       +
               expect(voteState?.deleted, true);

     

       123
       123
       +
             });

     

       124
       124
       +
       

     

       125
       125
       +
             test('should rollback on API error', () async {

     

       126
       126
       +
               // Set up initial state (not voted)

     

       127
       127
       +
               expect(voteProvider.isLiked(testPostUri), false);

     

       128
       128
       +
       

     

       129
       129
       +
               // Mock API failure

     

       130
       130
       +
               when(

     

       131
       131
       +
                 mockVoteService.createVote(

     

       132
       132
       +
                   postUri: testPostUri,

     

       133
       133
       +
                   postCid: testPostCid,

     

       134
       134
       +
                 ),

     

       135
       135
       +
               ).thenThrow(

     

       136
       136
       +
                 ApiException('Network error', statusCode: 500),

     

       137
       137
       +
               );

     

       138
       138
       +
       

     

       139
       139
       +
               var notificationCount = 0;

     

       140
       140
       +
               voteProvider.addListener(() {

     

       141
       141
       +
                 notificationCount++;

     

       142
       142
       +
               });

     

       143
       143
       +
       

     

       144
       144
       +
               // Try to toggle vote

     

       145
       145
       +
               expect(

     

       146
       146
       +
                 () => voteProvider.toggleVote(

     

       147
       147
       +
                   postUri: testPostUri,

     

       148
       148
       +
                   postCid: testPostCid,

     

       149
       149
       +
                 ),

     

       150
       150
       +
                 throwsA(isA<ApiException>()),

     

       151
       151
       +
               );

     

       152
       152
       +
       

     

       153
       153
       +
               // Should rollback to initial state (not liked)

     

       154
       154
       +
               await Future.delayed(Duration.zero); // Wait for async completion

     

       155
       155
       +
               expect(voteProvider.isLiked(testPostUri), false);

     

       156
       156
       +
               expect(voteProvider.getVoteState(testPostUri), null);

     

       157
       157
       +
       

     

       158
       158
       +
               // Should have notified listeners (optimistic + rollback)

     

       159
       159
       +
               expect(notificationCount, greaterThanOrEqualTo(2));

     

       160
       160
       +
             });

     

       161
       161
       +
       

     

       162
       162
       +
             test('should rollback to previous state on error', () async {

     

       163
       163
       +
               // Set up initial voted state

     

       164
       164
       +
               voteProvider.setInitialVoteState(

     

       165
       165
       +
                 postUri: testPostUri,

     

       166
       166
       +
                 voteDirection: 'up',

     

       167
       167
       +
                 voteUri: 'at://did:plc:test/social.coves.interaction.vote/456',

     

       168
       168
       +
               );

     

       169
       169
       +
       

     

       170
       170
       +
               final initialState = voteProvider.getVoteState(testPostUri);

     

       171
       171
       +
               expect(voteProvider.isLiked(testPostUri), true);

     

       172
       172
       +
       

     

       173
       173
       +
               // Mock API failure when trying to toggle off

     

       174
       174
       +
               when(

     

       175
       175
       +
                 mockVoteService.createVote(

     

       176
       176
       +
                   postUri: testPostUri,

     

       177
       177
       +
                   postCid: testPostCid,

     

       178
       178
       +
                 ),

     

       179
       179
       +
               ).thenThrow(

     

       180
       180
       +
                 NetworkException('Connection failed'),

     

       181
       181
       +
               );

     

       182
       182
       +
       

     

       183
       183
       +
               // Try to toggle vote off

     

       184
       184
       +
               expect(

     

       185
       185
       +
                 () => voteProvider.toggleVote(

     

       186
       186
       +
                   postUri: testPostUri,

     

       187
       187
       +
                   postCid: testPostCid,

     

       188
       188
       +
                 ),

     

       189
       189
       +
                 throwsA(isA<ApiException>()),

     

       190
       190
       +
               );

     

       191
       191
       +
       

     

       192
       192
       +
               // Should rollback to initial liked state

     

       193
       193
       +
               await Future.delayed(Duration.zero); // Wait for async completion

     

       194
       194
       +
               expect(voteProvider.isLiked(testPostUri), true);

     

       195
       195
       +
               expect(voteProvider.getVoteState(testPostUri)?.uri, initialState?.uri);

     

       196
       196
       +
             });

     

       197
       197
       +
       

     

       198
       198
       +
             test('should prevent concurrent requests for same post', () async {

     

       199
       199
       +
               // Mock slow API response

     

       200
       200
       +
               when(

     

       201
       201
       +
                 mockVoteService.createVote(

     

       202
       202
       +
                   postUri: testPostUri,

     

       203
       203
       +
                   postCid: testPostCid,

     

       204
       204
       +
                 ),

     

       205
       205
       +
               ).thenAnswer(

     

       206
       206
       +
                 (_) async {

     

       207
       207
       +
                   await Future.delayed(const Duration(milliseconds: 100));

     

       208
       208
       +
                   return const VoteResponse(

     

       209
       209
       +
                     uri: 'at://did:plc:test/social.coves.interaction.vote/456',

     

       210
       210
       +
                     cid: 'bafy123',

     

       211
       211
       +
                     rkey: '456',

     

       212
       212
       +
                     deleted: false,

     

       213
       213
       +
                   );

     

       214
       214
       +
                 },

     

       215
       215
       +
               );

     

       216
       216
       +
       

     

       217
       217
       +
               // Start first request

     

       218
       218
       +
               final future1 = voteProvider.toggleVote(

     

       219
       219
       +
                 postUri: testPostUri,

     

       220
       220
       +
                 postCid: testPostCid,

     

       221
       221
       +
               );

     

       222
       222
       +
       

     

       223
       223
       +
               // Try to start second request before first completes

     

       224
       224
       +
               final result2 = await voteProvider.toggleVote(

     

       225
       225
       +
                 postUri: testPostUri,

     

       226
       226
       +
                 postCid: testPostCid,

     

       227
       227
       +
               );

     

       228
       228
       +
       

     

       229
       229
       +
               // Second request should be ignored

     

       230
       230
       +
               expect(result2, false);

     

       231
       231
       +
       

     

       232
       232
       +
               // First request should complete normally

     

       233
       233
       +
               final result1 = await future1;

     

       234
       234
       +
               expect(result1, true);

     

       235
       235
       +
       

     

       236
       236
       +
               // Should have only called API once

     

       237
       237
       +
               verify(

     

       238
       238
       +
                 mockVoteService.createVote(

     

       239
       239
       +
                   postUri: testPostUri,

     

       240
       240
       +
                   postCid: testPostCid,

     

       241
       241
       +
                 ),

     

       242
       242
       +
               ).called(1);

     

       243
       243
       +
             });

     

       244
       244
       +
       

     

       245
       245
       +
             test('should handle downvote direction', () async {

     

       246
       246
       +
               when(

     

       247
       247
       +
                 mockVoteService.createVote(

     

       248
       248
       +
                   postUri: testPostUri,

     

       249
       249
       +
                   postCid: testPostCid,

     

       250
       250
       +
                   direction: 'down',

     

       251
       251
       +
                 ),

     

       252
       252
       +
               ).thenAnswer(

     

       253
       253
       +
                 (_) async => const VoteResponse(

     

       254
       254
       +
                   uri: 'at://did:plc:test/social.coves.interaction.vote/456',

     

       255
       255
       +
                   cid: 'bafy123',

     

       256
       256
       +
                   rkey: '456',

     

       257
       257
       +
                   deleted: false,

     

       258
       258
       +
                 ),

     

       259
       259
       +
               );

     

       260
       260
       +
       

     

       261
       261
       +
               await voteProvider.toggleVote(

     

       262
       262
       +
                 postUri: testPostUri,

     

       263
       263
       +
                 postCid: testPostCid,

     

       264
       264
       +
                 direction: 'down',

     

       265
       265
       +
               );

     

       266
       266
       +
       

     

       267
       267
       +
               final voteState = voteProvider.getVoteState(testPostUri);

     

       268
       268
       +
               expect(voteState?.direction, 'down');

     

       269
       269
       +
               expect(voteState?.deleted, false);

     

       270
       270
       +
       

     

       271
       271
       +
               // Should not be "liked" (isLiked checks for 'up' direction)

     

       272
       272
       +
               expect(voteProvider.isLiked(testPostUri), false);

     

       273
       273
       +
             });

     

       274
       274
       +
           });

     

       275
       275
       +
       

     

       276
       276
       +
           group('setInitialVoteState', () {

     

       277
       277
       +
             const testPostUri = 'at://did:plc:test/social.coves.post.record/123';

     

       278
       278
       +
       

     

       279
       279
       +
             test('should set initial vote state from API data', () {

     

       280
       280
       +
               voteProvider.setInitialVoteState(

     

       281
       281
       +
                 postUri: testPostUri,

     

       282
       282
       +
                 voteDirection: 'up',

     

       283
       283
       +
                 voteUri: 'at://did:plc:test/social.coves.interaction.vote/456',

     

       284
       284
       +
               );

     

       285
       285
       +
       

     

       286
       286
       +
               expect(voteProvider.isLiked(testPostUri), true);

     

       287
       287
       +
       

     

       288
       288
       +
               final voteState = voteProvider.getVoteState(testPostUri);

     

       289
       289
       +
               expect(voteState?.direction, 'up');

     

       290
       290
       +
               expect(voteState?.uri, 'at://did:plc:test/social.coves.interaction.vote/456');

     

       291
       291
       +
               expect(voteState?.deleted, false);

     

       292
       292
       +
             });

     

       293
       293
       +
       

     

       294
       294
       +
             test('should remove vote state when voteDirection is null', () {

     

       295
       295
       +
               // First set a vote

     

       296
       296
       +
               voteProvider.setInitialVoteState(

     

       297
       297
       +
                 postUri: testPostUri,

     

       298
       298
       +
                 voteDirection: 'up',

     

       299
       299
       +
                 voteUri: 'at://did:plc:test/social.coves.interaction.vote/456',

     

       300
       300
       +
               );

     

       301
       301
       +
       

     

       302
       302
       +
               expect(voteProvider.isLiked(testPostUri), true);

     

       303
       303
       +
       

     

       304
       304
       +
               // Then clear it

     

       305
       305
       +
               voteProvider.setInitialVoteState(

     

       306
       306
       +
                 postUri: testPostUri,

     

       307
       307
       +
               );

     

       308
       308
       +
       

     

       309
       309
       +
               expect(voteProvider.isLiked(testPostUri), false);

     

       310
       310
       +
               expect(voteProvider.getVoteState(testPostUri), null);

     

       311
       311
       +
             });

     

       312
       312
       +
       

     

       313
       313
       +
             test('should not notify listeners when setting initial state', () {

     

       314
       314
       +
               var notificationCount = 0;

     

       315
       315
       +
               voteProvider.addListener(() {

     

       316
       316
       +
                 notificationCount++;

     

       317
       317
       +
               });

     

       318
       318
       +
       

     

       319
       319
       +
               voteProvider.setInitialVoteState(

     

       320
       320
       +
                 postUri: testPostUri,

     

       321
       321
       +
                 voteDirection: 'up',

     

       322
       322
       +
                 voteUri: 'at://did:plc:test/social.coves.interaction.vote/456',

     

       323
       323
       +
               );

     

       324
       324
       +
       

     

       325
       325
       +
               // Should NOT notify listeners (silent initialization)

     

       326
       326
       +
               expect(notificationCount, 0);

     

       327
       327
       +
             });

     

       328
       328
       +
           });

     

       329
       329
       +
       

     

       330
       330
       +
           group('clear', () {

     

       331
       331
       +
             test('should clear all vote state', () {

     

       332
       332
       +
               const post1 = 'at://did:plc:test/social.coves.post.record/1';

     

       333
       333
       +
               const post2 = 'at://did:plc:test/social.coves.post.record/2';

     

       334
       334
       +
       

     

       335
       335
       +
               // Set up multiple votes

     

       336
       336
       +
               voteProvider.setInitialVoteState(

     

       337
       337
       +
                 postUri: post1,

     

       338
       338
       +
                 voteDirection: 'up',

     

       339
       339
       +
                 voteUri: 'at://did:plc:test/social.coves.interaction.vote/1',

     

       340
       340
       +
               );

     

       341
       341
       +
               voteProvider.setInitialVoteState(

     

       342
       342
       +
                 postUri: post2,

     

       343
       343
       +
                 voteDirection: 'up',

     

       344
       344
       +
                 voteUri: 'at://did:plc:test/social.coves.interaction.vote/2',

     

       345
       345
       +
               );

     

       346
       346
       +
       

     

       347
       347
       +
               expect(voteProvider.isLiked(post1), true);

     

       348
       348
       +
               expect(voteProvider.isLiked(post2), true);

     

       349
       349
       +
       

     

       350
       350
       +
               // Clear all

     

       351
       351
       +
               voteProvider.clear();

     

       352
       352
       +
       

     

       353
       353
       +
               // Should have no votes

     

       354
       354
       +
               expect(voteProvider.isLiked(post1), false);

     

       355
       355
       +
               expect(voteProvider.isLiked(post2), false);

     

       356
       356
       +
               expect(voteProvider.getVoteState(post1), null);

     

       357
       357
       +
               expect(voteProvider.getVoteState(post2), null);

     

       358
       358
       +
             });

     

       359
       359
       +
       

     

       360
       360
       +
             test('should notify listeners when cleared', () {

     

       361
       361
       +
               var notificationCount = 0;

     

       362
       362
       +
               voteProvider.addListener(() {

     

       363
       363
       +
                 notificationCount++;

     

       364
       364
       +
               });

     

       365
       365
       +
       

     

       366
       366
       +
               voteProvider.clear();

     

       367
       367
       +
       

     

       368
       368
       +
               expect(notificationCount, 1);

     

       369
       369
       +
             });

     

       370
       370
       +
           });

     

       371
       371
       +
       

     

       372
       372
       +
           group('isPending', () {

     

       373
       373
       +
             const testPostUri = 'at://did:plc:test/social.coves.post.record/123';

     

       374
       374
       +
             const testPostCid = 'bafy2bzacepostcid123';

     

       375
       375
       +
       

     

       376
       376
       +
             test('should return true while request is in progress', () async {

     

       377
       377
       +
               // Mock slow API response

     

       378
       378
       +
               when(

     

       379
       379
       +
                 mockVoteService.createVote(

     

       380
       380
       +
                   postUri: testPostUri,

     

       381
       381
       +
                   postCid: testPostCid,

     

       382
       382
       +
                 ),

     

       383
       383
       +
               ).thenAnswer(

     

       384
       384
       +
                 (_) async {

     

       385
       385
       +
                   await Future.delayed(const Duration(milliseconds: 50));

     

       386
       386
       +
                   return const VoteResponse(

     

       387
       387
       +
                     uri: 'at://did:plc:test/social.coves.interaction.vote/456',

     

       388
       388
       +
                     cid: 'bafy123',

     

       389
       389
       +
                     rkey: '456',

     

       390
       390
       +
                     deleted: false,

     

       391
       391
       +
                   );

     

       392
       392
       +
                 },

     

       393
       393
       +
               );

     

       394
       394
       +
       

     

       395
       395
       +
               expect(voteProvider.isPending(testPostUri), false);

     

       396
       396
       +
       

     

       397
       397
       +
               // Start request

     

       398
       398
       +
               final future = voteProvider.toggleVote(

     

       399
       399
       +
                 postUri: testPostUri,

     

       400
       400
       +
                 postCid: testPostCid,

     

       401
       401
       +
               );

     

       402
       402
       +
       

     

       403
       403
       +
               // Give it time to set pending flag

     

       404
       404
       +
               await Future.delayed(const Duration(milliseconds: 10));

     

       405
       405
       +
       

     

       406
       406
       +
               // Should be pending now

     

       407
       407
       +
               expect(voteProvider.isPending(testPostUri), true);

     

       408
       408
       +
       

     

       409
       409
       +
               // Wait for completion

     

       410
       410
       +
               await future;

     

       411
       411
       +
       

     

       412
       412
       +
               // Should not be pending anymore

     

       413
       413
       +
               expect(voteProvider.isPending(testPostUri), false);

     

       414
       414
       +
             });

     

       415
       415
       +
       

     

       416
       416
       +
             test('should return false for posts with no pending request', () {

     

       417
       417
       +
               const testPostUri = 'at://did:plc:test/social.coves.post.record/123';

     

       418
       418
       +
               expect(voteProvider.isPending(testPostUri), false);

     

       419
       419
       +
             });

     

       420
       420
       +
           });

     

       421
       421
       +
       

     

       422
       422
       +
           group('Auth state listener', () {

     

       423
       423
       +
             test('should clear votes when user signs out', () {

     

       424
       424
       +
               const testPostUri = 'at://did:plc:test/social.coves.post.record/123';

     

       425
       425
       +
       

     

       426
       426
       +
               // Set up vote state

     

       427
       427
       +
               voteProvider.setInitialVoteState(

     

       428
       428
       +
                 postUri: testPostUri,

     

       429
       429
       +
                 voteDirection: 'up',

     

       430
       430
       +
                 voteUri: 'at://did:plc:test/social.coves.interaction.vote/456',

     

       431
       431
       +
               );

     

       432
       432
       +
       

     

       433
       433
       +
               expect(voteProvider.isLiked(testPostUri), true);

     

       434
       434
       +
       

     

       435
       435
       +
               // Simulate sign out by changing auth state

     

       436
       436
       +
               when(mockAuthProvider.isAuthenticated).thenReturn(false);

     

       437
       437
       +
       

     

       438
       438
       +
               // Trigger the auth listener by calling it directly

     

       439
       439
       +
               // (In real app, this would be triggered by AuthProvider.notifyListeners)

     

       440
       440
       +
               voteProvider.clear();

     

       441
       441
       +
       

     

       442
       442
       +
               // Votes should be cleared

     

       443
       443
       +
               expect(voteProvider.isLiked(testPostUri), false);

     

       444
       444
       +
               expect(voteProvider.getVoteState(testPostUri), null);

     

       445
       445
       +
             });

     

       446
       446
       +
       

     

       447
       447
       +
             test('should not clear votes when user is still authenticated', () {

     

       448
       448
       +
               const testPostUri = 'at://did:plc:test/social.coves.post.record/123';

     

       449
       449
       +
       

     

       450
       450
       +
               // Set up vote state

     

       451
       451
       +
               voteProvider.setInitialVoteState(

     

       452
       452
       +
                 postUri: testPostUri,

     

       453
       453
       +
                 voteDirection: 'up',

     

       454
       454
       +
                 voteUri: 'at://did:plc:test/social.coves.interaction.vote/456',

     

       455
       455
       +
               );

     

       456
       456
       +
       

     

       457
       457
       +
               expect(voteProvider.isLiked(testPostUri), true);

     

       458
       458
       +
       

     

       459
       459
       +
               // Auth state remains authenticated

     

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

     

       461
       461
       +
       

     

       462
       462
       +
               // Votes should NOT be cleared

     

       463
       463
       +
               expect(voteProvider.isLiked(testPostUri), true);

     

       464
       464
       +
             });

     

       465
       465
       +
           });

     

       466
       466
       +
         });

     

       467
       467
       +
       }

+157

test/providers/vote_provider_test.mocks.dart

···

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

     

       2
       2
       +
       // in coves_flutter/test/providers/vote_provider_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 _i3;

     

       7
       7
       +
       import 'dart:ui' as _i5;

     

       8
       8
       +
       

     

       9
       9
       +
       import 'package:coves_flutter/providers/auth_provider.dart' as _i4;

     

       10
       10
       +
       import 'package:coves_flutter/services/vote_service.dart' as _i2;

     

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

     

       12
       12
       +
       

     

       13
       13
       +
       // ignore_for_file: type=lint

     

       14
       14
       +
       // ignore_for_file: avoid_redundant_argument_values

     

       15
       15
       +
       // ignore_for_file: avoid_setters_without_getters

     

       16
       16
       +
       // ignore_for_file: comment_references

     

       17
       17
       +
       // ignore_for_file: deprecated_member_use

     

       18
       18
       +
       // ignore_for_file: deprecated_member_use_from_same_package

     

       19
       19
       +
       // ignore_for_file: implementation_imports

     

       20
       20
       +
       // ignore_for_file: invalid_use_of_visible_for_testing_member

     

       21
       21
       +
       // ignore_for_file: must_be_immutable

     

       22
       22
       +
       // ignore_for_file: prefer_const_constructors

     

       23
       23
       +
       // ignore_for_file: unnecessary_parenthesis

     

       24
       24
       +
       // ignore_for_file: camel_case_types

     

       25
       25
       +
       // ignore_for_file: subtype_of_sealed_class

     

       26
       26
       +
       // ignore_for_file: invalid_use_of_internal_member

     

       27
       27
       +
       

     

       28
       28
       +
       class _FakeVoteResponse_0 extends _i1.SmartFake implements _i2.VoteResponse {

     

       29
       29
       +
         _FakeVoteResponse_0(Object parent, Invocation parentInvocation)

     

       30
       30
       +
           : super(parent, parentInvocation);

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       /// A class which mocks [VoteService].

     

       34
       34
       +
       ///

     

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

     

       36
       36
       +
       class MockVoteService extends _i1.Mock implements _i2.VoteService {

     

       37
       37
       +
         MockVoteService() {

     

       38
       38
       +
           _i1.throwOnMissingStub(this);

     

       39
       39
       +
         }

     

       40
       40
       +
       

     

       41
       41
       +
         @override

     

       42
       42
       +
         _i3.Future<_i2.VoteResponse> createVote({

     

       43
       43
       +
           required String? postUri,

     

       44
       44
       +
           required String? postCid,

     

       45
       45
       +
           String? direction = 'up',

     

       46
       46
       +
         }) =>

     

       47
       47
       +
             (super.noSuchMethod(

     

       48
       48
       +
                   Invocation.method(#createVote, [], {

     

       49
       49
       +
                     #postUri: postUri,

     

       50
       50
       +
                     #postCid: postCid,

     

       51
       51
       +
                     #direction: direction,

     

       52
       52
       +
                   }),

     

       53
       53
       +
                   returnValue: _i3.Future<_i2.VoteResponse>.value(

     

       54
       54
       +
                     _FakeVoteResponse_0(

     

       55
       55
       +
                       this,

     

       56
       56
       +
                       Invocation.method(#createVote, [], {

     

       57
       57
       +
                         #postUri: postUri,

     

       58
       58
       +
                         #postCid: postCid,

     

       59
       59
       +
                         #direction: direction,

     

       60
       60
       +
                       }),

     

       61
       61
       +
                     ),

     

       62
       62
       +
                   ),

     

       63
       63
       +
                 )

     

       64
       64
       +
                 as _i3.Future<_i2.VoteResponse>);

     

       65
       65
       +
       }

     

       66
       66
       +
       

     

       67
       67
       +
       /// A class which mocks [AuthProvider].

     

       68
       68
       +
       ///

     

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

     

       70
       70
       +
       class MockAuthProvider extends _i1.Mock implements _i4.AuthProvider {

     

       71
       71
       +
         MockAuthProvider() {

     

       72
       72
       +
           _i1.throwOnMissingStub(this);

     

       73
       73
       +
         }

     

       74
       74
       +
       

     

       75
       75
       +
         @override

     

       76
       76
       +
         bool get isAuthenticated =>

     

       77
       77
       +
             (super.noSuchMethod(

     

       78
       78
       +
                   Invocation.getter(#isAuthenticated),

     

       79
       79
       +
                   returnValue: false,

     

       80
       80
       +
                 )

     

       81
       81
       +
                 as bool);

     

       82
       82
       +
       

     

       83
       83
       +
         @override

     

       84
       84
       +
         bool get isLoading =>

     

       85
       85
       +
             (super.noSuchMethod(Invocation.getter(#isLoading), returnValue: false)

     

       86
       86
       +
                 as bool);

     

       87
       87
       +
       

     

       88
       88
       +
         @override

     

       89
       89
       +
         bool get hasListeners =>

     

       90
       90
       +
             (super.noSuchMethod(Invocation.getter(#hasListeners), returnValue: false)

     

       91
       91
       +
                 as bool);

     

       92
       92
       +
       

     

       93
       93
       +
         @override

     

       94
       94
       +
         _i3.Future<String?> getAccessToken() =>

     

       95
       95
       +
             (super.noSuchMethod(

     

       96
       96
       +
                   Invocation.method(#getAccessToken, []),

     

       97
       97
       +
                   returnValue: _i3.Future<String?>.value(),

     

       98
       98
       +
                 )

     

       99
       99
       +
                 as _i3.Future<String?>);

     

       100
       100
       +
       

     

       101
       101
       +
         @override

     

       102
       102
       +
         _i3.Future<void> initialize() =>

     

       103
       103
       +
             (super.noSuchMethod(

     

       104
       104
       +
                   Invocation.method(#initialize, []),

     

       105
       105
       +
                   returnValue: _i3.Future<void>.value(),

     

       106
       106
       +
                   returnValueForMissingStub: _i3.Future<void>.value(),

     

       107
       107
       +
                 )

     

       108
       108
       +
                 as _i3.Future<void>);

     

       109
       109
       +
       

     

       110
       110
       +
         @override

     

       111
       111
       +
         _i3.Future<void> signIn(String? handle) =>

     

       112
       112
       +
             (super.noSuchMethod(

     

       113
       113
       +
                   Invocation.method(#signIn, [handle]),

     

       114
       114
       +
                   returnValue: _i3.Future<void>.value(),

     

       115
       115
       +
                   returnValueForMissingStub: _i3.Future<void>.value(),

     

       116
       116
       +
                 )

     

       117
       117
       +
                 as _i3.Future<void>);

     

       118
       118
       +
       

     

       119
       119
       +
         @override

     

       120
       120
       +
         _i3.Future<void> signOut() =>

     

       121
       121
       +
             (super.noSuchMethod(

     

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

     

       123
       123
       +
                   returnValue: _i3.Future<void>.value(),

     

       124
       124
       +
                   returnValueForMissingStub: _i3.Future<void>.value(),

     

       125
       125
       +
                 )

     

       126
       126
       +
                 as _i3.Future<void>);

     

       127
       127
       +
       

     

       128
       128
       +
         @override

     

       129
       129
       +
         void clearError() => super.noSuchMethod(

     

       130
       130
       +
           Invocation.method(#clearError, []),

     

       131
       131
       +
           returnValueForMissingStub: null,

     

       132
       132
       +
         );

     

       133
       133
       +
       

     

       134
       134
       +
         @override

     

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

     

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

     

       137
       137
       +
           returnValueForMissingStub: null,

     

       138
       138
       +
         );

     

       139
       139
       +
       

     

       140
       140
       +
         @override

     

       141
       141
       +
         void addListener(_i5.VoidCallback? listener) => super.noSuchMethod(

     

       142
       142
       +
           Invocation.method(#addListener, [listener]),

     

       143
       143
       +
           returnValueForMissingStub: null,

     

       144
       144
       +
         );

     

       145
       145
       +
       

     

       146
       146
       +
         @override

     

       147
       147
       +
         void removeListener(_i5.VoidCallback? listener) => super.noSuchMethod(

     

       148
       148
       +
           Invocation.method(#removeListener, [listener]),

     

       149
       149
       +
           returnValueForMissingStub: null,

     

       150
       150
       +
         );

     

       151
       151
       +
       

     

       152
       152
       +
         @override

     

       153
       153
       +
         void notifyListeners() => super.noSuchMethod(

     

       154
       154
       +
           Invocation.method(#notifyListeners, []),

     

       155
       155
       +
           returnValueForMissingStub: null,

     

       156
       156
       +
         );

     

       157
       157
       +
       }

+480

test/services/vote_service_test.dart

···

       1
       1
       +
       import 'dart:convert';

     

       2
       2
       +
       

     

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

     

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

     

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

     

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

     

       7
       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';

     

       13
       13
       +
       

     

       14
       14
       +
       // Generate mocks for OAuthSession

     

       15
       15
       +
       @GenerateMocks([OAuthSession])

     

       16
       16
       +
       void main() {

     

       17
       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
       +
       

     

       264
       264
       +
           group('createVote', () {

     

       265
       265
       +
       

     

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

     

       267
       267
       +
               // Create a real VoteService instance that we can test with

     

       268
       268
       +
               // We'll use a minimal test to verify the VoteResponse parsing logic

     

       269
       269
       +
       

     

       270
       270
       +
               const response = VoteResponse(

     

       271
       271
       +
                 uri: 'at://did:plc:test/social.coves.interaction.vote/456',

     

       272
       272
       +
                 cid: 'bafy123',

     

       273
       273
       +
                 rkey: '456',

     

       274
       274
       +
                 deleted: false,

     

       275
       275
       +
               );

     

       276
       276
       +
       

     

       277
       277
       +
               expect(response.uri, 'at://did:plc:test/social.coves.interaction.vote/456');

     

       278
       278
       +
               expect(response.cid, 'bafy123');

     

       279
       279
       +
               expect(response.rkey, '456');

     

       280
       280
       +
               expect(response.deleted, false);

     

       281
       281
       +
             });

     

       282
       282
       +
       

     

       283
       283
       +
             test('should return deleted response when vote is toggled off', () {

     

       284
       284
       +
               const response = VoteResponse(deleted: true);

     

       285
       285
       +
       

     

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

     

       287
       287
       +
               expect(response.uri, null);

     

       288
       288
       +
               expect(response.cid, null);

     

       289
       289
       +
             });

     

       290
       290
       +
       

     

       291
       291
       +
             test('should throw ApiException on Dio network error', () {

     

       292
       292
       +
               // Test ApiException.fromDioError for connection errors

     

       293
       293
       +
               final dioError = DioException(

     

       294
       294
       +
                 requestOptions: RequestOptions(path: '/test'),

     

       295
       295
       +
                 type: DioExceptionType.connectionError,

     

       296
       296
       +
               );

     

       297
       297
       +
       

     

       298
       298
       +
               final exception = ApiException.fromDioError(dioError);

     

       299
       299
       +
       

     

       300
       300
       +
               expect(exception, isA<NetworkException>());

     

       301
       301
       +
               expect(

     

       302
       302
       +
                 exception.message,

     

       303
       303
       +
                 contains('Connection failed'),

     

       304
       304
       +
               );

     

       305
       305
       +
             });

     

       306
       306
       +
       

     

       307
       307
       +
             test('should throw ApiException on Dio timeout', () {

     

       308
       308
       +
               final dioError = DioException(

     

       309
       309
       +
                 requestOptions: RequestOptions(path: '/test'),

     

       310
       310
       +
                 type: DioExceptionType.connectionTimeout,

     

       311
       311
       +
               );

     

       312
       312
       +
       

     

       313
       313
       +
               final exception = ApiException.fromDioError(dioError);

     

       314
       314
       +
       

     

       315
       315
       +
               expect(exception, isA<NetworkException>());

     

       316
       316
       +
               expect(exception.message, contains('timeout'));

     

       317
       317
       +
             });

     

       318
       318
       +
       

     

       319
       319
       +
             test('should throw AuthenticationException on 401 response', () {

     

       320
       320
       +
               final dioError = DioException(

     

       321
       321
       +
                 requestOptions: RequestOptions(path: '/test'),

     

       322
       322
       +
                 type: DioExceptionType.badResponse,

     

       323
       323
       +
                 response: Response(

     

       324
       324
       +
                   requestOptions: RequestOptions(path: '/test'),

     

       325
       325
       +
                   statusCode: 401,

     

       326
       326
       +
                   data: {'message': 'Unauthorized'},

     

       327
       327
       +
                 ),

     

       328
       328
       +
               );

     

       329
       329
       +
       

     

       330
       330
       +
               final exception = ApiException.fromDioError(dioError);

     

       331
       331
       +
       

     

       332
       332
       +
               expect(exception, isA<AuthenticationException>());

     

       333
       333
       +
               expect(exception.statusCode, 401);

     

       334
       334
       +
               expect(exception.message, 'Unauthorized');

     

       335
       335
       +
             });

     

       336
       336
       +
       

     

       337
       337
       +
             test('should throw NotFoundException on 404 response', () {

     

       338
       338
       +
               final dioError = DioException(

     

       339
       339
       +
                 requestOptions: RequestOptions(path: '/test'),

     

       340
       340
       +
                 type: DioExceptionType.badResponse,

     

       341
       341
       +
                 response: Response(

     

       342
       342
       +
                   requestOptions: RequestOptions(path: '/test'),

     

       343
       343
       +
                   statusCode: 404,

     

       344
       344
       +
                   data: {'message': 'Post not found'},

     

       345
       345
       +
                 ),

     

       346
       346
       +
               );

     

       347
       347
       +
       

     

       348
       348
       +
               final exception = ApiException.fromDioError(dioError);

     

       349
       349
       +
       

     

       350
       350
       +
               expect(exception, isA<NotFoundException>());

     

       351
       351
       +
               expect(exception.statusCode, 404);

     

       352
       352
       +
               expect(exception.message, 'Post not found');

     

       353
       353
       +
             });

     

       354
       354
       +
       

     

       355
       355
       +
             test('should throw ServerException on 500 response', () {

     

       356
       356
       +
               final dioError = DioException(

     

       357
       357
       +
                 requestOptions: RequestOptions(path: '/test'),

     

       358
       358
       +
                 type: DioExceptionType.badResponse,

     

       359
       359
       +
                 response: Response(

     

       360
       360
       +
                   requestOptions: RequestOptions(path: '/test'),

     

       361
       361
       +
                   statusCode: 500,

     

       362
       362
       +
                   data: {'error': 'Internal server error'},

     

       363
       363
       +
                 ),

     

       364
       364
       +
               );

     

       365
       365
       +
       

     

       366
       366
       +
               final exception = ApiException.fromDioError(dioError);

     

       367
       367
       +
       

     

       368
       368
       +
               expect(exception, isA<ServerException>());

     

       369
       369
       +
               expect(exception.statusCode, 500);

     

       370
       370
       +
               expect(exception.message, 'Internal server error');

     

       371
       371
       +
             });

     

       372
       372
       +
       

     

       373
       373
       +
             test('should extract error message from response data', () {

     

       374
       374
       +
               final dioError = DioException(

     

       375
       375
       +
                 requestOptions: RequestOptions(path: '/test'),

     

       376
       376
       +
                 type: DioExceptionType.badResponse,

     

       377
       377
       +
                 response: Response(

     

       378
       378
       +
                   requestOptions: RequestOptions(path: '/test'),

     

       379
       379
       +
                   statusCode: 400,

     

       380
       380
       +
                   data: {'message': 'Invalid post URI'},

     

       381
       381
       +
                 ),

     

       382
       382
       +
               );

     

       383
       383
       +
       

     

       384
       384
       +
               final exception = ApiException.fromDioError(dioError);

     

       385
       385
       +
       

     

       386
       386
       +
               expect(exception.message, 'Invalid post URI');

     

       387
       387
       +
               expect(exception.statusCode, 400);

     

       388
       388
       +
             });

     

       389
       389
       +
       

     

       390
       390
       +
             test('should use default message if no error message in response', () {

     

       391
       391
       +
               final dioError = DioException(

     

       392
       392
       +
                 requestOptions: RequestOptions(path: '/test'),

     

       393
       393
       +
                 type: DioExceptionType.badResponse,

     

       394
       394
       +
                 response: Response(

     

       395
       395
       +
                   requestOptions: RequestOptions(path: '/test'),

     

       396
       396
       +
                   statusCode: 400,

     

       397
       397
       +
                   data: {},

     

       398
       398
       +
                 ),

     

       399
       399
       +
               );

     

       400
       400
       +
       

     

       401
       401
       +
               final exception = ApiException.fromDioError(dioError);

     

       402
       402
       +
       

     

       403
       403
       +
               expect(exception.message, 'Server error');

     

       404
       404
       +
             });

     

       405
       405
       +
       

     

       406
       406
       +
             test('should handle cancelled requests', () {

     

       407
       407
       +
               final dioError = DioException(

     

       408
       408
       +
                 requestOptions: RequestOptions(path: '/test'),

     

       409
       409
       +
                 type: DioExceptionType.cancel,

     

       410
       410
       +
               );

     

       411
       411
       +
       

     

       412
       412
       +
               final exception = ApiException.fromDioError(dioError);

     

       413
       413
       +
       

     

       414
       414
       +
               expect(exception.message, contains('cancelled'));

     

       415
       415
       +
             });

     

       416
       416
       +
       

     

       417
       417
       +
             test('should handle bad certificate errors', () {

     

       418
       418
       +
               final dioError = DioException(

     

       419
       419
       +
                 requestOptions: RequestOptions(path: '/test'),

     

       420
       420
       +
                 type: DioExceptionType.badCertificate,

     

       421
       421
       +
               );

     

       422
       422
       +
       

     

       423
       423
       +
               final exception = ApiException.fromDioError(dioError);

     

       424
       424
       +
       

     

       425
       425
       +
               expect(exception, isA<NetworkException>());

     

       426
       426
       +
               expect(exception.message, contains('certificate'));

     

       427
       427
       +
             });

     

       428
       428
       +
       

     

       429
       429
       +
             test('should handle unknown errors', () {

     

       430
       430
       +
               final dioError = DioException(

     

       431
       431
       +
                 requestOptions: RequestOptions(path: '/test'),

     

       432
       432
       +
               );

     

       433
       433
       +
       

     

       434
       434
       +
               final exception = ApiException.fromDioError(dioError);

     

       435
       435
       +
       

     

       436
       436
       +
               expect(exception, isA<NetworkException>());

     

       437
       437
       +
               expect(exception.message, contains('Network error'));

     

       438
       438
       +
             });

     

       439
       439
       +
           });

     

       440
       440
       +
       

     

       441
       441
       +
           group('VoteResponse', () {

     

       442
       442
       +
             test('should create response with uri, cid, and rkey', () {

     

       443
       443
       +
               const response = VoteResponse(

     

       444
       444
       +
                 uri: 'at://vote/123',

     

       445
       445
       +
                 cid: 'bafy123',

     

       446
       446
       +
                 rkey: '123',

     

       447
       447
       +
                 deleted: false,

     

       448
       448
       +
               );

     

       449
       449
       +
       

     

       450
       450
       +
               expect(response.uri, 'at://vote/123');

     

       451
       451
       +
               expect(response.cid, 'bafy123');

     

       452
       452
       +
               expect(response.rkey, '123');

     

       453
       453
       +
               expect(response.deleted, false);

     

       454
       454
       +
             });

     

       455
       455
       +
       

     

       456
       456
       +
             test('should create response with rkey extracted from uri', () {

     

       457
       457
       +
               const response = VoteResponse(

     

       458
       458
       +
                 uri: 'at://vote/456',

     

       459
       459
       +
                 cid: 'bafy456',

     

       460
       460
       +
                 rkey: '456',

     

       461
       461
       +
                 deleted: false,

     

       462
       462
       +
               );

     

       463
       463
       +
       

     

       464
       464
       +
               expect(response.uri, 'at://vote/456');

     

       465
       465
       +
               expect(response.cid, 'bafy456');

     

       466
       466
       +
               expect(response.rkey, '456');

     

       467
       467
       +
               expect(response.deleted, false);

     

       468
       468
       +
             });

     

       469
       469
       +
       

     

       470
       470
       +
             test('should create deleted response', () {

     

       471
       471
       +
               const response = VoteResponse(deleted: true);

     

       472
       472
       +
       

     

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

     

       474
       474
       +
               expect(response.uri, null);

     

       475
       475
       +
               expect(response.cid, null);

     

       476
       476
       +
               expect(response.rkey, null);

     

       477
       477
       +
             });

     

       478
       478
       +
           });

     

       479
       479
       +
         });

     

       480
       480
       +
       }

+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
       +
       }

+333

test/widgets/animated_heart_icon_test.dart

···

       1
       1
       +
       import 'package:coves_flutter/widgets/icons/animated_heart_icon.dart';

     

       2
       2
       +
       import 'package:flutter/material.dart';

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       void main() {

     

       6
       6
       +
         group('AnimatedHeartIcon', () {

     

       7
       7
       +
           testWidgets('should render with default size', (tester) async {

     

       8
       8
       +
             await tester.pumpWidget(

     

       9
       9
       +
               const MaterialApp(

     

       10
       10
       +
                 home: Scaffold(

     

       11
       11
       +
                   body: AnimatedHeartIcon(isLiked: false),

     

       12
       12
       +
                 ),

     

       13
       13
       +
               ),

     

       14
       14
       +
             );

     

       15
       15
       +
       

     

       16
       16
       +
             // Widget should render

     

       17
       17
       +
             expect(find.byType(AnimatedHeartIcon), findsOneWidget);

     

       18
       18
       +
       

     

       19
       19
       +
             // Find the SizedBox that defines the size

     

       20
       20
       +
             final sizedBox = tester.widget<SizedBox>(

     

       21
       21
       +
               find.descendant(

     

       22
       22
       +
                 of: find.byType(AnimatedHeartIcon),

     

       23
       23
       +
                 matching: find.byType(SizedBox),

     

       24
       24
       +
               ).first,

     

       25
       25
       +
             );

     

       26
       26
       +
       

     

       27
       27
       +
             // Default size should be 18

     

       28
       28
       +
             expect(sizedBox.width, 18);

     

       29
       29
       +
             expect(sizedBox.height, 18);

     

       30
       30
       +
           });

     

       31
       31
       +
       

     

       32
       32
       +
           testWidgets('should render with custom size', (tester) async {

     

       33
       33
       +
             await tester.pumpWidget(

     

       34
       34
       +
               const MaterialApp(

     

       35
       35
       +
                 home: Scaffold(

     

       36
       36
       +
                   body: AnimatedHeartIcon(isLiked: false, size: 32),

     

       37
       37
       +
                 ),

     

       38
       38
       +
               ),

     

       39
       39
       +
             );

     

       40
       40
       +
       

     

       41
       41
       +
             // Find the SizedBox that defines the size

     

       42
       42
       +
             final sizedBox = tester.widget<SizedBox>(

     

       43
       43
       +
               find.descendant(

     

       44
       44
       +
                 of: find.byType(AnimatedHeartIcon),

     

       45
       45
       +
                 matching: find.byType(SizedBox),

     

       46
       46
       +
               ).first,

     

       47
       47
       +
             );

     

       48
       48
       +
       

     

       49
       49
       +
             // Custom size should be 32

     

       50
       50
       +
             expect(sizedBox.width, 32);

     

       51
       51
       +
             expect(sizedBox.height, 32);

     

       52
       52
       +
           });

     

       53
       53
       +
       

     

       54
       54
       +
           testWidgets('should use custom color when provided', (tester) async {

     

       55
       55
       +
             const customColor = Colors.blue;

     

       56
       56
       +
       

     

       57
       57
       +
             await tester.pumpWidget(

     

       58
       58
       +
               const MaterialApp(

     

       59
       59
       +
                 home: Scaffold(

     

       60
       60
       +
                   body: AnimatedHeartIcon(

     

       61
       61
       +
                     isLiked: false,

     

       62
       62
       +
                     color: customColor,

     

       63
       63
       +
                   ),

     

       64
       64
       +
                 ),

     

       65
       65
       +
               ),

     

       66
       66
       +
             );

     

       67
       67
       +
       

     

       68
       68
       +
             // Widget should render with custom color

     

       69
       69
       +
             expect(find.byType(AnimatedHeartIcon), findsOneWidget);

     

       70
       70
       +
             // Note: We can't easily verify the color without accessing the CustomPainter,

     

       71
       71
       +
             // but we can verify the widget accepts the parameter

     

       72
       72
       +
           });

     

       73
       73
       +
       

     

       74
       74
       +
           testWidgets('should use custom liked color when provided', (tester) async {

     

       75
       75
       +
             const customLikedColor = Colors.pink;

     

       76
       76
       +
       

     

       77
       77
       +
             await tester.pumpWidget(

     

       78
       78
       +
               const MaterialApp(

     

       79
       79
       +
                 home: Scaffold(

     

       80
       80
       +
                   body: AnimatedHeartIcon(

     

       81
       81
       +
                     isLiked: true,

     

       82
       82
       +
                     likedColor: customLikedColor,

     

       83
       83
       +
                   ),

     

       84
       84
       +
                 ),

     

       85
       85
       +
               ),

     

       86
       86
       +
             );

     

       87
       87
       +
       

     

       88
       88
       +
             // Widget should render with custom liked color

     

       89
       89
       +
             expect(find.byType(AnimatedHeartIcon), findsOneWidget);

     

       90
       90
       +
           });

     

       91
       91
       +
       

     

       92
       92
       +
           testWidgets('should start animation when isLiked changes to true',

     

       93
       93
       +
               (tester) async {

     

       94
       94
       +
             // Start with unliked state

     

       95
       95
       +
             await tester.pumpWidget(

     

       96
       96
       +
               const MaterialApp(

     

       97
       97
       +
                 home: Scaffold(

     

       98
       98
       +
                   body: AnimatedHeartIcon(isLiked: false),

     

       99
       99
       +
                 ),

     

       100
       100
       +
               ),

     

       101
       101
       +
             );

     

       102
       102
       +
       

     

       103
       103
       +
             // Verify initial state

     

       104
       104
       +
             expect(find.byType(AnimatedHeartIcon), findsOneWidget);

     

       105
       105
       +
       

     

       106
       106
       +
             // Change to liked state

     

       107
       107
       +
             await tester.pumpWidget(

     

       108
       108
       +
               const MaterialApp(

     

       109
       109
       +
                 home: Scaffold(

     

       110
       110
       +
                   body: AnimatedHeartIcon(isLiked: true),

     

       111
       111
       +
                 ),

     

       112
       112
       +
               ),

     

       113
       113
       +
             );

     

       114
       114
       +
       

     

       115
       115
       +
             // Pump frames to allow animation to start

     

       116
       116
       +
             await tester.pump();

     

       117
       117
       +
             await tester.pump(const Duration(milliseconds: 100));

     

       118
       118
       +
       

     

       119
       119
       +
             // Widget should still be present and animating

     

       120
       120
       +
             expect(find.byType(AnimatedHeartIcon), findsOneWidget);

     

       121
       121
       +
           });

     

       122
       122
       +
       

     

       123
       123
       +
           testWidgets('should not animate when isLiked changes to false',

     

       124
       124
       +
               (tester) async {

     

       125
       125
       +
             // Start with liked state

     

       126
       126
       +
             await tester.pumpWidget(

     

       127
       127
       +
               const MaterialApp(

     

       128
       128
       +
                 home: Scaffold(

     

       129
       129
       +
                   body: AnimatedHeartIcon(isLiked: true),

     

       130
       130
       +
                 ),

     

       131
       131
       +
               ),

     

       132
       132
       +
             );

     

       133
       133
       +
       

     

       134
       134
       +
             await tester.pump();

     

       135
       135
       +
       

     

       136
       136
       +
             // Change to unliked state

     

       137
       137
       +
             await tester.pumpWidget(

     

       138
       138
       +
               const MaterialApp(

     

       139
       139
       +
                 home: Scaffold(

     

       140
       140
       +
                   body: AnimatedHeartIcon(isLiked: false),

     

       141
       141
       +
                 ),

     

       142
       142
       +
               ),

     

       143
       143
       +
             );

     

       144
       144
       +
       

     

       145
       145
       +
             await tester.pump();

     

       146
       146
       +
       

     

       147
       147
       +
             // Widget should update without error

     

       148
       148
       +
             expect(find.byType(AnimatedHeartIcon), findsOneWidget);

     

       149
       149
       +
           });

     

       150
       150
       +
       

     

       151
       151
       +
           testWidgets('should complete animation after duration', (tester) async {

     

       152
       152
       +
             // Start with unliked state

     

       153
       153
       +
             await tester.pumpWidget(

     

       154
       154
       +
               const MaterialApp(

     

       155
       155
       +
                 home: Scaffold(

     

       156
       156
       +
                   body: AnimatedHeartIcon(isLiked: false),

     

       157
       157
       +
                 ),

     

       158
       158
       +
               ),

     

       159
       159
       +
             );

     

       160
       160
       +
       

     

       161
       161
       +
             // Change to liked state

     

       162
       162
       +
             await tester.pumpWidget(

     

       163
       163
       +
               const MaterialApp(

     

       164
       164
       +
                 home: Scaffold(

     

       165
       165
       +
                   body: AnimatedHeartIcon(isLiked: true),

     

       166
       166
       +
                 ),

     

       167
       167
       +
               ),

     

       168
       168
       +
             );

     

       169
       169
       +
       

     

       170
       170
       +
             // Pump through the entire animation duration (800ms)

     

       171
       171
       +
             await tester.pump();

     

       172
       172
       +
             await tester.pump(const Duration(milliseconds: 800));

     

       173
       173
       +
             await tester.pumpAndSettle();

     

       174
       174
       +
       

     

       175
       175
       +
             // Widget should still be present after animation completes

     

       176
       176
       +
             expect(find.byType(AnimatedHeartIcon), findsOneWidget);

     

       177
       177
       +
           });

     

       178
       178
       +
       

     

       179
       179
       +
           testWidgets('should handle rapid state changes', (tester) async {

     

       180
       180
       +
             // Start with unliked state

     

       181
       181
       +
             await tester.pumpWidget(

     

       182
       182
       +
               const MaterialApp(

     

       183
       183
       +
                 home: Scaffold(

     

       184
       184
       +
                   body: AnimatedHeartIcon(isLiked: false),

     

       185
       185
       +
                 ),

     

       186
       186
       +
               ),

     

       187
       187
       +
             );

     

       188
       188
       +
       

     

       189
       189
       +
             // Rapidly toggle states

     

       190
       190
       +
             await tester.pumpWidget(

     

       191
       191
       +
               const MaterialApp(

     

       192
       192
       +
                 home: Scaffold(

     

       193
       193
       +
                   body: AnimatedHeartIcon(isLiked: true),

     

       194
       194
       +
                 ),

     

       195
       195
       +
               ),

     

       196
       196
       +
             );

     

       197
       197
       +
             await tester.pump(const Duration(milliseconds: 50));

     

       198
       198
       +
       

     

       199
       199
       +
             await tester.pumpWidget(

     

       200
       200
       +
               const MaterialApp(

     

       201
       201
       +
                 home: Scaffold(

     

       202
       202
       +
                   body: AnimatedHeartIcon(isLiked: false),

     

       203
       203
       +
                 ),

     

       204
       204
       +
               ),

     

       205
       205
       +
             );

     

       206
       206
       +
             await tester.pump(const Duration(milliseconds: 50));

     

       207
       207
       +
       

     

       208
       208
       +
             await tester.pumpWidget(

     

       209
       209
       +
               const MaterialApp(

     

       210
       210
       +
                 home: Scaffold(

     

       211
       211
       +
                   body: AnimatedHeartIcon(isLiked: true),

     

       212
       212
       +
                 ),

     

       213
       213
       +
               ),

     

       214
       214
       +
             );

     

       215
       215
       +
             await tester.pump(const Duration(milliseconds: 50));

     

       216
       216
       +
       

     

       217
       217
       +
             // Widget should handle rapid changes without error

     

       218
       218
       +
             expect(find.byType(AnimatedHeartIcon), findsOneWidget);

     

       219
       219
       +
           });

     

       220
       220
       +
       

     

       221
       221
       +
           testWidgets('should use OverflowBox to allow animation overflow',

     

       222
       222
       +
               (tester) async {

     

       223
       223
       +
             await tester.pumpWidget(

     

       224
       224
       +
               const MaterialApp(

     

       225
       225
       +
                 home: Scaffold(

     

       226
       226
       +
                   body: AnimatedHeartIcon(isLiked: true),

     

       227
       227
       +
                 ),

     

       228
       228
       +
               ),

     

       229
       229
       +
             );

     

       230
       230
       +
       

     

       231
       231
       +
             // Find the OverflowBox

     

       232
       232
       +
             expect(find.byType(OverflowBox), findsOneWidget);

     

       233
       233
       +
       

     

       234
       234
       +
             final overflowBox = tester.widget<OverflowBox>(

     

       235
       235
       +
               find.byType(OverflowBox),

     

       236
       236
       +
             );

     

       237
       237
       +
       

     

       238
       238
       +
             // OverflowBox should have larger max dimensions (2.5x the icon size)

     

       239
       239
       +
             // to accommodate the 1.3x scale and particle burst

     

       240
       240
       +
             expect(overflowBox.maxWidth, 18 * 2.5);

     

       241
       241
       +
             expect(overflowBox.maxHeight, 18 * 2.5);

     

       242
       242
       +
           });

     

       243
       243
       +
       

     

       244
       244
       +
           testWidgets('should render CustomPaint for heart icon', (tester) async {

     

       245
       245
       +
             await tester.pumpWidget(

     

       246
       246
       +
               const MaterialApp(

     

       247
       247
       +
                 home: Scaffold(

     

       248
       248
       +
                   body: AnimatedHeartIcon(isLiked: false),

     

       249
       249
       +
                 ),

     

       250
       250
       +
               ),

     

       251
       251
       +
             );

     

       252
       252
       +
       

     

       253
       253
       +
             // Find the CustomPaint widget (used for rendering the heart)

     

       254
       254
       +
             expect(find.byType(CustomPaint), findsAtLeastNWidgets(1));

     

       255
       255
       +
           });

     

       256
       256
       +
       

     

       257
       257
       +
           testWidgets('should not animate on initial render when isLiked is true',

     

       258
       258
       +
               (tester) async {

     

       259
       259
       +
             // Render with isLiked=true initially

     

       260
       260
       +
             await tester.pumpWidget(

     

       261
       261
       +
               const MaterialApp(

     

       262
       262
       +
                 home: Scaffold(

     

       263
       263
       +
                   body: AnimatedHeartIcon(isLiked: true),

     

       264
       264
       +
                 ),

     

       265
       265
       +
               ),

     

       266
       266
       +
             );

     

       267
       267
       +
       

     

       268
       268
       +
             await tester.pump();

     

       269
       269
       +
       

     

       270
       270
       +
             // Widget should render in liked state without animation

     

       271
       271
       +
             // (Animation only triggers on state change, not initial render)

     

       272
       272
       +
             expect(find.byType(AnimatedHeartIcon), findsOneWidget);

     

       273
       273
       +
           });

     

       274
       274
       +
       

     

       275
       275
       +
           testWidgets('should dispose controller properly', (tester) async {

     

       276
       276
       +
             await tester.pumpWidget(

     

       277
       277
       +
               const MaterialApp(

     

       278
       278
       +
                 home: Scaffold(

     

       279
       279
       +
                   body: AnimatedHeartIcon(isLiked: false),

     

       280
       280
       +
                 ),

     

       281
       281
       +
               ),

     

       282
       282
       +
             );

     

       283
       283
       +
       

     

       284
       284
       +
             // Remove the widget

     

       285
       285
       +
             await tester.pumpWidget(

     

       286
       286
       +
               const MaterialApp(

     

       287
       287
       +
                 home: Scaffold(

     

       288
       288
       +
                   body: SizedBox.shrink(),

     

       289
       289
       +
                 ),

     

       290
       290
       +
               ),

     

       291
       291
       +
             );

     

       292
       292
       +
       

     

       293
       293
       +
             // Should dispose without error

     

       294
       294
       +
             // (No assertions needed - test passes if no exception is thrown)

     

       295
       295
       +
           });

     

       296
       296
       +
       

     

       297
       297
       +
           testWidgets('should rebuild when isLiked changes', (tester) async {

     

       298
       298
       +
             var buildCount = 0;

     

       299
       299
       +
       

     

       300
       300
       +
             await tester.pumpWidget(

     

       301
       301
       +
               MaterialApp(

     

       302
       302
       +
                 home: Scaffold(

     

       303
       303
       +
                   body: Builder(

     

       304
       304
       +
                     builder: (context) {

     

       305
       305
       +
                       buildCount++;

     

       306
       306
       +
                       return const AnimatedHeartIcon(isLiked: false);

     

       307
       307
       +
                     },

     

       308
       308
       +
                   ),

     

       309
       309
       +
                 ),

     

       310
       310
       +
               ),

     

       311
       311
       +
             );

     

       312
       312
       +
       

     

       313
       313
       +
             final initialBuildCount = buildCount;

     

       314
       314
       +
       

     

       315
       315
       +
             // Change isLiked state

     

       316
       316
       +
             await tester.pumpWidget(

     

       317
       317
       +
               MaterialApp(

     

       318
       318
       +
                 home: Scaffold(

     

       319
       319
       +
                   body: Builder(

     

       320
       320
       +
                     builder: (context) {

     

       321
       321
       +
                       buildCount++;

     

       322
       322
       +
                       return const AnimatedHeartIcon(isLiked: true);

     

       323
       323
       +
                     },

     

       324
       324
       +
                   ),

     

       325
       325
       +
                 ),

     

       326
       326
       +
               ),

     

       327
       327
       +
             );

     

       328
       328
       +
       

     

       329
       329
       +
             // Should rebuild

     

       330
       330
       +
             expect(buildCount, greaterThan(initialBuildCount));

     

       331
       331
       +
           });

     

       332
       332
       +
         });

     

       333
       333
       +
       }

+28

test/widgets/feed_screen_test.dart

···

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

     

       2
       2
        
       import 'package:coves_flutter/providers/auth_provider.dart';

     

       3
       3
        
       import 'package:coves_flutter/providers/feed_provider.dart';

     

       4
       4
       +
       import 'package:coves_flutter/providers/vote_provider.dart';

     

       4
       5
        
       import 'package:coves_flutter/screens/home/feed_screen.dart';

     

       6
       6
       +
       import 'package:coves_flutter/services/vote_service.dart';

     

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

     

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

     

       7
       9
        
       import 'package:provider/provider.dart';

     
···

       24
       26
        
       

     

       25
       27
        
         void setLoading({required bool value}) {

     

       26
       28
        
           _isLoading = value;

     

       29
       29
       +
           notifyListeners();

     

       30
       30
       +
         }

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       // Fake VoteProvider for testing

     

       34
       34
       +
       class FakeVoteProvider extends VoteProvider {

     

       35
       35
       +
         FakeVoteProvider()

     

       36
       36
       +
             : super(

     

       37
       37
       +
                 voteService: VoteService(

     

       38
       38
       +
                   sessionGetter: () async => null,

     

       39
       39
       +
                   didGetter: () => null,

     

       40
       40
       +
                   pdsUrlGetter: () => null,

     

       41
       41
       +
                 ),

     

       42
       42
       +
                 authProvider: FakeAuthProvider(),

     

       43
       43
       +
               );

     

       44
       44
       +
       

     

       45
       45
       +
         final Map<String, bool> _likes = {};

     

       46
       46
       +
       

     

       47
       47
       +
         @override

     

       48
       48
       +
         bool isLiked(String postUri) => _likes[postUri] ?? false;

     

       49
       49
       +
       

     

       50
       50
       +
         void setLiked(String postUri, bool value) {

     

       51
       51
       +
           _likes[postUri] = value;

     

       27
       52
        
           notifyListeners();

     

       28
       53
        
         }

     

       29
       54
        
       }

     
···

       103
       128
        
         group('FeedScreen Widget Tests', () {

     

       104
       129
        
           late FakeAuthProvider fakeAuthProvider;

     

       105
       130
        
           late FakeFeedProvider fakeFeedProvider;

     

       131
       131
       +
           late FakeVoteProvider fakeVoteProvider;

     

       106
       132
        
       

     

       107
       133
        
           setUp(() {

     

       108
       134
        
             fakeAuthProvider = FakeAuthProvider();

     

       109
       135
        
             fakeFeedProvider = FakeFeedProvider();

     

       136
       136
       +
             fakeVoteProvider = FakeVoteProvider();

     

       110
       137
        
           });

     

       111
       138
        
       

     

       112
       139
        
           Widget createTestWidget() {

     
···

       114
       141
        
               providers: [

     

       115
       142
        
                 ChangeNotifierProvider<AuthProvider>.value(value: fakeAuthProvider),

     

       116
       143
        
                 ChangeNotifierProvider<FeedProvider>.value(value: fakeFeedProvider),

     

       144
       144
       +
                 ChangeNotifierProvider<VoteProvider>.value(value: fakeVoteProvider),

     

       117
       145
        
               ],

     

       118
       146
        
               child: const MaterialApp(home: FeedScreen()),

     

       119
       147
        
             );

-252

test/widgets/feed_screen_test.mocks.dart

···

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

     

       2
       2
       -
       // in coves_flutter/test/widgets/feed_screen_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 _i3;

     

       7
       7
       -
       import 'dart:ui' as _i4;

     

       8
       8
       -
       

     

       9
       9
       -
       import 'package:coves_flutter/models/post.dart' as _i6;

     

       10
       10
       -
       import 'package:coves_flutter/providers/auth_provider.dart' as _i2;

     

       11
       11
       -
       import 'package:coves_flutter/providers/feed_provider.dart' as _i5;

     

       12
       12
       -
       import 'package:mockito/mockito.dart' as _i1;

     

       13
       13
       -
       import 'package:mockito/src/dummies.dart' as _i7;

     

       14
       14
       -
       

     

       15
       15
       -
       // ignore_for_file: type=lint

     

       16
       16
       -
       // ignore_for_file: avoid_redundant_argument_values

     

       17
       17
       -
       // ignore_for_file: avoid_setters_without_getters

     

       18
       18
       -
       // ignore_for_file: comment_references

     

       19
       19
       -
       // ignore_for_file: deprecated_member_use

     

       20
       20
       -
       // ignore_for_file: deprecated_member_use_from_same_package

     

       21
       21
       -
       // ignore_for_file: implementation_imports

     

       22
       22
       -
       // ignore_for_file: invalid_use_of_visible_for_testing_member

     

       23
       23
       -
       // ignore_for_file: must_be_immutable

     

       24
       24
       -
       // ignore_for_file: prefer_const_constructors

     

       25
       25
       -
       // ignore_for_file: unnecessary_parenthesis

     

       26
       26
       -
       // ignore_for_file: camel_case_types

     

       27
       27
       -
       // ignore_for_file: subtype_of_sealed_class

     

       28
       28
       -
       // ignore_for_file: invalid_use_of_internal_member

     

       29
       29
       -
       

     

       30
       30
       -
       /// A class which mocks [AuthProvider].

     

       31
       31
       -
       ///

     

       32
       32
       -
       /// See the documentation for Mockito's code generation for more information.

     

       33
       33
       -
       class MockAuthProvider extends _i1.Mock implements _i2.AuthProvider {

     

       34
       34
       -
         MockAuthProvider() {

     

       35
       35
       -
           _i1.throwOnMissingStub(this);

     

       36
       36
       -
         }

     

       37
       37
       -
       

     

       38
       38
       -
         @override

     

       39
       39
       -
         bool get isAuthenticated =>

     

       40
       40
       -
             (super.noSuchMethod(

     

       41
       41
       -
                   Invocation.getter(#isAuthenticated),

     

       42
       42
       -
                   returnValue: false,

     

       43
       43
       -
                 )

     

       44
       44
       -
                 as bool);

     

       45
       45
       -
       

     

       46
       46
       -
         @override

     

       47
       47
       -
         bool get isLoading =>

     

       48
       48
       -
             (super.noSuchMethod(Invocation.getter(#isLoading), returnValue: false)

     

       49
       49
       -
                 as bool);

     

       50
       50
       -
       

     

       51
       51
       -
         @override

     

       52
       52
       -
         bool get hasListeners =>

     

       53
       53
       -
             (super.noSuchMethod(Invocation.getter(#hasListeners), returnValue: false)

     

       54
       54
       -
                 as bool);

     

       55
       55
       -
       

     

       56
       56
       -
         @override

     

       57
       57
       -
         _i3.Future<String?> getAccessToken() =>

     

       58
       58
       -
             (super.noSuchMethod(

     

       59
       59
       -
                   Invocation.method(#getAccessToken, []),

     

       60
       60
       -
                   returnValue: _i3.Future<String?>.value(),

     

       61
       61
       -
                 )

     

       62
       62
       -
                 as _i3.Future<String?>);

     

       63
       63
       -
       

     

       64
       64
       -
         @override

     

       65
       65
       -
         _i3.Future<void> initialize() =>

     

       66
       66
       -
             (super.noSuchMethod(

     

       67
       67
       -
                   Invocation.method(#initialize, []),

     

       68
       68
       -
                   returnValue: _i3.Future<void>.value(),

     

       69
       69
       -
                   returnValueForMissingStub: _i3.Future<void>.value(),

     

       70
       70
       -
                 )

     

       71
       71
       -
                 as _i3.Future<void>);

     

       72
       72
       -
       

     

       73
       73
       -
         @override

     

       74
       74
       -
         _i3.Future<void> signIn(String? handle) =>

     

       75
       75
       -
             (super.noSuchMethod(

     

       76
       76
       -
                   Invocation.method(#signIn, [handle]),

     

       77
       77
       -
                   returnValue: _i3.Future<void>.value(),

     

       78
       78
       -
                   returnValueForMissingStub: _i3.Future<void>.value(),

     

       79
       79
       -
                 )

     

       80
       80
       -
                 as _i3.Future<void>);

     

       81
       81
       -
       

     

       82
       82
       -
         @override

     

       83
       83
       -
         _i3.Future<void> signOut() =>

     

       84
       84
       -
             (super.noSuchMethod(

     

       85
       85
       -
                   Invocation.method(#signOut, []),

     

       86
       86
       -
                   returnValue: _i3.Future<void>.value(),

     

       87
       87
       -
                   returnValueForMissingStub: _i3.Future<void>.value(),

     

       88
       88
       -
                 )

     

       89
       89
       -
                 as _i3.Future<void>);

     

       90
       90
       -
       

     

       91
       91
       -
         @override

     

       92
       92
       -
         void clearError() => super.noSuchMethod(

     

       93
       93
       -
           Invocation.method(#clearError, []),

     

       94
       94
       -
           returnValueForMissingStub: null,

     

       95
       95
       -
         );

     

       96
       96
       -
       

     

       97
       97
       -
         @override

     

       98
       98
       -
         void dispose() => super.noSuchMethod(

     

       99
       99
       -
           Invocation.method(#dispose, []),

     

       100
       100
       -
           returnValueForMissingStub: null,

     

       101
       101
       -
         );

     

       102
       102
       -
       

     

       103
       103
       -
         @override

     

       104
       104
       -
         void addListener(_i4.VoidCallback? listener) => super.noSuchMethod(

     

       105
       105
       -
           Invocation.method(#addListener, [listener]),

     

       106
       106
       -
           returnValueForMissingStub: null,

     

       107
       107
       -
         );

     

       108
       108
       -
       

     

       109
       109
       -
         @override

     

       110
       110
       -
         void removeListener(_i4.VoidCallback? listener) => super.noSuchMethod(

     

       111
       111
       -
           Invocation.method(#removeListener, [listener]),

     

       112
       112
       -
           returnValueForMissingStub: null,

     

       113
       113
       -
         );

     

       114
       114
       -
       

     

       115
       115
       -
         @override

     

       116
       116
       -
         void notifyListeners() => super.noSuchMethod(

     

       117
       117
       -
           Invocation.method(#notifyListeners, []),

     

       118
       118
       -
           returnValueForMissingStub: null,

     

       119
       119
       -
         );

     

       120
       120
       -
       }

     

       121
       121
       -
       

     

       122
       122
       -
       /// A class which mocks [FeedProvider].

     

       123
       123
       -
       ///

     

       124
       124
       -
       /// See the documentation for Mockito's code generation for more information.

     

       125
       125
       -
       class MockFeedProvider extends _i1.Mock implements _i5.FeedProvider {

     

       126
       126
       -
         MockFeedProvider() {

     

       127
       127
       -
           _i1.throwOnMissingStub(this);

     

       128
       128
       -
         }

     

       129
       129
       -
       

     

       130
       130
       -
         @override

     

       131
       131
       -
         List<_i6.FeedViewPost> get posts =>

     

       132
       132
       -
             (super.noSuchMethod(

     

       133
       133
       -
                   Invocation.getter(#posts),

     

       134
       134
       -
                   returnValue: <_i6.FeedViewPost>[],

     

       135
       135
       -
                 )

     

       136
       136
       -
                 as List<_i6.FeedViewPost>);

     

       137
       137
       -
       

     

       138
       138
       -
         @override

     

       139
       139
       -
         bool get isLoading =>

     

       140
       140
       -
             (super.noSuchMethod(Invocation.getter(#isLoading), returnValue: false)

     

       141
       141
       -
                 as bool);

     

       142
       142
       -
       

     

       143
       143
       -
         @override

     

       144
       144
       -
         bool get isLoadingMore =>

     

       145
       145
       -
             (super.noSuchMethod(Invocation.getter(#isLoadingMore), returnValue: false)

     

       146
       146
       -
                 as bool);

     

       147
       147
       -
       

     

       148
       148
       -
         @override

     

       149
       149
       -
         bool get hasMore =>

     

       150
       150
       -
             (super.noSuchMethod(Invocation.getter(#hasMore), returnValue: false)

     

       151
       151
       -
                 as bool);

     

       152
       152
       -
       

     

       153
       153
       -
         @override

     

       154
       154
       -
         String get sort =>

     

       155
       155
       -
             (super.noSuchMethod(

     

       156
       156
       -
                   Invocation.getter(#sort),

     

       157
       157
       -
                   returnValue: _i7.dummyValue<String>(this, Invocation.getter(#sort)),

     

       158
       158
       -
                 )

     

       159
       159
       -
                 as String);

     

       160
       160
       -
       

     

       161
       161
       -
         @override

     

       162
       162
       -
         bool get hasListeners =>

     

       163
       163
       -
             (super.noSuchMethod(Invocation.getter(#hasListeners), returnValue: false)

     

       164
       164
       -
                 as bool);

     

       165
       165
       -
       

     

       166
       166
       -
         @override

     

       167
       167
       -
         _i3.Future<void> loadFeed({bool? refresh = false}) =>

     

       168
       168
       -
             (super.noSuchMethod(

     

       169
       169
       -
                   Invocation.method(#loadFeed, [], {#refresh: refresh}),

     

       170
       170
       -
                   returnValue: _i3.Future<void>.value(),

     

       171
       171
       -
                   returnValueForMissingStub: _i3.Future<void>.value(),

     

       172
       172
       -
                 )

     

       173
       173
       -
                 as _i3.Future<void>);

     

       174
       174
       -
       

     

       175
       175
       -
         @override

     

       176
       176
       -
         _i3.Future<void> fetchTimeline({bool? refresh = false}) =>

     

       177
       177
       -
             (super.noSuchMethod(

     

       178
       178
       -
                   Invocation.method(#fetchTimeline, [], {#refresh: refresh}),

     

       179
       179
       -
                   returnValue: _i3.Future<void>.value(),

     

       180
       180
       -
                   returnValueForMissingStub: _i3.Future<void>.value(),

     

       181
       181
       -
                 )

     

       182
       182
       -
                 as _i3.Future<void>);

     

       183
       183
       -
       

     

       184
       184
       -
         @override

     

       185
       185
       -
         _i3.Future<void> fetchDiscover({bool? refresh = false}) =>

     

       186
       186
       -
             (super.noSuchMethod(

     

       187
       187
       -
                   Invocation.method(#fetchDiscover, [], {#refresh: refresh}),

     

       188
       188
       -
                   returnValue: _i3.Future<void>.value(),

     

       189
       189
       -
                   returnValueForMissingStub: _i3.Future<void>.value(),

     

       190
       190
       -
                 )

     

       191
       191
       -
                 as _i3.Future<void>);

     

       192
       192
       -
       

     

       193
       193
       -
         @override

     

       194
       194
       -
         _i3.Future<void> loadMore() =>

     

       195
       195
       -
             (super.noSuchMethod(

     

       196
       196
       -
                   Invocation.method(#loadMore, []),

     

       197
       197
       -
                   returnValue: _i3.Future<void>.value(),

     

       198
       198
       -
                   returnValueForMissingStub: _i3.Future<void>.value(),

     

       199
       199
       -
                 )

     

       200
       200
       -
                 as _i3.Future<void>);

     

       201
       201
       -
       

     

       202
       202
       -
         @override

     

       203
       203
       -
         void setSort(String? newSort, {String? newTimeframe}) => super.noSuchMethod(

     

       204
       204
       -
           Invocation.method(#setSort, [newSort], {#newTimeframe: newTimeframe}),

     

       205
       205
       -
           returnValueForMissingStub: null,

     

       206
       206
       -
         );

     

       207
       207
       -
       

     

       208
       208
       -
         @override

     

       209
       209
       -
         _i3.Future<void> retry() =>

     

       210
       210
       -
             (super.noSuchMethod(

     

       211
       211
       -
                   Invocation.method(#retry, []),

     

       212
       212
       -
                   returnValue: _i3.Future<void>.value(),

     

       213
       213
       -
                   returnValueForMissingStub: _i3.Future<void>.value(),

     

       214
       214
       -
                 )

     

       215
       215
       -
                 as _i3.Future<void>);

     

       216
       216
       -
       

     

       217
       217
       -
         @override

     

       218
       218
       -
         void clearError() => super.noSuchMethod(

     

       219
       219
       -
           Invocation.method(#clearError, []),

     

       220
       220
       -
           returnValueForMissingStub: null,

     

       221
       221
       -
         );

     

       222
       222
       -
       

     

       223
       223
       -
         @override

     

       224
       224
       -
         void reset() => super.noSuchMethod(

     

       225
       225
       -
           Invocation.method(#reset, []),

     

       226
       226
       -
           returnValueForMissingStub: null,

     

       227
       227
       -
         );

     

       228
       228
       -
       

     

       229
       229
       -
         @override

     

       230
       230
       -
         void dispose() => super.noSuchMethod(

     

       231
       231
       -
           Invocation.method(#dispose, []),

     

       232
       232
       -
           returnValueForMissingStub: null,

     

       233
       233
       -
         );

     

       234
       234
       -
       

     

       235
       235
       -
         @override

     

       236
       236
       -
         void addListener(_i4.VoidCallback? listener) => super.noSuchMethod(

     

       237
       237
       -
           Invocation.method(#addListener, [listener]),

     

       238
       238
       -
           returnValueForMissingStub: null,

     

       239
       239
       -
         );

     

       240
       240
       -
       

     

       241
       241
       -
         @override

     

       242
       242
       -
         void removeListener(_i4.VoidCallback? listener) => super.noSuchMethod(

     

       243
       243
       -
           Invocation.method(#removeListener, [listener]),

     

       244
       244
       -
           returnValueForMissingStub: null,

     

       245
       245
       -
         );

     

       246
       246
       -
       

     

       247
       247
       -
         @override

     

       248
       248
       -
         void notifyListeners() => super.noSuchMethod(

     

       249
       249
       -
           Invocation.method(#notifyListeners, []),

     

       250
       250
       -
           returnValueForMissingStub: null,

     

       251
       251
       -
         );

     

       252
       252
       -
       }

+231

test/widgets/sign_in_dialog_test.dart

···

       1
       1
       +
       import 'package:coves_flutter/widgets/sign_in_dialog.dart';

     

       2
       2
       +
       import 'package:flutter/material.dart';

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       void main() {

     

       6
       6
       +
         group('SignInDialog', () {

     

       7
       7
       +
           testWidgets('should display default title and message', (tester) async {

     

       8
       8
       +
             await tester.pumpWidget(

     

       9
       9
       +
               MaterialApp(

     

       10
       10
       +
                 home: Scaffold(

     

       11
       11
       +
                   body: Builder(

     

       12
       12
       +
                     builder: (context) {

     

       13
       13
       +
                       return ElevatedButton(

     

       14
       14
       +
                         onPressed: () => SignInDialog.show(context),

     

       15
       15
       +
                         child: const Text('Show Dialog'),

     

       16
       16
       +
                       );

     

       17
       17
       +
                     },

     

       18
       18
       +
                   ),

     

       19
       19
       +
                 ),

     

       20
       20
       +
               ),

     

       21
       21
       +
             );

     

       22
       22
       +
       

     

       23
       23
       +
             // Tap button to show dialog

     

       24
       24
       +
             await tester.tap(find.text('Show Dialog'));

     

       25
       25
       +
             await tester.pumpAndSettle();

     

       26
       26
       +
       

     

       27
       27
       +
             // Verify default title and message

     

       28
       28
       +
             expect(find.text('Sign in required'), findsOneWidget);

     

       29
       29
       +
             expect(

     

       30
       30
       +
               find.text('You need to sign in to interact with posts.'),

     

       31
       31
       +
               findsOneWidget,

     

       32
       32
       +
             );

     

       33
       33
       +
           });

     

       34
       34
       +
       

     

       35
       35
       +
           testWidgets('should display custom title and message', (tester) async {

     

       36
       36
       +
             await tester.pumpWidget(

     

       37
       37
       +
               MaterialApp(

     

       38
       38
       +
                 home: Scaffold(

     

       39
       39
       +
                   body: Builder(

     

       40
       40
       +
                     builder: (context) {

     

       41
       41
       +
                       return ElevatedButton(

     

       42
       42
       +
                         onPressed: () => SignInDialog.show(

     

       43
       43
       +
                           context,

     

       44
       44
       +
                           title: 'Custom Title',

     

       45
       45
       +
                           message: 'Custom message here',

     

       46
       46
       +
                         ),

     

       47
       47
       +
                         child: const Text('Show Dialog'),

     

       48
       48
       +
                       );

     

       49
       49
       +
                     },

     

       50
       50
       +
                   ),

     

       51
       51
       +
                 ),

     

       52
       52
       +
               ),

     

       53
       53
       +
             );

     

       54
       54
       +
       

     

       55
       55
       +
             // Tap button to show dialog

     

       56
       56
       +
             await tester.tap(find.text('Show Dialog'));

     

       57
       57
       +
             await tester.pumpAndSettle();

     

       58
       58
       +
       

     

       59
       59
       +
             // Verify custom title and message

     

       60
       60
       +
             expect(find.text('Custom Title'), findsOneWidget);

     

       61
       61
       +
             expect(find.text('Custom message here'), findsOneWidget);

     

       62
       62
       +
           });

     

       63
       63
       +
       

     

       64
       64
       +
           testWidgets('should have Cancel and Sign In buttons', (tester) async {

     

       65
       65
       +
             await tester.pumpWidget(

     

       66
       66
       +
               MaterialApp(

     

       67
       67
       +
                 home: Scaffold(

     

       68
       68
       +
                   body: Builder(

     

       69
       69
       +
                     builder: (context) {

     

       70
       70
       +
                       return ElevatedButton(

     

       71
       71
       +
                         onPressed: () => SignInDialog.show(context),

     

       72
       72
       +
                         child: const Text('Show Dialog'),

     

       73
       73
       +
                       );

     

       74
       74
       +
                     },

     

       75
       75
       +
                   ),

     

       76
       76
       +
                 ),

     

       77
       77
       +
               ),

     

       78
       78
       +
             );

     

       79
       79
       +
       

     

       80
       80
       +
             // Tap button to show dialog

     

       81
       81
       +
             await tester.tap(find.text('Show Dialog'));

     

       82
       82
       +
             await tester.pumpAndSettle();

     

       83
       83
       +
       

     

       84
       84
       +
             // Verify buttons exist

     

       85
       85
       +
             expect(find.text('Cancel'), findsOneWidget);

     

       86
       86
       +
             expect(find.text('Sign In'), findsOneWidget);

     

       87
       87
       +
           });

     

       88
       88
       +
       

     

       89
       89
       +
           testWidgets('should return false when Cancel is tapped', (tester) async {

     

       90
       90
       +
             bool? result;

     

       91
       91
       +
       

     

       92
       92
       +
             await tester.pumpWidget(

     

       93
       93
       +
               MaterialApp(

     

       94
       94
       +
                 home: Scaffold(

     

       95
       95
       +
                   body: Builder(

     

       96
       96
       +
                     builder: (context) {

     

       97
       97
       +
                       return ElevatedButton(

     

       98
       98
       +
                         onPressed: () async {

     

       99
       99
       +
                           result = await SignInDialog.show(context);

     

       100
       100
       +
                         },

     

       101
       101
       +
                         child: const Text('Show Dialog'),

     

       102
       102
       +
                       );

     

       103
       103
       +
                     },

     

       104
       104
       +
                   ),

     

       105
       105
       +
                 ),

     

       106
       106
       +
               ),

     

       107
       107
       +
             );

     

       108
       108
       +
       

     

       109
       109
       +
             // Tap button to show dialog

     

       110
       110
       +
             await tester.tap(find.text('Show Dialog'));

     

       111
       111
       +
             await tester.pumpAndSettle();

     

       112
       112
       +
       

     

       113
       113
       +
             // Tap Cancel button

     

       114
       114
       +
             await tester.tap(find.text('Cancel'));

     

       115
       115
       +
             await tester.pumpAndSettle();

     

       116
       116
       +
       

     

       117
       117
       +
             // Verify result is false

     

       118
       118
       +
             expect(result, false);

     

       119
       119
       +
       

     

       120
       120
       +
             // Dialog should be dismissed

     

       121
       121
       +
             expect(find.text('Sign in required'), findsNothing);

     

       122
       122
       +
           });

     

       123
       123
       +
       

     

       124
       124
       +
           testWidgets('should return true when Sign In is tapped', (tester) async {

     

       125
       125
       +
             bool? result;

     

       126
       126
       +
       

     

       127
       127
       +
             await tester.pumpWidget(

     

       128
       128
       +
               MaterialApp(

     

       129
       129
       +
                 home: Scaffold(

     

       130
       130
       +
                   body: Builder(

     

       131
       131
       +
                     builder: (context) {

     

       132
       132
       +
                       return ElevatedButton(

     

       133
       133
       +
                         onPressed: () async {

     

       134
       134
       +
                           result = await SignInDialog.show(context);

     

       135
       135
       +
                         },

     

       136
       136
       +
                         child: const Text('Show Dialog'),

     

       137
       137
       +
                       );

     

       138
       138
       +
                     },

     

       139
       139
       +
                   ),

     

       140
       140
       +
                 ),

     

       141
       141
       +
               ),

     

       142
       142
       +
             );

     

       143
       143
       +
       

     

       144
       144
       +
             // Tap button to show dialog

     

       145
       145
       +
             await tester.tap(find.text('Show Dialog'));

     

       146
       146
       +
             await tester.pumpAndSettle();

     

       147
       147
       +
       

     

       148
       148
       +
             // Tap Sign In button

     

       149
       149
       +
             await tester.tap(find.text('Sign In'));

     

       150
       150
       +
             await tester.pumpAndSettle();

     

       151
       151
       +
       

     

       152
       152
       +
             // Verify result is true

     

       153
       153
       +
             expect(result, true);

     

       154
       154
       +
       

     

       155
       155
       +
             // Dialog should be dismissed

     

       156
       156
       +
             expect(find.text('Sign in required'), findsNothing);

     

       157
       157
       +
           });

     

       158
       158
       +
       

     

       159
       159
       +
           testWidgets('should dismiss when tapped outside (barrier)', (tester) async {

     

       160
       160
       +
             bool? result;

     

       161
       161
       +
       

     

       162
       162
       +
             await tester.pumpWidget(

     

       163
       163
       +
               MaterialApp(

     

       164
       164
       +
                 home: Scaffold(

     

       165
       165
       +
                   body: Builder(

     

       166
       166
       +
                     builder: (context) {

     

       167
       167
       +
                       return ElevatedButton(

     

       168
       168
       +
                         onPressed: () async {

     

       169
       169
       +
                           result = await SignInDialog.show(context);

     

       170
       170
       +
                         },

     

       171
       171
       +
                         child: const Text('Show Dialog'),

     

       172
       172
       +
                       );

     

       173
       173
       +
                     },

     

       174
       174
       +
                   ),

     

       175
       175
       +
                 ),

     

       176
       176
       +
               ),

     

       177
       177
       +
             );

     

       178
       178
       +
       

     

       179
       179
       +
             // Tap button to show dialog

     

       180
       180
       +
             await tester.tap(find.text('Show Dialog'));

     

       181
       181
       +
             await tester.pumpAndSettle();

     

       182
       182
       +
       

     

       183
       183
       +
             // Tap outside the dialog (on the barrier)

     

       184
       184
       +
             await tester.tapAt(const Offset(10, 10));

     

       185
       185
       +
             await tester.pumpAndSettle();

     

       186
       186
       +
       

     

       187
       187
       +
             // Verify result is null (dismissed without selecting an option)

     

       188
       188
       +
             expect(result, null);

     

       189
       189
       +
       

     

       190
       190
       +
             // Dialog should be dismissed

     

       191
       191
       +
             expect(find.text('Sign in required'), findsNothing);

     

       192
       192
       +
           });

     

       193
       193
       +
       

     

       194
       194
       +
           testWidgets('should use app colors for styling', (tester) async {

     

       195
       195
       +
             await tester.pumpWidget(

     

       196
       196
       +
               MaterialApp(

     

       197
       197
       +
                 home: Scaffold(

     

       198
       198
       +
                   body: Builder(

     

       199
       199
       +
                     builder: (context) {

     

       200
       200
       +
                       return ElevatedButton(

     

       201
       201
       +
                         onPressed: () => SignInDialog.show(context),

     

       202
       202
       +
                         child: const Text('Show Dialog'),

     

       203
       203
       +
                       );

     

       204
       204
       +
                     },

     

       205
       205
       +
                   ),

     

       206
       206
       +
                 ),

     

       207
       207
       +
               ),

     

       208
       208
       +
             );

     

       209
       209
       +
       

     

       210
       210
       +
             // Tap button to show dialog

     

       211
       211
       +
             await tester.tap(find.text('Show Dialog'));

     

       212
       212
       +
             await tester.pumpAndSettle();

     

       213
       213
       +
       

     

       214
       214
       +
             // Find the AlertDialog widget

     

       215
       215
       +
             final alertDialog = tester.widget<AlertDialog>(

     

       216
       216
       +
               find.byType(AlertDialog),

     

       217
       217
       +
             );

     

       218
       218
       +
       

     

       219
       219
       +
             // Verify background color is set

     

       220
       220
       +
             expect(alertDialog.backgroundColor, isNotNull);

     

       221
       221
       +
       

     

       222
       222
       +
             // Find the Sign In button

     

       223
       223
       +
             final signInButton = tester.widget<ElevatedButton>(

     

       224
       224
       +
               find.widgetWithText(ElevatedButton, 'Sign In'),

     

       225
       225
       +
             );

     

       226
       226
       +
       

     

       227
       227
       +
             // Verify button styling

     

       228
       228
       +
             expect(signInButton.style, isNotNull);

     

       229
       229
       +
           });

     

       230
       230
       +
         });

     

       231
       231
       +
       }