@_nazmiforreal/flutter-ota 0.1.2 → 0.1.4

package/dart-src/plugins/plugin-core/test/helpers_test.dart

@@ -0,0 +1,259 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart'
+    show Bundle, BundleMetadata, Platform;
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('paginateBundles', () {
+    List<Bundle> makeBundles(int count) =>
+        List.generate(count, (i) => _testBundle(id: 'b-${i.toString().padLeft(3, '0')}'));
+
+    test('offset-based first page', () {
+      final result = paginateBundles(bundles: makeBundles(25), limit: 10, offset: 0);
+      expect(result.data.length, 10);
+      expect(result.pagination.total, 25);
+      expect(result.pagination.hasNextPage, isTrue);
+      expect(result.pagination.hasPreviousPage, isFalse);
+      expect(result.pagination.currentPage, 1);
+      expect(result.pagination.nextCursor, isNotNull);
+      expect(result.pagination.previousCursor, isNull);
+    });
+
+    test('offset-based last page', () {
+      final result = paginateBundles(bundles: makeBundles(25), limit: 10, offset: 20);
+      expect(result.data.length, 5);
+      expect(result.pagination.hasNextPage, isFalse);
+      expect(result.pagination.hasPreviousPage, isTrue);
+    });
+
+    test('cursor-based after', () {
+      final result = paginateBundles(
+        bundles: makeBundles(10),
+        limit: 3,
+        cursor: const DatabaseBundleCursor(after: 'b-004'),
+      );
+      // Sorted desc: b-009..b-000. After b-004 (id < 'b-004'): b-003, b-002, b-001, b-000
+      expect(result.data.length, 3);
+      expect(result.data.first.id, 'b-003');
+      expect(result.data.last.id, 'b-001');
+    });
+
+    test('cursor-based before', () {
+      final result = paginateBundles(
+        bundles: makeBundles(10),
+        limit: 3,
+        cursor: const DatabaseBundleCursor(before: 'b-005'),
+      );
+      // Before b-005 in desc: candidates id > b-005 = [b-009, b-008, b-007, b-006]
+      // Take last 3 (closest to cursor): b-008, b-007, b-006
+      expect(result.data.length, 3);
+      expect(result.data.first.id, 'b-008');
+      expect(result.data.last.id, 'b-006');
+    });
+
+    test('empty result preserves cursor', () {
+      final result = paginateBundles(
+        bundles: makeBundles(5),
+        limit: 10,
+        cursor: const DatabaseBundleCursor(after: 'b-000'),
+      );
+      // Desc sorted: b-004, b-003, b-002, b-001, b-000
+      // after 'b-000': nothing has id < 'b-000' → empty, previousCursor preserved
+      expect(result.data, isEmpty);
+      expect(result.pagination.previousCursor, 'b-000');
+    });
+  });
+
+  group('filterCompatibleAppVersions', () {
+    test('filters and sorts descending', () {
+      final result = filterCompatibleAppVersions(
+        ['^1.0.0', '^2.0.0', '^0.5.0'],
+        '1.3.0',
+      );
+      expect(result, ['^1.0.0']);
+    });
+
+    test('multiple compatible versions sorted desc', () {
+      final result = filterCompatibleAppVersions(
+        ['>=1.0.0', '>=1.2.0', '>=2.0.0'],
+        '1.5.0',
+      );
+      expect(result, ['>=1.2.0', '>=1.0.0']);
+    });
+  });
+
+  group('parseStorageUri', () {
+    test('parses supabase-storage URI', () {
+      final result = parseStorageUri(
+        'supabase-storage://bucket/path/to/file.zip',
+        'supabase-storage',
+      );
+      expect(result.protocol, 'supabase-storage');
+      expect(result.bucket, 'bucket');
+      expect(result.key, 'path/to/file.zip');
+    });
+
+    test('parses s3 URI', () {
+      final result = parseStorageUri('s3://my-bucket/key.zip', 's3');
+      expect(result.bucket, 'my-bucket');
+      expect(result.key, 'key.zip');
+    });
+
+    test('decodes percent-encoded keys', () {
+      final result = parseStorageUri(
+        'supabase-storage://bucket/path%20with%20spaces/file.zip',
+        'supabase-storage',
+      );
+      expect(result.key, 'path with spaces/file.zip');
+    });
+
+    test('throws on wrong protocol', () {
+      expect(
+        () => parseStorageUri('s3://bucket/key', 'supabase-storage'),
+        throwsFormatException,
+      );
+    });
+  });
+
+  group('contentAddressedAssets', () {
+    test('builds sha256 path with extension', () {
+      final path = getContentAddressedAssetStoragePath(
+        assetPath: 'index.android.bundle',
+        fileHash: 'abcdef1234567890',
+      );
+      expect(path, 'sha256/ab/abcdef1234567890.bundle');
+    });
+
+    test('preserves .br extension', () {
+      final path = getContentAddressedAssetStoragePath(
+        assetPath: 'index.android.bundle.br',
+        fileHash: 'abcdef1234567890',
+      );
+      expect(path, 'sha256/ab/abcdef1234567890.br');
+    });
+
+    test('handles no extension', () {
+      final path = getContentAddressedAssetStoragePath(
+        assetPath: 'manifest',
+        fileHash: 'abcdef1234567890',
+      );
+      expect(path, 'sha256/ab/abcdef1234567890');
+    });
+  });
+
+  group('compressionFormat', () {
+    test('detects zip', () {
+      expect(detectCompressionFormat('bundle.zip').format, CompressionFormat.zip);
+    });
+
+    test('detects tar.br', () {
+      expect(detectCompressionFormat('bundle.tar.br').format, CompressionFormat.tarBr);
+    });
+
+    test('detects tar.gz', () {
+      expect(detectCompressionFormat('bundle.tar.gz').format, CompressionFormat.tarGz);
+    });
+
+    test('defaults to zip', () {
+      expect(detectCompressionFormat('bundle.xyz').format, CompressionFormat.zip);
+    });
+
+    test('getContentType returns mime type for zip', () {
+      expect(getContentType('bundle.zip'), 'application/zip');
+    });
+  });
+
+  group('storageProfile', () {
+    test('isNodeStoragePlugin checks profiles.node', () {
+      final plugin = _DummyStoragePlugin(node: true, runtime: false);
+      expect(isNodeStoragePlugin(plugin), isTrue);
+      expect(isRuntimeStoragePlugin(plugin), isFalse);
+    });
+
+    test('isRuntimeStoragePlugin checks profiles.runtime', () {
+      final plugin = _DummyStoragePlugin(node: false, runtime: true);
+      expect(isNodeStoragePlugin(plugin), isFalse);
+      expect(isRuntimeStoragePlugin(plugin), isTrue);
+    });
+
+    test('assertNodeStoragePlugin throws if missing', () {
+      final plugin = _DummyStoragePlugin(node: false, runtime: true);
+      expect(() => assertNodeStoragePlugin(plugin), throwsStateError);
+    });
+  });
+
+  group('createStorageKeyBuilder', () {
+    test('with base path', () {
+      final getKey = createStorageKeyBuilder('bundles');
+      expect(getKey('v1', 'patch.zip'), 'bundles/v1/patch.zip');
+    });
+
+    test('without base path', () {
+      final getKey = createStorageKeyBuilder(null);
+      expect(getKey('v1', 'file.zip'), 'v1/file.zip');
+    });
+  });
+}
+
+Bundle _testBundle({String id = 'test-bundle-id'}) {
+  return Bundle(
+    id: id,
+    channel: 'production',
+    platform: Platform.android,
+    enabled: true,
+    shouldForceUpdate: false,
+    fileHash: 'abc123',
+    gitCommitHash: null,
+    message: null,
+    targetAppVersion: '1.0.0',
+    fingerprintHash: null,
+    storageUri: 'supabase-storage://bucket/path',
+    metadata: const BundleMetadata(),
+    patches: const [],
+    rolloutCohortCount: 1000,
+    targetCohorts: null,
+  );
+}
+
+class _DummyStoragePlugin extends StoragePlugin {
+  _DummyStoragePlugin({required bool node, required bool runtime})
+      : _node = node,
+        _runtime = runtime;
+
+  final bool _node;
+  final bool _runtime;
+
+  @override
+  String get name => 'dummy';
+
+  @override
+  String get supportedProtocol => 'dummy';
+
+  @override
+  StoragePluginProfiles get profiles => StoragePluginProfiles(
+        node: _node ? _DummyNodeStorageProfile() : null,
+        runtime: _runtime ? _DummyRuntimeStorageProfile() : null,
+      );
+}
+
+class _DummyNodeStorageProfile extends NodeStorageProfile {
+  @override
+  Future<Map<String, String>> upload(String key, String filePath) async => {};
+  @override
+  Future<bool> exists(String storageUri) async => false;
+  @override
+  Future<void> delete(String storageUri) async {}
+  @override
+  Future<void> downloadFile(String storageUri, String filePath) async {}
+  @override
+  Future<List<StorageObject>> listObjects([String? prefix]) async => [];
+  @override
+  Future<void> deleteObjects(List<String> keys) async {}
+}
+
+class _DummyRuntimeStorageProfile extends RuntimeStorageProfile {
+  @override
+  Future<Map<String, String>> getDownloadUrl(String storageUri) async => {};
+  @override
+  Future<String?> readText(String storageUri) async => null;
+}

package/dart-src/plugins/plugin-core/test/query_bundles_test.dart

@@ -0,0 +1,139 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart'
+    show Bundle, BundleMetadata, Platform;
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('calculatePagination', () {
+    test('empty total', () {
+      final p = calculatePagination(0, limit: 10, offset: 0);
+      expect(p.total, 0);
+      expect(p.hasNextPage, isFalse);
+      expect(p.hasPreviousPage, isFalse);
+      expect(p.currentPage, 1);
+      expect(p.totalPages, 0);
+    });
+
+    test('first page', () {
+      final p = calculatePagination(25, limit: 10, offset: 0);
+      expect(p.total, 25);
+      expect(p.hasNextPage, isTrue);
+      expect(p.hasPreviousPage, isFalse);
+      expect(p.currentPage, 1);
+      expect(p.totalPages, 3);
+    });
+
+    test('middle page', () {
+      final p = calculatePagination(25, limit: 10, offset: 10);
+      expect(p.currentPage, 2);
+      expect(p.hasNextPage, isTrue);
+      expect(p.hasPreviousPage, isTrue);
+    });
+
+    test('last page', () {
+      final p = calculatePagination(25, limit: 10, offset: 20);
+      expect(p.currentPage, 3);
+      expect(p.hasNextPage, isFalse);
+      expect(p.hasPreviousPage, isTrue);
+    });
+  });
+
+  group('bundleIdMatchesFilter', () {
+    test('null filter matches all', () {
+      expect(bundleIdMatchesFilter('abc', null), isTrue);
+    });
+
+    test('eq match', () {
+      expect(bundleIdMatchesFilter('abc', const DatabaseBundleIdFilter(eq: 'abc')), isTrue);
+      expect(bundleIdMatchesFilter('abc', const DatabaseBundleIdFilter(eq: 'def')), isFalse);
+    });
+
+    test('gt match', () {
+      expect(bundleIdMatchesFilter('b', const DatabaseBundleIdFilter(gt: 'a')), isTrue);
+      expect(bundleIdMatchesFilter('a', const DatabaseBundleIdFilter(gt: 'b')), isFalse);
+    });
+
+    test('in match', () {
+      expect(bundleIdMatchesFilter('a', const DatabaseBundleIdFilter(ins: ['a', 'b'])), isTrue);
+      expect(bundleIdMatchesFilter('c', const DatabaseBundleIdFilter(ins: ['a', 'b'])), isFalse);
+    });
+
+    test('combined filters', () {
+      final f = DatabaseBundleIdFilter(gte: 'a', lte: 'z');
+      expect(bundleIdMatchesFilter('m', f), isTrue);
+      expect(bundleIdMatchesFilter('0', f), isFalse);
+    });
+  });
+
+  group('bundleMatchesQueryWhere', () {
+    test('null where matches all', () {
+      final bundle = _testBundle(channel: 'prod');
+      expect(bundleMatchesQueryWhere(bundle, null), isTrue);
+    });
+
+    test('filters by channel', () {
+      final bundle = _testBundle(channel: 'prod');
+      expect(bundleMatchesQueryWhere(bundle, const DatabaseBundleQueryWhere(channel: 'prod')), isTrue);
+      expect(bundleMatchesQueryWhere(bundle, const DatabaseBundleQueryWhere(channel: 'dev')), isFalse);
+    });
+
+    test('filters by enabled', () {
+      final bundle = _testBundle(enabled: true);
+      expect(bundleMatchesQueryWhere(bundle, const DatabaseBundleQueryWhere(enabled: true)), isTrue);
+      expect(bundleMatchesQueryWhere(bundle, const DatabaseBundleQueryWhere(enabled: false)), isFalse);
+    });
+
+    test('filters by targetAppVersion null', () {
+      final bundle = _testBundle(targetAppVersion: null);
+      expect(bundleMatchesQueryWhere(bundle, const DatabaseBundleQueryWhere(targetAppVersionNotNull: true)), isFalse);
+      expect(bundleMatchesQueryWhere(bundle, const DatabaseBundleQueryWhere(targetAppVersionNotNull: false)), isTrue);
+    });
+  });
+
+  group('sortBundles', () {
+    test('sorts descending by default', () {
+      final bundles = [
+        _testBundle(id: 'c'),
+        _testBundle(id: 'a'),
+        _testBundle(id: 'b'),
+      ];
+      final sorted = sortBundles(bundles, null);
+      expect(sorted.map((b) => b.id).toList(), ['c', 'b', 'a']);
+    });
+
+    test('sorts ascending', () {
+      final bundles = [
+        _testBundle(id: 'c'),
+        _testBundle(id: 'a'),
+        _testBundle(id: 'b'),
+      ];
+      final sorted = sortBundles(bundles, const DatabaseBundleQueryOrder(direction: 'asc'));
+      expect(sorted.map((b) => b.id).toList(), ['a', 'b', 'c']);
+    });
+  });
+}
+
+Bundle _testBundle({
+  String id = 'test-bundle-id',
+  String channel = 'production',
+  bool enabled = true,
+  String? targetAppVersion = '1.0.0',
+}) {
+  return Bundle(
+    id: id,
+    channel: channel,
+    platform: Platform.android,
+    enabled: enabled,
+    shouldForceUpdate: false,
+    fileHash: 'abc123',
+    gitCommitHash: null,
+    message: null,
+    targetAppVersion: targetAppVersion,
+    fingerprintHash: null,
+    storageUri: 'supabase-storage://bucket/path',
+    metadata: const BundleMetadata(),
+    patches: const [],
+    rolloutCohortCount: 1000,
+    targetCohorts: null,
+  );
+}

package/dart-src/plugins/plugin-core/test/request_update_bundle_state_test.dart

@@ -0,0 +1,86 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart';
+import 'package:flutter_patcher_plugin_core/src/bundle_unit_of_work_store.dart';
+import 'package:flutter_patcher_plugin_core/src/request_update_bundle_state.dart';
+import 'package:test/test.dart';
+
+Bundle _bundle(String id) => Bundle(
+  id: id,
+  platform: Platform.android,
+  shouldForceUpdate: false,
+  enabled: true,
+  fileHash: 'hash_$id',
+  storageUri: 's3://bucket/$id.zip',
+  channel: 'production',
+);
+
+void main() {
+  setUp(() {
+    clearUnitOfWorkStore();
+  });
+
+  group('seedRequestUpdateBundles', () {
+    test('seeds bundles into context UoW', () {
+      final context = <String, Object?>{};
+      seedRequestUpdateBundles(context, [_bundle('a'), _bundle('b')]);
+      final seeds = getRequestUpdateBundleSeeds(context);
+      expect(seeds.length, 2);
+      expect(seeds.map((b) => b.id).toSet(), {'a', 'b'});
+    });
+
+    test('ignores null context', () {
+      seedRequestUpdateBundles(null, [_bundle('a')]);
+      // Should not throw
+    });
+
+    test('ignores empty seeds', () {
+      final context = <String, Object?>{};
+      seedRequestUpdateBundles(context, [null]);
+      final seeds = getRequestUpdateBundleSeeds(context);
+      expect(seeds, isEmpty);
+    });
+
+    test('filters out null seeds', () {
+      final context = <String, Object?>{};
+      seedRequestUpdateBundles(context, [_bundle('a'), null, _bundle('b')]);
+      final seeds = getRequestUpdateBundleSeeds(context);
+      expect(seeds.length, 2);
+    });
+  });
+
+  group('getRequestUpdateBundleSeeds', () {
+    test('returns empty for null context', () {
+      expect(getRequestUpdateBundleSeeds(null), isEmpty);
+    });
+
+    test('returns empty for unseeded context', () {
+      expect(getRequestUpdateBundleSeeds(<String, Object?>{}), isEmpty);
+    });
+  });
+
+  group('createRequestUpdateBundleResolver', () {
+    test('creates resolver for valid context', () async {
+      final context = <String, Object?>{};
+      seedRequestUpdateBundles(context, [_bundle('x')]);
+      final resolver = createRequestUpdateBundleResolver(context);
+
+      expect(resolver.hasSeededBundles, isTrue);
+      expect(resolver.peek('x'), isNotNull);
+      expect(resolver.peek('missing'), isNull);
+    });
+
+    test('creates standalone resolver for null context', () async {
+      final resolver = createRequestUpdateBundleResolver(null);
+      expect(resolver.hasSeededBundles, isFalse);
+      expect(resolver.peek('anything'), isNull);
+    });
+
+    test('getById delegates to underlying UoW', () async {
+      final context = <String, Object?>{};
+      final resolver = createRequestUpdateBundleResolver(context);
+
+      final result = await resolver.getById('y', () async => _bundle('y'));
+      expect(result, isNotNull);
+      expect(result!.id, 'y');
+    });
+  });
+}

package/dart-src/plugins/plugin-core/test/uuidv7_test.dart

@@ -0,0 +1,77 @@
+import 'package:flutter_patcher_plugin_core/src/uuidv7.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('extractTimestampFromUUIDv7', () {
+    test('extracts timestamp from known UUID', () {
+      // Timestamp hex = 01894f2e3a00 = 1737105248768
+      final uuid = '01894f2e-3a00-7000-8000-000000000000';
+      final ts = extractTimestampFromUUIDv7(uuid);
+      expect(ts, 0x01894f2e3a00);
+    });
+
+    test('round-trips createUUIDv7 timestamp', () {
+      final uuid = createUUIDv7();
+      final ts = extractTimestampFromUUIDv7(uuid);
+      final now = DateTime.now().millisecondsSinceEpoch;
+      // Should be within 50ms of now
+      expect((now - ts).abs(), lessThan(50));
+    });
+  });
+
+  group('createUUIDv7', () {
+    test('produces valid UUID v7 format', () {
+      final uuid = createUUIDv7();
+      // 8-4-4-4-12 format
+      expect(uuid, matches(RegExp(
+        r'^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$',
+      )));
+    });
+
+    test('generates unique UUIDs', () {
+      final ids = <String>{};
+      for (var i = 0; i < 100; i++) {
+        ids.add(createUUIDv7());
+      }
+      expect(ids.length, 100);
+    });
+
+    test('UUIDs with different timestamps are ordered correctly', () {
+      // Create two UUIDs with known timestamps
+      final uuid1 = createUUIDv7WithSameTimestamp(
+        '01900000-0001-7000-8000-000000000000',
+      );
+      final uuid2 = createUUIDv7WithSameTimestamp(
+        '01900000-0002-7000-8000-000000000000',
+      );
+      expect(uuid2.compareTo(uuid1), greaterThan(0));
+    });
+  });
+
+  group('createUUIDv7WithSameTimestamp', () {
+    test('preserves timestamp from original UUID', () {
+      final original = createUUIDv7();
+      final originalTs = extractTimestampFromUUIDv7(original);
+      final derived = createUUIDv7WithSameTimestamp(original);
+      final derivedTs = extractTimestampFromUUIDv7(derived);
+      expect(derivedTs, originalTs);
+    });
+
+    test('produces different random bits', () {
+      final original = createUUIDv7();
+      // Generate a few — at least one should differ in random part
+      final differentFound = List.generate(10, (_) =>
+          createUUIDv7WithSameTimestamp(original))
+          .any((u) => u != original);
+      expect(differentFound, isTrue);
+    });
+
+    test('derived UUID still has version 7 and correct variant', () {
+      final original = createUUIDv7();
+      final derived = createUUIDv7WithSameTimestamp(original);
+      expect(derived, matches(RegExp(
+        r'^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$',
+      )));
+    });
+  });
+}