@_nazmiforreal/flutter-ota 0.1.2 → 0.1.3

package/dart-src/plugins/postgres/test/mock_postgres_client.dart

@@ -0,0 +1,297 @@
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart';
+
+import 'package:flutter_patcher_postgres/flutter_patcher_postgres.dart';
+
+/// In-memory store backing [MockPostgresClient]. Mirrors the `bundles` and
+/// `bundle_patches` tables (snake_case row maps).
+class Store {
+  Store({List<Bundle>? seed}) {
+    if (seed != null) {
+      for (final b in seed) {
+        bundleRows.add(bundleToRowValues(b));
+        bundlePatchRows.addAll(bundleToPatchRows(b));
+      }
+    }
+  }
+
+  final List<Map<String, dynamic>> bundleRows = [];
+  final List<Map<String, dynamic>> bundlePatchRows = [];
+
+  Map<String, dynamic>? bundleRowById(String id) => bundleRows
+      .where((row) => row['id'] == id)
+      .cast<Map<String, dynamic>?>()
+      .firstOrNull;
+}
+
+/// Mock [PostgresClientLike] that emulates the queries the plugin issues
+/// against an in-memory [Store]. Faithful enough to exercise the plugin's
+/// SQL building, row mapping, transactions, and RPC calls without a live DB.
+class MockPostgresClient implements PostgresClientLike {
+  MockPostgresClient(this.store);
+
+  final Store store;
+  final List<String> executedSqls = [];
+  final List<Map<String, dynamic>> executedParams = [];
+
+  @override
+  Future<List<Map<String, dynamic>>> execute(
+    String sql,
+    Map<String, dynamic> parameters,
+  ) async {
+    executedSqls.add(sql);
+    executedParams.add(parameters);
+    return _handle(sql, parameters);
+  }
+
+  @override
+  Future<T> runTx<T>(Future<T> Function(PostgresClientLike tx) fn) async {
+    return fn(_TxClient(this));
+  }
+
+  @override
+  Future<void> close() async {}
+
+  List<Map<String, dynamic>> _handle(
+    String sql,
+    Map<String, dynamic> params,
+  ) {
+    if (sql.contains('get_target_app_version_list')) {
+      return _targetAppVersionList(params);
+    }
+    if (sql.contains('get_update_info_by_app_version')) {
+      return _updateInfoByAppVersion(params);
+    }
+    if (sql.contains('get_update_info_by_fingerprint_hash')) {
+      return _updateInfoByFingerprint(params);
+    }
+    if (sql.contains('GROUP BY channel')) return _channels();
+    if (sql.contains('COUNT(*)')) return _count(sql, params);
+    if (sql.contains('FROM bundle_patches') && sql.contains('ANY')) {
+      return _patchesForIds(params);
+    }
+    if (sql.contains('INSERT INTO bundle_patches')) {
+      _upsertPatch(params);
+      return [];
+    }
+    if (sql.contains('INSERT INTO bundles')) {
+      _upsertBundle(params);
+      return [];
+    }
+    if (sql.contains('DELETE FROM bundle_patches')) {
+      _deletePatches(sql, params);
+      return [];
+    }
+    if (sql.contains('DELETE FROM bundles')) {
+      return _deleteBundle(sql, params);
+    }
+    if (sql.contains('SELECT * FROM bundles')) {
+      return _selectBundles(sql, params);
+    }
+    return [];
+  }
+
+  dynamic _paramAfter(String sql, String token, Map<String, dynamic> params) {
+    final idx = sql.indexOf(token);
+    if (idx < 0) return null;
+    final rest = sql.substring(idx + token.length).trim();
+    final match = RegExp(r'@(\w+)').firstMatch(rest);
+    if (match == null) return null;
+    final name = match.group(1)!;
+    return params['@$name'] ?? params[name];
+  }
+
+  List<Map<String, dynamic>> _filterBundles(
+    String sql,
+    Map<String, dynamic> params,
+  ) {
+    return store.bundleRows.where((row) {
+      final channel = _paramAfter(sql, 'channel =', params);
+      if (channel != null && row['channel'] != channel) return false;
+      final platform = _paramAfter(sql, 'platform =', params);
+      if (platform != null && row['platform'] != platform) return false;
+      final enabled = _paramAfter(sql, 'enabled =', params);
+      if (enabled != null && row['enabled'] != enabled) return false;
+      final target = _paramAfter(sql, 'target_app_version =', params);
+      if (target != null && row['target_app_version'] != target) return false;
+      final idEq = _paramAfter(sql, 'id =', params);
+      if (idEq != null && row['id'] != idEq) return false;
+      return true;
+    }).toList();
+  }
+
+  List<Map<String, dynamic>> _selectBundles(
+    String sql,
+    Map<String, dynamic> params,
+  ) {
+    var rows = _filterBundles(sql, params);
+
+    if (sql.contains('ORDER BY id asc')) {
+      rows = rows.toList()..sort((a, b) => (a['id'] as String).compareTo(b['id'] as String));
+    } else {
+      rows = rows.toList()
+        ..sort((a, b) => (b['id'] as String).compareTo(a['id'] as String));
+    }
+
+    final limit = params['@limit'] as int?;
+    final offset = params['@offset'] as int? ?? 0;
+    if (limit != null && limit > 0) {
+      final end = (offset + limit).clamp(0, rows.length);
+      rows = rows.sublist(offset.clamp(0, rows.length), end);
+    } else if (offset > 0) {
+      rows = rows.sublist(offset.clamp(0, rows.length));
+    }
+    return rows;
+  }
+
+  List<Map<String, dynamic>> _count(String sql, Map<String, dynamic> params) {
+    return [
+      {'total': _filterBundles(sql, params).length},
+    ];
+  }
+
+  List<Map<String, dynamic>> _channels() {
+    final channels = store.bundleRows.map((r) => r['channel'] as String).toSet().toList();
+    return channels.map((c) => {'channel': c}).toList();
+  }
+
+  List<Map<String, dynamic>> _patchesForIds(Map<String, dynamic> params) {
+    final ids = (params['bundle_ids'] as List).cast<String>();
+    return store.bundlePatchRows.where((p) => ids.contains(p['bundle_id'])).toList();
+  }
+
+  void _upsertBundle(Map<String, dynamic> params) {
+    final row = <String, dynamic>{};
+    params.forEach((k, v) => row[k] = v);
+    final existing = store.bundleRows.indexWhere((r) => r['id'] == row['id']);
+    if (existing >= 0) {
+      store.bundleRows[existing] = row;
+    } else {
+      store.bundleRows.add(row);
+    }
+  }
+
+  void _upsertPatch(Map<String, dynamic> params) {
+    final row = <String, dynamic>{};
+    params.forEach((k, v) => row[k] = v);
+    final existing = store.bundlePatchRows.indexWhere((r) => r['id'] == row['id']);
+    if (existing >= 0) {
+      store.bundlePatchRows[existing] = row;
+    } else {
+      store.bundlePatchRows.add(row);
+    }
+  }
+
+  void _deletePatches(String sql, Map<String, dynamic> params) {
+    final id = params['@p0'] ?? params['p0'];
+    if (sql.contains('base_bundle_id')) {
+      store.bundlePatchRows.removeWhere((p) => p['base_bundle_id'] == id);
+    } else {
+      store.bundlePatchRows.removeWhere((p) => p['bundle_id'] == id);
+    }
+  }
+
+  List<Map<String, dynamic>> _deleteBundle(
+    String sql,
+    Map<String, dynamic> params,
+  ) {
+    final id = params['@p0'] ?? params['p0'];
+    final existed = store.bundleRows.any((r) => r['id'] == id);
+    store.bundleRows.removeWhere((r) => r['id'] == id);
+    store.bundlePatchRows.removeWhere((p) => p['bundle_id'] == id);
+    return existed ? [{'id': id}] : [];
+  }
+
+  List<Map<String, dynamic>> _targetAppVersionList(Map<String, dynamic> params) {
+    final platform = params['app_platform'];
+    final min = params['min_bundle_id'] as String? ?? '';
+    final versions = store.bundleRows
+        .where((r) => r['platform'] == platform && (r['id'] as String).compareTo(min) >= 0)
+        .map((r) => r['target_app_version'])
+        .where((v) => v != null)
+        .toSet()
+        .cast<String>()
+        .toList();
+    return versions.map((v) => {'target_app_version': v}).toList();
+  }
+
+  Map<String, dynamic>? _newestMatch(
+    bool Function(Map<String, dynamic> row) predicate,
+  ) {
+    final matches = store.bundleRows.where(predicate).toList()
+      ..sort((a, b) => (b['id'] as String).compareTo(a['id'] as String));
+    return matches.isEmpty ? null : matches.first;
+  }
+
+  List<Map<String, dynamic>> _updateInfoByAppVersion(Map<String, dynamic> params) {
+    final platform = params['app_platform'];
+    final channel = params['target_channel'];
+    final min = params['min_bundle_id'] as String? ?? '';
+    final list = (params['target_app_version_list'] as List?)?.cast<String>() ?? [];
+    final row = _newestMatch((r) =>
+        r['platform'] == platform &&
+        r['enabled'] == true &&
+        r['channel'] == channel &&
+        (r['id'] as String).compareTo(min) >= 0 &&
+        list.contains(r['target_app_version']));
+    if (row == null) return [];
+    return [_infoRow(row)];
+  }
+
+  List<Map<String, dynamic>> _updateInfoByFingerprint(Map<String, dynamic> params) {
+    final platform = params['app_platform'];
+    final channel = params['target_channel'];
+    final min = params['min_bundle_id'] as String? ?? '';
+    final fp = params['target_fingerprint_hash'];
+    final row = _newestMatch((r) =>
+        r['platform'] == platform &&
+        r['enabled'] == true &&
+        r['channel'] == channel &&
+        (r['id'] as String).compareTo(min) >= 0 &&
+        r['fingerprint_hash'] == fp);
+    if (row == null) return [];
+    return [_infoRow(row)];
+  }
+
+  Map<String, dynamic> _infoRow(Map<String, dynamic> row) => {
+        'id': row['id'],
+        'should_force_update': row['should_force_update'],
+        'message': row['message'],
+        'status': 'UPDATE',
+        'storage_uri': row['storage_uri'],
+        'file_hash': row['file_hash'],
+      };
+}
+
+class _TxClient implements PostgresClientLike {
+  _TxClient(this._parent);
+
+  final MockPostgresClient _parent;
+
+  @override
+  Future<List<Map<String, dynamic>>> execute(
+    String sql,
+    Map<String, dynamic> parameters,
+  ) =>
+      _parent.execute(sql, parameters);
+
+  @override
+  Future<T> runTx<T>(Future<T> Function(PostgresClientLike tx) fn) =>
+      throw UnsupportedError('Nested transactions are not supported');
+
+  @override
+  Future<void> close() async {}
+}
+
+/// Build a [PostgresConfig] wired to [MockPostgresClient].
+PostgresConfig mockPostgresConfig(Store store) => PostgresConfig(
+      host: 'mock',
+      database: 'mock',
+      clientFactory: (_) => MockPostgresClient(store),
+    );
+
+/// Create a [DatabasePlugin] backed by the mock store.
+DatabasePlugin newPlugin({Store? store}) {
+  final s = store ?? Store();
+  final plugin = postgresDatabase(mockPostgresConfig(s))();
+  return plugin;
+}

package/dart-src/plugins/postgres/test/postgres_bundle_mapper_test.dart

@@ -0,0 +1,140 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart'
+    show Bundle, BundleMetadata, BundlePatchArtifact, Platform;
+import 'package:flutter_patcher_postgres/flutter_patcher_postgres.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('postgres bundle mapper', () {
+    test('bundleToRowValues emits snake_case columns', () {
+      final bundle = Bundle(
+        id: '018f0000-0000-7000-8000-000000000001',
+        platform: Platform.android,
+        shouldForceUpdate: true,
+        enabled: true,
+        fileHash: 'hash-1',
+        gitCommitHash: 'abc',
+        message: 'hello',
+        channel: 'production',
+        storageUri: 'file:///b1',
+        targetAppVersion: '1.2.3',
+        fingerprintHash: null,
+        metadata: const BundleMetadata(appVersion: '1.2.3'),
+        manifestStorageUri: 'file:///m1',
+        manifestFileHash: 'mh1',
+        assetBaseStorageUri: 'file:///a1',
+        patches: const [
+          BundlePatchArtifact(
+            baseBundleId: '018f0000-0000-7000-8000-000000000000',
+            baseFileHash: 'base-hash',
+            patchFileHash: 'patch-hash',
+            patchStorageUri: 'file:///p1',
+          ),
+        ],
+        patchBaseBundleId: '018f0000-0000-7000-8000-000000000000',
+        patchBaseFileHash: 'base-hash',
+        patchFileHash: 'patch-hash',
+        patchStorageUri: 'file:///p1',
+        rolloutCohortCount: 1000,
+        targetCohorts: const ['team-a'],
+      );
+
+      final row = bundleToRowValues(bundle);
+      expect(row['id'], bundle.id);
+      expect(row['should_force_update'], true);
+      expect(row['file_hash'], 'hash-1');
+      expect(row['target_app_version'], '1.2.3');
+      expect(row['platform'], 'android');
+      expect(row['manifest_storage_uri'], 'file:///m1');
+      expect(row['rollout_cohort_count'], 1000);
+      expect(row['target_cohorts'], const ['team-a']);
+      expect(row['metadata'], isA<Map>());
+    });
+
+    test('mapRowToBundle rebuilds derived patch fields', () {
+      final bundle = Bundle(
+        id: '018f0000-0000-7000-8000-000000000001',
+        platform: Platform.android,
+        shouldForceUpdate: false,
+        enabled: true,
+        fileHash: 'hash-1',
+        channel: 'production',
+        storageUri: 'file:///b1',
+        targetAppVersion: '1.2.3',
+        message: null,
+        fingerprintHash: null,
+        metadata: const BundleMetadata(appVersion: '1.2.3'),
+        manifestStorageUri: null,
+        manifestFileHash: null,
+        assetBaseStorageUri: null,
+        patches: const [
+          BundlePatchArtifact(
+            baseBundleId: '018f0000-0000-7000-8000-000000000000',
+            baseFileHash: 'base-hash',
+            patchFileHash: 'patch-hash',
+            patchStorageUri: 'file:///p1',
+          ),
+        ],
+        patchBaseBundleId: null,
+        patchBaseFileHash: null,
+        patchFileHash: null,
+        patchStorageUri: null,
+        rolloutCohortCount: 1000,
+        targetCohorts: null,
+      );
+
+      final row = bundleToRowValues(bundle);
+      final patchRows = bundleToPatchRows(bundle);
+      final back = mapRowToBundle(
+        PostgresBundleRow.fromJson(row),
+        [PostgresBundlePatchRow.fromJson(patchRows.first)],
+      );
+
+      expect(back.id, bundle.id);
+      expect(back.fileHash, 'hash-1');
+      expect(back.patches, hasLength(1));
+      expect(back.patches!.first.patchFileHash, 'patch-hash');
+      expect(back.patchStorageUri, 'file:///p1');
+      expect(back.rolloutCohortCount, 1000);
+      expect(back.metadata?.appVersion, '1.2.3');
+    });
+
+    test('bundleToPatchRows builds compound ids', () {
+      final bundle = Bundle(
+        id: 'bid',
+        platform: Platform.android,
+        shouldForceUpdate: false,
+        enabled: true,
+        fileHash: 'h',
+        channel: 'production',
+        storageUri: 's',
+        message: null,
+        fingerprintHash: null,
+        metadata: null,
+        manifestStorageUri: null,
+        manifestFileHash: null,
+        assetBaseStorageUri: null,
+        patches: const [
+          BundlePatchArtifact(
+            baseBundleId: 'base',
+            baseFileHash: 'bh',
+            patchFileHash: 'ph',
+            patchStorageUri: 'ps',
+          ),
+        ],
+        patchBaseBundleId: null,
+        patchBaseFileHash: null,
+        patchFileHash: null,
+        patchStorageUri: null,
+        rolloutCohortCount: 1000,
+        targetCohorts: null,
+      );
+
+      final rows = bundleToPatchRows(bundle);
+      expect(rows, hasLength(1));
+      expect(rows.first['id'], 'bid:base');
+      expect(rows.first['bundle_id'], 'bid');
+      expect(rows.first['base_bundle_id'], 'base');
+      expect(rows.first['order_index'], 0);
+    });
+  });
+}

package/dart-src/plugins/postgres/test/postgres_database_test.dart

@@ -0,0 +1,181 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart'
+    show
+        AppVersionGetBundlesArgs,
+        Bundle,
+        FingerprintGetBundlesArgs,
+        Platform,
+        UpdateInfo,
+        UpdateStatus,
+        nilUuid;
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show
+        DatabaseBundleQueryOptions,
+        DatabaseBundleQueryWhere,
+        Paginated;
+import 'package:test/test.dart';
+
+import 'mock_postgres_client.dart';
+
+Bundle _bundle(String id,
+        {String channel = 'production',
+        String? fingerprintHash}) =>
+    Bundle(
+      id: id,
+      platform: Platform.android,
+      shouldForceUpdate: false,
+      enabled: true,
+      fileHash: 'file-hash-$id',
+      channel: channel,
+      storageUri: 'file:///bundle-$id',
+      targetAppVersion: '1.0.0',
+      message: null,
+      fingerprintHash: fingerprintHash,
+      metadata: null,
+      manifestStorageUri: null,
+      manifestFileHash: null,
+      assetBaseStorageUri: null,
+      patches: const [],
+      patchBaseBundleId: null,
+      patchBaseFileHash: null,
+      patchFileHash: null,
+      patchStorageUri: null,
+      rolloutCohortCount: 1000,
+      targetCohorts: null,
+    );
+
+void main() {
+  group('postgresDatabase', () {
+    test('getChannels returns distinct channels', () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(_bundle('018f0000-0000-7000-8000-000000000001'));
+      await plugin.appendBundle(_bundle('018f0000-0000-7000-8000-000000000002',
+          channel: 'staging'));
+      await plugin.commitBundle();
+
+      final channels = await plugin.getChannels();
+      expect(channels, containsAll(['production', 'staging']));
+      expect(channels.length, 2);
+    });
+
+    test('getBundles returns bundles and pagination', () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(_bundle('018f0000-0000-7000-8000-000000000001'));
+      await plugin.appendBundle(_bundle('018f0000-0000-7000-8000-000000000002'));
+      await plugin.commitBundle();
+
+      final result = await plugin.getBundles(
+        const DatabaseBundleQueryOptions(limit: 10),
+      );
+      expect(result, isA<Paginated<List<Bundle>>>());
+      expect(result.data, hasLength(2));
+      expect(result.pagination.total, 2);
+    });
+
+    test('getBundles filters by channel', () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(_bundle('018f0000-0000-7000-8000-000000000001'));
+      await plugin.appendBundle(_bundle('018f0000-0000-7000-8000-000000000002',
+          channel: 'staging'));
+      await plugin.commitBundle();
+
+      final result = await plugin.getBundles(
+        DatabaseBundleQueryOptions(
+          where: const DatabaseBundleQueryWhere(channel: 'staging'),
+          limit: 10,
+        ),
+      );
+      expect(result.data, hasLength(1));
+      expect(result.data.first.channel, 'staging');
+    });
+
+    test('getBundleById returns null for missing, bundle for existing',
+        () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(_bundle('018f0000-0000-7000-8000-000000000001'));
+      await plugin.commitBundle();
+
+      expect(await plugin.getBundleById('does-not-exist'), isNull);
+      final got = await plugin.getBundleById('018f0000-0000-7000-8000-000000000001');
+      expect(got, isNotNull);
+      expect(got!.id, '018f0000-0000-7000-8000-000000000001');
+    });
+
+    test('commitBundle append -> update -> delete reflects in store', () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(_bundle('018f0000-0000-7000-8000-000000000001'));
+      await plugin.commitBundle();
+
+      var got = await plugin.getBundleById('018f0000-0000-7000-8000-000000000001');
+      expect(got!.enabled, true);
+
+      await plugin.updateBundle(got.id, {'enabled': false});
+      await plugin.commitBundle();
+      got = await plugin.getBundleById('018f0000-0000-7000-8000-000000000001');
+      expect(got!.enabled, false);
+
+      await plugin.deleteBundle(got);
+      await plugin.commitBundle();
+      expect(
+        await plugin.getBundleById('018f0000-0000-7000-8000-000000000001'),
+        isNull,
+      );
+    });
+
+    test('getUpdateInfo via RPC returns UpdateInfo for compatible bundle',
+        () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(_bundle('018f0000-0000-7000-8000-000000000001'));
+      await plugin.commitBundle();
+
+      final info = await plugin.getUpdateInfo(
+        AppVersionGetBundlesArgs(
+          appVersion: '1.0.0',
+          bundleId: nilUuid,
+          channel: 'production',
+          minBundleId: nilUuid,
+          platform: Platform.android,
+        ),
+      );
+      expect(info, isA<UpdateInfo>());
+      expect(info!.status, UpdateStatus.update);
+      expect(info.storageUri, 'file:///bundle-018f0000-0000-7000-8000-000000000001');
+    });
+
+    test('getUpdateInfo via fingerprint returns matching bundle', () async {
+      final plugin = newPlugin();
+      final fpBundle = _bundle('018f0000-0000-7000-8000-000000000001',
+          fingerprintHash: 'fp-abc');
+      await plugin.appendBundle(fpBundle);
+      await plugin.commitBundle();
+
+      final info = await plugin.getUpdateInfo(
+        FingerprintGetBundlesArgs(
+          fingerprintHash: 'fp-abc',
+          bundleId: nilUuid,
+          channel: 'production',
+          minBundleId: nilUuid,
+          platform: Platform.android,
+        ),
+      );
+      expect(info, isA<UpdateInfo>());
+      expect(info!.fileHash, 'file-hash-018f0000-0000-7000-8000-000000000001');
+    });
+
+    test('getUpdateInfo returns null when no compatible bundle', () async {
+      final plugin = newPlugin();
+      await plugin.appendBundle(_bundle('018f0000-0000-7000-8000-000000000001'));
+      await plugin.commitBundle();
+
+      final info = await plugin.getUpdateInfo(
+        AppVersionGetBundlesArgs(
+          appVersion: '9.9.9',
+          bundleId: nilUuid,
+          channel: 'production',
+          minBundleId: nilUuid,
+          platform: Platform.android,
+        ),
+      );
+      expect(info, isNull);
+    });
+  });
+}