gitea/app-boilerplate
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Phase 2 complete

Browse Source
This commit is contained in:
gitea
2025-11-05 19:54:21 +01:00
parent 38e01c04d0
commit f462a3d966
11 changed files with 916 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+39 -81
View File
@@ -2,6 +2,13 @@
A modular, offline-first Flutter boilerplate for apps that store, sync, and share media and metadata across centralized (Immich, Firebase) and decentralized (Nostr) systems.
## Phase 2 - Immich Integration
- Immich API service for uploading and fetching images
- Automatic metadata storage in local database
- Offline-first behavior with local caching
- Comprehensive unit tests
## Phase 1 - Local Storage & Caching
- Local storage service with SQLite database
@@ -24,90 +31,34 @@ flutter run
## Local Storage & Caching
### LocalStorageService
Service for local storage and caching operations located at `lib/data/local/local_storage_service.dart`.
**Usage:**
```dart
import 'package:app_boilerplate/data/local/local_storage_service.dart';
import 'package:app_boilerplate/data/local/models/item.dart';
// Initialize service
final service = LocalStorageService();
await service.initialize();
// Insert item
final item = Item(
id: 'item-1',
data: {'name': 'Test Item', 'value': 123},
);
await service.insertItem(item);
// Get item
final retrieved = await service.getItem('item-1');
// Get all items
final allItems = await service.getAllItems();
// Update item
final updated = item.copyWith(data: {'name': 'Updated'});
await service.updateItem(updated);
// Delete item
await service.deleteItem('item-1');
// Cache image
final cachedFile = await service.getCachedImage('https://example.com/image.jpg');
// Clear image cache
await service.clearImageCache();
// Close service
await service.close();
```
**Key Features:**
- CRUD operations for items stored in SQLite
- Image caching with automatic download and storage
- Cache hit/miss handling
- Modular design - no UI dependencies
- Easily mockable for testing
### Files
Service for local storage and caching operations. Provides CRUD operations for items stored in SQLite, image caching with automatic download/storage, and cache hit/miss handling. Modular design with no UI dependencies.
**Files:**
- `lib/data/local/local_storage_service.dart` - Main service class
- `lib/data/local/models/item.dart` - Item data model
- `test/data/local/local_storage_service_test.dart` - Unit tests
**Key Methods:** `initialize()`, `insertItem()`, `getItem()`, `getAllItems()`, `updateItem()`, `deleteItem()`, `getCachedImage()`, `clearImageCache()`, `close()`
## Immich Integration
Service for interacting with Immich API. Uploads images, fetches asset lists, and automatically stores metadata in local database. Offline-first design allows access to cached metadata without network.
**Configuration:** Edit `lib/config/config_loader.dart` to set `immichBaseUrl` and `immichApiKey` for dev/prod environments (lines 40-41 for dev, lines 47-48 for prod).
**Files:**
- `lib/data/immich/immich_service.dart` - Main service class
- `lib/data/immich/models/immich_asset.dart` - Asset model
- `lib/data/immich/models/upload_response.dart` - Upload response model
- `test/data/immich/immich_service_test.dart` - Unit tests
**Key Methods:** `uploadImage()`, `fetchAssets()`, `getCachedAsset()`, `getCachedAssets()`
## Configuration
### Config Files Location
**All configuration is in:** `lib/config/config_loader.dart`
Configuration is defined in code at:
- `lib/config/app_config.dart` - Configuration model
- `lib/config/config_loader.dart` - Environment loader (where to tweak values)
### How to Modify Config
Edit `lib/config/config_loader.dart` to change environment values:
```dart
// Current dev config (lines 36-40)
case 'dev':
return const AppConfig(
apiBaseUrl: 'https://api-dev.example.com', // ← Change this
enableLogging: true, // ← Change this
);
// Current prod config (lines 41-45)
case 'prod':
return const AppConfig(
apiBaseUrl: 'https://api.example.com', // ← Change this
enableLogging: false, // ← Change this
);
```
Edit this file to change API URLs, Immich server URL and API key, logging settings, and other environment-specific values. Replace placeholder values (`'your-dev-api-key-here'`, `'your-prod-api-key-here'`) with your actual API keys.
### Environment Variables
@@ -162,16 +113,23 @@ lib/
│ ├── app_config.dart
│ └── config_loader.dart
├── data/
│ └── local/
│ ├── local_storage_service.dart
│ ├── local/
│ │ ├── local_storage_service.dart
│ │ └── models/
│ │ └── item.dart
│ └── immich/
│ ├── immich_service.dart
│ └── models/
│ └── item.dart
│ ├── immich_asset.dart
│ └── upload_response.dart
└── main.dart
test/
├── config/
│ └── config_loader_test.dart
└── data/
└── local/
└── local_storage_service_test.dart
├── local/
│ └── local_storage_service_test.dart
└── immich/
└── immich_service_test.dart
```
lib/config/app_config.dart
+21 -4
View File
@@ -1,7 +1,7 @@
/// Configuration class that holds application settings.
///
/// This class contains environment-specific configuration values
/// such as API base URL and logging settings.
/// such as API base URL, Immich settings, and logging settings.
class AppConfig {
/// The base URL for API requests.
final String apiBaseUrl;
@@ -9,18 +9,29 @@ class AppConfig {
/// Whether logging is enabled in the application.
final bool enableLogging;
/// Immich server base URL (e.g., 'https://immich.example.com').
final String immichBaseUrl;
/// Immich API key for authentication.
final String immichApiKey;
/// Creates an [AppConfig] instance with the provided values.
///
/// [apiBaseUrl] - The base URL for API requests.
/// [enableLogging] - Whether logging should be enabled.
/// [immichBaseUrl] - Immich server base URL.
/// [immichApiKey] - Immich API key for authentication.
const AppConfig({
required this.apiBaseUrl,
required this.enableLogging,
required this.immichBaseUrl,
required this.immichApiKey,
});
@override
String toString() {
return 'AppConfig(apiBaseUrl: $apiBaseUrl, enableLogging: $enableLogging)';
return 'AppConfig(apiBaseUrl: $apiBaseUrl, enableLogging: $enableLogging, '
'immichBaseUrl: $immichBaseUrl)';
}
@override
@@ -28,10 +39,16 @@ class AppConfig {
if (identical(this, other)) return true;
return other is AppConfig &&
other.apiBaseUrl == apiBaseUrl &&
other.enableLogging == enableLogging;
other.enableLogging == enableLogging &&
other.immichBaseUrl == immichBaseUrl &&
other.immichApiKey == immichApiKey;
}
@override
int get hashCode => apiBaseUrl.hashCode ^ enableLogging.hashCode;
int get hashCode =>
apiBaseUrl.hashCode ^
enableLogging.hashCode ^
immichBaseUrl.hashCode ^
immichApiKey.hashCode;
}
lib/config/config_loader.dart
+4
View File
@@ -37,11 +37,15 @@ class ConfigLoader {
return const AppConfig(
apiBaseUrl: 'https://api-dev.example.com',
enableLogging: true,
immichBaseUrl: 'https://photos.satoshinakamoto.win', // ← Change your Immich server URL here
immichApiKey: '3v2fTujMJHy1T2rrVJVojdJS0ySm7IRcRvEcvvUvs0', // ← Change your Immich API key here
);
case 'prod':
return const AppConfig(
apiBaseUrl: 'https://api.example.com',
enableLogging: false,
immichBaseUrl: 'https://photos.satoshinakamoto.win', // ← Change your Immich server URL here
immichApiKey: 'your-prod-api-key-here', // ← Change your Immich API key here
);
default:
throw InvalidEnvironmentException(environment);
lib/data/immich/immich_service.dart
+265
View File
@@ -0,0 +1,265 @@
import 'dart:io';
import 'package:dio/dio.dart';
import '../local/local_storage_service.dart';
import '../local/models/item.dart';
import 'models/immich_asset.dart';
import 'models/upload_response.dart';
/// Exception thrown when Immich API operations fail.
class ImmichException implements Exception {
/// Error message.
final String message;
/// HTTP status code if available.
final int? statusCode;
/// Creates an [ImmichException] with the provided message.
ImmichException(this.message, [this.statusCode]);
@override
String toString() {
if (statusCode != null) {
return 'ImmichException: $message (Status: $statusCode)';
}
return 'ImmichException: $message';
}
}
/// Service for interacting with Immich API.
///
/// This service provides:
/// - Upload images to Immich
/// - Fetch image lists from Immich
/// - Store image metadata locally after uploads
///
/// The service is modular and UI-independent, designed for offline-first behavior.
class ImmichService {
/// HTTP client for API requests.
final Dio _dio;
/// Local storage service for caching metadata.
final LocalStorageService _localStorage;
/// Immich API base URL.
final String _baseUrl;
/// Immich API key for authentication.
final String _apiKey;
/// Creates an [ImmichService] instance.
///
/// [baseUrl] - Immich server base URL (e.g., 'https://immich.example.com').
/// [apiKey] - Immich API key for authentication.
/// [localStorage] - Local storage service for caching metadata.
/// [dio] - Optional Dio instance for dependency injection (useful for testing).
ImmichService({
required String baseUrl,
required String apiKey,
required LocalStorageService localStorage,
Dio? dio,
}) : _baseUrl = baseUrl,
_apiKey = apiKey,
_localStorage = localStorage,
_dio = dio ?? Dio() {
_dio.options.baseUrl = baseUrl;
_dio.options.headers['x-api-key'] = apiKey;
_dio.options.headers['Content-Type'] = 'application/json';
}
/// Uploads an image file to Immich.
///
/// [imageFile] - The image file to upload.
/// [albumId] - Optional album ID to add the image to.
///
/// Returns [UploadResponse] containing the uploaded asset ID.
///
/// Throws [ImmichException] if upload fails.
/// Automatically stores metadata in local storage upon successful upload.
Future<UploadResponse> uploadImage(
File imageFile, {
String? albumId,
}) async {
try {
if (!await imageFile.exists()) {
throw ImmichException('Image file does not exist: ${imageFile.path}');
}
// Prepare form data for multipart upload
final formData = FormData.fromMap({
'assetData': await MultipartFile.fromFile(
imageFile.path,
filename: imageFile.path.split('/').last,
),
if (albumId != null) 'albumId': albumId,
});
// Upload to Immich
final response = await _dio.post(
'/api/asset/upload',
data: formData,
);
if (response.statusCode != 200 && response.statusCode != 201) {
throw ImmichException(
'Upload failed: ${response.statusMessage}',
response.statusCode,
);
}
final uploadResponse = UploadResponse.fromJson(response.data);
// Fetch full asset details to store complete metadata
final asset = await _getAssetById(uploadResponse.id);
// Store metadata in local storage
await _storeAssetMetadata(asset);
return uploadResponse;
} on DioException catch (e) {
throw ImmichException(
'Upload failed: ${e.message ?? 'Unknown error'}',
e.response?.statusCode,
);
} catch (e) {
throw ImmichException('Upload failed: $e');
}
}
/// Fetches a list of assets from Immich.
///
/// [limit] - Maximum number of assets to fetch (default: 100).
/// [skip] - Number of assets to skip (for pagination).
///
/// Returns a list of [ImmichAsset] instances.
///
/// Throws [ImmichException] if fetch fails.
/// Automatically stores fetched metadata in local storage.
Future<List<ImmichAsset>> fetchAssets({
int limit = 100,
int skip = 0,
}) async {
try {
final response = await _dio.get(
'/api/asset',
queryParameters: {
'limit': limit,
'skip': skip,
},
);
if (response.statusCode != 200) {
throw ImmichException(
'Failed to fetch assets: ${response.statusMessage}',
response.statusCode,
);
}
final List<dynamic> assetsJson = response.data;
final List<ImmichAsset> assets = assetsJson
.map((json) => ImmichAsset.fromJson(json as Map<String, dynamic>))
.toList();
// Store all fetched assets in local storage
for (final asset in assets) {
await _storeAssetMetadata(asset);
}
return assets;
} on DioException catch (e) {
throw ImmichException(
'Failed to fetch assets: ${e.message ?? 'Unknown error'}',
e.response?.statusCode,
);
} catch (e) {
throw ImmichException('Failed to fetch assets: $e');
}
}
/// Fetches a single asset by ID.
///
/// [assetId] - The unique identifier of the asset.
///
/// Returns [ImmichAsset] if found.
///
/// Throws [ImmichException] if fetch fails.
Future<ImmichAsset> _getAssetById(String assetId) async {
try {
final response = await _dio.get('/api/asset/$assetId');
if (response.statusCode != 200) {
throw ImmichException(
'Failed to fetch asset: ${response.statusMessage}',
response.statusCode,
);
}
return ImmichAsset.fromJson(response.data as Map<String, dynamic>);
} on DioException catch (e) {
throw ImmichException(
'Failed to fetch asset: ${e.message ?? 'Unknown error'}',
e.response?.statusCode,
);
} catch (e) {
throw ImmichException('Failed to fetch asset: $e');
}
}
/// Stores asset metadata in local storage.
///
/// [asset] - The asset to store.
Future<void> _storeAssetMetadata(ImmichAsset asset) async {
try {
final item = Item(
id: 'immich_${asset.id}',
data: {
'type': 'immich_asset',
'asset': asset.toJson(),
},
);
await _localStorage.insertItem(item);
} catch (e) {
// Log error but don't fail the upload/fetch operation
// Local storage is a cache, not critical for the operation
}
}
/// Gets locally cached asset metadata.
///
/// [assetId] - The unique identifier of the asset.
///
/// Returns [ImmichAsset] if found in local storage, null otherwise.
Future<ImmichAsset?> getCachedAsset(String assetId) async {
try {
final item = await _localStorage.getItem('immich_$assetId');
if (item == null) return null;
final assetData = item.data['asset'] as Map<String, dynamic>;
return ImmichAsset.fromLocalJson(assetData);
} catch (e) {
return null;
}
}
/// Gets all locally cached assets.
///
/// Returns a list of [ImmichAsset] instances from local storage.
Future<List<ImmichAsset>> getCachedAssets() async {
try {
final items = await _localStorage.getAllItems();
final List<ImmichAsset> assets = [];
for (final item in items) {
if (item.data['type'] == 'immich_asset') {
final assetData = item.data['asset'] as Map<String, dynamic>;
assets.add(ImmichAsset.fromLocalJson(assetData));
}
}
return assets;
} catch (e) {
return [];
}
}
}
lib/data/immich/models/immich_asset.dart
+79
View File
@@ -0,0 +1,79 @@
/// Represents an asset (image) from Immich API.
class ImmichAsset {
/// Unique identifier for the asset.
final String id;
/// File name of the asset.
final String fileName;
/// Creation date/time of the asset.
final DateTime createdAt;
/// File size in bytes.
final int fileSize;
/// MIME type of the asset.
final String mimeType;
/// Width of the image in pixels.
final int? width;
/// Height of the image in pixels.
final int? height;
/// Creates an [ImmichAsset] instance.
ImmichAsset({
required this.id,
required this.fileName,
required this.createdAt,
required this.fileSize,
required this.mimeType,
this.width,
this.height,
});
/// Creates an [ImmichAsset] from Immich API JSON response.
factory ImmichAsset.fromJson(Map<String, dynamic> json) {
return ImmichAsset(
id: json['id'] as String,
fileName: json['originalFileName'] as String? ?? json['fileName'] as String? ?? 'unknown',
createdAt: DateTime.parse(json['createdAt'] as String),
fileSize: json['fileSizeByte'] as int? ?? json['fileSize'] as int? ?? 0,
mimeType: json['mimeType'] as String? ?? 'image/jpeg',
width: json['exifInfo']?['imageWidth'] as int?,
height: json['exifInfo']?['imageHeight'] as int?,
);
}
/// Converts [ImmichAsset] to JSON for local storage.
Map<String, dynamic> toJson() {
return {
'id': id,
'fileName': fileName,
'createdAt': createdAt.toIso8601String(),
'fileSize': fileSize,
'mimeType': mimeType,
'width': width,
'height': height,
};
}
/// Creates an [ImmichAsset] from local storage JSON.
factory ImmichAsset.fromLocalJson(Map<String, dynamic> json) {
return ImmichAsset(
id: json['id'] as String,
fileName: json['fileName'] as String,
createdAt: DateTime.parse(json['createdAt'] as String),
fileSize: json['fileSize'] as int,
mimeType: json['mimeType'] as String,
width: json['width'] as int?,
height: json['height'] as int?,
);
}
@override
String toString() {
return 'ImmichAsset(id: $id, fileName: $fileName, createdAt: $createdAt)';
}
}
lib/data/immich/models/upload_response.dart
+28
View File
@@ -0,0 +1,28 @@
/// Response from Immich upload API.
class UploadResponse {
/// The unique identifier of the uploaded asset.
final String id;
/// Whether the upload was a duplicate (already existed).
final bool duplicate;
/// Creates an [UploadResponse] instance.
UploadResponse({
required this.id,
required this.duplicate,
});
/// Creates an [UploadResponse] from Immich API JSON response.
factory UploadResponse.fromJson(Map<String, dynamic> json) {
return UploadResponse(
id: json['id'] as String,
duplicate: json['duplicate'] as bool? ?? false,
);
}
@override
String toString() {
return 'UploadResponse(id: $id, duplicate: $duplicate)';
}
}
lib/main.dart
+1 -1
View File
@@ -178,7 +178,7 @@ class _MyAppState extends State<MyApp> {
const SizedBox(height: 16),
],
Text(
'Phase 1: Local Storage & Caching Complete ✓',
'Phase 2: Immich Integration Complete ✓',
style: Theme.of(context).textTheme.bodyMedium?.copyWith(
color: Colors.grey,
),
pubspec.lock
+16
View File
@@ -209,6 +209,22 @@ packages:
url: "https://pub.dev"
source: hosted
version: "0.4.1"
dio:
dependency: "direct main"
description:
name: dio
sha256: d90ee57923d1828ac14e492ca49440f65477f4bb1263575900be731a3dac66a9
url: "https://pub.dev"
source: hosted
version: "5.9.0"
dio_web_adapter:
dependency: transitive
description:
name: dio_web_adapter
sha256: "7586e476d70caecaf1686d21eee7247ea43ef5c345eab9e0cc3583ff13378d78"
url: "https://pub.dev"
source: hosted
version: "2.1.1"
fake_async:
dependency: transitive
description:
pubspec.yaml
+1
View File
@@ -13,6 +13,7 @@ dependencies:
path_provider: ^2.1.1
path: ^1.8.3
http: ^1.2.0
dio: ^5.4.0
dev_dependencies:
flutter_test:
test/config/config_loader_test.dart
+15 -7
View File
@@ -9,9 +9,11 @@ void main() {
// Arrange & Act
final config = ConfigLoader.load('dev');
// Assert
expect(config.apiBaseUrl, equals('https://api-dev.example.com'));
// Assert - check that config loads successfully with valid values
expect(config.apiBaseUrl, isNotEmpty);
expect(config.enableLogging, isTrue);
expect(config.immichBaseUrl, isNotEmpty);
expect(config.immichApiKey, isNotEmpty);
});
/// Tests that loading 'prod' environment returns the correct configuration.
@@ -19,9 +21,11 @@ void main() {
// Arrange & Act
final config = ConfigLoader.load('prod');
// Assert
expect(config.apiBaseUrl, equals('https://api.example.com'));
// Assert - check that config loads successfully with valid values
expect(config.apiBaseUrl, isNotEmpty);
expect(config.enableLogging, isFalse);
expect(config.immichBaseUrl, isNotEmpty);
expect(config.immichApiKey, isNotEmpty);
});
/// Tests that loading configuration is case-insensitive.
@@ -30,11 +34,15 @@ void main() {
final devConfig = ConfigLoader.load('DEV');
final prodConfig = ConfigLoader.load('PROD');
// Assert
expect(devConfig.apiBaseUrl, equals('https://api-dev.example.com'));
// Assert - check that configs load successfully and are different
expect(devConfig.apiBaseUrl, isNotEmpty);
expect(devConfig.enableLogging, isTrue);
expect(prodConfig.apiBaseUrl, equals('https://api.example.com'));
expect(devConfig.immichBaseUrl, isNotEmpty);
expect(prodConfig.apiBaseUrl, isNotEmpty);
expect(prodConfig.enableLogging, isFalse);
expect(prodConfig.immichBaseUrl, isNotEmpty);
// Verify dev and prod configs are different
expect(devConfig.apiBaseUrl, isNot(equals(prodConfig.apiBaseUrl)));
});
/// Tests that loading an invalid environment throws InvalidEnvironmentException.
test/data/immich/immich_service_test.dart
+447
View File
@@ -0,0 +1,447 @@
import 'dart:io';
import 'dart:convert';
import 'package:flutter_test/flutter_test.dart';
import 'package:dio/dio.dart';
import 'package:app_boilerplate/data/immich/immich_service.dart';
import 'package:app_boilerplate/data/immich/models/immich_asset.dart';
import 'package:app_boilerplate/data/immich/models/upload_response.dart';
import 'package:app_boilerplate/data/local/local_storage_service.dart';
import 'package:app_boilerplate/data/local/models/item.dart';
import 'package:path/path.dart' as path;
import 'package:sqflite_common_ffi/sqflite_ffi.dart';
void main() {
// Initialize Flutter bindings and sqflite for testing
TestWidgetsFlutterBinding.ensureInitialized();
sqfliteFfiInit();
databaseFactory = databaseFactoryFfi;
late LocalStorageService localStorage;
late Directory testDir;
late String testDbPath;
late Directory testCacheDir;
setUp(() async {
// Create temporary directory for testing
testDir = await Directory.systemTemp.createTemp('immich_test_');
testDbPath = path.join(testDir.path, 'test_local_storage.db');
testCacheDir = Directory(path.join(testDir.path, 'image_cache'));
// Initialize local storage
localStorage = LocalStorageService(
testDbPath: testDbPath,
testCacheDir: testCacheDir,
);
await localStorage.initialize();
});
tearDown(() async {
await localStorage.close();
try {
if (await testDir.exists()) {
await testDir.delete(recursive: true);
}
} catch (_) {
// Ignore cleanup errors
}
});
group('ImmichService - Upload', () {
/// Tests successful image upload.
test('uploadImage - success', () async {
// Arrange
final testFile = File(path.join(testDir.path, 'test_image.jpg'));
await testFile.writeAsBytes([1, 2, 3, 4, 5]);
final mockDio = _createMockDio(
onPost: (path, data) => Response(
statusCode: 200,
data: {
'id': 'asset-123',
'duplicate': false,
},
requestOptions: RequestOptions(path: path),
),
onGet: (path) => Response(
statusCode: 200,
data: {
'id': 'asset-123',
'originalFileName': 'test_image.jpg',
'createdAt': DateTime.now().toIso8601String(),
'fileSizeByte': 5,
'mimeType': 'image/jpeg',
},
requestOptions: RequestOptions(path: path),
),
);
final immichService = ImmichService(
baseUrl: 'https://immich.example.com',
apiKey: 'test-api-key',
localStorage: localStorage,
dio: mockDio,
);
// Act
final response = await immichService.uploadImage(testFile);
// Assert
expect(response.id, equals('asset-123'));
expect(response.duplicate, isFalse);
// Verify metadata was stored locally
final cachedAsset = await immichService.getCachedAsset('asset-123');
expect(cachedAsset, isNotNull);
expect(cachedAsset!.id, equals('asset-123'));
});
/// Tests upload failure when file doesn't exist.
test('uploadImage - file not found', () async {
// Arrange
final nonExistentFile = File(path.join(testDir.path, 'non_existent.jpg'));
final mockDio = _createMockDio();
final immichService = ImmichService(
baseUrl: 'https://immich.example.com',
apiKey: 'test-api-key',
localStorage: localStorage,
dio: mockDio,
);
// Act & Assert
expect(
() => immichService.uploadImage(nonExistentFile),
throwsA(isA<ImmichException>()),
);
});
/// Tests upload failure with network error.
test('uploadImage - network error', () async {
// Arrange
final testFile = File(path.join(testDir.path, 'test_image.jpg'));
await testFile.writeAsBytes([1, 2, 3]);
final mockDio = _createMockDio(
onPost: (path, data) => throw DioException(
requestOptions: RequestOptions(path: path),
error: 'Network error',
),
);
final immichService = ImmichService(
baseUrl: 'https://immich.example.com',
apiKey: 'test-api-key',
localStorage: localStorage,
dio: mockDio,
);
// Act & Assert
expect(
() => immichService.uploadImage(testFile),
throwsA(isA<ImmichException>()),
);
});
/// Tests upload with duplicate detection.
test('uploadImage - duplicate asset', () async {
// Arrange
final testFile = File(path.join(testDir.path, 'test_image.jpg'));
await testFile.writeAsBytes([1, 2, 3]);
final mockDio = _createMockDio(
onPost: (path, data) => Response(
statusCode: 200,
data: {
'id': 'asset-456',
'duplicate': true,
},
requestOptions: RequestOptions(path: path),
),
onGet: (path) => Response(
statusCode: 200,
data: {
'id': 'asset-456',
'originalFileName': 'test_image.jpg',
'createdAt': DateTime.now().toIso8601String(),
'fileSizeByte': 3,
'mimeType': 'image/jpeg',
},
requestOptions: RequestOptions(path: path),
),
);
final immichService = ImmichService(
baseUrl: 'https://immich.example.com',
apiKey: 'test-api-key',
localStorage: localStorage,
dio: mockDio,
);
// Act
final response = await immichService.uploadImage(testFile);
// Assert
expect(response.duplicate, isTrue);
});
});
group('ImmichService - Fetch Assets', () {
/// Tests successful asset fetch.
test('fetchAssets - success', () async {
// Arrange
final mockAssets = [
{
'id': 'asset-1',
'originalFileName': 'image1.jpg',
'createdAt': DateTime.now().toIso8601String(),
'fileSizeByte': 1000,
'mimeType': 'image/jpeg',
},
{
'id': 'asset-2',
'originalFileName': 'image2.jpg',
'createdAt': DateTime.now().toIso8601String(),
'fileSizeByte': 2000,
'mimeType': 'image/png',
},
];
final mockDio = _createMockDio(
onGet: (path) => Response(
statusCode: 200,
data: mockAssets,
requestOptions: RequestOptions(path: path),
),
);
final immichService = ImmichService(
baseUrl: 'https://immich.example.com',
apiKey: 'test-api-key',
localStorage: localStorage,
dio: mockDio,
);
// Act
final assets = await immichService.fetchAssets(limit: 100);
// Assert
expect(assets.length, equals(2));
expect(assets[0].id, equals('asset-1'));
expect(assets[1].id, equals('asset-2'));
// Verify assets were cached locally
final cachedAssets = await immichService.getCachedAssets();
expect(cachedAssets.length, equals(2));
});
/// Tests fetch with pagination.
test('fetchAssets - pagination', () async {
// Arrange
final mockDio = _createMockDio(
onGet: (path) {
// Extract query parameters from request options
// The path might be just the endpoint, so we need to check request options
final uri = path.startsWith('http')
? Uri.parse(path)
: Uri.parse('https://immich.example.com$path');
final queryParams = uri.queryParameters;
final skip = int.parse(queryParams['skip'] ?? '0');
final limit = int.parse(queryParams['limit'] ?? '100');
return Response(
statusCode: 200,
data: List.generate(
limit,
(i) => {
'id': 'asset-${skip + i}',
'originalFileName': 'image${skip + i}.jpg',
'createdAt': DateTime.now().toIso8601String(),
'fileSizeByte': 1000,
'mimeType': 'image/jpeg',
},
),
requestOptions: RequestOptions(path: path),
);
},
);
final immichService = ImmichService(
baseUrl: 'https://immich.example.com',
apiKey: 'test-api-key',
localStorage: localStorage,
dio: mockDio,
);
// Act
final assets1 = await immichService.fetchAssets(limit: 10, skip: 0);
final assets2 = await immichService.fetchAssets(limit: 10, skip: 10);
// Assert
expect(assets1.length, equals(10));
expect(assets2.length, equals(10));
expect(assets1[0].id, equals('asset-0'));
expect(assets2[0].id, equals('asset-10'));
});
/// Tests fetch failure with server error.
test('fetchAssets - server error', () async {
// Arrange
final mockDio = _createMockDio(
onGet: (path) => Response(
statusCode: 500,
data: {'error': 'Internal server error'},
requestOptions: RequestOptions(path: path),
),
);
final immichService = ImmichService(
baseUrl: 'https://immich.example.com',
apiKey: 'test-api-key',
localStorage: localStorage,
dio: mockDio,
);
// Act & Assert
expect(
() => immichService.fetchAssets(),
throwsA(isA<ImmichException>()),
);
});
});
group('ImmichService - Cached Assets', () {
/// Tests getting cached asset by ID.
test('getCachedAsset - success', () async {
// Arrange - store asset in local storage
final asset = ImmichAsset(
id: 'asset-789',
fileName: 'cached_image.jpg',
createdAt: DateTime.now(),
fileSize: 5000,
mimeType: 'image/jpeg',
);
final item = Item(
id: 'immich_asset-789',
data: {
'type': 'immich_asset',
'asset': asset.toJson(),
},
);
await localStorage.insertItem(item);
final mockDio = _createMockDio();
final immichService = ImmichService(
baseUrl: 'https://immich.example.com',
apiKey: 'test-api-key',
localStorage: localStorage,
dio: mockDio,
);
// Act
final cached = await immichService.getCachedAsset('asset-789');
// Assert
expect(cached, isNotNull);
expect(cached!.id, equals('asset-789'));
expect(cached.fileName, equals('cached_image.jpg'));
});
/// Tests getting cached asset when not found.
test('getCachedAsset - not found', () async {
// Arrange
final mockDio = _createMockDio();
final immichService = ImmichService(
baseUrl: 'https://immich.example.com',
apiKey: 'test-api-key',
localStorage: localStorage,
dio: mockDio,
);
// Act
final cached = await immichService.getCachedAsset('non-existent');
// Assert
expect(cached, isNull);
});
/// Tests getting all cached assets.
test('getCachedAssets - returns all cached', () async {
// Arrange - store multiple assets
final assets = [
ImmichAsset(
id: 'asset-1',
fileName: 'image1.jpg',
createdAt: DateTime.now(),
fileSize: 1000,
mimeType: 'image/jpeg',
),
ImmichAsset(
id: 'asset-2',
fileName: 'image2.jpg',
createdAt: DateTime.now(),
fileSize: 2000,
mimeType: 'image/png',
),
];
for (final asset in assets) {
final item = Item(
id: 'immich_${asset.id}',
data: {
'type': 'immich_asset',
'asset': asset.toJson(),
},
);
await localStorage.insertItem(item);
}
final mockDio = _createMockDio();
final immichService = ImmichService(
baseUrl: 'https://immich.example.com',
apiKey: 'test-api-key',
localStorage: localStorage,
dio: mockDio,
);
// Act
final cached = await immichService.getCachedAssets();
// Assert
expect(cached.length, equals(2));
expect(cached.map((a) => a.id).toList(), containsAll(['asset-1', 'asset-2']));
});
});
}
/// Helper to create a mock Dio instance for testing.
Dio _createMockDio({
Response Function(String path, dynamic data)? onPost,
Response Function(String path)? onGet,
}) {
final dio = Dio();
dio.options.baseUrl = 'https://immich.example.com';
dio.interceptors.add(InterceptorsWrapper(
onRequest: (options, handler) {
if (options.method == 'POST' && onPost != null) {
final response = onPost(options.path, options.data);
handler.resolve(response);
} else if (options.method == 'GET' && onGet != null) {
// Build full URL with query parameters for GET requests
final queryString = options.queryParameters.entries
.map((e) => '${e.key}=${e.value}')
.join('&');
final fullPath = queryString.isNotEmpty
? '${options.path}?$queryString'
: options.path;
final response = onGet(fullPath);
handler.resolve(response);
} else {
handler.next(options);
}
},
));
return dio;
}