@_nazmiforreal/flutter-ota 0.1.2 → 0.1.3

package/dart-src/packages/core/test/types_test.dart

@@ -0,0 +1,129 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart';
+import 'package:test/test.dart';
+
+Bundle _sample() => Bundle(
+      id: '019b76da-a800-7cc2-b5a5-c8f4a1e9d001',
+      platform: Platform.android,
+      shouldForceUpdate: false,
+      enabled: true,
+      fileHash: 'a' * 64,
+      storageUri: 'supabase-storage://flutter-patcher-storage/bundles/x/bundle.zip',
+      gitCommitHash: 'deadbeef',
+      message: 'test bundle',
+      channel: 'production',
+      targetAppVersion: '^1.2.0',
+      metadata: const BundleMetadata(appVersion: '1.2.3'),
+      rolloutCohortCount: 137,
+      targetCohorts: ['qa-group'],
+      patches: [
+        BundlePatchArtifact(
+          baseBundleId: 'base-id',
+          baseFileHash: 'b' * 64,
+          patchFileHash: 'c' * 64,
+          patchStorageUri: 'supabase-storage://bucket/patches/p.bsdiff',
+        ),
+      ],
+    );
+
+void main() {
+  group('Bundle JSON', () {
+    test('camelCase roundtrip preserves all fields', () {
+      final b = _sample();
+      final parsed = Bundle.fromJson(b.toJson());
+      expect(parsed.id, b.id);
+      expect(parsed.platform, Platform.android);
+      expect(parsed.channel, 'production');
+      expect(parsed.targetAppVersion, '^1.2.0');
+      expect(parsed.metadata?.appVersion, '1.2.3');
+      expect(parsed.rolloutCohortCount, 137);
+      expect(parsed.targetCohorts, ['qa-group']);
+      expect(parsed.patches?.single, b.patches!.single);
+    });
+
+    test('snake_case DB row parses (PostgREST shape)', () {
+      final row = _sample().toSqlJson();
+      final parsed = Bundle.fromJson(row.cast<String, dynamic>());
+      expect(parsed.id, _sample().id);
+      expect(parsed.shouldForceUpdate, isFalse);
+      expect(parsed.patches?.single.baseBundleId, 'base-id');
+      expect(parsed.rolloutCohortCount, 137);
+    });
+
+    test('defaults applied on sparse json', () {
+      final parsed = Bundle.fromJson({
+        'id': 'x',
+        'platform': 'android',
+        'file_hash': 'h',
+        'storage_uri': 's://u',
+      });
+      expect(parsed.channel, 'production');
+      expect(parsed.enabled, isFalse);
+      expect(parsed.shouldForceUpdate, isFalse);
+      expect(parsed.message, isNull);
+    });
+
+    test('sql row carries constraint-relevant fields', () {
+      final sql = _sample().toSqlJson();
+      expect(sql.containsKey('target_app_version'), isTrue);
+      expect(sql['metadata'], isA<Map>());
+      // XOR constraint mirrors DB CHECK:
+      final hasFingerprint = sql['fingerprint_hash'] != null;
+      final hasVersion = sql['target_app_version'] != null;
+      expect(hasFingerprint || hasVersion, isTrue);
+    });
+
+    test('equality by wire fields', () {
+      expect(_sample(), equals(_sample()));
+    });
+  });
+
+  group('AppUpdateInfo union', () {
+    test('parses UP_TO_DATE', () {
+      final info = AppUpdateInfo.fromJson({'status': 'UP_TO_DATE'});
+      expect(info, isA<AppUpToDateInfo>());
+    });
+
+    test('parses UPDATE with changed assets', () {
+      final info = AppUpdateInfo.fromJson({
+        'id': 'new-id',
+        'shouldForceUpdate': true,
+        'message': null,
+        'status': 'UPDATE',
+        'fileUrl': 'https://cdn/b.zip',
+        'fileHash': 'd' * 64,
+        'changedAssets': {
+          'assets/logo.png': {
+            'fileHash': 'e' * 64,
+            'file': {'url': 'https://cdn/logo.png', 'compression': null},
+            'patch': null,
+          },
+        },
+      }) as AppUpdateAvailableInfo;
+      expect(info.status, UpdateStatus.update);
+      expect(info.changedAssets?['assets/logo.png']?.file?.url,
+          'https://cdn/logo.png');
+    });
+
+    test('available info serializes', () {
+      const info = AppUpdateAvailableInfo(
+        id: 'i',
+        shouldForceUpdate: true,
+        message: null,
+        status: UpdateStatus.rollback,
+        fileUrl: null,
+        fileHash: null,
+      );
+      expect(info.toJson()['status'], 'ROLLBACK');
+    });
+  });
+
+  group('enums', () {
+    test('values match hot-updater strings', () {
+      expect(Platform.ios.value, 'ios');
+      expect(Platform.android.value, 'android');
+      expect(AppUpdateStatus.upToDate.value, 'UP_TO_DATE');
+      expect(UpdateStrategy.fingerprint.value, 'fingerprint');
+      expect(() => Platform.fromValue('windows'), throwsArgumentError);
+    });
+  });
+}

package/dart-src/packages/core/test/uuid_test.dart

@@ -0,0 +1,38 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('uuidV7', () {
+    test('generates RFC-compliant v7 strings', () {
+      final id = uuidV7();
+      expect(id.length, 36);
+      expect(isUuidV7(id), isTrue, reason: id);
+    });
+
+    test('encodes provided timestamp', () {
+      final ts = DateTime.utc(2026, 1, 1);
+      final id = uuidV7(now: ts);
+      final tsHex = ts.millisecondsSinceEpoch.toRadixString(16).padLeft(12, '0');
+      expect(id.substring(0, 8), tsHex.substring(0, 8));
+      expect(id.substring(9, 13), tsHex.substring(8, 12));
+      expect(id[14], '7');
+    });
+
+    test('lexicographic order matches chronological order', () {
+      final base = DateTime.utc(2026, 5, 5, 12);
+      final earlier = uuidV7(now: base);
+      final later = uuidV7(now: base.add(const Duration(seconds: 10)));
+      expect(compareBundleIds(earlier, later), -1);
+      expect(compareBundleIds(later, earlier), 1);
+    });
+
+    test('uniqueness over bulk generation', () {
+      final ids = List.generate(5000, (_) => uuidV7()).toSet();
+      expect(ids.length, 5000);
+    });
+  });
+
+  test('nilUuid matches hot-updater sentinel', () {
+    expect(nilUuid, '00000000-0000-0000-0000-000000000000');
+  });
+}

package/dart-src/plugins/aws/test/aws_database_test.dart

@@ -0,0 +1,167 @@
+import 'package:flutter_patcher_core/flutter_patcher_core.dart'
+    show
+        AppVersionGetBundlesArgs,
+        Bundle,
+        Platform,
+        nilUuid;
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show DatabaseBundleQueryOptions, DatabasePlugin;
+import 'package:flutter_patcher_aws/flutter_patcher_aws.dart'
+    show S3DatabaseConfig, AwsS3ClientLike, AwsCloudFrontClientLike, s3Database;
+import 'package:test/test.dart';
+
+import 'mock_aws_s3_client.dart' show Store, MockAwsS3Client;
+
+/// Records CloudFront invalidation calls for assertions.
+class MockCloudFrontClient implements AwsCloudFrontClientLike {
+  MockCloudFrontClient();
+
+  final List<(String, List<String>)> invalidations = [];
+
+  @override
+  Future<void> createInvalidation(
+    String distributionId,
+    List<String> paths, {
+    bool shouldWait = false,
+  }) async {
+    invalidations.add((distributionId, List<String>.from(paths)));
+  }
+}
+
+Bundle _makeBundle({
+  required String id,
+  String channel = 'production',
+  String? targetAppVersion,
+  String? fingerprintHash,
+}) =>
+    Bundle(
+      id: id,
+      channel: channel,
+      enabled: true,
+      shouldForceUpdate: false,
+      fileHash: 'h-$id',
+      platform: Platform.android,
+      targetAppVersion: targetAppVersion,
+      storageUri: 's3://test-bucket/$id',
+      fingerprintHash: fingerprintHash,
+      message: 'msg-$id',
+      patches: null,
+    );
+
+void main() {
+  group('aws s3Database', () {
+    late Store store;
+    late MockCloudFrontClient cf;
+    late DatabasePlugin plugin;
+
+    S3DatabaseConfig config({
+      required AwsS3ClientLike Function(S3DatabaseConfig) clientFactory,
+      String? cloudfrontDistributionId,
+    }) =>
+        S3DatabaseConfig(
+          bucketName: 'test-bucket',
+          region: 'us-east-1',
+          accessKeyId: 'ak',
+          secretAccessKey: 'sk',
+          clientFactory: clientFactory,
+          cloudfrontDistributionId: cloudfrontDistributionId,
+          cloudfrontClientFactory: (_) => cf,
+        );
+
+    setUp(() {
+      store = Store();
+      cf = MockCloudFrontClient();
+      plugin = s3Database(config(
+        clientFactory: (_) => MockAwsS3Client(store),
+        cloudfrontDistributionId: 'DIST123',
+      ))();
+    });
+
+    test('plugin metadata', () {
+      expect(plugin.name, 's3Database');
+    });
+
+    test('commitBundle writes update.json and invalidates CloudFront',
+        () async {
+      await plugin.appendBundle(
+        _makeBundle(id: 'b1', targetAppVersion: '1.0.0'),
+      );
+      await plugin.commitBundle();
+
+      final keys = store.objects.keys.toList();
+      expect(
+        keys,
+        contains('production/android/1.0.0/update.json'),
+      );
+
+      expect(cf.invalidations, isNotEmpty);
+      expect(cf.invalidations.first.$1, 'DIST123');
+    });
+
+    test('getUpdateInfo (appVersion) resolves committed bundle', () async {
+      await plugin.appendBundle(
+        _makeBundle(id: 'b1', targetAppVersion: '1.0.0'),
+      );
+      await plugin.commitBundle();
+
+      final info = await plugin.getUpdateInfo(
+        AppVersionGetBundlesArgs(
+          platform: Platform.android,
+          bundleId: nilUuid,
+          appVersion: '1.0.0',
+          channel: 'production',
+          minBundleId: nilUuid,
+        ),
+      );
+      expect(info, isNotNull);
+      expect(info!.id, 'b1');
+    });
+
+    test('getBundles returns committed bundles', () async {
+      await plugin.appendBundle(
+        _makeBundle(id: 'b1', targetAppVersion: '1.0.0'),
+      );
+      await plugin.commitBundle();
+
+      final result = await plugin.getBundles(
+        const DatabaseBundleQueryOptions(limit: 100, offset: 0),
+      );
+      expect(result.data, hasLength(1));
+      expect(result.data.first.id, 'b1');
+    });
+
+    test('deleteBundle removes update.json and invalidates', () async {
+      await plugin.appendBundle(
+        _makeBundle(id: 'b1', targetAppVersion: '1.0.0'),
+      );
+      await plugin.commitBundle();
+      expect(store.objects.keys, contains('production/android/1.0.0/update.json'));
+
+      cf.invalidations.clear();
+      final bundle = (await plugin.getBundles(
+        const DatabaseBundleQueryOptions(limit: 100, offset: 0),
+      ))
+          .data
+          .first;
+      await plugin.deleteBundle(bundle);
+      await plugin.commitBundle();
+
+      expect(
+        store.objects.keys,
+        isNot(contains('production/android/1.0.0/update.json')),
+      );
+      expect(cf.invalidations, isNotEmpty);
+    });
+
+    test('no CloudFront invalidation when distribution id omitted', () async {
+      final noCf = s3Database(config(
+        clientFactory: (_) => MockAwsS3Client(store),
+      ))();
+      await noCf.appendBundle(
+        _makeBundle(id: 'b1', targetAppVersion: '1.0.0'),
+      );
+      await noCf.commitBundle();
+      expect(cf.invalidations, isEmpty);
+    });
+  });
+}

package/dart-src/plugins/aws/test/aws_lambda_edge_storage_test.dart

@@ -0,0 +1,190 @@
+import 'dart:convert' show base64, base64Decode, utf8;
+import 'dart:math' show Random;
+import 'dart:typed_data' show Uint8List;
+
+import 'package:asn1lib/asn1lib.dart';
+import 'package:flutter_patcher_aws/flutter_patcher_aws.dart'
+    show
+        AwsLambdaEdgeStorageConfig,
+        cloudfrontSignedUrl,
+        s3LambdaEdgeStorage,
+        verifyCloudfrontSignedUrl;
+import 'package:flutter_patcher_plugin_core/flutter_patcher_plugin_core.dart'
+    show RuntimeStorageProfile;
+import 'package:pointycastle/export.dart'
+    show
+        FortunaRandom,
+        KeyParameter,
+        ParametersWithRandom,
+        RSAKeyGenerator,
+        RSAKeyGeneratorParameters,
+        RSAPrivateKey,
+        RSAPublicKey;
+import 'package:test/test.dart';
+
+import 'mock_aws_s3_client.dart' show MockAwsS3Client, Store;
+
+List<int> _b64urlDecode(String s) {
+  final normalized = s.replaceAll('-', '+').replaceAll('_', '/');
+  final padded = normalized.padRight(
+    normalized.length + (4 - normalized.length % 4) % 4,
+    '=',
+  );
+  return base64Decode(padded);
+}
+
+String _wrapPem(String label, String b64) {
+  final chunks = <String>[];
+  for (var i = 0; i < b64.length; i += 64) {
+    chunks.add(b64.substring(i, i + 64 > b64.length ? b64.length : i + 64));
+  }
+  return '-----BEGIN $label-----\n${chunks.join('\n')}\n-----END $label-----\n';
+}
+
+String _encodePrivatePkcs1(RSAPrivateKey k, RSAPublicKey pub) {
+  final p = k.p!;
+  final q = k.q!;
+  final d = k.privateExponent!;
+  final dP = d % (p - BigInt.one);
+  final dQ = d % (q - BigInt.one);
+  final qInv = q.modInverse(p);
+  final seq = ASN1Sequence();
+  seq.add(ASN1Integer(BigInt.zero));
+  seq.add(ASN1Integer(k.modulus!));
+  seq.add(ASN1Integer(pub.exponent!));
+  seq.add(ASN1Integer(d));
+  seq.add(ASN1Integer(p));
+  seq.add(ASN1Integer(q));
+  seq.add(ASN1Integer(dP));
+  seq.add(ASN1Integer(dQ));
+  seq.add(ASN1Integer(qInv));
+  return _wrapPem('RSA PRIVATE KEY', base64.encode(seq.encodedBytes));
+}
+
+String _encodePublic(RSAPublicKey pub) {
+  final keySeq = ASN1Sequence();
+  keySeq.add(ASN1Integer(pub.modulus!));
+  keySeq.add(ASN1Integer(pub.exponent!));
+  final spki = ASN1Sequence();
+  final alg = ASN1Sequence();
+  alg.add(ASN1ObjectIdentifier.fromComponents([1, 2, 840, 113549, 1, 1, 1]));
+  alg.add(ASN1Null());
+  spki.add(alg);
+  spki.add(ASN1BitString(keySeq.encodedBytes));
+  return _wrapPem('PUBLIC KEY', base64.encode(spki.encodedBytes));
+}
+
+(String, String) _generateKeyPair() {
+  final rng = FortunaRandom();
+  final seedSource = Random.secure();
+  rng.seed(
+    KeyParameter(
+      Uint8List.fromList(
+        List<int>.generate(32, (_) => seedSource.nextInt(256)),
+      ),
+    ),
+  );
+  final kg = RSAKeyGenerator()
+    ..init(
+      ParametersWithRandom(
+        RSAKeyGeneratorParameters(BigInt.from(65537), 2048, 12),
+        rng,
+      ),
+    );
+  final pair = kg.generateKeyPair();
+  final priv = pair.privateKey as RSAPrivateKey;
+  final pub = pair.publicKey as RSAPublicKey;
+  return (_encodePrivatePkcs1(priv, pub), _encodePublic(pub));
+}
+
+AwsLambdaEdgeStorageConfig _edgeConfig(
+  Store store,
+  String privatePem, {
+  String? publicBaseUrl,
+  Future<String> Function()? publicBaseUrlResolver,
+}) =>
+    AwsLambdaEdgeStorageConfig(
+      bucketName: 'test-bucket',
+      region: 'us-east-1',
+      accessKeyId: 'ak',
+      secretAccessKey: 'sk',
+      keyPairId: 'KP123',
+      publicBaseUrl: publicBaseUrl,
+      publicBaseUrlResolver: publicBaseUrlResolver,
+      getPrivateKey: () async => privatePem,
+      clientFactory: (_) => MockAwsS3Client(store),
+    );
+
+void main() {
+  group('aws cloudfront signed url', () {
+    final (privatePem, publicPem) = _generateKeyPair();
+
+    test('cloudfrontSignedUrl round-trips and verifies', () {
+      const url = 'https://cdn.example.com/bundles/x.zip';
+      final signed = cloudfrontSignedUrl(
+        url: url,
+        keyPairId: 'KP123',
+        privateKeyPem: privatePem,
+        dateLessThan: DateTime.now().add(const Duration(days: 365)),
+      );
+      expect(signed, contains('Policy='));
+      expect(signed, contains('Signature='));
+      expect(signed, contains('Key-Pair-Id=KP123'));
+      expect(
+        verifyCloudfrontSignedUrl(signedUrl: signed, publicKeyPem: publicPem),
+        isTrue,
+      );
+
+      final uri = Uri.parse(signed);
+      final policyJson = utf8.decode(_b64urlDecode(uri.queryParameters['Policy']!));
+      expect(policyJson, contains(url));
+    });
+
+    test('s3LambdaEdgeStorage signs s3 download urls', () async {
+      final store = Store();
+      final plugin = s3LambdaEdgeStorage(
+        _edgeConfig(store, privatePem, publicBaseUrl: 'https://cdn.example.com'),
+      );
+      final RuntimeStorageProfile runtime = plugin.profiles.runtime!;
+
+      final res = await runtime.getDownloadUrl('s3://test-bucket/bundles/x.zip');
+      final fileUrl = res['fileUrl']!;
+      expect(fileUrl, contains('Key-Pair-Id=KP123'));
+      expect(
+        verifyCloudfrontSignedUrl(signedUrl: fileUrl, publicKeyPem: publicPem),
+        isTrue,
+      );
+
+      final uri = Uri.parse(fileUrl);
+      final policy = utf8.decode(_b64urlDecode(uri.queryParameters['Policy']!));
+      expect(policy, contains('https://cdn.example.com/bundles/x.zip'));
+    });
+
+    test('s3LambdaEdgeStorage resolves publicBaseUrl via function', () async {
+      final store = Store();
+      final plugin = s3LambdaEdgeStorage(
+        _edgeConfig(
+          store,
+          privatePem,
+          publicBaseUrlResolver: () async => 'https://edge.acme.dev',
+        ),
+      );
+      final runtime = plugin.profiles.runtime!;
+      final res = await runtime.getDownloadUrl('s3://test-bucket/a.zip');
+      expect(
+        verifyCloudfrontSignedUrl(
+          signedUrl: res['fileUrl']!,
+          publicKeyPem: publicPem,
+        ),
+        isTrue,
+      );
+      expect(res['fileUrl'], contains('https://edge.acme.dev/a.zip'));
+    });
+
+    test('plugin name carries WithCloudFrontSignedUrl suffix', () {
+      final store = Store();
+      final plugin = s3LambdaEdgeStorage(_edgeConfig(store, privatePem));
+      expect(plugin.name, 's3StorageWithCloudFrontSignedUrl');
+    });
+  });
+}

package/dart-src/plugins/aws/test/aws_storage_test.dart

@@ -0,0 +1,73 @@
+import 'dart:io' show Directory, File;
+
+import 'package:flutter_patcher_aws/flutter_patcher_aws.dart' show s3Storage;
+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_aws_s3_client.dart' show Store, mockConfig;
+
+void main() {
+  group('aws s3Storage', () {
+    late Store store;
+    late StoragePlugin plugin;
+    late String tmpFile;
+    late String outFile;
+
+    setUp(() {
+      store = Store();
+      plugin = s3Storage(mockConfig(store));
+      final dir = Directory.systemTemp.createTempSync('fp_s3_').path;
+      tmpFile = '$dir/bundle.zip';
+      File(tmpFile).writeAsBytesSync([1, 2, 3, 4]);
+      outFile = '$dir/out.zip';
+    });
+
+    test('plugin metadata', () {
+      expect(plugin.name, 's3Storage');
+      expect(plugin.supportedProtocol, 's3');
+      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'], 's3://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('s3://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/aws/test/mock_aws_s3_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_aws/flutter_patcher_aws.dart'
+    show AwsS3ClientLike, AwsS3StorageConfig;
+
+/// In-memory store backing [MockAwsS3Client].
+class Store {
+  final Map<String, List<int>> objects = {};
+}
+
+/// Mock AWS S3 client that stores objects in memory.
+class MockAwsS3Client implements AwsS3ClientLike {
+  MockAwsS3Client(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> getPresignedUrl(String key, {int expiresIn = 3600}) async =>
+      'https://$bucketName.s3.us-east-1.amazonaws.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: 's3://$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 [AwsS3StorageConfig] wired to an in-memory [Store].
+AwsS3StorageConfig mockConfig(Store store) => AwsS3StorageConfig(
+      bucketName: 'test-bucket',
+      region: 'us-east-1',
+      accessKeyId: 'test-access-key',
+      secretAccessKey: 'test-secret',
+      clientFactory: (_) => MockAwsS3Client(store),
+    );