@_nazmiforreal/flutter-ota 0.1.2 → 0.1.4

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

@@ -0,0 +1,294 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart';
+import 'package:flutter_patcher_plugin_core/src/bundle_unit_of_work.dart';
+import 'package:flutter_patcher_plugin_core/src/bundle_unit_of_work_store.dart';
+import 'package:flutter_patcher_plugin_core/src/create_database_plugin.dart';
+import 'package:flutter_patcher_plugin_core/src/types.dart';
+import 'package:test/test.dart';
+
+class _MockDatabasePlugin extends AbstractDatabasePlugin {
+  _MockDatabasePlugin({required this.id, required this.bundles});
+
+  final String id;
+  final List<Bundle> bundles;
+
+  final List<BundleChange> committedChanges = [];
+
+  String get name => 'mock-$id';
+
+  @override
+  Future<Bundle?> getBundleById(String bundleId) async {
+    return bundles.where((b) => b.id == bundleId).firstOrNull;
+  }
+
+  @override
+  Future<Paginated<List<Bundle>>> getBundles(
+    DatabaseBundleQueryOptions options,
+  ) async {
+    final where = options.where;
+    var filtered = bundles;
+    if (where?.channel != null) {
+      filtered = filtered.where((b) => b.channel == where!.channel).toList();
+    }
+    return Paginated(
+      data: filtered,
+      pagination: PaginationInfo(
+        total: filtered.length,
+        hasNextPage: false,
+        hasPreviousPage: false,
+        currentPage: 1,
+        totalPages: 1,
+      ),
+    );
+  }
+
+  @override
+  Future<List<String>> getChannels() async => ['production'];
+
+  @override
+  Future<void> commitBundle({required List<BundleChange> changedSets}) async {
+    committedChanges.addAll(changedSets);
+  }
+
+  @override
+  Future<UpdateInfo?> getUpdateInfo(GetBundlesArgs args) async => null;
+
+  @override
+  Future<void> onUnmount() async {}
+}
+
+Bundle _bundle(String id, {String channel = 'production'}) => Bundle(
+  id: id,
+  platform: Platform.android,
+  shouldForceUpdate: false,
+  enabled: true,
+  fileHash: 'hash_$id',
+  storageUri: 's3://bucket/$id.zip',
+  channel: channel,
+  targetAppVersion: '1.0.0',
+);
+
+void main() {
+  setUp(() {
+    clearUnitOfWorkStore();
+  });
+
+  group('createDatabasePlugin', () {
+    late _MockDatabasePlugin mockImpl;
+
+    setUp(() {
+      mockImpl = _MockDatabasePlugin(
+        id: 'test',
+        bundles: [_bundle('b1'), _bundle('b2')],
+      );
+    });
+
+    test('returns a factory function', () {
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => _MockDatabasePlugin(
+          id: config, bundles: [_bundle('b1')],
+        ),
+      );
+      final createDb = factory('test');
+      expect(createDb, isA<Function>());
+    });
+
+    test('factory creates a DatabasePlugin', () {
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => _MockDatabasePlugin(
+          id: config, bundles: [_bundle('b1')],
+        ),
+      );
+      final db = factory('test')();
+      expect(db, isA<DatabasePlugin>());
+      expect(db.name, 'testDb');
+    });
+
+    test('getBundleById delegates to underlying impl', () async {
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => _MockDatabasePlugin(
+          id: config, bundles: [_bundle('b1'), _bundle('b2')],
+        ),
+      );
+      final db = factory('test')();
+      final result = await db.getBundleById('b1');
+      expect(result, isNotNull);
+      expect(result!.id, 'b1');
+    });
+
+    test('getBundleById returns null for missing', () async {
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => _MockDatabasePlugin(
+          id: config, bundles: [_bundle('b1')],
+        ),
+      );
+      final db = factory('test')();
+      final result = await db.getBundleById('missing');
+      expect(result, isNull);
+    });
+
+    test('getBundles returns paginated results', () async {
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => _MockDatabasePlugin(
+          id: config, bundles: [_bundle('b1'), _bundle('b2')],
+        ),
+      );
+      final db = factory('test')();
+      final result = await db.getBundles(
+        const DatabaseBundleQueryOptions(),
+      );
+      expect(result.data.length, 2);
+      expect(result.pagination.total, 2);
+    });
+
+    test('getChannels delegates correctly', () async {
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => _MockDatabasePlugin(
+          id: config, bundles: [_bundle('b1')],
+        ),
+      );
+      final db = factory('test')();
+      final channels = await db.getChannels();
+      expect(channels, ['production']);
+    });
+
+    test('appendBundle + commitBundle sends insert', () async {
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => mockImpl,
+      );
+      final db = factory('test')();
+
+      await db.appendBundle(_bundle('new'));
+      await db.commitBundle();
+
+      expect(mockImpl.committedChanges.length, 1);
+      expect(mockImpl.committedChanges.first.operation, BundleChangeOperation.insert);
+      expect(mockImpl.committedChanges.first.data.id, 'new');
+    });
+
+    test('updateBundle + commitBundle sends update', () async {
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => mockImpl,
+      );
+      final db = factory('test')();
+
+      await db.updateBundle('b1', {'enabled': false});
+      await db.commitBundle();
+
+      expect(mockImpl.committedChanges.length, 1);
+      expect(mockImpl.committedChanges.first.operation, BundleChangeOperation.update);
+      expect(mockImpl.committedChanges.first.data.enabled, false);
+    });
+
+    test('deleteBundle + commitBundle sends delete', () async {
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => mockImpl,
+      );
+      final db = factory('test')();
+
+      await db.deleteBundle(_bundle('b1'));
+      await db.commitBundle();
+
+      expect(mockImpl.committedChanges.length, 1);
+      expect(mockImpl.committedChanges.first.operation, BundleChangeOperation.delete);
+    });
+
+    test('commitBundle with no changes sends empty', () async {
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => mockImpl,
+      );
+      final db = factory('test')();
+
+      await db.commitBundle();
+      expect(mockImpl.committedChanges, isEmpty);
+    });
+
+    test('each factory call creates isolated UoW', () async {
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => mockImpl,
+      );
+      final db1 = factory('test')();
+      final db2 = factory('test')();
+
+      await db1.appendBundle(_bundle('only1'));
+      // db2 should not have db1's changes
+      await db2.commitBundle();
+      expect(mockImpl.committedChanges, isEmpty);
+    });
+
+    test('hook onDatabaseUpdated fires after commit', () async {
+      var hookCalled = false;
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => mockImpl,
+      );
+      final db = factory('test', DatabasePluginHooks(
+        onDatabaseUpdated: () async { hookCalled = true; },
+      ))();
+
+      await db.appendBundle(_bundle('x'));
+      await db.commitBundle();
+      expect(hookCalled, isTrue);
+    });
+
+    test('getUpdateInfo delegates to underlying impl', () async {
+      final factory = createDatabasePlugin<String>(
+        name: 'testDb',
+        factory: (config) => mockImpl,
+      );
+      final db = factory('test')();
+      final result = await db.getUpdateInfo(
+        FingerprintGetBundlesArgs(
+          platform: Platform.android,
+          bundleId: 'b1',
+          fingerprintHash: 'abc',
+        ),
+      );
+      expect(result, isNull);
+    });
+  });
+
+  group('mergeBundleUpdate', () {
+    test('replaces targetCohorts', () {
+      final base = _bundle('a');
+      final updated = mergeBundleUpdate(base, {
+        'targetCohorts': ['cohort1'],
+      });
+      expect(updated.targetCohorts, ['cohort1']);
+    });
+
+    test('replaces patches', () {
+      final base = _bundle('a');
+      final updated = mergeBundleUpdate(base, {
+        'patches': [],
+      });
+      expect(updated.patches, isEmpty);
+    });
+
+    test('updates scalar fields', () {
+      final base = _bundle('a');
+      final updated = mergeBundleUpdate(base, {
+        'enabled': false,
+      });
+      expect(updated.enabled, false);
+    });
+
+    test('preserves existing fields not in patch', () {
+      final base = _bundle('a');
+      final updated = mergeBundleUpdate(base, {
+        'enabled': false,
+      });
+      expect(updated.fileHash, 'hash_a');
+    });
+  });
+}

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

@@ -0,0 +1,192 @@
+import 'package:flutter_patcher_plugin_core/src/create_storage_plugin.dart';
+import 'package:flutter_patcher_plugin_core/src/types.dart';
+import 'package:test/test.dart';
+
+class _MockNodeProfile implements NodeStorageProfile {
+  @override
+  Future<Map<String, String>> upload(String key, String filePath) async => {
+    'storageUri': 'mock://$key',
+  };
+
+  @override
+  Future<bool> exists(String storageUri) async => true;
+
+  @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 _MockRuntimeProfile implements RuntimeStorageProfile {
+  @override
+  Future<Map<String, String>> getDownloadUrl(String storageUri) async => {
+    'url': 'https://example.com/$storageUri',
+  };
+
+  @override
+  Future<String?> readText(String storageUri) async => 'content';
+}
+
+void main() {
+  group('createNodeStoragePlugin', () {
+    test('creates a storage plugin with node profile', () {
+      final factory = createNodeStoragePlugin<String>(
+        name: 'testStorage',
+        supportedProtocol: 'mock://',
+        factory: (config) => _MockNodeProfile(),
+      );
+      final plugin = factory('cfg');
+      expect(plugin.name, 'testStorage');
+      expect(plugin.supportedProtocol, 'mock://');
+      expect(plugin.profiles.hasNode, isTrue);
+      expect(plugin.profiles.hasRuntime, isFalse);
+    });
+
+    test('factory is lazy — not called until profile method invoked', () async {
+      var called = false;
+      final factory = createNodeStoragePlugin<String>(
+        name: 'testStorage',
+        supportedProtocol: 'mock://',
+        factory: (config) {
+          called = true;
+          return _MockNodeProfile();
+        },
+      );
+      final plugin = factory('cfg');
+      expect(called, isFalse);
+      // Calling a method on the profile triggers the factory
+      await plugin.profiles.node!.exists('uri');
+      expect(called, isTrue);
+    });
+
+    test('upload calls hook after completion', () async {
+      var hookCalled = false;
+      final factory = createNodeStoragePlugin<String>(
+        name: 'testStorage',
+        supportedProtocol: 'mock://',
+        factory: (config) => _MockNodeProfile(),
+      );
+      final plugin = factory('cfg', StoragePluginHooks(
+        onStorageUploaded: () async { hookCalled = true; },
+      ));
+      await plugin.profiles.node!.upload('key', '/path');
+      expect(hookCalled, isTrue);
+    });
+
+    test('without hook, upload works fine', () async {
+      final factory = createNodeStoragePlugin<String>(
+        name: 'testStorage',
+        supportedProtocol: 'mock://',
+        factory: (config) => _MockNodeProfile(),
+      );
+      final plugin = factory('cfg');
+      final result = await plugin.profiles.node!.upload('key', '/path');
+      expect(result['storageUri'], 'mock://key');
+    });
+
+    test('multiple method calls use same cached underlying profile', () async {
+      var callCount = 0;
+      final factory = createNodeStoragePlugin<String>(
+        name: 'testStorage',
+        supportedProtocol: 'mock://',
+        factory: (config) {
+          callCount++;
+          return _MockNodeProfile();
+        },
+      );
+      final plugin = factory('cfg');
+      // First method call triggers factory
+      await plugin.profiles.node!.exists('uri');
+      expect(callCount, 1);
+      // Second method call reuses the same cached profile
+      await plugin.profiles.node!.exists('uri2');
+      expect(callCount, 1);
+    });
+  });
+
+  group('createRuntimeStoragePlugin', () {
+    test('creates a storage plugin with runtime profile', () {
+      final factory = createRuntimeStoragePlugin<String>(
+        name: 'testRuntime',
+        supportedProtocol: 'mock://',
+        factory: (config) => _MockRuntimeProfile(),
+      );
+      final plugin = factory('cfg');
+      expect(plugin.name, 'testRuntime');
+      expect(plugin.profiles.hasNode, isFalse);
+      expect(plugin.profiles.hasRuntime, isTrue);
+    });
+
+    test('runtime profile delegates correctly', () async {
+      final factory = createRuntimeStoragePlugin<String>(
+        name: 'testRuntime',
+        supportedProtocol: 'mock://',
+        factory: (config) => _MockRuntimeProfile(),
+      );
+      final plugin = factory('cfg');
+      final url = await plugin.profiles.runtime!
+          .getDownloadUrl('mock://file.zip');
+      expect(url['url'], contains('file.zip'));
+    });
+  });
+
+  group('createUniversalStoragePlugin', () {
+    test('creates a storage plugin with both profiles', () {
+      final factory = createUniversalStoragePlugin<String>(
+        name: 'testUniversal',
+        supportedProtocol: 'mock://',
+        factory: (config) => (
+          node: _MockNodeProfile(),
+          runtime: _MockRuntimeProfile(),
+        ),
+      );
+      final plugin = factory('cfg');
+      expect(plugin.name, 'testUniversal');
+      expect(plugin.profiles.hasNode, isTrue);
+      expect(plugin.profiles.hasRuntime, isTrue);
+    });
+
+    test('both profiles work independently', () async {
+      final factory = createUniversalStoragePlugin<String>(
+        name: 'testUniversal',
+        supportedProtocol: 'mock://',
+        factory: (config) => (
+          node: _MockNodeProfile(),
+          runtime: _MockRuntimeProfile(),
+        ),
+      );
+      final plugin = factory('cfg');
+
+      final nodeResult = await plugin.profiles.node!.upload('k', '/p');
+      expect(nodeResult, isNotEmpty);
+
+      final runtimeUrl = await plugin.profiles.runtime!
+          .getDownloadUrl('mock://file');
+      expect(runtimeUrl, isNotEmpty);
+    });
+
+    test('factory is lazy', () async {
+      var called = false;
+      final factory = createUniversalStoragePlugin<String>(
+        name: 'testUniversal',
+        supportedProtocol: 'mock://',
+        factory: (config) {
+          called = true;
+          return (node: _MockNodeProfile(), runtime: _MockRuntimeProfile());
+        },
+      );
+      final plugin = factory('cfg');
+      expect(called, isFalse);
+      // Calling a method on the node profile triggers the factory
+      await plugin.profiles.node!.exists('uri');
+      expect(called, isTrue);
+    });
+  });
+}

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

@@ -0,0 +1,51 @@
+import 'package:flutter_patcher_plugin_core/src/generate_min_bundle_id.dart';
+import 'package:flutter_patcher_plugin_core/src/uuidv7.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('generateMinBundleId', () {
+    test('produces valid UUID v7 format', () {
+      final id = generateMinBundleId();
+      expect(id, 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('has zeroed random bits', () {
+      final id = generateMinBundleId();
+      final parts = id.split('-');
+      // version+rand_a should be 7000 (version 7, rand_a=0)
+      expect(parts[2], '7000');
+      // variant+rand_b starts with 8, rest is 0
+      expect(parts[3], '8000');
+      // node is all zeros
+      expect(parts[4], '000000000000');
+    });
+
+    test('timestamp is close to current time', () {
+      final before = DateTime.now().millisecondsSinceEpoch;
+      final id = generateMinBundleId();
+      final after = DateTime.now().millisecondsSinceEpoch;
+      final ts = extractTimestampFromUUIDv7(id);
+      expect(ts, greaterThanOrEqualTo(before));
+      expect(ts, lessThanOrEqualTo(after));
+    });
+
+    test('sorts before a normal UUIDv7 at the same millisecond', () {
+      // Create a min bundle ID
+      final minId = generateMinBundleId();
+      // Create a normal UUIDv7 (with random bits)
+      final normalId = createUUIDv7();
+      // Both are at approximately the same time, but min should be <= normal
+      // when timestamps are close
+      final minTs = extractTimestampFromUUIDv7(minId);
+      final normalTs = extractTimestampFromUUIDv7(normalId);
+      // If timestamps are the same, min should sort first
+      if (minTs == normalTs) {
+        expect(minId.compareTo(normalId), lessThan(0));
+      }
+      // Otherwise just verify the format is valid
+      expect(minId.length, 36);
+    });
+  });
+}