@_nazmiforreal/flutter-ota 0.1.2 → 0.1.3

package/dart-src/packages/cli-tools/test/backends_test.dart

@@ -0,0 +1,207 @@
+import 'dart:io';
+
+import 'package:flutter_patcher_aws/flutter_patcher_aws.dart';
+import 'package:flutter_patcher_cli/flutter_patcher_cli.dart';
+import 'package:flutter_patcher_cloudflare/flutter_patcher_cloudflare.dart';
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart';
+import 'package:test/test.dart';
+
+import 'mocks/mock_aws_s3_client.dart' as aws;
+import 'mocks/mock_d1_client.dart' as d1;
+import 'mocks/mock_postgres_client.dart' as pg;
+
+// --- R2 (cloudflare storage) mock ------------------------------------------
+
+class MockR2Client implements R2S3ClientLike {
+  MockR2Client(this.store);
+  final aws.Store store;
+
+  @override
+  Future<void> deleteObject(String key) async => store.objects.remove(key);
+  @override
+  Future<void> deleteObjects(List<String> keys) async =>
+      keys.forEach(store.objects.remove);
+  @override
+  Future<bool> headObject(String key) async => store.objects.containsKey(key);
+  @override
+  Future<List<int>> getObjectAsBytes(String key) async =>
+      store.objects[key] ?? (throw Exception('NoSuchKey: $key'));
+  @override
+  Future<String> getObjectAsString(String key) async =>
+      String.fromCharCodes(await getObjectAsBytes(key));
+  @override
+  Future<String> getSignedUrl(String key, {int expiresIn = 3600}) async =>
+      'https://r2.mock/$key?sig=mock&expires=$expiresIn';
+  @override
+  Future<List<StorageObject>> listObjects([String? prefix]) async {
+    final p = prefix ?? '';
+    return store.objects.keys
+        .where((k) => k.startsWith(p))
+        .map((k) => StorageObject(
+              key: k,
+              storageUri: 'r2://$k',
+              size: store.objects[k]!.length,
+            ))
+        .toList();
+  }
+
+  @override
+  Future<void> putObject(String key, List<int> body, String contentType) async =>
+      store.objects[key] = body;
+}
+
+// --- CloudFront (aws db invalidation) mock ----------------------------------
+
+class MockCloudFrontClient implements AwsCloudFrontClientLike {
+  @override
+  Future<void> createInvalidation(
+    String distributionId,
+    List<String> paths, {
+    bool shouldWait = false,
+  }) async {
+    // No-op for tests.
+  }
+}
+
+// --- helpers ----------------------------------------------------------------
+
+Directory makeSource() {
+  final dir = Directory.systemTemp.createTempSync('fp-src-');
+  File('${dir.path}/app.so').writeAsStringSync('fake-libapp-bytes');
+  return dir;
+}
+
+FlutterPatcherConfig cfgFor(String provider) => FlutterPatcherConfig(
+      provider: provider,
+      supabase: const SupabaseConfigJson(url: 'https://x.supabase.co'),
+      postgres: const PostgresConfigJson(host: 'mock', database: 'mock'),
+      cloudflare: const CloudflareConfigJson(
+        accountId: 'acct',
+        d1DatabaseId: 'dbid',
+        apiToken: 'token',
+        r2Bucket: 'bundles',
+        r2AccessKeyId: 'rk',
+        r2SecretAccessKey: 'rs',
+      ),
+      aws: const AwsConfigJson(
+        bucket: 'b',
+        region: 'us-east-1',
+        accessKeyId: 'k',
+        secretAccessKey: 's',
+      ),
+      channel: 'production',
+      platform: 'android',
+      source: './dist',
+    );
+
+Future<void> runBackendLifecycle(String name, Backend backend) async {
+  final source = makeSource();
+  try {
+    final bundle = await deployBundle(
+      backend,
+      DeployOptions(
+        source: source.path,
+        channel: 'production',
+        platform: 'android',
+        message: 'first',
+        targetAppVersion: '>=1.0.0',
+      ),
+    );
+    expect(bundle.id, isNotEmpty, reason: '$name: deployed id');
+    expect(bundle.storageUri, isNotEmpty, reason: '$name: storageUri set');
+
+    // The artifact bytes were actually uploaded to storage.
+    expect(await backend.storage.exists(bundle.storageUri), isTrue,
+        reason: '$name: storage has bundle');
+
+    // Node profile can download the bytes back.
+    final dl = File('${Directory.systemTemp.path}/fp-dl-${bundle.id}.zip');
+    await backend.storage.downloadFile(bundle.storageUri, dl.path);
+    expect(dl.existsSync() && await dl.length() > 0, isTrue,
+        reason: '$name: download succeeds');
+    await dl.delete();
+
+    // listBundles round-trips.
+    final listed = await listBundles(backend, const ListOptions());
+    final found = listed.data.where((b) => b.id == bundle.id).toList();
+    expect(found, hasLength(1), reason: '$name: bundle listed');
+
+    // getChannel resolves the live (enabled) bundle.
+    final live = await getChannel(backend, 'production');
+    expect(live?.id, bundle.id, reason: '$name: channel live');
+
+    // promote a second bundle, then rollback disables the latest.
+    final second = await deployBundle(
+      backend,
+      DeployOptions(
+        source: source.path,
+        channel: 'production',
+        platform: 'android',
+        message: 'second',
+        targetAppVersion: '>=1.0.0',
+      ),
+    );
+    await promoteBundle(backend, second.id, 'production');
+    final disabled = await rollbackChannel(backend, 'production');
+    expect(disabled, second.id, reason: '$name: rollback disabled latest');
+
+    // delete removes the bundle.
+    await deleteBundle(backend, bundle.id);
+    final afterDelete = await listBundles(
+      backend,
+      ListOptions(channel: 'production'),
+    );
+    expect(
+      afterDelete.data.where((b) => b.id == bundle.id).isEmpty,
+      isTrue,
+      reason: '$name: bundle deleted',
+    );
+  } finally {
+    source.deleteSync(recursive: true);
+  }
+}
+
+// --- tests ------------------------------------------------------------------
+
+void main() {
+  group('cli backends', () {
+    test('postgres backend (postgresDatabase + postgresStorage)', () async {
+      final store = pg.Store();
+      final backend = resolveBackend(
+        cfgFor('postgres'),
+        postgresClientFactory: (_) => pg.MockPostgresClient(store),
+      );
+      await runBackendLifecycle('postgres', backend);
+    });
+
+    test('cloudflare backend (d1Database + r2Storage)', () async {
+      final dbStore = d1.Store();
+      final r2Store = aws.Store();
+      final backend = resolveBackend(
+        cfgFor('cloudflare'),
+        d1ClientFactory: (_) => d1.MockD1Client(dbStore),
+        r2ClientFactory: (_) => MockR2Client(r2Store),
+      );
+      await runBackendLifecycle('cloudflare', backend);
+    });
+
+    test('aws backend (s3Database + s3Storage)', () async {
+      final dbStore = aws.Store();
+      final storageStore = aws.Store();
+      final backend = resolveBackend(
+        cfgFor('aws'),
+        awsS3ClientFactory: (_) => aws.MockAwsS3Client(dbStore),
+        awsCloudFrontClientFactory: (_) => MockCloudFrontClient(),
+        awsStorageClientFactory: (_) => aws.MockAwsS3Client(storageStore),
+      );
+      await runBackendLifecycle('aws', backend);
+    });
+
+    test('resolveBackend rejects unknown provider', () {
+      expect(
+        () => resolveBackend(cfgFor('bogus')),
+        throwsA(isA<UnsupportedError>()),
+      );
+    });
+  });
+}

package/dart-src/packages/cli-tools/test/build_pack_test.dart

@@ -0,0 +1,101 @@
+import 'dart:convert';
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:archive/archive.dart';
+import 'package:crypto/crypto.dart';
+import 'package:flutter_patcher_cli/flutter_patcher_cli.dart';
+import 'package:test/test.dart';
+
+// Builds an in-memory APK containing libapp.so for every supported ABI, then
+// verifies `packPatch` emits a single device-ready patch.zip that includes all
+// ABIs (so one bundle installs on any device).
+Future<Uint8List> _buildFakeApk() async {
+  final apk = Archive();
+  for (final abi in const ['arm64-v8a', 'armeabi-v7a', 'x86_64']) {
+    final content = utf8.encode('LIBAPP_$abi');
+    apk.addFile(ArchiveFile('lib/$abi/libapp.so', content.length, content));
+  }
+  final bytes = ZipEncoder().encode(apk);
+  return Uint8List.fromList(bytes);
+}
+
+void main() {
+  test('packPatch includes every ABI found in the APK', () async {
+    final apkBytes = await _buildFakeApk();
+    final dir = Directory.systemTemp.createTempSync('fp-pack-');
+    final apkFile = File('${dir.path}/app.apk')..writeAsBytesSync(apkBytes);
+    final outDir = '${dir.path}/dist';
+    try {
+      final result = await packPatch(
+        apkPath: apkFile.path,
+        version: '1.2.3',
+        targetVersionCode: 7,
+        out: outDir,
+      );
+
+      expect(result.abis, hasLength(3));
+      expect(result.abis, containsAll(['arm64-v8a', 'armeabi-v7a', 'x86_64']));
+
+      final patchBytes = File(result.payloadPath).readAsBytesSync();
+      final patch = ZipDecoder().decodeBytes(patchBytes);
+
+      final names = patch.files.map((f) => f.name).toList();
+      expect(names, contains('manifest.json'));
+      expect(names, contains('lib/arm64-v8a/libapp.so'));
+      expect(names, contains('lib/armeabi-v7a/libapp.so'));
+      expect(names, contains('lib/x86_64/libapp.so'));
+
+      final manifestFile =
+          patch.files.firstWhere((f) => f.name == 'manifest.json');
+      final manifest = Map<String, dynamic>.from(
+        jsonDecode(utf8.decode(manifestFile.content as List<int>))
+            as Map,
+      );
+      expect(manifest['schemaVersion'], 2);
+      expect(manifest['version'], '1.2.3');
+      expect(manifest['targetVersionCode'], 7);
+
+      final lib = Map<String, dynamic>.from(manifest['lib'] as Map);
+      expect(lib.keys, hasLength(3));
+      for (final abi in ['arm64-v8a', 'armeabi-v7a', 'x86_64']) {
+        final entry = Map<String, dynamic>.from(lib[abi] as Map);
+        expect(entry['path'], 'lib/$abi/libapp.so');
+        final expectedMd5 = md5.convert(utf8.encode('LIBAPP_$abi')).toString();
+        expect(entry['md5'], expectedMd5);
+      }
+
+      // outer manifest records all abis too
+      final outer = Map<String, dynamic>.from(
+        jsonDecode(File(result.manifestPath).readAsStringSync()) as Map,
+      );
+      expect(outer['payload'], 'patch.zip');
+      expect(
+        (outer['abis'] as List).cast<String>(),
+        containsAll(['arm64-v8a', 'armeabi-v7a', 'x86_64']),
+      );
+    } finally {
+      dir.deleteSync(recursive: true);
+    }
+  });
+
+  test('packPatch throws PackException when libapp.so is missing', () async {
+    final apk = Archive()..addFile(ArchiveFile('classes.dex', 0, <int>[]));
+    final dir = Directory.systemTemp.createTempSync('fp-pack-bad-');
+    final apkFile = File('${dir.path}/bad.apk')
+      ..writeAsBytesSync(Uint8List.fromList(ZipEncoder().encode(apk)));
+    try {
+      expect(
+        () => packPatch(
+          apkPath: apkFile.path,
+          version: '1.0.0',
+          targetVersionCode: 1,
+          out: '${dir.path}/dist',
+        ),
+        throwsA(isA<PackException>()),
+      );
+    } finally {
+      dir.deleteSync(recursive: true);
+    }
+  });
+}