@_nazmiforreal/flutter-ota 0.1.2 → 0.1.4

package/dart-src/plugins/cloudflare/test/mock_r2_client.dart

@@ -0,0 +1,83 @@
+import 'dart:convert' show utf8;
+
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show StorageObject;
+
+import 'package:flutter_patcher_cloudflare/flutter_patcher_cloudflare.dart'
+    show R2S3StorageConfig, R2S3ClientLike;
+
+/// In-memory store backing [MockR2Client].
+class Store {
+  final Map<String, List<int>> objects = {};
+}
+
+/// Mock R2 S3 client that stores objects in memory.
+class MockR2Client implements R2S3ClientLike {
+  MockR2Client(this.store, {this.bucketName = 'bucket'});
+
+  final Store store;
+  final String bucketName;
+
+  @override
+  Future<void> deleteObject(String key) async => store.objects.remove(key);
+
+  @override
+  Future<void> deleteObjects(List<String> keys) async {
+    for (final key in keys) {
+      store.objects.remove(key);
+    }
+  }
+
+  @override
+  Future<bool> headObject(String key) async =>
+      store.objects.containsKey(key);
+
+  @override
+  Future<List<int>> getObjectAsBytes(String key) async {
+    final bytes = store.objects[key];
+    if (bytes == null) throw Exception('NoSuchKey: $key');
+    return bytes;
+  }
+
+  @override
+  Future<String> getObjectAsString(String key) async =>
+      utf8.decode(await getObjectAsBytes(key));
+
+  @override
+  Future<String> getSignedUrl(String key, {int expiresIn = 3600}) async =>
+      'https://$bucketName.r2.cloudflarestorage.com/$bucketName/$key'
+      '?X-Amz-Signature=mock&X-Amz-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://$bucketName/$k',
+            size: store.objects[k]!.length,
+          ),
+        )
+        .toList();
+  }
+
+  @override
+  Future<void> putObject(
+    String key,
+    List<int> body,
+    String contentType,
+  ) async {
+    store.objects[key] = body;
+  }
+}
+
+/// Build an [R2S3StorageConfig] wired to an in-memory [Store].
+R2S3StorageConfig mockR2Config(Store store) => R2S3StorageConfig(
+      accountId: 'test-account',
+      bucketName: 'test-bucket',
+      accessKeyId: 'test-access-key',
+      secretAccessKey: 'test-secret',
+      clientFactory: (_) => MockR2Client(store),
+    );

package/dart-src/plugins/cloudflare/test/r2_storage_test.dart

@@ -0,0 +1,77 @@
+import 'dart:io' show Directory, File;
+
+import 'package:flutter_patcher_cloudflare/flutter_patcher_cloudflare.dart'
+    show r2Storage;
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show StoragePlugin;
+import 'package:path/path.dart' show basename;
+import 'package:test/test.dart';
+
+import 'mock_r2_client.dart' show Store, mockR2Config;
+
+void main() {
+  group('cloudflare r2Storage', () {
+    late Store store;
+    late StoragePlugin plugin;
+    late String tmpFile;
+    late String outFile;
+
+    setUp(() {
+      store = Store();
+      plugin = r2Storage(mockR2Config(store));
+      final dir = Directory.systemTemp.createTempSync('fp_r2_').path;
+      tmpFile = '$dir/bundle.zip';
+      File(tmpFile).writeAsBytesSync([1, 2, 3, 4]);
+      outFile = '$dir/out.zip';
+    });
+
+    test('plugin metadata', () {
+      expect(plugin.name, 'r2Storage');
+      expect(plugin.supportedProtocol, 'r2');
+      expect(plugin.profiles.hasNode, isTrue);
+      expect(plugin.profiles.hasRuntime, isTrue);
+    });
+
+    test('node upload + exists + downloadFile + delete', () async {
+      final node = plugin.profiles.node!;
+      final res = await node.upload('v1', tmpFile);
+      expect(
+        res['storageUri'],
+        'r2://test-bucket/v1/${basename(tmpFile)}',
+      );
+      expect(await node.exists(res['storageUri']!), isTrue);
+
+      await node.downloadFile(res['storageUri']!, outFile);
+      expect(File(outFile).readAsBytesSync(), [1, 2, 3, 4]);
+
+      await node.delete(res['storageUri']!);
+      expect(await node.exists(res['storageUri']!), isFalse);
+    });
+
+    test('runtime getDownloadUrl + readText (and missing → null)', () async {
+      final node = plugin.profiles.node!;
+      final runtime = plugin.profiles.runtime!;
+
+      final manifest = '${Directory.systemTemp.path}/fp_manifest.json';
+      File(manifest).writeAsStringSync('{"hello":1}');
+      final uploaded = await node.upload('manifests', manifest);
+
+      final url = await runtime.getDownloadUrl(uploaded['storageUri']!);
+      expect(url['fileUrl'], contains('manifests/'));
+
+      final text = await runtime.readText(uploaded['storageUri']!);
+      expect(text, '{"hello":1}');
+
+      expect(await runtime.readText('r2://test-bucket/missing'), isNull);
+    });
+
+    test('listObjects filters by prefix', () async {
+      final node = plugin.profiles.node!;
+      await node.upload('a', tmpFile);
+      await node.upload('b', tmpFile);
+
+      expect(await node.listObjects(), hasLength(2));
+      expect(await node.listObjects('a/'), hasLength(1));
+    });
+  });
+}

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

@@ -0,0 +1,166 @@
+import 'package:flutter_patcher_plugin_core/src/asset_storage_layout.dart';
+import 'package:flutter_patcher_plugin_core/src/bundle_storage_layout.dart';
+import 'package:flutter_patcher_plugin_core/src/legacy_asset_storage_layout.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('assetStorageLayout', () {
+    group('getAssetStorageLayout', () {
+      test('classifies /assets roots as content-addressed storage', () {
+        expect(
+          getAssetStorageLayout('s3://bucket/assets'),
+          'content-addressed',
+        );
+        expect(
+          getAssetStorageLayout('s3://bucket/releases/assets/'),
+          'content-addressed',
+        );
+      });
+
+      test('classifies non-/assets roots as legacy per-bundle file storage',
+          () {
+        expect(
+          getAssetStorageLayout('s3://bucket/releases/bundle-id/files'),
+          'legacy-files',
+        );
+      });
+    });
+
+    group('getManifestAssetStoragePath', () {
+      test('resolves content-addressed manifest assets by file hash', () {
+        expect(
+          getManifestAssetStoragePath(
+            assetBaseStorageUri: 's3://bucket/assets',
+            assetPath: 'index.ios.bundle.br',
+            fileHash: 'abcdef',
+          ),
+          'sha256/ab/abcdef.br',
+        );
+      });
+
+      test('resolves legacy manifest assets by manifest-relative path', () {
+        expect(
+          getManifestAssetStoragePath(
+            assetBaseStorageUri: 's3://bucket/releases/bundle-id/files',
+            assetPath: 'assets/logo.png',
+            fileHash: 'abcdef',
+          ),
+          'assets/logo.png',
+        );
+      });
+    });
+
+    group('createStorageUriWithRelativePath', () {
+      test('creates escaped child storage uris', () {
+        expect(
+          createStorageUriWithRelativePath(
+            baseStorageUri: 's3://bucket/releases/assets/',
+            relativePath: 'assets/icon one.png',
+          ),
+          's3://bucket/releases/assets/assets/icon%20one.png',
+        );
+      });
+    });
+
+    group('resolveManifestAssetStorageUri', () {
+      test('resolves manifest asset storage uris through the layout', () {
+        expect(
+          resolveManifestAssetStorageUri(
+            assetBaseStorageUri: 's3://bucket/assets',
+            assetPath: 'assets/logo.png',
+            fileHash: 'abcdef',
+          ),
+          's3://bucket/assets/sha256/ab/abcdef.png',
+        );
+      });
+    });
+
+    group('isBrotliManifestAssetPath', () {
+      test('matches index.*.bundle paths', () {
+        expect(isBrotliManifestAssetPath('index.ios.bundle'), isTrue);
+        expect(isBrotliManifestAssetPath('nested/index.android.bundle'),
+            isTrue);
+      });
+
+      test('rejects non-index bundle paths', () {
+        expect(isBrotliManifestAssetPath('main.ios.bundle'), isFalse);
+      });
+    });
+
+    group('getManifestAssetDownloadPath', () {
+      test('appends .br to index bundle paths', () {
+        expect(
+          getManifestAssetDownloadPath('index.ios.bundle'),
+          'index.ios.bundle.br',
+        );
+        expect(
+          getManifestAssetDownloadPath('nested/index.android.bundle'),
+          'nested/index.android.bundle.br',
+        );
+      });
+
+      test('passes through non-index bundle paths', () {
+        expect(
+          getManifestAssetDownloadPath('main.ios.bundle'),
+          'main.ios.bundle',
+        );
+      });
+    });
+  });
+
+  group('bundleStorageLayout', () {
+    group('createBundleStorageKey', () {
+      test('stores new bundle artifacts below the bundles namespace', () {
+        expect(createBundleStorageKey('bundle-id'), 'bundles/bundle-id');
+        expect(
+          createBundleStorageKey('bundle-id', ['patches', 'base-id']),
+          'bundles/bundle-id/patches/base-id',
+        );
+      });
+    });
+
+    group('createStorageRootUriWithPath', () {
+      test('derives the shared storage root from bundle URIs', () {
+        expect(
+          createStorageRootUriWithPath(
+            's3://bucket/releases/bundles/bundle-id/manifest.json',
+            'bundle-id',
+            'assets',
+          ),
+          's3://bucket/releases/assets',
+        );
+      });
+
+      test('rejects storage URIs that do not contain the bundle id', () {
+        expect(
+          () => createStorageRootUriWithPath(
+            'https://uploads.example.com/object',
+            'bundle-id',
+            'assets',
+          ),
+          throwsA(isA<StateError>()),
+        );
+      });
+
+      test('preserves encoded storage root segments', () {
+        expect(
+          createStorageRootUriWithPath(
+            's3://bucket/release%20files/bundles/bundle-id/manifest.json',
+            'bundle-id',
+            'assets/sha256',
+          ),
+          's3://bucket/release%20files/assets/sha256',
+        );
+      });
+    });
+  });
+
+  group('legacyAssetStorageLayout', () {
+    test('getLegacyManifestAssetStoragePath returns assetPath unchanged', () {
+      expect(
+        getLegacyManifestAssetStoragePath(assetPath: 'assets/logo.png'),
+        'assets/logo.png',
+      );
+    });
+  });
+}

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

@@ -0,0 +1,74 @@
+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:test/test.dart';
+
+void main() {
+  setUp(() {
+    clearUnitOfWorkStore();
+  });
+
+  group('isUnitOfWorkContext', () {
+    test('returns true for Map<String, Object?>', () {
+      expect(isUnitOfWorkContext(<String, Object?>{}), isTrue);
+    });
+
+    test('returns false for null', () {
+      expect(isUnitOfWorkContext(null), isFalse);
+    });
+
+    test('returns false for non-map', () {
+      expect(isUnitOfWorkContext('string'), isFalse);
+      expect(isUnitOfWorkContext(42), isFalse);
+    });
+
+    test('returns false for wrong map type', () {
+      // Dart generics are covariant, so Map<String, int> IS Map<String, Object?>
+      // Only key-type mismatches fail the check
+      expect(isUnitOfWorkContext(<int, Object?>{}), isFalse);
+      expect(isUnitOfWorkContext(<int, String>{}), isFalse);
+    });
+  });
+
+  group('getRequestBundleUnitOfWork', () {
+    test('returns null for null context', () {
+      expect(getRequestBundleUnitOfWork(null), isNull);
+    });
+
+    test('returns null for invalid context', () {
+      expect(getRequestBundleUnitOfWork('not a map'), isNull);
+    });
+
+    test('creates new UoW for valid context', () {
+      final context = <String, Object?>{};
+      final uow1 = getRequestBundleUnitOfWork(context);
+      expect(uow1, isA<BundleUnitOfWork>());
+    });
+
+    test('returns same UoW for same context (identity)', () {
+      final context = <String, Object?>{};
+      final uow1 = getRequestBundleUnitOfWork(context);
+      final uow2 = getRequestBundleUnitOfWork(context);
+      expect(identical(uow1, uow2), isTrue);
+    });
+
+    test('returns different UoW for different contexts', () {
+      final ctx1 = <String, Object?>{};
+      final ctx2 = <String, Object?>{};
+      final uow1 = getRequestBundleUnitOfWork(ctx1);
+      final uow2 = getRequestBundleUnitOfWork(ctx2);
+      expect(identical(uow1, uow2), isFalse);
+    });
+  });
+
+  group('clearUnitOfWorkStore', () {
+    test('removes all entries', () {
+      final ctx = <String, Object?>{};
+      final uow = getRequestBundleUnitOfWork(ctx);
+      expect(uow, isNotNull);
+      clearUnitOfWorkStore();
+      // After clearing, a new UoW should be created for the same context
+      final uow2 = getRequestBundleUnitOfWork(ctx);
+      expect(identical(uow, uow2), isFalse);
+    });
+  });
+}