格式化代码

test/integration/server_test.dart

@@ -0,0 +1,505 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:http/http.dart' as http;
+import 'package:path/path.dart' as p;
+import 'package:shelf/shelf.dart';
+import 'package:shelf/shelf_io.dart' as shelf_io;
+import 'package:test/test.dart';
+
+import '../../bin/domain/repositories/album_repository.dart';
+import '../../bin/domain/repositories/photo_repository.dart';
+import '../../bin/middleware/exception_handler.dart';
+import '../../bin/router.dart';
+import '../../bin/util/vips.dart';
+
+/// Minimal valid PNG (100x100) for test fixtures.
+List<int> _createTestPng({int width = 100, int height = 100}) {
+  final buffer = BytesBuilder();
+  // PNG signature
+  buffer.addByte(0x89);
+  buffer.addByte(0x50);
+  buffer.addByte(0x4E);
+  buffer.addByte(0x47);
+  buffer.addByte(0x0D);
+  buffer.addByte(0x0A);
+  buffer.addByte(0x1A);
+  buffer.addByte(0x0A);
+  // IHDR chunk length (13 bytes)
+  buffer.addByte(0x00);
+  buffer.addByte(0x00);
+  buffer.addByte(0x00);
+  buffer.addByte(0x0D);
+  // IHDR chunk type
+  buffer.addByte(0x49);
+  buffer.addByte(0x48);
+  buffer.addByte(0x44);
+  buffer.addByte(0x52);
+  // Width (big-endian)
+  buffer.addByte((width >> 24) & 0xFF);
+  buffer.addByte((width >> 16) & 0xFF);
+  buffer.addByte((width >> 8) & 0xFF);
+  buffer.addByte(width & 0xFF);
+  // Height (big-endian)
+  buffer.addByte((height >> 24) & 0xFF);
+  buffer.addByte((height >> 16) & 0xFF);
+  buffer.addByte((height >> 8) & 0xFF);
+  buffer.addByte(height & 0xFF);
+  // Rest of IHDR
+  buffer.addByte(0x08);
+  buffer.addByte(0x02);
+  buffer.addByte(0x00);
+  buffer.addByte(0x00);
+  buffer.addByte(0x00);
+  // CRC (dummy)
+  buffer.addByte(0x00);
+  buffer.addByte(0x00);
+  buffer.addByte(0x00);
+  buffer.addByte(0x00);
+  // IEND
+  buffer.addByte(0x00);
+  buffer.addByte(0x00);
+  buffer.addByte(0x00);
+  buffer.addByte(0x00);
+  buffer.addByte(0x49);
+  buffer.addByte(0x45);
+  buffer.addByte(0x4E);
+  buffer.addByte(0x44);
+  buffer.addByte(0xAE);
+  buffer.addByte(0x42);
+  buffer.addByte(0x60);
+  buffer.addByte(0x82);
+  return buffer.toBytes();
+}
+
+/// Creates a fresh in-memory server with isolated temp directories.
+///
+/// This is the key optimization over the old approach:
+/// - No subprocess spawning (fast startup)
+/// - Random port via port 0 (no port conflicts)
+/// - Per-test temp directories (no data pollution)
+/// - Reusable HTTP client (connection pooling)
+class TestServer {
+  late final Directory dataDir;
+  late final Directory cacheDir;
+  late final HttpServer server;
+  late final http.Client client;
+  late final String baseUrl;
+
+  /// Start the server with the given test data (if any).
+  ///
+  /// [testAlbums] is a map of album name -> list of (filename, fileData).
+  static Future<TestServer> start({
+    Map<String, List<(String, List<int>)>>? testAlbums,
+  }) async {
+    final s = TestServer._();
+    s.dataDir = await Directory.systemTemp.createTemp('itest_data_');
+    s.cacheDir = await Directory.systemTemp.createTemp('itest_cache_');
+
+    // Create test data if provided
+    if (testAlbums != null) {
+      for (final entry in testAlbums.entries) {
+        final albumDir = Directory(p.join(s.dataDir.path, entry.key));
+        await albumDir.create(recursive: true);
+        for (final (name, data) in entry.value) {
+          File(p.join(albumDir.path, name)).writeAsBytesSync(data);
+        }
+      }
+    }
+
+    final router = AppRouter(
+      albumRepository: AlbumRepository(basePath: s.dataDir.path),
+      photoRepository: PhotoRepository(s.dataDir.path),
+      vips: Vips(cacheDir: s.cacheDir.path),
+    );
+
+    final handler = Pipeline()
+        .addMiddleware(exceptionHandler())
+        .addHandler(router.createRouter().call);
+
+    s.server = await shelf_io.serve(
+      handler,
+      InternetAddress.loopbackIPv4,
+      0, // Random available port
+    );
+    s.client = http.Client();
+    s.baseUrl = 'http://localhost:${s.server.port}';
+    return s;
+  }
+
+  TestServer._();
+
+  Future<void> stop() async {
+    client.close();
+    await server.close(force: true);
+    if (await dataDir.exists()) {
+      await dataDir.delete(recursive: true);
+    }
+    if (await cacheDir.exists()) {
+      await cacheDir.delete(recursive: true);
+    }
+  }
+
+  Future<http.Response> get(String path) =>
+      client.get(Uri.parse('$baseUrl$path'));
+}
+
+void main() {
+  group('Integration tests (in-memory server)', () {
+    late TestServer server;
+
+    tearDown(() async {
+      await server.stop();
+    });
+
+    group('Root endpoint', () {
+      test('GET /api/v1/ returns Hello World', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v1/');
+        expect(response.statusCode, 200);
+        expect(response.body, 'Hello, World!\n');
+      });
+    });
+
+    group('Echo endpoint', () {
+      test('GET /api/v1/echo/<message> returns the message', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v1/echo/hello');
+        expect(response.statusCode, 200);
+        expect(response.body, 'hello\n');
+      });
+
+      test('GET /api/v1/echo/<message> with special characters', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v1/echo/test%20message');
+        expect(response.statusCode, 200);
+        expect(response.body, contains('test'));
+      });
+    });
+
+    group('Album endpoints', () {
+      test('GET /api/v1/album returns empty list when no albums', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v1/album');
+        expect(response.statusCode, 200);
+        expect(response.headers['content-type'], contains('application/json'));
+        final albums = jsonDecode(response.body) as List;
+        expect(albums, isEmpty);
+      });
+
+      test('GET /api/v1/album returns albums when data exists', () async {
+        server = await TestServer.start(
+          testAlbums: {
+            'vacation': [('photo.png', _createTestPng())],
+            'birthday': [('photo2.png', _createTestPng())],
+          },
+        );
+        final response = await server.get('/api/v1/album');
+        expect(response.statusCode, 200);
+        final albums = jsonDecode(response.body) as List;
+        expect(albums.length, 2);
+        final names = albums.map((a) => a['name'] as String).toSet();
+        expect(names, containsAll(['vacation', 'birthday']));
+      });
+
+      test('GET /api/v1/album/<id> with invalid id returns 400', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v1/album/invalid_id');
+        expect(response.statusCode, 400);
+        expect(response.body, contains('Invalid album id'));
+      });
+
+      test('GET /api/v1/album/<id> with non-existent id returns 404', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v1/album/999999');
+        expect(response.statusCode, 404);
+        expect(response.body, contains('Album not found'));
+      });
+
+      test('GET /api/v1/album/<id> returns album details', () async {
+        server = await TestServer.start(testAlbums: {'my_album': []});
+        final listResponse = await server.get('/api/v1/album');
+        final albums = jsonDecode(listResponse.body) as List;
+        final albumId = albums.first['id'];
+
+        final response = await server.get('/api/v1/album/$albumId');
+        expect(response.statusCode, 200);
+        final album = jsonDecode(response.body) as Map;
+        expect(album['id'], albumId);
+        expect(album['name'], 'my_album');
+      });
+
+      test(
+        'GET /api/v1/album/<id>/photo with invalid id returns 400',
+        () async {
+          server = await TestServer.start();
+          final response = await server.get('/api/v1/album/invalid_id/photo');
+          expect(response.statusCode, 400);
+          expect(response.body, contains('Invalid album id'));
+        },
+      );
+
+      test('GET /api/v1/album/<id>/photo returns photos', () async {
+        server = await TestServer.start(
+          testAlbums: {
+            'photo_album': [
+              ('image.png', _createTestPng(width: 640, height: 480)),
+            ],
+          },
+        );
+        final listResponse = await server.get('/api/v1/album');
+        final albums = jsonDecode(listResponse.body) as List;
+        final albumId = albums.first['id'];
+
+        final response = await server.get('/api/v1/album/$albumId/photo');
+        expect(response.statusCode, 200);
+        final photos = jsonDecode(response.body) as List;
+        expect(photos, isNotEmpty);
+        expect(photos.first['fileName'], 'image.png');
+        expect(photos.first['mimeType'], 'image/png');
+        expect(photos.first['width'], 640);
+        expect(photos.first['height'], 480);
+      });
+
+      test(
+        'GET /api/v1/album/<id>/photo returns empty for empty album',
+        () async {
+          server = await TestServer.start(testAlbums: {'empty_album': []});
+          final listResponse = await server.get('/api/v1/album');
+          final albums = jsonDecode(listResponse.body) as List;
+          final albumId = albums.first['id'];
+
+          final response = await server.get('/api/v1/album/$albumId/photo');
+          expect(response.statusCode, 200);
+          final photos = jsonDecode(response.body) as List;
+          expect(photos, isEmpty);
+        },
+      );
+    });
+
+    group('Photo endpoints', () {
+      test('GET /api/v1/photo/<id> with invalid id returns 400', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v1/photo/abc');
+        expect(response.statusCode, 400);
+        expect(response.body, contains('Invalid photo id'));
+      });
+
+      test('GET /api/v1/photo/<id> with non-existent id returns 404', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v1/photo/12345');
+        expect(response.statusCode, 404);
+        expect(response.body, contains('Photo not found'));
+      });
+
+      test('GET /api/v1/photo/<id> returns photo metadata', () async {
+        server = await TestServer.start(
+          testAlbums: {
+            'photos': [('photo.png', _createTestPng(width: 800, height: 600))],
+          },
+        );
+        final listResponse = await server.get('/api/v1/album');
+        final albums = jsonDecode(listResponse.body) as List;
+        final albumId = albums.first['id'];
+
+        final photosResponse = await server.get('/api/v1/album/$albumId/photo');
+        final photos = jsonDecode(photosResponse.body) as List;
+        final photoId = photos.first['id'];
+
+        final response = await server.get('/api/v1/photo/$photoId');
+        expect(response.statusCode, 200);
+        final photo = jsonDecode(response.body) as Map;
+        expect(photo['fileName'], 'photo.png');
+        expect(photo['width'], 800);
+        expect(photo['height'], 600);
+        expect(photo['mimeType'], 'image/png');
+        expect(photo, containsPair('createdAt', isA<String>()));
+      });
+
+      test('GET /api/v1/photo/<id>/file with invalid id returns 400', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v1/photo/abc/file');
+        expect(response.statusCode, 400);
+        expect(response.body, contains('Invalid photo id'));
+      });
+
+      test(
+        'GET /api/v1/photo/<id>/file with non-existent id returns 404',
+        () async {
+          server = await TestServer.start();
+          final response = await server.get('/api/v1/photo/12345/file');
+          expect(response.statusCode, 404);
+          expect(response.body, contains('Photo not found'));
+        },
+      );
+
+      test('GET /api/v1/photo/<id>/file returns file content', () async {
+        final testData = _createTestPng(width: 100, height: 100);
+        server = await TestServer.start(
+          testAlbums: {
+            'files': [('download.png', testData)],
+          },
+        );
+        final listResponse = await server.get('/api/v1/album');
+        final albums = jsonDecode(listResponse.body) as List;
+        final albumId = albums.first['id'];
+
+        final photosResponse = await server.get('/api/v1/album/$albumId/photo');
+        final photos = jsonDecode(photosResponse.body) as List;
+        final photoId = photos.first['id'];
+
+        final response = await server.get('/api/v1/photo/$photoId/file');
+        expect(response.statusCode, 200);
+        expect(response.contentLength, greaterThan(0));
+        expect(response.bodyBytes, testData);
+      });
+
+      test(
+        'GET /api/v1/photo/<id>/file returns correct content type',
+        () async {
+          server = await TestServer.start(
+            testAlbums: {
+              'types': [('image.png', _createTestPng())],
+            },
+          );
+          final listResponse = await server.get('/api/v1/album');
+          final albums = jsonDecode(listResponse.body) as List;
+          final albumId = albums.first['id'];
+
+          final photosResponse = await server.get(
+            '/api/v1/album/$albumId/photo',
+          );
+          final photos = jsonDecode(photosResponse.body) as List;
+          final photoId = photos.first['id'];
+
+          final response = await server.get('/api/v1/photo/$photoId/file');
+          expect(response.headers['content-type'], contains('image/png'));
+        },
+      );
+    });
+
+    group('Preview endpoint', () {
+      test(
+        'GET /api/v1/photo/<id>/preview with invalid id returns 400',
+        () async {
+          server = await TestServer.start();
+          final response = await server.get('/api/v1/photo/abc/preview');
+          expect(response.statusCode, 400);
+          expect(response.body, contains('Invalid photo id'));
+        },
+      );
+
+      test(
+        'GET /api/v1/photo/<id>/preview with non-existent id returns 404',
+        () async {
+          server = await TestServer.start();
+          final response = await server.get('/api/v1/photo/12345/preview');
+          expect(response.statusCode, 404);
+          expect(response.body, contains('Photo not found'));
+        },
+      );
+
+      test(
+        'GET /api/v1/photo/<id>/preview throws when vips not installed',
+        () async {
+          server = await TestServer.start(
+            testAlbums: {
+              'preview': [('image.png', _createTestPng())],
+            },
+          );
+          final listResponse = await server.get('/api/v1/album');
+          final albums = jsonDecode(listResponse.body) as List;
+          final albumId = albums.first['id'];
+
+          final photosResponse = await server.get(
+            '/api/v1/album/$albumId/photo',
+          );
+          final photos = jsonDecode(photosResponse.body) as List;
+          final photoId = photos.first['id'];
+
+          // This will fail because vips CLI is not available,
+          // but the handler should return 500, not crash
+          final response = await server.get(
+            '/api/v1/photo/$photoId/preview?w=100&h=100',
+          );
+          expect(response.statusCode, 500);
+        },
+      );
+    });
+
+    group('404 handling', () {
+      test('Unknown route returns 404', () async {
+        server = await TestServer.start();
+        final response = await server.get('/foobar');
+        expect(response.statusCode, 404);
+      });
+
+      test('Unknown nested route returns 404', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v2/unknown');
+        expect(response.statusCode, 404);
+      });
+
+      test('Unknown API endpoint returns 404', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v1/nonexistent');
+        expect(response.statusCode, 404);
+      });
+    });
+
+    group('Response format', () {
+      test('album endpoint returns valid JSON', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v1/album');
+        expect(response.statusCode, 200);
+        expect(response.headers['content-type'], contains('application/json'));
+        expect(() => jsonDecode(response.body), returnsNormally);
+      });
+
+      test('photo metadata has all required fields', () async {
+        server = await TestServer.start(
+          testAlbums: {
+            'format': [('test.png', _createTestPng())],
+          },
+        );
+        final listResponse = await server.get('/api/v1/album');
+        final albums = jsonDecode(listResponse.body) as List;
+        final albumId = albums.first['id'];
+
+        final photosResponse = await server.get('/api/v1/album/$albumId/photo');
+        final photos = jsonDecode(photosResponse.body) as List;
+        final photoId = photos.first['id'];
+
+        final response = await server.get('/api/v1/photo/$photoId');
+        final photo = jsonDecode(response.body) as Map;
+
+        expect(photo, containsPair('id', isA<int>()));
+        expect(photo, containsPair('albumId', isA<int>()));
+        expect(photo, containsPair('filePath', isA<String>()));
+        expect(photo, containsPair('fileName', isA<String>()));
+        expect(photo, containsPair('fileSize', isA<int>()));
+        expect(photo, containsPair('mimeType', isA<String>()));
+        expect(photo, containsPair('createdAt', isA<String>()));
+      });
+    });
+
+    group('Test isolation', () {
+      test('each test starts with clean data', () async {
+        // Start a server, add an album, stop it
+        server = await TestServer.start(testAlbums: {'temp_album': []});
+        final response = await server.get('/api/v1/album');
+        final albums = jsonDecode(response.body) as List;
+        expect(albums.length, 1);
+        // This test's data is isolated - the next test won't see it
+      });
+
+      test('previous test data is not visible', () async {
+        server = await TestServer.start();
+        final response = await server.get('/api/v1/album');
+        final albums = jsonDecode(response.body) as List;
+        // Should be empty because previous test's data was cleaned up
+        expect(albums, isEmpty);
+      });
+    });
+  });
+}