格式化代码

test/unit/util/vips_test.dart

@@ -0,0 +1,190 @@
+import 'dart:io';
+
+import 'package:path/path.dart' as p;
+import 'package:test/test.dart';
+
+import '../../../bin/util/vips.dart';
+
+void main() {
+  late Directory tempDir;
+  late Directory cacheDir;
+
+  setUp(() async {
+    tempDir = await Directory.systemTemp.createTemp('vips_test_');
+    cacheDir = await Directory.systemTemp.createTemp('vips_cache_');
+  });
+
+  tearDown(() async {
+    if (await tempDir.exists()) {
+      await tempDir.delete(recursive: true);
+    }
+    if (await cacheDir.exists()) {
+      await cacheDir.delete(recursive: true);
+    }
+  });
+
+  group('Vips', () {
+    test('should construct with required parameters', () {
+      final v = Vips(cacheDir: '/some/cache/path');
+
+      expect(v.cacheDir, '/some/cache/path');
+      expect(v.vipsExecuteFile, isNull);
+    });
+
+    test('should construct with custom vips executable', () {
+      final v = Vips(
+        vipsExecuteFile: '/custom/path/vips',
+        cacheDir: '/some/cache/path',
+      );
+
+      expect(v.vipsExecuteFile, '/custom/path/vips');
+      expect(v.cacheDir, '/some/cache/path');
+    });
+  });
+
+  group('generatePreview', () {
+    test('should throw when source file does not exist', () async {
+      final v = Vips(cacheDir: cacheDir.path);
+
+      expect(
+        () => v.generatePreview('/nonexistent/file.jpg'),
+        throwsA(isA<Exception>()),
+      );
+    });
+
+    test('should throw when vips is not installed', () async {
+      final v = Vips(cacheDir: cacheDir.path);
+
+      // Create a dummy file but vips likely isn't installed in test env
+      final dummyFile = File(p.join(tempDir.path, 'dummy.jpg'));
+      dummyFile.writeAsBytesSync(List.filled(100, 0));
+
+      expect(
+        () => v.generatePreview(dummyFile.path),
+        throwsA(isA<Exception>()),
+      );
+    });
+
+    test('should create cache directory if it does not exist', () async {
+      final customCacheDir = p.join(tempDir.path, 'new_cache');
+      final previewDirPath = p.join(customCacheDir, 'preview');
+      final v = Vips(cacheDir: customCacheDir);
+
+      final dummyFile = File(p.join(tempDir.path, 'test.png'));
+      dummyFile.writeAsBytesSync(List.filled(100, 0));
+
+      // This will likely fail due to missing vips, but we verify
+      // the cache directory creation attempt happens before the process call
+      try {
+        await v.generatePreview(dummyFile.path);
+      } catch (_) {
+        // Expected - vips not installed
+      }
+
+      // The preview subdirectory should have been created
+      expect(Directory(previewDirPath).existsSync(), isTrue);
+    });
+  });
+
+  group('caching behavior', () {
+    test('should return cached file when it already exists', () async {
+      final v = Vips(cacheDir: cacheDir.path);
+
+      // Create source file
+      final sourceFile = File(p.join(tempDir.path, 'test_image.jpg'));
+      sourceFile.writeAsBytesSync(List.filled(100, 0));
+
+      // Pre-create the expected cached file
+      final baseName = p.basename(sourceFile.path).hashCode.toString();
+      final cachedFile = File(
+        p.join(cacheDir.path, 'preview', '${baseName}_100x100.webp'),
+      );
+      cachedFile.parent.createSync(recursive: true);
+      cachedFile.writeAsBytesSync([0x52, 0x49, 0x46, 0x46]); // RIFF header
+
+      // Now call generatePreview - it should return the cached file
+      final result = await v.generatePreview(sourceFile.path, w: 100, h: 100);
+
+      expect(p.normalize(result.path), p.normalize(cachedFile.path));
+      expect(result.existsSync(), isTrue);
+    });
+
+    test('should not call vips when cache hit', () async {
+      final v = Vips(cacheDir: cacheDir.path);
+
+      // Create source file
+      final sourceFile = File(p.join(tempDir.path, 'cached.jpg'));
+      sourceFile.writeAsBytesSync(List.filled(100, 0));
+
+      // Create the expected cached file
+      final baseName = p.basename(sourceFile.path).hashCode.toString();
+      final cachedFile = File(
+        p.join(cacheDir.path, 'preview', '${baseName}_200x100.webp'),
+      );
+      cachedFile.parent.createSync(recursive: true);
+      cachedFile.writeAsBytesSync([0x01, 0x02, 0x03]);
+
+      final result = await v.generatePreview(sourceFile.path, w: 200, h: 100);
+
+      // Should return the cached file without calling vips
+      expect(p.normalize(result.path), p.normalize(cachedFile.path));
+      expect(result.existsSync(), isTrue);
+    });
+
+    test(
+      'should use correct cache filename format for different sizes',
+      () async {
+        final v = Vips(cacheDir: cacheDir.path);
+
+        // Create source file
+        final sourceFile = File(p.join(tempDir.path, 'sizing.jpg'));
+        sourceFile.writeAsBytesSync(List.filled(100, 0));
+
+        // Create cached file for 400x300
+        final baseName = p.basename(sourceFile.path).hashCode.toString();
+        final cachedFile = File(
+          p.join(cacheDir.path, 'preview', '${baseName}_400x300.webp'),
+        );
+        cachedFile.parent.createSync(recursive: true);
+        cachedFile.writeAsBytesSync([0xAA]);
+
+        final result = await v.generatePreview(sourceFile.path, w: 400, h: 300);
+        expect(p.normalize(result.path), p.normalize(cachedFile.path));
+      },
+    );
+
+    test('should use correct cache filename format for width only', () async {
+      final v = Vips(cacheDir: cacheDir.path);
+
+      final sourceFile = File(p.join(tempDir.path, 'width_only.jpg'));
+      sourceFile.writeAsBytesSync(List.filled(100, 0));
+
+      final baseName = p.basename(sourceFile.path).hashCode.toString();
+      final cachedFile = File(
+        p.join(cacheDir.path, 'preview', '${baseName}_500x0.webp'),
+      );
+      cachedFile.parent.createSync(recursive: true);
+      cachedFile.writeAsBytesSync([0xBB]);
+
+      final result = await v.generatePreview(sourceFile.path, w: 500);
+      expect(p.normalize(result.path), p.normalize(cachedFile.path));
+    });
+
+    test('should use correct cache filename format for height only', () async {
+      final v = Vips(cacheDir: cacheDir.path);
+
+      final sourceFile = File(p.join(tempDir.path, 'height_only.jpg'));
+      sourceFile.writeAsBytesSync(List.filled(100, 0));
+
+      final baseName = p.basename(sourceFile.path).hashCode.toString();
+      final cachedFile = File(
+        p.join(cacheDir.path, 'preview', '${baseName}_0x600.webp'),
+      );
+      cachedFile.parent.createSync(recursive: true);
+      cachedFile.writeAsBytesSync([0xCC]);
+
+      final result = await v.generatePreview(sourceFile.path, h: 600);
+      expect(p.normalize(result.path), p.normalize(cachedFile.path));
+    });
+  });
+}