...

test/gallery_test.dart

@@ -0,0 +1,190 @@
+import 'package:flutter/services.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:ux/testing.dart';
+import 'package:ux/ux.dart';
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  group('UxGallery facade — method channel parsing', () {
+    const channel = MethodChannel('ux/gallery');
+
+    setUp(() {
+      UxGallery.backend = MethodChannelGalleryBackend();
+    });
+
+    tearDown(() {
+      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+          .setMockMethodCallHandler(channel, null);
+    });
+
+    test('permission() parses the granted state', () async {
+      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+          .setMockMethodCallHandler(channel, (call) async {
+        expect(call.method, 'permission');
+        return 'granted';
+      });
+
+      expect(await UxGallery.permission(), UxGalleryPermission.granted);
+    });
+
+    test('permission() falls back to denied on unknown values', () async {
+      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+          .setMockMethodCallHandler(channel, (_) async => 'mystery');
+
+      expect(await UxGallery.permission(), UxGalleryPermission.denied);
+    });
+
+    test('albums() decodes a list of UxAlbum', () async {
+      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+          .setMockMethodCallHandler(channel, (call) async {
+        expect(call.method, 'albums');
+        expect((call.arguments as Map)['filter'], 'any');
+        return [
+          {
+            'id': 'recents',
+            'name': 'Recents',
+            'count': 1234,
+            'cover_kind': 'image',
+          },
+          {
+            'id': 'videos',
+            'name': 'Videos',
+            'count': 12,
+            'cover_kind': 'video',
+          },
+        ];
+      });
+
+      final albums = await UxGallery.albums();
+      expect(albums, hasLength(2));
+      expect(albums[0].id, 'recents');
+      expect(albums[0].count, 1234);
+      expect(albums[0].coverKind, UxAssetKind.image);
+      expect(albums[1].coverKind, UxAssetKind.video);
+    });
+
+    test('assets() decodes durations and timestamps', () async {
+      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+          .setMockMethodCallHandler(channel, (call) async {
+        expect(call.method, 'assets');
+        final args = call.arguments as Map;
+        expect(args['albumId'], 'recents');
+        expect(args['filter'], 'video');
+        expect(args['start'], 0);
+        expect(args['end'], 60);
+        return [
+          {
+            'id': 'a1',
+            'kind': 'video',
+            'duration_ms': 8500,
+            'width': 1080,
+            'height': 1920,
+            'created_ms': 1700000000000,
+          },
+        ];
+      });
+
+      final assets = await UxGallery.assets(
+        albumId: 'recents',
+        filter: UxAssetKind.video,
+        start: 0,
+        end: 60,
+      );
+      expect(assets, hasLength(1));
+      expect(assets.single.kind, UxAssetKind.video);
+      expect(assets.single.duration, const Duration(milliseconds: 8500));
+      expect(assets.single.createdAt.millisecondsSinceEpoch, 1700000000000);
+    });
+
+    test('thumbnail() returns the byte payload + dims', () async {
+      TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger
+          .setMockMethodCallHandler(channel, (call) async {
+        expect(call.method, 'thumbnail');
+        final args = call.arguments as Map;
+        expect(args['assetId'], 'a1');
+        expect(args['sizePx'], 381);
+        return {
+          'bytes': Uint8List.fromList([1, 2, 3]),
+          'width': 381,
+          'height': 254,
+        };
+      });
+
+      final thumb = await UxGallery.thumbnail('a1', sizePx: 381);
+      expect(thumb.bytes, [1, 2, 3]);
+      expect(thumb.width, 381);
+      expect(thumb.height, 254);
+    });
+  });
+
+  group('FakeUxGalleryBackend', () {
+    test('requestPermission flips state to granted by default', () async {
+      final fake = FakeUxGalleryBackend(
+        permissionState: UxGalleryPermission.notDetermined,
+      );
+      UxGallery.backend = fake;
+
+      expect(await UxGallery.permission(),
+          UxGalleryPermission.notDetermined);
+      expect(await UxGallery.requestPermission(),
+          UxGalleryPermission.granted);
+      expect(await UxGallery.permission(), UxGalleryPermission.granted);
+    });
+
+    test('assets honours the (start, end) page window per album', () async {
+      final pile = [
+        for (var i = 0; i < 50; i++)
+          UxAsset(
+            id: 'a$i',
+            kind: UxAssetKind.image,
+            width: 100,
+            height: 100,
+            createdAt: DateTime.fromMillisecondsSinceEpoch(i * 1000),
+          ),
+      ];
+      final fake = FakeUxGalleryBackend(
+        recents: pile,
+        assetsByAlbum: {'all': pile},
+      );
+      UxGallery.backend = fake;
+
+      final firstPage = await UxGallery.assets(start: 0, end: 10);
+      expect(firstPage.map((a) => a.id), [
+        for (var i = 0; i < 10; i++) 'a$i',
+      ]);
+      final tail = await UxGallery.assets(albumId: 'all', start: 45, end: 999);
+      expect(tail, hasLength(5));
+      final past = await UxGallery.assets(start: 200, end: 210);
+      expect(past, isEmpty);
+    });
+
+    test('assets filters by kind when requested', () async {
+      final mix = [
+        UxAsset(
+          id: 'p',
+          kind: UxAssetKind.image,
+          width: 1,
+          height: 1,
+          createdAt: DateTime(2024),
+        ),
+        UxAsset(
+          id: 'v',
+          kind: UxAssetKind.video,
+          duration: const Duration(seconds: 3),
+          width: 1,
+          height: 1,
+          createdAt: DateTime(2024),
+        ),
+      ];
+      UxGallery.backend = FakeUxGalleryBackend(recents: mix);
+
+      final justVideos = await UxGallery.assets(
+        filter: UxAssetKind.video,
+        start: 0,
+        end: 10,
+      );
+      expect(justVideos.map((a) => a.id), ['v']);
+    });
+  });
+}