bretton.dev / coves-mobile
Main coves client
fork atom

feat: update vote lexicon and add optimistic vote updates

This PR implements several improvements to the voting system:

**1. Vote Lexicon Migration**
- Migrate from social.coves.interaction.vote to social.coves.feed.vote
- Aligns with backend migration (commit 7a87d6b)
- Follows atProto conventions (like app.bsky.feed.like)

**2. Optimistic Score Updates**
- Vote counts update immediately when users vote
- Score adjustments tracked per post:
- Create upvote: +1
- Remove upvote: -1
- Create downvote: -1
- Remove downvote: +1
- Switch up→down: -2
- Switch down→up: +2
- Automatic rollback on API errors
- 7 new tests covering all scenarios

**3. Initial Vote State Loading**
- Added VoteService.getUserVotes() to query PDS for user's votes
- Added VoteProvider.loadInitialVotes() to bulk-load vote state
- FeedProvider loads vote state after fetching posts
- Hearts now fill correctly on app reload

**4. Performance Optimization** (PR Review)
- Added vote state cache to avoid O(n) PDS lookups
- VoteProvider passes cached state (rkey + direction) to VoteService
- Eliminates 5-10 API calls for users with many votes
- Performance: O(1) instead of O(n)

**5. Code Quality Improvements** (PR Review)
- Fix: Unsafe force unwrap in Provider initialization (main.dart:57)
- Fix: Added specific catch types (on Exception catch)
- Fix: Reset score adjustments when loading votes (prevents double-counting)
- All 119 tests passing ✅

**Breaking Changes:** None
**Migration Required:** None (backward compatible)

**Test Results:**
- 119/119 tests passing
- 0 errors, 0 warnings
- Updated test mocks for new optional parameters

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

bretton.dev b0379244 f4f89f51

options
unified split
Changed files
+603 -62
DEVELOPMENT_SUMMARY.md
lib
main.dart
providers
feed_provider.dart
vote_provider.dart
services
vote_service.dart
widgets
post_card.dart
test
providers
vote_provider_test.dart
vote_provider_test.mocks.dart
services
vote_service_test.dart
+7 -7
DEVELOPMENT_SUMMARY.md 
···

       
56

       
 

       



     

       
57

       
 

       
### Vote Record Schema


     

       
58

       
 

       



     

       
59

       
-

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


     

       
60

       
 

       



     

       
61

       
 

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


     

       
62

       
 

       
```json


     

       
63

       
 

       
{


     

       
64

       
-

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


     

       
65

       
 

       
  "subject": {


     

       
66

       
 

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


     

       
67

       
 

       
    "cid": "bafy2bzacepostcid123"


     
···

       
154

       
 

       



     

       
155

       
 

       
**rkey Extraction**:


     

       
156

       
 

       
```dart


     

       
157

       
-

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


     

       
158

       
 

       
// Result: "3kby..."


     

       
159

       
 

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


     

       
160

       
 

       
```


     
···

       
353

       
 

       
## 9. Backend Integration Requirements


     

       
354

       
 

       



     

       
355

       
 

       
### Jetstream Listener


     

       
356

       
-

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


     

       
357

       
 

       



     

       
358

       
 

       
```json


     

       
359

       
 

       
{


     
···

       
361

       
 

       
  "kind": "commit",


     

       
362

       
 

       
  "commit": {


     

       
363

       
 

       
    "operation": "create",


     

       
364

       
-

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


     

       
365

       
 

       
    "rkey": "3kby...",


     

       
366

       
 

       
    "cid": "bafy2bzacevotecid123",


     

       
367

       
 

       
    "record": {


     

       
368

       
-

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


     

       
369

       
 

       
      "subject": {


     

       
370

       
 

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


     

       
371

       
 

       
        "cid": "bafy2bzacepostcid123"


     
···

       
397

       
 

       
    "viewer": {


     

       
398

       
 

       
      "vote": {


     

       
399

       
 

       
        "direction": "up",


     

       
400

       
-

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


     

       
401

       
 

       
      }


     

       
402

       
 

       
    }


     

       
403

       
 

       
  }


     
···

       
56

       
 

       



     

       
57

       
 

       
### Vote Record Schema


     

       
58

       
 

       



     

       
59

       
+

       
**Collection Name**: `social.coves.feed.vote`


     

       
60

       
 

       



     

       
61

       
 

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


     

       
62

       
 

       
```json


     

       
63

       
 

       
{


     

       
64

       
+

       
  "$type": "social.coves.feed.vote",


     

       
65

       
 

       
  "subject": {


     

       
66

       
 

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


     

       
67

       
 

       
    "cid": "bafy2bzacepostcid123"


     
···

       
154

       
 

       



     

       
155

       
 

       
**rkey Extraction**:


     

       
156

       
 

       
```dart


     

       
157

       
+

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


     

       
158

       
 

       
// Result: "3kby..."


     

       
159

       
 

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


     

       
160

       
 

       
```


     
···

       
353

       
 

       
## 9. Backend Integration Requirements


     

       
354

       
 

       



     

       
355

       
 

       
### Jetstream Listener


     

       
356

       
+

       
The backend must listen for `social.coves.feed.vote` records from Jetstream:


     

       
357

       
 

       



     

       
358

       
 

       
```json


     

       
359

       
 

       
{


     
···

       
361

       
 

       
  "kind": "commit",


     

       
362

       
 

       
  "commit": {


     

       
363

       
 

       
    "operation": "create",


     

       
364

       
+

       
    "collection": "social.coves.feed.vote",


     

       
365

       
 

       
    "rkey": "3kby...",


     

       
366

       
 

       
    "cid": "bafy2bzacevotecid123",


     

       
367

       
 

       
    "record": {


     

       
368

       
+

       
      "$type": "social.coves.feed.vote",


     

       
369

       
 

       
      "subject": {


     

       
370

       
 

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


     

       
371

       
 

       
        "cid": "bafy2bzacepostcid123"


     
···

       
397

       
 

       
    "viewer": {


     

       
398

       
 

       
      "vote": {


     

       
399

       
 

       
        "direction": "up",


     

       
400

       
+

       
        "uri": "at://did:plc:user/social.coves.feed.vote/3kby..."


     

       
401

       
 

       
      }


     

       
402

       
 

       
    }


     

       
403

       
 

       
  }
+16 -1
lib/main.dart 
···

       
40

       
 

       
    MultiProvider(


     

       
41

       
 

       
      providers: [


     

       
42

       
 

       
        ChangeNotifierProvider.value(value: authProvider),


     

       
43

       
-

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


     

       
44

       
 

       
        ChangeNotifierProvider(


     

       
45

       
 

       
          create: (_) => VoteProvider(


     

       
46

       
 

       
            voteService: voteService,


     

       
47

       
 

       
            authProvider: authProvider,


     

       
48

       
 

       
          ),


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
49

       
 

       
        ),


     

       
50

       
 

       
      ],


     

       
51

       
 

       
      child: const CovesApp(),


     
···

       
40

       
 

       
    MultiProvider(


     

       
41

       
 

       
      providers: [


     

       
42

       
 

       
        ChangeNotifierProvider.value(value: authProvider),


     

       

       

       
     

       
43

       
 

       
        ChangeNotifierProvider(


     

       
44

       
 

       
          create: (_) => VoteProvider(


     

       
45

       
 

       
            voteService: voteService,


     

       
46

       
 

       
            authProvider: authProvider,


     

       
47

       
 

       
          ),


     

       
48

       
+

       
        ),


     

       
49

       
+

       
        ChangeNotifierProxyProvider2<AuthProvider, VoteProvider, FeedProvider>(


     

       
50

       
+

       
          create: (context) => FeedProvider(


     

       
51

       
+

       
            authProvider,


     

       
52

       
+

       
            voteProvider: context.read<VoteProvider>(),


     

       
53

       
+

       
            voteService: voteService,


     

       
54

       
+

       
          ),


     

       
55

       
+

       
          update: (context, auth, vote, previous) {


     

       
56

       
+

       
            // Reuse existing provider to maintain state across rebuilds


     

       
57

       
+

       
            return previous ??


     

       
58

       
+

       
                FeedProvider(


     

       
59

       
+

       
                  auth,


     

       
60

       
+

       
                  voteProvider: vote,


     

       
61

       
+

       
                  voteService: voteService,


     

       
62

       
+

       
                );


     

       
63

       
+

       
          },


     

       
64

       
 

       
        ),


     

       
65

       
 

       
      ],


     

       
66

       
 

       
      child: const CovesApp(),
+27 -1
lib/providers/feed_provider.dart 
···

       
3

       
 

       
import 'package:flutter/foundation.dart';


     

       
4

       
 

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


     

       
5

       
 

       
import '../services/coves_api_service.dart';


     

       

       

       
     

       
6

       
 

       
import 'auth_provider.dart';


     

       

       

       
     

       
7

       
 

       



     

       
8

       
 

       
/// Feed Provider


     

       
9

       
 

       
///


     
···

       
14

       
 

       
/// tokens before each authenticated request (critical for atProto OAuth


     

       
15

       
 

       
/// token rotation).


     

       
16

       
 

       
class FeedProvider with ChangeNotifier {


     

       
17

       
-

       
  FeedProvider(this._authProvider, {CovesApiService? apiService}) {


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
18

       
 

       
    // Use injected service (for testing) or create new one (for production)


     

       
19

       
 

       
    // Pass token getter to API service for automatic fresh token retrieval


     

       
20

       
 

       
    _apiService =


     
···

       
54

       
 

       



     

       
55

       
 

       
  final AuthProvider _authProvider;


     

       
56

       
 

       
  late final CovesApiService _apiService;


     

       

       

       
     

       

       

       
     

       
57

       
 

       



     

       
58

       
 

       
  // Track previous auth state to detect transitions


     

       
59

       
 

       
  bool _wasAuthenticated = false;


     
···

       
179

       
 

       



     

       
180

       
 

       
      if (kDebugMode) {


     

       
181

       
 

       
        debugPrint('✅ $feedName loaded: ${_posts.length} posts total');


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
182

       
 

       
      }


     

       
183

       
 

       
    } on Exception catch (e) {


     

       
184

       
 

       
      _error = e.toString();


     
···

       
3

       
 

       
import 'package:flutter/foundation.dart';


     

       
4

       
 

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


     

       
5

       
 

       
import '../services/coves_api_service.dart';


     

       
6

       
+

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


     

       
7

       
 

       
import 'auth_provider.dart';


     

       
8

       
+

       
import 'vote_provider.dart';


     

       
9

       
 

       



     

       
10

       
 

       
/// Feed Provider


     

       
11

       
 

       
///


     
···

       
16

       
 

       
/// tokens before each authenticated request (critical for atProto OAuth


     

       
17

       
 

       
/// token rotation).


     

       
18

       
 

       
class FeedProvider with ChangeNotifier {


     

       
19

       
+

       
  FeedProvider(


     

       
20

       
+

       
    this._authProvider, {


     

       
21

       
+

       
    CovesApiService? apiService,


     

       
22

       
+

       
    VoteProvider? voteProvider,


     

       
23

       
+

       
    VoteService? voteService,


     

       
24

       
+

       
  })  : _voteProvider = voteProvider,


     

       
25

       
+

       
        _voteService = voteService {


     

       
26

       
 

       
    // Use injected service (for testing) or create new one (for production)


     

       
27

       
 

       
    // Pass token getter to API service for automatic fresh token retrieval


     

       
28

       
 

       
    _apiService =


     
···

       
62

       
 

       



     

       
63

       
 

       
  final AuthProvider _authProvider;


     

       
64

       
 

       
  late final CovesApiService _apiService;


     

       
65

       
+

       
  final VoteProvider? _voteProvider;


     

       
66

       
+

       
  final VoteService? _voteService;


     

       
67

       
 

       



     

       
68

       
 

       
  // Track previous auth state to detect transitions


     

       
69

       
 

       
  bool _wasAuthenticated = false;


     
···

       
189

       
 

       



     

       
190

       
 

       
      if (kDebugMode) {


     

       
191

       
 

       
        debugPrint('✅ $feedName loaded: ${_posts.length} posts total');


     

       
192

       
+

       
      }


     

       
193

       
+

       



     

       
194

       
+

       
      // Load initial vote state from PDS (only if authenticated)


     

       
195

       
+

       
      if (_authProvider.isAuthenticated &&


     

       
196

       
+

       
          _voteProvider != null &&


     

       
197

       
+

       
          _voteService != null) {


     

       
198

       
+

       
        try {


     

       
199

       
+

       
          final userVotes = await _voteService.getUserVotes();


     

       
200

       
+

       
          _voteProvider.loadInitialVotes(userVotes);


     

       
201

       
+

       
        } on Exception catch (e) {


     

       
202

       
+

       
          if (kDebugMode) {


     

       
203

       
+

       
            debugPrint('⚠️  Failed to load vote state: $e');


     

       
204

       
+

       
          }


     

       
205

       
+

       
          // Don't fail the feed load if vote loading fails


     

       
206

       
+

       
          // Keep silent per PR review discussion


     

       
207

       
+

       
        }


     

       
208

       
 

       
      }


     

       
209

       
 

       
    } on Exception catch (e) {


     

       
210

       
 

       
      _error = e.toString();
+104 -4
lib/providers/vote_provider.dart 
···

       
1

       
 

       
import 'package:flutter/foundation.dart';


     

       
2

       
 

       



     

       
3

       
 

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


     

       
4

       
-

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


     

       
5

       
 

       
import 'auth_provider.dart';


     

       
6

       
 

       



     

       
7

       
 

       
/// Vote Provider


     
···

       
46

       
 

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


     

       
47

       
 

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


     

       
48

       
 

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
49

       
 

       
  /// Get vote state for a post


     

       
50

       
 

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


     

       
51

       
 

       



     
···

       
57

       
 

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


     

       
58

       
 

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


     

       
59

       
 

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
60

       
 

       
  /// Toggle vote (like/unlike)


     

       
61

       
 

       
  ///


     

       
62

       
 

       
  /// Uses optimistic updates:


     
···

       
90

       
 

       



     

       
91

       
 

       
    // Save current state for rollback on error


     

       
92

       
 

       
    final previousState = _votes[postUri];


     

       

       

       
     

       
93

       
 

       
    final currentState = previousState;


     

       
94

       
 

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
95

       
 

       
    // Optimistic update


     

       
96

       
 

       
    if (currentState?.direction == direction &&


     

       
97

       
 

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


     
···

       
109

       
 

       
        deleted: false,


     

       
110

       
 

       
      );


     

       
111

       
 

       
    }


     

       

       

       
     

       

       

       
     

       

       

       
     

       
112

       
 

       
    notifyListeners();


     

       
113

       
 

       



     

       
114

       
 

       
    // Mark request as pending


     

       
115

       
 

       
    _pendingRequests[postUri] = true;


     

       
116

       
 

       



     

       
117

       
 

       
    try {


     

       
118

       
-

       
      // Make API call


     

       
119

       
 

       
      final response = await _voteService.createVote(


     

       
120

       
 

       
        postUri: postUri,


     

       
121

       
 

       
        postCid: postCid,


     

       
122

       
 

       
        direction: direction,


     

       

       

       
     

       

       

       
     

       
123

       
 

       
      );


     

       
124

       
 

       



     

       
125

       
 

       
      // Update with server response


     
···

       
152

       
 

       
      } else {


     

       
153

       
 

       
        _votes.remove(postUri);


     

       
154

       
 

       
      }


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
155

       
 

       
      notifyListeners();


     

       
156

       
 

       



     

       
157

       
 

       
      rethrow;


     
···

       
176

       
 

       
  }) {


     

       
177

       
 

       
    if (voteDirection != null) {


     

       
178

       
 

       
      // Extract rkey from vote URI if available


     

       
179

       
-

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


     

       
180

       
 

       
      String? rkey;


     

       
181

       
 

       
      if (voteUri != null) {


     

       
182

       
 

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


     
···

       
197

       
 

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


     

       
198

       
 

       
  }


     

       
199

       
 

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
200

       
 

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


     

       
201

       
 

       
  void clear() {


     

       
202

       
 

       
    _votes.clear();


     

       
203

       
 

       
    _pendingRequests.clear();


     

       

       

       
     

       
204

       
 

       
    notifyListeners();


     

       
205

       
 

       
  }


     

       
206

       
 

       
}


     
···

       
224

       
 

       



     

       
225

       
 

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


     

       
226

       
 

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


     

       
227

       
-

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


     

       
228

       
 

       
  final String? rkey;


     

       
229

       
 

       



     

       
230

       
 

       
  /// Whether the vote has been deleted


     
···

       
1

       
 

       
import 'package:flutter/foundation.dart';


     

       
2

       
 

       



     

       
3

       
 

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


     

       
4

       
+

       
import '../services/vote_service.dart' show VoteService, VoteInfo;


     

       
5

       
 

       
import 'auth_provider.dart';


     

       
6

       
 

       



     

       
7

       
 

       
/// Vote Provider


     
···

       
46

       
 

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


     

       
47

       
 

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


     

       
48

       
 

       



     

       
49

       
+

       
  // Map of post URI -> score adjustment (for optimistic UI updates)


     

       
50

       
+

       
  // Tracks the local delta from the server's score


     

       
51

       
+

       
  final Map<String, int> _scoreAdjustments = {};


     

       
52

       
+

       



     

       
53

       
 

       
  /// Get vote state for a post


     

       
54

       
 

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


     

       
55

       
 

       



     
···

       
61

       
 

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


     

       
62

       
 

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


     

       
63

       
 

       



     

       
64

       
+

       
  /// Get adjusted score for a post (server score + local optimistic adjustment)


     

       
65

       
+

       
  ///


     

       
66

       
+

       
  /// This allows the UI to show immediate feedback when users vote, even before


     

       
67

       
+

       
  /// the backend processes the vote and returns updated counts.


     

       
68

       
+

       
  ///


     

       
69

       
+

       
  /// Parameters:


     

       
70

       
+

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


     

       
71

       
+

       
  /// - [serverScore]: The score from the server (upvotes - downvotes)


     

       
72

       
+

       
  ///


     

       
73

       
+

       
  /// Returns: The adjusted score based on local vote state


     

       
74

       
+

       
  int getAdjustedScore(String postUri, int serverScore) {


     

       
75

       
+

       
    final adjustment = _scoreAdjustments[postUri] ?? 0;


     

       
76

       
+

       
    return serverScore + adjustment;


     

       
77

       
+

       
  }


     

       
78

       
+

       



     

       
79

       
 

       
  /// Toggle vote (like/unlike)


     

       
80

       
 

       
  ///


     

       
81

       
 

       
  /// Uses optimistic updates:


     
···

       
109

       
 

       



     

       
110

       
 

       
    // Save current state for rollback on error


     

       
111

       
 

       
    final previousState = _votes[postUri];


     

       
112

       
+

       
    final previousAdjustment = _scoreAdjustments[postUri] ?? 0;


     

       
113

       
 

       
    final currentState = previousState;


     

       
114

       
 

       



     

       
115

       
+

       
    // Calculate score adjustment for optimistic update


     

       
116

       
+

       
    int newAdjustment = previousAdjustment;


     

       
117

       
+

       



     

       
118

       
+

       
    if (currentState?.direction == direction &&


     

       
119

       
+

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


     

       
120

       
+

       
      // Toggle off - removing vote


     

       
121

       
+

       
      if (direction == 'up') {


     

       
122

       
+

       
        newAdjustment -= 1; // Remove upvote


     

       
123

       
+

       
      } else {


     

       
124

       
+

       
        newAdjustment += 1; // Remove downvote


     

       
125

       
+

       
      }


     

       
126

       
+

       
    } else if (currentState?.direction != null &&


     

       
127

       
+

       
               currentState?.direction != direction &&


     

       
128

       
+

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


     

       
129

       
+

       
      // Switching vote direction


     

       
130

       
+

       
      if (direction == 'up') {


     

       
131

       
+

       
        newAdjustment += 2; // Remove downvote (-1) and add upvote (+1)


     

       
132

       
+

       
      } else {


     

       
133

       
+

       
        newAdjustment -= 2; // Remove upvote (-1) and add downvote (+1)


     

       
134

       
+

       
      }


     

       
135

       
+

       
    } else {


     

       
136

       
+

       
      // Creating new vote (or re-creating after delete)


     

       
137

       
+

       
      if (direction == 'up') {


     

       
138

       
+

       
        newAdjustment += 1; // Add upvote


     

       
139

       
+

       
      } else {


     

       
140

       
+

       
        newAdjustment -= 1; // Add downvote


     

       
141

       
+

       
      }


     

       
142

       
+

       
    }


     

       
143

       
+

       



     

       
144

       
 

       
    // Optimistic update


     

       
145

       
 

       
    if (currentState?.direction == direction &&


     

       
146

       
 

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


     
···

       
158

       
 

       
        deleted: false,


     

       
159

       
 

       
      );


     

       
160

       
 

       
    }


     

       
161

       
+

       



     

       
162

       
+

       
    // Apply score adjustment


     

       
163

       
+

       
    _scoreAdjustments[postUri] = newAdjustment;


     

       
164

       
 

       
    notifyListeners();


     

       
165

       
 

       



     

       
166

       
 

       
    // Mark request as pending


     

       
167

       
 

       
    _pendingRequests[postUri] = true;


     

       
168

       
 

       



     

       
169

       
 

       
    try {


     

       
170

       
+

       
      // Make API call - pass existing vote info to avoid O(n) PDS lookup


     

       
171

       
 

       
      final response = await _voteService.createVote(


     

       
172

       
 

       
        postUri: postUri,


     

       
173

       
 

       
        postCid: postCid,


     

       
174

       
 

       
        direction: direction,


     

       
175

       
+

       
        existingVoteRkey: currentState?.rkey,


     

       
176

       
+

       
        existingVoteDirection: currentState?.direction,


     

       
177

       
 

       
      );


     

       
178

       
 

       



     

       
179

       
 

       
      // Update with server response


     
···

       
206

       
 

       
      } else {


     

       
207

       
 

       
        _votes.remove(postUri);


     

       
208

       
 

       
      }


     

       
209

       
+

       



     

       
210

       
+

       
      // Rollback score adjustment


     

       
211

       
+

       
      if (previousAdjustment != 0) {


     

       
212

       
+

       
        _scoreAdjustments[postUri] = previousAdjustment;


     

       
213

       
+

       
      } else {


     

       
214

       
+

       
        _scoreAdjustments.remove(postUri);


     

       
215

       
+

       
      }


     

       
216

       
+

       



     

       
217

       
 

       
      notifyListeners();


     

       
218

       
 

       



     

       
219

       
 

       
      rethrow;


     
···

       
238

       
 

       
  }) {


     

       
239

       
 

       
    if (voteDirection != null) {


     

       
240

       
 

       
      // Extract rkey from vote URI if available


     

       
241

       
+

       
      // URI format: at://did:plc:xyz/social.coves.feed.vote/3kby...


     

       
242

       
 

       
      String? rkey;


     

       
243

       
 

       
      if (voteUri != null) {


     

       
244

       
 

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


     
···

       
259

       
 

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


     

       
260

       
 

       
  }


     

       
261

       
 

       



     

       
262

       
+

       
  /// Load initial vote states from a map of votes


     

       
263

       
+

       
  ///


     

       
264

       
+

       
  /// This is used to bulk-load vote state after querying the user's PDS.


     

       
265

       
+

       
  /// Typically called after loading feed posts to fill in which posts


     

       
266

       
+

       
  /// the user has voted on.


     

       
267

       
+

       
  ///


     

       
268

       
+

       
  /// IMPORTANT: This clears score adjustments since the server score


     

       
269

       
+

       
  /// already reflects the loaded votes. If we kept stale adjustments,


     

       
270

       
+

       
  /// we'd double-count votes (server score + our adjustment).


     

       
271

       
+

       
  ///


     

       
272

       
+

       
  /// Parameters:


     

       
273

       
+

       
  /// - [votes]: Map of post URI -> vote info from VoteService.getUserVotes()


     

       
274

       
+

       
  void loadInitialVotes(Map<String, VoteInfo> votes) {


     

       
275

       
+

       
    for (final entry in votes.entries) {


     

       
276

       
+

       
      final postUri = entry.key;


     

       
277

       
+

       
      final voteInfo = entry.value;


     

       
278

       
+

       



     

       
279

       
+

       
      _votes[postUri] = VoteState(


     

       
280

       
+

       
        direction: voteInfo.direction,


     

       
281

       
+

       
        uri: voteInfo.voteUri,


     

       
282

       
+

       
        rkey: voteInfo.rkey,


     

       
283

       
+

       
        deleted: false,


     

       
284

       
+

       
      );


     

       
285

       
+

       



     

       
286

       
+

       
      // Clear any stale score adjustments for this post


     

       
287

       
+

       
      // The server score already includes this vote


     

       
288

       
+

       
      _scoreAdjustments.remove(postUri);


     

       
289

       
+

       
    }


     

       
290

       
+

       



     

       
291

       
+

       
    if (kDebugMode) {


     

       
292

       
+

       
      debugPrint('📊 Initialized ${votes.length} vote states');


     

       
293

       
+

       
    }


     

       
294

       
+

       



     

       
295

       
+

       
    // Notify once after loading all votes


     

       
296

       
+

       
    notifyListeners();


     

       
297

       
+

       
  }


     

       
298

       
+

       



     

       
299

       
 

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


     

       
300

       
 

       
  void clear() {


     

       
301

       
 

       
    _votes.clear();


     

       
302

       
 

       
    _pendingRequests.clear();


     

       
303

       
+

       
    _scoreAdjustments.clear();


     

       
304

       
 

       
    notifyListeners();


     

       
305

       
 

       
  }


     

       
306

       
 

       
}


     
···

       
324

       
 

       



     

       
325

       
 

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


     

       
326

       
 

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


     

       
327

       
+

       
  /// "at://did:plc:xyz/social.coves.feed.vote/3kby...")


     

       
328

       
 

       
  final String? rkey;


     

       
329

       
 

       



     

       
330

       
 

       
  /// Whether the vote has been deleted
+134 -9
lib/services/vote_service.dart 
···

       
44

       
 

       
  final String? Function()? _pdsUrlGetter;


     

       
45

       
 

       



     

       
46

       
 

       
  /// Collection name for vote records


     

       
47

       
-

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


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
48

       
 

       



     

       
49

       
 

       
  /// Create or toggle vote


     

       
50

       
 

       
  ///


     

       
51

       
 

       
  /// Implements smart toggle logic:


     

       
52

       
-

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


     

       
53

       
 

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


     

       
54

       
 

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


     

       
55

       
 

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


     
···

       
59

       
 

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


     

       
60

       
 

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


     

       
61

       
 

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


     

       

       

       
     

       

       

       
     

       
62

       
 

       
  ///


     

       
63

       
 

       
  /// Returns:


     

       
64

       
 

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


     
···

       
70

       
 

       
    required String postUri,


     

       
71

       
 

       
    required String postCid,


     

       
72

       
 

       
    String direction = 'up',


     

       

       

       
     

       

       

       
     

       
73

       
 

       
  }) async {


     

       
74

       
 

       
    try {


     

       
75

       
 

       
      // Get user's DID and PDS URL


     
···

       
92

       
 

       
      }


     

       
93

       
 

       



     

       
94

       
 

       
      // Step 1: Check for existing vote


     

       
95

       
-

       
      final existingVote = await _findExistingVote(


     

       
96

       
-

       
        userDid: userDid,


     

       
97

       
-

       
        postUri: postUri,


     

       
98

       
-

       
      );


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
99

       
 

       



     

       
100

       
 

       
      if (existingVote != null) {


     

       
101

       
 

       
        if (kDebugMode) {


     
···

       
137

       
 

       
      }


     

       
138

       
 

       



     

       
139

       
 

       
      return response;


     

       
140

       
-

       
    } catch (e) {


     

       
141

       
 

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


     

       
142

       
 

       
    }


     

       
143

       
 

       
  }


     
···

       
204

       
 

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


     

       
205

       
 

       



     

       
206

       
 

       
              // Extract rkey from URI


     

       
207

       
-

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


     

       
208

       
 

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


     

       
209

       
 

       



     

       
210

       
 

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


     
···

       
218

       
 

       



     

       
219

       
 

       
      // Vote not found after searching all pages


     

       
220

       
 

       
      return null;


     

       
221

       
-

       
    } catch (e) {


     

       
222

       
 

       
      if (kDebugMode) {


     

       
223

       
 

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


     

       
224

       
 

       
      }


     
···

       
363

       
 

       
  /// Record key for deletion


     

       
364

       
 

       
  final String rkey;


     

       
365

       
 

       
}


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     
···

       
44

       
 

       
  final String? Function()? _pdsUrlGetter;


     

       
45

       
 

       



     

       
46

       
 

       
  /// Collection name for vote records


     

       
47

       
+

       
  static const String voteCollection = 'social.coves.feed.vote';


     

       
48

       
+

       



     

       
49

       
+

       
  /// Get all votes for the current user


     

       
50

       
+

       
  ///


     

       
51

       
+

       
  /// Queries the user's PDS for all their vote records and returns a map


     

       
52

       
+

       
  /// of post URI -> vote info. This is used to initialize vote state when


     

       
53

       
+

       
  /// loading the feed.


     

       
54

       
+

       
  ///


     

       
55

       
+

       
  /// Returns:


     

       
56

       
+

       
  /// - Map<String, VoteInfo> where key is the post URI


     

       
57

       
+

       
  /// - Empty map if not authenticated or no votes found


     

       
58

       
+

       
  Future<Map<String, VoteInfo>> getUserVotes() async {


     

       
59

       
+

       
    try {


     

       
60

       
+

       
      final userDid = _didGetter?.call();


     

       
61

       
+

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


     

       
62

       
+

       
        return {};


     

       
63

       
+

       
      }


     

       
64

       
+

       



     

       
65

       
+

       
      final session = await _sessionGetter?.call();


     

       
66

       
+

       
      if (session == null) {


     

       
67

       
+

       
        return {};


     

       
68

       
+

       
      }


     

       
69

       
+

       



     

       
70

       
+

       
      final votes = <String, VoteInfo>{};


     

       
71

       
+

       
      String? cursor;


     

       
72

       
+

       



     

       
73

       
+

       
      // Paginate through all vote records


     

       
74

       
+

       
      do {


     

       
75

       
+

       
        final url = cursor == null


     

       
76

       
+

       
            ? '/xrpc/com.atproto.repo.listRecords?repo=$userDid&collection=$voteCollection&limit=100'


     

       
77

       
+

       
            : '/xrpc/com.atproto.repo.listRecords?repo=$userDid&collection=$voteCollection&limit=100&cursor=$cursor';


     

       
78

       
+

       



     

       
79

       
+

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


     

       
80

       
+

       



     

       
81

       
+

       
        if (response.statusCode != 200) {


     

       
82

       
+

       
          if (kDebugMode) {


     

       
83

       
+

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


     

       
84

       
+

       
          }


     

       
85

       
+

       
          break;


     

       
86

       
+

       
        }


     

       
87

       
+

       



     

       
88

       
+

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


     

       
89

       
+

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


     

       
90

       
+

       



     

       
91

       
+

       
        if (records != null) {


     

       
92

       
+

       
          for (final record in records) {


     

       
93

       
+

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


     

       
94

       
+

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


     

       
95

       
+

       
            final uri = recordMap['uri'] as String?;


     

       
96

       
+

       



     

       
97

       
+

       
            if (value == null || uri == null) {


     

       
98

       
+

       
              continue;


     

       
99

       
+

       
            }


     

       
100

       
+

       



     

       
101

       
+

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


     

       
102

       
+

       
            final direction = value['direction'] as String?;


     

       
103

       
+

       



     

       
104

       
+

       
            if (subject == null || direction == null) {


     

       
105

       
+

       
              continue;


     

       
106

       
+

       
            }


     

       
107

       
+

       



     

       
108

       
+

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


     

       
109

       
+

       
            if (subjectUri != null) {


     

       
110

       
+

       
              // Extract rkey from vote URI


     

       
111

       
+

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


     

       
112

       
+

       



     

       
113

       
+

       
              votes[subjectUri] = VoteInfo(


     

       
114

       
+

       
                direction: direction,


     

       
115

       
+

       
                voteUri: uri,


     

       
116

       
+

       
                rkey: rkey,


     

       
117

       
+

       
              );


     

       
118

       
+

       
            }


     

       
119

       
+

       
          }


     

       
120

       
+

       
        }


     

       
121

       
+

       



     

       
122

       
+

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


     

       
123

       
+

       
      } while (cursor != null);


     

       
124

       
+

       



     

       
125

       
+

       
      if (kDebugMode) {


     

       
126

       
+

       
        debugPrint('📊 Loaded ${votes.length} votes from PDS');


     

       
127

       
+

       
      }


     

       
128

       
+

       



     

       
129

       
+

       
      return votes;


     

       
130

       
+

       
    } on Exception catch (e) {


     

       
131

       
+

       
      if (kDebugMode) {


     

       
132

       
+

       
        debugPrint('⚠️  Failed to load user votes: $e');


     

       
133

       
+

       
      }


     

       
134

       
+

       
      return {};


     

       
135

       
+

       
    }


     

       
136

       
+

       
  }


     

       
137

       
 

       



     

       
138

       
 

       
  /// Create or toggle vote


     

       
139

       
 

       
  ///


     

       
140

       
 

       
  /// Implements smart toggle logic:


     

       
141

       
+

       
  /// 1. Query PDS for existing vote on this post (or use cached state)


     

       
142

       
 

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


     

       
143

       
 

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


     

       
144

       
 

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


     
···

       
148

       
 

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


     

       
149

       
 

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


     

       
150

       
 

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


     

       
151

       
+

       
  /// - [existingVoteRkey]: Optional rkey from cached state (avoids O(n) lookup)


     

       
152

       
+

       
  /// - [existingVoteDirection]: Optional direction from cached state


     

       
153

       
 

       
  ///


     

       
154

       
 

       
  /// Returns:


     

       
155

       
 

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


     
···

       
161

       
 

       
    required String postUri,


     

       
162

       
 

       
    required String postCid,


     

       
163

       
 

       
    String direction = 'up',


     

       
164

       
+

       
    String? existingVoteRkey,


     

       
165

       
+

       
    String? existingVoteDirection,


     

       
166

       
 

       
  }) async {


     

       
167

       
 

       
    try {


     

       
168

       
 

       
      // Get user's DID and PDS URL


     
···

       
185

       
 

       
      }


     

       
186

       
 

       



     

       
187

       
 

       
      // Step 1: Check for existing vote


     

       
188

       
+

       
      // Use cached state if available to avoid O(n) PDS lookup


     

       
189

       
+

       
      ExistingVote? existingVote;


     

       
190

       
+

       
      if (existingVoteRkey != null && existingVoteDirection != null) {


     

       
191

       
+

       
        existingVote = ExistingVote(


     

       
192

       
+

       
          direction: existingVoteDirection,


     

       
193

       
+

       
          rkey: existingVoteRkey,


     

       
194

       
+

       
        );


     

       
195

       
+

       
        if (kDebugMode) {


     

       
196

       
+

       
          debugPrint('   Using cached vote state (avoiding PDS lookup)');


     

       
197

       
+

       
        }


     

       
198

       
+

       
      } else {


     

       
199

       
+

       
        existingVote = await _findExistingVote(


     

       
200

       
+

       
          userDid: userDid,


     

       
201

       
+

       
          postUri: postUri,


     

       
202

       
+

       
        );


     

       
203

       
+

       
      }


     

       
204

       
 

       



     

       
205

       
 

       
      if (existingVote != null) {


     

       
206

       
 

       
        if (kDebugMode) {


     
···

       
242

       
 

       
      }


     

       
243

       
 

       



     

       
244

       
 

       
      return response;


     

       
245

       
+

       
    } on Exception catch (e) {


     

       
246

       
 

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


     

       
247

       
 

       
    }


     

       
248

       
 

       
  }


     
···

       
309

       
 

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


     

       
310

       
 

       



     

       
311

       
 

       
              // Extract rkey from URI


     

       
312

       
+

       
              // Format: at://did:plc:xyz/social.coves.feed.vote/3kby...


     

       
313

       
 

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


     

       
314

       
 

       



     

       
315

       
 

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


     
···

       
323

       
 

       



     

       
324

       
 

       
      // Vote not found after searching all pages


     

       
325

       
 

       
      return null;


     

       
326

       
+

       
    } on Exception catch (e) {


     

       
327

       
 

       
      if (kDebugMode) {


     

       
328

       
 

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


     

       
329

       
 

       
      }


     
···

       
468

       
 

       
  /// Record key for deletion


     

       
469

       
 

       
  final String rkey;


     

       
470

       
 

       
}


     

       
471

       
+

       



     

       
472

       
+

       
/// Vote Info


     

       
473

       
+

       
///


     

       
474

       
+

       
/// Information about a user's vote on a post, returned from getUserVotes().


     

       
475

       
+

       
class VoteInfo {


     

       
476

       
+

       
  const VoteInfo({


     

       
477

       
+

       
    required this.direction,


     

       
478

       
+

       
    required this.voteUri,


     

       
479

       
+

       
    required this.rkey,


     

       
480

       
+

       
  });


     

       
481

       
+

       



     

       
482

       
+

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


     

       
483

       
+

       
  final String direction;


     

       
484

       
+

       



     

       
485

       
+

       
  /// AT-URI of the vote record


     

       
486

       
+

       
  final String voteUri;


     

       
487

       
+

       



     

       
488

       
+

       
  /// Record key (rkey) - last segment of URI


     

       
489

       
+

       
  final String rkey;


     

       
490

       
+

       
}
+5 -1
lib/widgets/post_card.dart 
···

       
218

       
 

       
                Consumer<VoteProvider>(


     

       
219

       
 

       
                  builder: (context, voteProvider, child) {


     

       
220

       
 

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


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
221

       
 

       



     

       
222

       
 

       
                    return InkWell(


     

       
223

       
 

       
                      onTap: () async {


     
···

       
272

       
 

       
                            ),


     

       
273

       
 

       
                            const SizedBox(width: 5),


     

       
274

       
 

       
                            Text(


     

       
275

       
-

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


     

       
276

       
 

       
                              style: TextStyle(


     

       
277

       
 

       
                                color: AppColors.textPrimary


     

       
278

       
 

       
                                    .withValues(alpha: 0.6),


     
···

       
218

       
 

       
                Consumer<VoteProvider>(


     

       
219

       
 

       
                  builder: (context, voteProvider, child) {


     

       
220

       
 

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


     

       
221

       
+

       
                    final adjustedScore = voteProvider.getAdjustedScore(


     

       
222

       
+

       
                      post.post.uri,


     

       
223

       
+

       
                      post.post.stats.score,


     

       
224

       
+

       
                    );


     

       
225

       
 

       



     

       
226

       
 

       
                    return InkWell(


     

       
227

       
 

       
                      onTap: () async {


     
···

       
276

       
 

       
                            ),


     

       
277

       
 

       
                            const SizedBox(width: 5),


     

       
278

       
 

       
                            Text(


     

       
279

       
+

       
                              DateTimeUtils.formatCount(adjustedScore),


     

       
280

       
 

       
                              style: TextStyle(


     

       
281

       
 

       
                                color: AppColors.textPrimary


     

       
282

       
 

       
                                    .withValues(alpha: 0.6),
+287 -32
test/providers/vote_provider_test.dart 
···

       
43

       
 

       
        // Mock successful API response


     

       
44

       
 

       
        when(


     

       
45

       
 

       
          mockVoteService.createVote(


     

       
46

       
-

       
            postUri: testPostUri,


     

       
47

       
-

       
            postCid: testPostCid,


     

       

       

       
     

       

       

       
     

       

       

       
     

       
48

       
 

       
          ),


     

       
49

       
 

       
        ).thenAnswer(


     

       
50

       
 

       
          (_) async => const VoteResponse(


     

       
51

       
-

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


     

       
52

       
 

       
            cid: 'bafy123',


     

       
53

       
 

       
            rkey: '456',


     

       
54

       
 

       
            deleted: false,


     
···

       
81

       
 

       
        // Vote state should be correct


     

       
82

       
 

       
        final voteState = voteProvider.getVoteState(testPostUri);


     

       
83

       
 

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


     

       
84

       
-

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


     

       
85

       
 

       
        expect(voteState?.deleted, false);


     

       
86

       
 

       
      });


     

       
87

       
 

       



     
···

       
90

       
 

       
        voteProvider.setInitialVoteState(


     

       
91

       
 

       
          postUri: testPostUri,


     

       
92

       
 

       
          voteDirection: 'up',


     

       
93

       
-

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


     

       
94

       
 

       
        );


     

       
95

       
 

       



     

       
96

       
 

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


     
···

       
98

       
 

       
        // Mock API response for toggling off


     

       
99

       
 

       
        when(


     

       
100

       
 

       
          mockVoteService.createVote(


     

       
101

       
-

       
            postUri: testPostUri,


     

       
102

       
-

       
            postCid: testPostCid,


     

       

       

       
     

       

       

       
     

       

       

       
     

       
103

       
 

       
          ),


     

       
104

       
 

       
        ).thenAnswer(


     

       
105

       
 

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


     
···

       
129

       
 

       
        // Mock API failure


     

       
130

       
 

       
        when(


     

       
131

       
 

       
          mockVoteService.createVote(


     

       
132

       
-

       
            postUri: testPostUri,


     

       
133

       
-

       
            postCid: testPostCid,


     

       

       

       
     

       

       

       
     

       

       

       
     

       
134

       
 

       
          ),


     

       
135

       
 

       
        ).thenThrow(


     

       
136

       
 

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


     
···

       
164

       
 

       
        voteProvider.setInitialVoteState(


     

       
165

       
 

       
          postUri: testPostUri,


     

       
166

       
 

       
          voteDirection: 'up',


     

       
167

       
-

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


     

       
168

       
 

       
        );


     

       
169

       
 

       



     

       
170

       
 

       
        final initialState = voteProvider.getVoteState(testPostUri);


     
···

       
173

       
 

       
        // Mock API failure when trying to toggle off


     

       
174

       
 

       
        when(


     

       
175

       
 

       
          mockVoteService.createVote(


     

       
176

       
-

       
            postUri: testPostUri,


     

       
177

       
-

       
            postCid: testPostCid,


     

       

       

       
     

       

       

       
     

       

       

       
     

       
178

       
 

       
          ),


     

       
179

       
 

       
        ).thenThrow(


     

       
180

       
 

       
          NetworkException('Connection failed'),


     
···

       
199

       
 

       
        // Mock slow API response


     

       
200

       
 

       
        when(


     

       
201

       
 

       
          mockVoteService.createVote(


     

       
202

       
-

       
            postUri: testPostUri,


     

       
203

       
-

       
            postCid: testPostCid,


     

       

       

       
     

       

       

       
     

       

       

       
     

       
204

       
 

       
          ),


     

       
205

       
 

       
        ).thenAnswer(


     

       
206

       
 

       
          (_) async {


     

       
207

       
 

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


     

       
208

       
 

       
            return const VoteResponse(


     

       
209

       
-

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


     

       
210

       
 

       
              cid: 'bafy123',


     

       
211

       
 

       
              rkey: '456',


     

       
212

       
 

       
              deleted: false,


     
···

       
236

       
 

       
        // Should have only called API once


     

       
237

       
 

       
        verify(


     

       
238

       
 

       
          mockVoteService.createVote(


     

       
239

       
-

       
            postUri: testPostUri,


     

       
240

       
-

       
            postCid: testPostCid,


     

       

       

       
     

       

       

       
     

       

       

       
     

       
241

       
 

       
          ),


     

       
242

       
 

       
        ).called(1);


     

       
243

       
 

       
      });


     
···

       
245

       
 

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


     

       
246

       
 

       
        when(


     

       
247

       
 

       
          mockVoteService.createVote(


     

       
248

       
-

       
            postUri: testPostUri,


     

       
249

       
-

       
            postCid: testPostCid,


     

       
250

       
-

       
            direction: 'down',


     

       

       

       
     

       

       

       
     

       
251

       
 

       
          ),


     

       
252

       
 

       
        ).thenAnswer(


     

       
253

       
 

       
          (_) async => const VoteResponse(


     

       
254

       
-

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


     

       
255

       
 

       
            cid: 'bafy123',


     

       
256

       
 

       
            rkey: '456',


     

       
257

       
 

       
            deleted: false,


     
···

       
280

       
 

       
        voteProvider.setInitialVoteState(


     

       
281

       
 

       
          postUri: testPostUri,


     

       
282

       
 

       
          voteDirection: 'up',


     

       
283

       
-

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


     

       
284

       
 

       
        );


     

       
285

       
 

       



     

       
286

       
 

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


     

       
287

       
 

       



     

       
288

       
 

       
        final voteState = voteProvider.getVoteState(testPostUri);


     

       
289

       
 

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


     

       
290

       
-

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


     

       
291

       
 

       
        expect(voteState?.deleted, false);


     

       
292

       
 

       
      });


     

       
293

       
 

       



     
···

       
296

       
 

       
        voteProvider.setInitialVoteState(


     

       
297

       
 

       
          postUri: testPostUri,


     

       
298

       
 

       
          voteDirection: 'up',


     

       
299

       
-

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


     

       
300

       
 

       
        );


     

       
301

       
 

       



     

       
302

       
 

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


     
···

       
319

       
 

       
        voteProvider.setInitialVoteState(


     

       
320

       
 

       
          postUri: testPostUri,


     

       
321

       
 

       
          voteDirection: 'up',


     

       
322

       
-

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


     

       
323

       
 

       
        );


     

       
324

       
 

       



     

       
325

       
 

       
        // Should NOT notify listeners (silent initialization)


     
···

       
336

       
 

       
        voteProvider.setInitialVoteState(


     

       
337

       
 

       
          postUri: post1,


     

       
338

       
 

       
          voteDirection: 'up',


     

       
339

       
-

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


     

       
340

       
 

       
        );


     

       
341

       
 

       
        voteProvider.setInitialVoteState(


     

       
342

       
 

       
          postUri: post2,


     

       
343

       
 

       
          voteDirection: 'up',


     

       
344

       
-

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


     

       
345

       
 

       
        );


     

       
346

       
 

       



     

       
347

       
 

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


     
···

       
377

       
 

       
        // Mock slow API response


     

       
378

       
 

       
        when(


     

       
379

       
 

       
          mockVoteService.createVote(


     

       
380

       
-

       
            postUri: testPostUri,


     

       
381

       
-

       
            postCid: testPostCid,


     

       

       

       
     

       

       

       
     

       

       

       
     

       
382

       
 

       
          ),


     

       
383

       
 

       
        ).thenAnswer(


     

       
384

       
 

       
          (_) async {


     

       
385

       
 

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


     

       
386

       
 

       
            return const VoteResponse(


     

       
387

       
-

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


     

       
388

       
 

       
              cid: 'bafy123',


     

       
389

       
 

       
              rkey: '456',


     

       
390

       
 

       
              deleted: false,


     
···

       
419

       
 

       
      });


     

       
420

       
 

       
    });


     

       
421

       
 

       



     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
422

       
 

       
    group('Auth state listener', () {


     

       
423

       
 

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


     

       
424

       
 

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


     
···

       
427

       
 

       
        voteProvider.setInitialVoteState(


     

       
428

       
 

       
          postUri: testPostUri,


     

       
429

       
 

       
          voteDirection: 'up',


     

       
430

       
-

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


     

       
431

       
 

       
        );


     

       
432

       
 

       



     

       
433

       
 

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


     
···

       
451

       
 

       
        voteProvider.setInitialVoteState(


     

       
452

       
 

       
          postUri: testPostUri,


     

       
453

       
 

       
          voteDirection: 'up',


     

       
454

       
-

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


     

       
455

       
 

       
        );


     

       
456

       
 

       



     

       
457

       
 

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


     
···

       
43

       
 

       
        // Mock successful API response


     

       
44

       
 

       
        when(


     

       
45

       
 

       
          mockVoteService.createVote(


     

       
46

       
+

       
            postUri: anyNamed('postUri'),


     

       
47

       
+

       
            postCid: anyNamed('postCid'),


     

       
48

       
+

       
            direction: anyNamed('direction'),


     

       
49

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
50

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
51

       
 

       
          ),


     

       
52

       
 

       
        ).thenAnswer(


     

       
53

       
 

       
          (_) async => const VoteResponse(


     

       
54

       
+

       
            uri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
55

       
 

       
            cid: 'bafy123',


     

       
56

       
 

       
            rkey: '456',


     

       
57

       
 

       
            deleted: false,


     
···

       
84

       
 

       
        // Vote state should be correct


     

       
85

       
 

       
        final voteState = voteProvider.getVoteState(testPostUri);


     

       
86

       
 

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


     

       
87

       
+

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


     

       
88

       
 

       
        expect(voteState?.deleted, false);


     

       
89

       
 

       
      });


     

       
90

       
 

       



     
···

       
93

       
 

       
        voteProvider.setInitialVoteState(


     

       
94

       
 

       
          postUri: testPostUri,


     

       
95

       
 

       
          voteDirection: 'up',


     

       
96

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
97

       
 

       
        );


     

       
98

       
 

       



     

       
99

       
 

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


     
···

       
101

       
 

       
        // Mock API response for toggling off


     

       
102

       
 

       
        when(


     

       
103

       
 

       
          mockVoteService.createVote(


     

       
104

       
+

       
            postUri: anyNamed('postUri'),


     

       
105

       
+

       
            postCid: anyNamed('postCid'),


     

       
106

       
+

       
            direction: anyNamed('direction'),


     

       
107

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
108

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
109

       
 

       
          ),


     

       
110

       
 

       
        ).thenAnswer(


     

       
111

       
 

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


     
···

       
135

       
 

       
        // Mock API failure


     

       
136

       
 

       
        when(


     

       
137

       
 

       
          mockVoteService.createVote(


     

       
138

       
+

       
            postUri: anyNamed('postUri'),


     

       
139

       
+

       
            postCid: anyNamed('postCid'),


     

       
140

       
+

       
            direction: anyNamed('direction'),


     

       
141

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
142

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
143

       
 

       
          ),


     

       
144

       
 

       
        ).thenThrow(


     

       
145

       
 

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


     
···

       
173

       
 

       
        voteProvider.setInitialVoteState(


     

       
174

       
 

       
          postUri: testPostUri,


     

       
175

       
 

       
          voteDirection: 'up',


     

       
176

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
177

       
 

       
        );


     

       
178

       
 

       



     

       
179

       
 

       
        final initialState = voteProvider.getVoteState(testPostUri);


     
···

       
182

       
 

       
        // Mock API failure when trying to toggle off


     

       
183

       
 

       
        when(


     

       
184

       
 

       
          mockVoteService.createVote(


     

       
185

       
+

       
            postUri: anyNamed('postUri'),


     

       
186

       
+

       
            postCid: anyNamed('postCid'),


     

       
187

       
+

       
            direction: anyNamed('direction'),


     

       
188

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
189

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
190

       
 

       
          ),


     

       
191

       
 

       
        ).thenThrow(


     

       
192

       
 

       
          NetworkException('Connection failed'),


     
···

       
211

       
 

       
        // Mock slow API response


     

       
212

       
 

       
        when(


     

       
213

       
 

       
          mockVoteService.createVote(


     

       
214

       
+

       
            postUri: anyNamed('postUri'),


     

       
215

       
+

       
            postCid: anyNamed('postCid'),


     

       
216

       
+

       
            direction: anyNamed('direction'),


     

       
217

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
218

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
219

       
 

       
          ),


     

       
220

       
 

       
        ).thenAnswer(


     

       
221

       
 

       
          (_) async {


     

       
222

       
 

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


     

       
223

       
 

       
            return const VoteResponse(


     

       
224

       
+

       
              uri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
225

       
 

       
              cid: 'bafy123',


     

       
226

       
 

       
              rkey: '456',


     

       
227

       
 

       
              deleted: false,


     
···

       
251

       
 

       
        // Should have only called API once


     

       
252

       
 

       
        verify(


     

       
253

       
 

       
          mockVoteService.createVote(


     

       
254

       
+

       
            postUri: anyNamed('postUri'),


     

       
255

       
+

       
            postCid: anyNamed('postCid'),


     

       
256

       
+

       
            direction: anyNamed('direction'),


     

       
257

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
258

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
259

       
 

       
          ),


     

       
260

       
 

       
        ).called(1);


     

       
261

       
 

       
      });


     
···

       
263

       
 

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


     

       
264

       
 

       
        when(


     

       
265

       
 

       
          mockVoteService.createVote(


     

       
266

       
+

       
            postUri: anyNamed('postUri'),


     

       
267

       
+

       
            postCid: anyNamed('postCid'),


     

       
268

       
+

       
            direction: anyNamed('direction'),


     

       
269

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
270

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
271

       
 

       
          ),


     

       
272

       
 

       
        ).thenAnswer(


     

       
273

       
 

       
          (_) async => const VoteResponse(


     

       
274

       
+

       
            uri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
275

       
 

       
            cid: 'bafy123',


     

       
276

       
 

       
            rkey: '456',


     

       
277

       
 

       
            deleted: false,


     
···

       
300

       
 

       
        voteProvider.setInitialVoteState(


     

       
301

       
 

       
          postUri: testPostUri,


     

       
302

       
 

       
          voteDirection: 'up',


     

       
303

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
304

       
 

       
        );


     

       
305

       
 

       



     

       
306

       
 

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


     

       
307

       
 

       



     

       
308

       
 

       
        final voteState = voteProvider.getVoteState(testPostUri);


     

       
309

       
 

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


     

       
310

       
+

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


     

       
311

       
 

       
        expect(voteState?.deleted, false);


     

       
312

       
 

       
      });


     

       
313

       
 

       



     
···

       
316

       
 

       
        voteProvider.setInitialVoteState(


     

       
317

       
 

       
          postUri: testPostUri,


     

       
318

       
 

       
          voteDirection: 'up',


     

       
319

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
320

       
 

       
        );


     

       
321

       
 

       



     

       
322

       
 

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


     
···

       
339

       
 

       
        voteProvider.setInitialVoteState(


     

       
340

       
 

       
          postUri: testPostUri,


     

       
341

       
 

       
          voteDirection: 'up',


     

       
342

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
343

       
 

       
        );


     

       
344

       
 

       



     

       
345

       
 

       
        // Should NOT notify listeners (silent initialization)


     
···

       
356

       
 

       
        voteProvider.setInitialVoteState(


     

       
357

       
 

       
          postUri: post1,


     

       
358

       
 

       
          voteDirection: 'up',


     

       
359

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/1',


     

       
360

       
 

       
        );


     

       
361

       
 

       
        voteProvider.setInitialVoteState(


     

       
362

       
 

       
          postUri: post2,


     

       
363

       
 

       
          voteDirection: 'up',


     

       
364

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/2',


     

       
365

       
 

       
        );


     

       
366

       
 

       



     

       
367

       
 

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


     
···

       
397

       
 

       
        // Mock slow API response


     

       
398

       
 

       
        when(


     

       
399

       
 

       
          mockVoteService.createVote(


     

       
400

       
+

       
            postUri: anyNamed('postUri'),


     

       
401

       
+

       
            postCid: anyNamed('postCid'),


     

       
402

       
+

       
            direction: anyNamed('direction'),


     

       
403

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
404

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
405

       
 

       
          ),


     

       
406

       
 

       
        ).thenAnswer(


     

       
407

       
 

       
          (_) async {


     

       
408

       
 

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


     

       
409

       
 

       
            return const VoteResponse(


     

       
410

       
+

       
              uri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
411

       
 

       
              cid: 'bafy123',


     

       
412

       
 

       
              rkey: '456',


     

       
413

       
 

       
              deleted: false,


     
···

       
442

       
 

       
      });


     

       
443

       
 

       
    });


     

       
444

       
 

       



     

       
445

       
+

       
    group('Score adjustments', () {


     

       
446

       
+

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


     

       
447

       
+

       
      const testPostCid = 'bafy2bzacepostcid123';


     

       
448

       
+

       



     

       
449

       
+

       
      test('should adjust score when creating upvote', () async {


     

       
450

       
+

       
        when(


     

       
451

       
+

       
          mockVoteService.createVote(


     

       
452

       
+

       
            postUri: anyNamed('postUri'),


     

       
453

       
+

       
            postCid: anyNamed('postCid'),


     

       
454

       
+

       
            direction: anyNamed('direction'),


     

       
455

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
456

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
457

       
+

       
          ),


     

       
458

       
+

       
        ).thenAnswer(


     

       
459

       
+

       
          (_) async => const VoteResponse(


     

       
460

       
+

       
            uri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
461

       
+

       
            cid: 'bafy123',


     

       
462

       
+

       
            rkey: '456',


     

       
463

       
+

       
            deleted: false,


     

       
464

       
+

       
          ),


     

       
465

       
+

       
        );


     

       
466

       
+

       



     

       
467

       
+

       
        // Initial score from server


     

       
468

       
+

       
        const serverScore = 10;


     

       
469

       
+

       



     

       
470

       
+

       
        // Before vote, adjustment should be 0


     

       
471

       
+

       
        expect(voteProvider.getAdjustedScore(testPostUri, serverScore), 10);


     

       
472

       
+

       



     

       
473

       
+

       
        // Create upvote


     

       
474

       
+

       
        await voteProvider.toggleVote(


     

       
475

       
+

       
          postUri: testPostUri,


     

       
476

       
+

       
          postCid: testPostCid,


     

       
477

       
+

       
        );


     

       
478

       
+

       



     

       
479

       
+

       
        // Should have +1 adjustment (upvote added)


     

       
480

       
+

       
        expect(voteProvider.getAdjustedScore(testPostUri, serverScore), 11);


     

       
481

       
+

       
      });


     

       
482

       
+

       



     

       
483

       
+

       
      test('should adjust score when removing upvote', () async {


     

       
484

       
+

       
        // Set initial state with upvote


     

       
485

       
+

       
        voteProvider.setInitialVoteState(


     

       
486

       
+

       
          postUri: testPostUri,


     

       
487

       
+

       
          voteDirection: 'up',


     

       
488

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
489

       
+

       
        );


     

       
490

       
+

       



     

       
491

       
+

       
        when(


     

       
492

       
+

       
          mockVoteService.createVote(


     

       
493

       
+

       
            postUri: anyNamed('postUri'),


     

       
494

       
+

       
            postCid: anyNamed('postCid'),


     

       
495

       
+

       
            direction: anyNamed('direction'),


     

       
496

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
497

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
498

       
+

       
          ),


     

       
499

       
+

       
        ).thenAnswer(


     

       
500

       
+

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


     

       
501

       
+

       
        );


     

       
502

       
+

       



     

       
503

       
+

       
        const serverScore = 10;


     

       
504

       
+

       



     

       
505

       
+

       
        // Before removing, adjustment should be 0 (server knows about upvote)


     

       
506

       
+

       
        expect(voteProvider.getAdjustedScore(testPostUri, serverScore), 10);


     

       
507

       
+

       



     

       
508

       
+

       
        // Remove upvote


     

       
509

       
+

       
        await voteProvider.toggleVote(


     

       
510

       
+

       
          postUri: testPostUri,


     

       
511

       
+

       
          postCid: testPostCid,


     

       
512

       
+

       
        );


     

       
513

       
+

       



     

       
514

       
+

       
        // Should have -1 adjustment (upvote removed)


     

       
515

       
+

       
        expect(voteProvider.getAdjustedScore(testPostUri, serverScore), 9);


     

       
516

       
+

       
      });


     

       
517

       
+

       



     

       
518

       
+

       
      test('should adjust score when creating downvote', () async {


     

       
519

       
+

       
        when(


     

       
520

       
+

       
          mockVoteService.createVote(


     

       
521

       
+

       
            postUri: anyNamed('postUri'),


     

       
522

       
+

       
            postCid: anyNamed('postCid'),


     

       
523

       
+

       
            direction: anyNamed('direction'),


     

       
524

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
525

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
526

       
+

       
          ),


     

       
527

       
+

       
        ).thenAnswer(


     

       
528

       
+

       
          (_) async => const VoteResponse(


     

       
529

       
+

       
            uri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
530

       
+

       
            cid: 'bafy123',


     

       
531

       
+

       
            rkey: '456',


     

       
532

       
+

       
            deleted: false,


     

       
533

       
+

       
          ),


     

       
534

       
+

       
        );


     

       
535

       
+

       



     

       
536

       
+

       
        const serverScore = 10;


     

       
537

       
+

       



     

       
538

       
+

       
        // Create downvote


     

       
539

       
+

       
        await voteProvider.toggleVote(


     

       
540

       
+

       
          postUri: testPostUri,


     

       
541

       
+

       
          postCid: testPostCid,


     

       
542

       
+

       
          direction: 'down',


     

       
543

       
+

       
        );


     

       
544

       
+

       



     

       
545

       
+

       
        // Should have -1 adjustment (downvote added)


     

       
546

       
+

       
        expect(voteProvider.getAdjustedScore(testPostUri, serverScore), 9);


     

       
547

       
+

       
      });


     

       
548

       
+

       



     

       
549

       
+

       
      test('should adjust score when switching from upvote to downvote',


     

       
550

       
+

       
          () async {


     

       
551

       
+

       
        // Set initial state with upvote


     

       
552

       
+

       
        voteProvider.setInitialVoteState(


     

       
553

       
+

       
          postUri: testPostUri,


     

       
554

       
+

       
          voteDirection: 'up',


     

       
555

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
556

       
+

       
        );


     

       
557

       
+

       



     

       
558

       
+

       
        when(


     

       
559

       
+

       
          mockVoteService.createVote(


     

       
560

       
+

       
            postUri: anyNamed('postUri'),


     

       
561

       
+

       
            postCid: anyNamed('postCid'),


     

       
562

       
+

       
            direction: anyNamed('direction'),


     

       
563

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
564

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
565

       
+

       
          ),


     

       
566

       
+

       
        ).thenAnswer(


     

       
567

       
+

       
          (_) async => const VoteResponse(


     

       
568

       
+

       
            uri: 'at://did:plc:test/social.coves.feed.vote/789',


     

       
569

       
+

       
            cid: 'bafy789',


     

       
570

       
+

       
            rkey: '789',


     

       
571

       
+

       
            deleted: false,


     

       
572

       
+

       
          ),


     

       
573

       
+

       
        );


     

       
574

       
+

       



     

       
575

       
+

       
        const serverScore = 10;


     

       
576

       
+

       



     

       
577

       
+

       
        // Switch to downvote


     

       
578

       
+

       
        await voteProvider.toggleVote(


     

       
579

       
+

       
          postUri: testPostUri,


     

       
580

       
+

       
          postCid: testPostCid,


     

       
581

       
+

       
          direction: 'down',


     

       
582

       
+

       
        );


     

       
583

       
+

       



     

       
584

       
+

       
        // Should have -2 adjustment (remove +1, add -1)


     

       
585

       
+

       
        expect(voteProvider.getAdjustedScore(testPostUri, serverScore), 8);


     

       
586

       
+

       
      });


     

       
587

       
+

       



     

       
588

       
+

       
      test('should adjust score when switching from downvote to upvote',


     

       
589

       
+

       
          () async {


     

       
590

       
+

       
        // Set initial state with downvote


     

       
591

       
+

       
        voteProvider.setInitialVoteState(


     

       
592

       
+

       
          postUri: testPostUri,


     

       
593

       
+

       
          voteDirection: 'down',


     

       
594

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
595

       
+

       
        );


     

       
596

       
+

       



     

       
597

       
+

       
        when(


     

       
598

       
+

       
          mockVoteService.createVote(


     

       
599

       
+

       
            postUri: anyNamed('postUri'),


     

       
600

       
+

       
            postCid: anyNamed('postCid'),


     

       
601

       
+

       
            direction: anyNamed('direction'),


     

       
602

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
603

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
604

       
+

       
          ),


     

       
605

       
+

       
        ).thenAnswer(


     

       
606

       
+

       
          (_) async => const VoteResponse(


     

       
607

       
+

       
            uri: 'at://did:plc:test/social.coves.feed.vote/789',


     

       
608

       
+

       
            cid: 'bafy789',


     

       
609

       
+

       
            rkey: '789',


     

       
610

       
+

       
            deleted: false,


     

       
611

       
+

       
          ),


     

       
612

       
+

       
        );


     

       
613

       
+

       



     

       
614

       
+

       
        const serverScore = 10;


     

       
615

       
+

       



     

       
616

       
+

       
        // Switch to upvote


     

       
617

       
+

       
        await voteProvider.toggleVote(


     

       
618

       
+

       
          postUri: testPostUri,


     

       
619

       
+

       
          postCid: testPostCid,


     

       
620

       
+

       
          direction: 'up',


     

       
621

       
+

       
        );


     

       
622

       
+

       



     

       
623

       
+

       
        // Should have +2 adjustment (remove -1, add +1)


     

       
624

       
+

       
        expect(voteProvider.getAdjustedScore(testPostUri, serverScore), 12);


     

       
625

       
+

       
      });


     

       
626

       
+

       



     

       
627

       
+

       
      test('should rollback score adjustment on error', () async {


     

       
628

       
+

       
        const serverScore = 10;


     

       
629

       
+

       



     

       
630

       
+

       
        when(


     

       
631

       
+

       
          mockVoteService.createVote(


     

       
632

       
+

       
            postUri: anyNamed('postUri'),


     

       
633

       
+

       
            postCid: anyNamed('postCid'),


     

       
634

       
+

       
            direction: anyNamed('direction'),


     

       
635

       
+

       
            existingVoteRkey: anyNamed('existingVoteRkey'),


     

       
636

       
+

       
            existingVoteDirection: anyNamed('existingVoteDirection'),


     

       
637

       
+

       
          ),


     

       
638

       
+

       
        ).thenThrow(


     

       
639

       
+

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


     

       
640

       
+

       
        );


     

       
641

       
+

       



     

       
642

       
+

       
        // Try to vote (will fail)


     

       
643

       
+

       
        expect(


     

       
644

       
+

       
          () => voteProvider.toggleVote(


     

       
645

       
+

       
            postUri: testPostUri,


     

       
646

       
+

       
            postCid: testPostCid,


     

       
647

       
+

       
          ),


     

       
648

       
+

       
          throwsA(isA<ApiException>()),


     

       
649

       
+

       
        );


     

       
650

       
+

       



     

       
651

       
+

       
        await Future.delayed(Duration.zero);


     

       
652

       
+

       



     

       
653

       
+

       
        // Adjustment should be rolled back to 0


     

       
654

       
+

       
        expect(voteProvider.getAdjustedScore(testPostUri, serverScore), 10);


     

       
655

       
+

       
      });


     

       
656

       
+

       



     

       
657

       
+

       
      test('should clear score adjustments when clearing all state', () {


     

       
658

       
+

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


     

       
659

       
+

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


     

       
660

       
+

       



     

       
661

       
+

       
        // Manually set some adjustments (simulating votes)


     

       
662

       
+

       
        voteProvider.setInitialVoteState(


     

       
663

       
+

       
          postUri: testPostUri1,


     

       
664

       
+

       
          voteDirection: 'up',


     

       
665

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/1',


     

       
666

       
+

       
        );


     

       
667

       
+

       



     

       
668

       
+

       
        // Clear all


     

       
669

       
+

       
        voteProvider.clear();


     

       
670

       
+

       



     

       
671

       
+

       
        // Adjustments should be cleared (back to 0)


     

       
672

       
+

       
        expect(voteProvider.getAdjustedScore(testPostUri1, 10), 10);


     

       
673

       
+

       
        expect(voteProvider.getAdjustedScore(testPostUri2, 5), 5);


     

       
674

       
+

       
      });


     

       
675

       
+

       
    });


     

       
676

       
+

       



     

       
677

       
 

       
    group('Auth state listener', () {


     

       
678

       
 

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


     

       
679

       
 

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


     
···

       
682

       
 

       
        voteProvider.setInitialVoteState(


     

       
683

       
 

       
          postUri: testPostUri,


     

       
684

       
 

       
          voteDirection: 'up',


     

       
685

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
686

       
 

       
        );


     

       
687

       
 

       



     

       
688

       
 

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


     
···

       
706

       
 

       
        voteProvider.setInitialVoteState(


     

       
707

       
 

       
          postUri: testPostUri,


     

       
708

       
 

       
          voteDirection: 'up',


     

       
709

       
+

       
          voteUri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
710

       
 

       
        );


     

       
711

       
 

       



     

       
712

       
 

       
        expect(voteProvider.isLiked(testPostUri), true);
+16
test/providers/vote_provider_test.mocks.dart 
···

       
39

       
 

       
  }


     

       
40

       
 

       



     

       
41

       
 

       
  @override


     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       

       

       
     

       
42

       
 

       
  _i3.Future<_i2.VoteResponse> createVote({


     

       
43

       
 

       
    required String? postUri,


     

       
44

       
 

       
    required String? postCid,


     

       
45

       
 

       
    String? direction = 'up',


     

       

       

       
     

       

       

       
     

       
46

       
 

       
  }) =>


     

       
47

       
 

       
      (super.noSuchMethod(


     

       
48

       
 

       
            Invocation.method(#createVote, [], {


     

       
49

       
 

       
              #postUri: postUri,


     

       
50

       
 

       
              #postCid: postCid,


     

       
51

       
 

       
              #direction: direction,


     

       

       

       
     

       

       

       
     

       
52

       
 

       
            }),


     

       
53

       
 

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


     

       
54

       
 

       
              _FakeVoteResponse_0(


     
···

       
57

       
 

       
                  #postUri: postUri,


     

       
58

       
 

       
                  #postCid: postCid,


     

       
59

       
 

       
                  #direction: direction,


     

       

       

       
     

       

       

       
     

       
60

       
 

       
                }),


     

       
61

       
 

       
              ),


     

       
62

       
 

       
            ),


     
···

       
39

       
 

       
  }


     

       
40

       
 

       



     

       
41

       
 

       
  @override


     

       
42

       
+

       
  _i3.Future<Map<String, _i2.VoteInfo>> getUserVotes() =>


     

       
43

       
+

       
      (super.noSuchMethod(


     

       
44

       
+

       
            Invocation.method(#getUserVotes, []),


     

       
45

       
+

       
            returnValue: _i3.Future<Map<String, _i2.VoteInfo>>.value(


     

       
46

       
+

       
              <String, _i2.VoteInfo>{},


     

       
47

       
+

       
            ),


     

       
48

       
+

       
          )


     

       
49

       
+

       
          as _i3.Future<Map<String, _i2.VoteInfo>>);


     

       
50

       
+

       



     

       
51

       
+

       
  @override


     

       
52

       
 

       
  _i3.Future<_i2.VoteResponse> createVote({


     

       
53

       
 

       
    required String? postUri,


     

       
54

       
 

       
    required String? postCid,


     

       
55

       
 

       
    String? direction = 'up',


     

       
56

       
+

       
    String? existingVoteRkey,


     

       
57

       
+

       
    String? existingVoteDirection,


     

       
58

       
 

       
  }) =>


     

       
59

       
 

       
      (super.noSuchMethod(


     

       
60

       
 

       
            Invocation.method(#createVote, [], {


     

       
61

       
 

       
              #postUri: postUri,


     

       
62

       
 

       
              #postCid: postCid,


     

       
63

       
 

       
              #direction: direction,


     

       
64

       
+

       
              #existingVoteRkey: existingVoteRkey,


     

       
65

       
+

       
              #existingVoteDirection: existingVoteDirection,


     

       
66

       
 

       
            }),


     

       
67

       
 

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


     

       
68

       
 

       
              _FakeVoteResponse_0(


     
···

       
71

       
 

       
                  #postUri: postUri,


     

       
72

       
 

       
                  #postCid: postCid,


     

       
73

       
 

       
                  #direction: direction,


     

       
74

       
+

       
                  #existingVoteRkey: existingVoteRkey,


     

       
75

       
+

       
                  #existingVoteDirection: existingVoteDirection,


     

       
76

       
 

       
                }),


     

       
77

       
 

       
              ),


     

       
78

       
 

       
            ),
+7 -7
test/services/vote_service_test.dart 
···

       
29

       
 

       
          jsonEncode({


     

       
30

       
 

       
            'records': [


     

       
31

       
 

       
              {


     

       
32

       
-

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


     

       
33

       
 

       
                'value': {


     

       
34

       
 

       
                  'subject': {


     

       
35

       
 

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


     
···

       
95

       
 

       
          jsonEncode({


     

       
96

       
 

       
            'records': [


     

       
97

       
 

       
              {


     

       
98

       
-

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


     

       
99

       
 

       
                'value': {


     

       
100

       
 

       
                  'subject': {


     

       
101

       
 

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


     
···

       
115

       
 

       
          jsonEncode({


     

       
116

       
 

       
            'records': [


     

       
117

       
 

       
              {


     

       
118

       
-

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


     

       
119

       
 

       
                'value': {


     

       
120

       
 

       
                  'subject': {


     

       
121

       
 

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


     
···

       
197

       
 

       
          jsonEncode({


     

       
198

       
 

       
            'records': [


     

       
199

       
 

       
              {


     

       
200

       
-

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


     

       
201

       
 

       
                'value': {


     

       
202

       
 

       
                  'subject': {


     

       
203

       
 

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


     
···

       
230

       
 

       
        ).thenAnswer(


     

       
231

       
 

       
          (_) async => http.Response(


     

       
232

       
 

       
            jsonEncode({


     

       
233

       
-

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


     

       
234

       
 

       
              'cid': 'bafy456',


     

       
235

       
 

       
            }),


     

       
236

       
 

       
            200,


     
···

       
268

       
 

       
        // We'll use a minimal test to verify the VoteResponse parsing logic


     

       
269

       
 

       



     

       
270

       
 

       
        const response = VoteResponse(


     

       
271

       
-

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


     

       
272

       
 

       
          cid: 'bafy123',


     

       
273

       
 

       
          rkey: '456',


     

       
274

       
 

       
          deleted: false,


     

       
275

       
 

       
        );


     

       
276

       
 

       



     

       
277

       
-

       
        expect(response.uri, 'at://did:plc:test/social.coves.interaction.vote/456');


     

       
278

       
 

       
        expect(response.cid, 'bafy123');


     

       
279

       
 

       
        expect(response.rkey, '456');


     

       
280

       
 

       
        expect(response.deleted, false);


     
···

       
29

       
 

       
          jsonEncode({


     

       
30

       
 

       
            'records': [


     

       
31

       
 

       
              {


     

       
32

       
+

       
                'uri': 'at://did:plc:test/social.coves.feed.vote/abc123',


     

       
33

       
 

       
                'value': {


     

       
34

       
 

       
                  'subject': {


     

       
35

       
 

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


     
···

       
95

       
 

       
          jsonEncode({


     

       
96

       
 

       
            'records': [


     

       
97

       
 

       
              {


     

       
98

       
+

       
                'uri': 'at://did:plc:test/social.coves.feed.vote/abc1',


     

       
99

       
 

       
                'value': {


     

       
100

       
 

       
                  'subject': {


     

       
101

       
 

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


     
···

       
115

       
 

       
          jsonEncode({


     

       
116

       
 

       
            'records': [


     

       
117

       
 

       
              {


     

       
118

       
+

       
                'uri': 'at://did:plc:test/social.coves.feed.vote/abc123',


     

       
119

       
 

       
                'value': {


     

       
120

       
 

       
                  'subject': {


     

       
121

       
 

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


     
···

       
197

       
 

       
          jsonEncode({


     

       
198

       
 

       
            'records': [


     

       
199

       
 

       
              {


     

       
200

       
+

       
                'uri': 'at://did:plc:test/social.coves.feed.vote/abc1',


     

       
201

       
 

       
                'value': {


     

       
202

       
 

       
                  'subject': {


     

       
203

       
 

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


     
···

       
230

       
 

       
        ).thenAnswer(


     

       
231

       
 

       
          (_) async => http.Response(


     

       
232

       
 

       
            jsonEncode({


     

       
233

       
+

       
              'uri': 'at://did:plc:test/social.coves.feed.vote/new123',


     

       
234

       
 

       
              'cid': 'bafy456',


     

       
235

       
 

       
            }),


     

       
236

       
 

       
            200,


     
···

       
268

       
 

       
        // We'll use a minimal test to verify the VoteResponse parsing logic


     

       
269

       
 

       



     

       
270

       
 

       
        const response = VoteResponse(


     

       
271

       
+

       
          uri: 'at://did:plc:test/social.coves.feed.vote/456',


     

       
272

       
 

       
          cid: 'bafy123',


     

       
273

       
 

       
          rkey: '456',


     

       
274

       
 

       
          deleted: false,


     

       
275

       
 

       
        );


     

       
276

       
 

       



     

       
277

       
+

       
        expect(response.uri, 'at://did:plc:test/social.coves.feed.vote/456');


     

       
278

       
 

       
        expect(response.cid, 'bafy123');


     

       
279

       
 

       
        expect(response.rkey, '456');


     

       
280

       
 

       
        expect(response.deleted, false);