Merge pull request #46 from shadowfish07/test/add

fix: 增加一些单测，修复一些问题

Author: shadowfish07

codecov.yml

@@ -0,0 +1,8 @@
+coverage:
+  status:
+    project:
+      default:
+        informational: true
+    patch:
+      default:
+        informational: true

lib/data/repository/bookmark/bookmark_repository.dart

@@ -29,122 +29,155 @@ class BookmarkRepository {
   /// 添加数据变化监听器
   void addListener(BookmarkChangeListener listener) {
     _listeners.add(listener);
+    appLogger.d('添加书签数据变化监听器，当前监听器数量: ${_listeners.length}');
   }
 
   /// 移除数据变化监听器
   void removeListener(BookmarkChangeListener listener) {
     _listeners.remove(listener);
+    appLogger.d('移除书签数据变化监听器，当前监听器数量: ${_listeners.length}');
   }
 
   /// 通知所有监听器数据已变化
   void _notifyListeners() {
+    appLogger.d('通知 ${_listeners.length} 个监听器书签数据已变化');
     for (final listener in _listeners) {
       listener();
     }
   }
 
   /// 插入或更新单个书签到缓存
-  void insertOrUpdateBookmark(Bookmark bookmark) {
+  void _insertOrUpdateBookmark(Bookmark bookmark, {bool batch = false}) {
     final index = _bookmarks.indexWhere((b) => b.id == bookmark.id);
     if (index != -1) {
       _bookmarks[index] = bookmark;
     } else {
       _bookmarks.add(bookmark);
     }
-    _notifyListeners();
+    if (!batch) {
+      _notifyListeners();
+    }
   }
 
   /// 批量插入或更新书签到缓存
   void _insertOrUpdateCachedBookmarks(List<Bookmark> bookmarks) {
+    appLogger.i('批量更新缓存书签，数量: ${bookmarks.length}');
     for (var bookmark in bookmarks) {
-      insertOrUpdateBookmark(bookmark);
+      _insertOrUpdateBookmark(bookmark, batch: true);
     }
+    _notifyListeners();
   }
 
   /// 从缓存获取单个书签
   Bookmark? getCachedBookmark(String id) {
-    return _bookmarks.where((b) => b.id == id).firstOrNull;
+    final bookmark = _bookmarks.where((b) => b.id == id).firstOrNull;
+    return bookmark;
   }
 
   /// 从缓存获取多个书签
   List<Bookmark?> getCachedBookmarks(List<String> ids) {
-    return ids.map((id) => getCachedBookmark(id)).toList();
+    appLogger.d('从缓存批量获取书签，请求数量: ${ids.length}');
+    final result = ids.map((id) => getCachedBookmark(id)).toList();
+    final foundCount = result.where((b) => b != null).length;
+    appLogger.d('批量获取书签完成，找到: $foundCount/${ids.length}');
+    return result;
   }
 
   /// 从缓存删除书签
   void _deleteCachedBookmark(String id) {
+    final removedCount = _bookmarks.length;
     _bookmarks.removeWhere((b) => b.id == id);
+    final actualRemovedCount = removedCount - _bookmarks.length;
+    appLogger.i('从缓存删除书签: $id, 删除数量: $actualRemovedCount');
     _notifyListeners();
   }
 
   /// 释放资源，清空所有监听器
   void dispose() {
+    appLogger.i('释放 BookmarkRepository 资源，清空 ${_listeners.length} 个监听器');
     _listeners.clear();
   }
 
   AsyncResult<List<Bookmark>> loadBookmarksByIds(List<String> ids) async {
+    appLogger.i('开始根据ID加载书签，数量: ${ids.length}');
     final result = await _readeckApiClient.getBookmarks(ids: ids);
     if (result.isSuccess()) {
-      _insertOrUpdateCachedBookmarks(result.getOrThrow());
+      final bookmarks = result.getOrThrow();
+      appLogger.i('成功加载书签 ${bookmarks.length} 个');
+      _insertOrUpdateCachedBookmarks(bookmarks);
       return result;
     }
 
+    appLogger.e('根据ID加载书签失败', error: result.exceptionOrNull());
     return result;
   }
 
   AsyncResult<List<Bookmark>> loadUnarchivedBookmarks({
     int limit = 10,
     int page = 1,
   }) async {
+    appLogger.i('开始加载未归档书签，页码: $page, 限制: $limit');
     final result = await _readeckApiClient.getBookmarks(
       isArchived: false,
       limit: limit,
       offset: (page - 1) * limit,
     );
     if (result.isSuccess()) {
-      _insertOrUpdateCachedBookmarks(result.getOrThrow());
+      final bookmarks = result.getOrThrow();
+      appLogger.i('成功加载未归档书签 ${bookmarks.length} 个');
+      _insertOrUpdateCachedBookmarks(bookmarks);
       return result;
     }
 
+    appLogger.e('加载未归档书签失败', error: result.exceptionOrNull());
     return result;
   }
 
   AsyncResult<List<Bookmark>> loadArchivedBookmarks({
     int limit = 10,
     int page = 1,
   }) async {
+    appLogger.i('开始加载已归档书签，页码: $page, 限制: $limit');
     final result = await _readeckApiClient.getBookmarks(
       isArchived: true,
       limit: limit,
       offset: (page - 1) * limit,
     );
     if (result.isSuccess()) {
-      _insertOrUpdateCachedBookmarks(result.getOrThrow());
+      final bookmarks = result.getOrThrow();
+      appLogger.i('成功加载已归档书签 ${bookmarks.length} 个');
+      _insertOrUpdateCachedBookmarks(bookmarks);
       return result;
     }
 
+    appLogger.e('加载已归档书签失败', error: result.exceptionOrNull());
     return result;
   }
 
   AsyncResult<List<Bookmark>> loadMarkedBookmarks({
     int limit = 10,
     int page = 1,
   }) async {
+    appLogger.i('开始加载已标记书签，页码: $page, 限制: $limit');
     final result = await _readeckApiClient.getBookmarks(
       isMarked: true,
       limit: limit,
       offset: (page - 1) * limit,
     );
     if (result.isSuccess()) {
-      _insertOrUpdateCachedBookmarks(result.getOrThrow());
+      final bookmarks = result.getOrThrow();
+      appLogger.i('成功加载已标记书签 ${bookmarks.length} 个');
+      _insertOrUpdateCachedBookmarks(bookmarks);
       return result;
     }
 
+    appLogger.e('加载已标记书签失败', error: result.exceptionOrNull());
     return result;
   }
 
   AsyncResult<List<Bookmark>> loadRandomUnarchivedBookmarks(
       int randomCount) async {
+    appLogger.i('开始加载随机未归档书签，请求数量: $randomCount');
     final allBookmarks = await loadUnarchivedBookmarks(limit: 100);
 
     if (allBookmarks.isSuccess()) {
@@ -153,63 +186,85 @@ class BookmarkRepository {
       // 随机打乱并取前5个
       final shuffled = List<Bookmark>.from(allBookmarks.getOrDefault([]));
       shuffled.shuffle(Random());
+      final randomBookmarks = shuffled.take(5).toList();
 
-      return Success(shuffled.take(5).toList());
+      appLogger.i('成功获取随机未归档书签 ${randomBookmarks.length} 个');
+      return Success(randomBookmarks);
     }
 
     appLogger.w('获取所有未读书签失败: $allBookmarks');
     return allBookmarks;
   }
 
   AsyncResult<void> toggleMarked(Bookmark bookmark) async {
+    final newMarkedState = !bookmark.isMarked;
+    appLogger
+        .i('切换书签标记状态: ${bookmark.id}, ${bookmark.isMarked} -> $newMarkedState');
     final result = await _readeckApiClient.updateBookmark(
       bookmark.id,
-      isMarked: !bookmark.isMarked,
+      isMarked: newMarkedState,
     );
     if (result.isSuccess()) {
-      insertOrUpdateBookmark(bookmark.copyWith(isMarked: !bookmark.isMarked));
+      _insertOrUpdateBookmark(bookmark.copyWith(isMarked: newMarkedState));
+      appLogger.i('书签标记状态切换成功: ${bookmark.id}');
+    } else {
+      appLogger.e('书签标记状态切换失败: ${bookmark.id}',
+          error: result.exceptionOrNull());
     }
     return result;
   }
 
   AsyncResult<void> toggleArchived(Bookmark bookmark) async {
+    final newArchivedState = !bookmark.isArchived;
+    appLogger.i(
+        '切换书签归档状态: ${bookmark.id}, ${bookmark.isArchived} -> $newArchivedState');
     final result = await _readeckApiClient.updateBookmark(
       bookmark.id,
-      isArchived: !bookmark.isArchived,
+      isArchived: newArchivedState,
     );
     if (result.isSuccess()) {
-      insertOrUpdateBookmark(
-          bookmark.copyWith(isArchived: !bookmark.isArchived));
+      _insertOrUpdateBookmark(bookmark.copyWith(isArchived: newArchivedState));
+      appLogger.i('书签归档状态切换成功: ${bookmark.id}');
+    } else {
+      appLogger.e('书签归档状态切换失败: ${bookmark.id}',
+          error: result.exceptionOrNull());
     }
     return result;
   }
 
   AsyncResult<void> updateLabels(Bookmark bookmark, List<String> labels) async {
+    appLogger.i('更新书签标签: ${bookmark.id}, 标签: ${labels.join(", ")}');
     final result = await _readeckApiClient.updateBookmark(
       bookmark.id,
       labels: labels,
     );
 
     if (result.isSuccess()) {
-      insertOrUpdateBookmark(bookmark.copyWith(labels: labels));
+      _insertOrUpdateBookmark(bookmark.copyWith(labels: labels));
+      appLogger.i('书签标签更新成功: ${bookmark.id}');
       return const Success(unit);
     }
 
+    appLogger.e('书签标签更新失败: ${bookmark.id}', error: result.exceptionOrNull());
     return Failure(result.exceptionOrNull()!);
   }
 
   AsyncResult<void> updateReadProgress(
       Bookmark bookmark, int readProgress) async {
+    appLogger.i(
+        '更新书签阅读进度: ${bookmark.id}, 进度: ${bookmark.readProgress} -> $readProgress');
     final result = await _readeckApiClient.updateBookmark(
       bookmark.id,
       readProgress: readProgress,
     );
 
     if (result.isSuccess()) {
-      insertOrUpdateBookmark(bookmark.copyWith(readProgress: readProgress));
+      _insertOrUpdateBookmark(bookmark.copyWith(readProgress: readProgress));
+      appLogger.i('书签阅读进度更新成功: ${bookmark.id}');
       return const Success(unit);
     }
 
+    appLogger.e('书签阅读进度更新失败: ${bookmark.id}', error: result.exceptionOrNull());
     return Failure(result.exceptionOrNull()!);
   }
 
@@ -262,10 +317,14 @@ class BookmarkRepository {
 
   /// 删除书签
   AsyncResult<void> deleteBookmark(String bookmarkId) async {
+    appLogger.i('开始删除书签: $bookmarkId');
     final result = await _readeckApiClient.deleteBookmark(bookmarkId);
     if (result.isSuccess()) {
       _deleteCachedBookmark(bookmarkId);
       await _databaseService.deleteBookmarkArticle(bookmarkId);
+      appLogger.i('书签删除成功: $bookmarkId');
+    } else {
+      appLogger.e('书签删除失败: $bookmarkId', error: result.exceptionOrNull());
     }
     return result;
   }

lib/data/service/readeck_api_client.dart

@@ -11,8 +11,10 @@ import 'package:readeck_app/utils/resource_not_found_exception.dart';
 import 'package:result_dart/result_dart.dart';
 
 class ReadeckApiClient {
-  ReadeckApiClient(this._host, this._token);
+  ReadeckApiClient(this._host, this._token, {http.Client? httpClient})
+      : _httpClient = httpClient ?? http.Client();
 
+  final http.Client _httpClient;
   String? _host;
   String? _token;
 
@@ -22,8 +24,13 @@ class ReadeckApiClient {
     _token = token;
   }
 
+  /// 释放资源
+  void dispose() {
+    _httpClient.close();
+  }
+
   bool get _isConfigured =>
-      (_host != null && _host != '') || (_token != null && _token != '');
+      (_host != null && _host != '') && (_token != null && _token != '');
 
   Map<String, String> get _headers => {
         'Authorization': 'Bearer $_token',
@@ -127,7 +134,7 @@ class ReadeckApiClient {
     final uri = Uri.parse('$_host/api/bookmarks$queryString');
 
     try {
-      final response = await http.get(uri, headers: _headers);
+      final response = await _httpClient.get(uri, headers: _headers);
 
       if (response.statusCode == 200) {
         // 检查响应体是否为空或无效
@@ -226,7 +233,7 @@ class ReadeckApiClient {
         Uri.parse('$_host/api/bookmarks/${Uri.encodeComponent(bookmarkId)}');
 
     try {
-      final response = await http.patch(
+      final response = await _httpClient.patch(
         uri,
         headers: _headers,
         body: json.encode(requestBody),
@@ -277,7 +284,7 @@ class ReadeckApiClient {
     final uri = Uri.parse('$_host/api/bookmarks/labels');
 
     try {
-      final response = await http.get(uri, headers: _headers);
+      final response = await _httpClient.get(uri, headers: _headers);
 
       if (response.statusCode == 200) {
         // 检查响应体是否为空或无效
@@ -334,7 +341,7 @@ class ReadeckApiClient {
         '$_host/api/bookmarks/${Uri.encodeComponent(bookmarkId)}/article');
 
     try {
-      final response = await http.get(uri, headers: {
+      final response = await _httpClient.get(uri, headers: {
         'Authorization': 'Bearer $_token',
         'Accept': 'text/html',
       });
@@ -381,7 +388,7 @@ class ReadeckApiClient {
         Uri.parse('$_host/api/bookmarks/${Uri.encodeComponent(bookmarkId)}');
 
     try {
-      final response = await http.delete(uri, headers: _headers);
+      final response = await _httpClient.delete(uri, headers: _headers);
 
       if (response.statusCode == 204) {
         appLogger.i('deleteBookmark success for bookmark: $bookmarkId');

lib/domain/use_cases/bookmark_operation_use_cases.dart

@@ -86,7 +86,7 @@ class BookmarkOperationUseCases {
           await _sharedPreferencesService.getReadingStats(bookmark.id);
       if (cachedStatsResult.isSuccess() &&
           cachedStatsResult.getOrNull() != null) {
-        appLogger.i('从缓存加载书签 ${bookmark.id} 的阅读统计数据');
+        appLogger.d('从缓存加载书签 ${bookmark.id} 的阅读统计数据');
         return cachedStatsResult.getOrNull()!;
       }