stack/getpaid 2 50 bullnym fiat foundation

integration_test/fiat_settlement_lifecycle_test.dart

@@ -0,0 +1,252 @@
+import 'package:bb_mobile/core/exchange/data/datasources/bullbitcoin_api_key_datasource.dart';
+import 'package:bb_mobile/core/exchange/data/models/scoped_api_key_model.dart';
+import 'package:bb_mobile/core/settings/domain/get_settings_usecase.dart';
+import 'package:bb_mobile/core/utils/result.dart';
+import 'package:bb_mobile/core/wallet/domain/usecases/create_default_wallets_usecase.dart';
+import 'package:bb_mobile/features/bullnym/domain/bullnym_client_port.dart';
+import 'package:bb_mobile/features/bullnym/domain/bullnym_fiat_settlement.dart';
+import 'package:bb_mobile/features/fiat_settlement/public/fiat_settlement_facade.dart';
+import 'package:bb_mobile/locator.dart';
+import 'package:bb_mobile/main.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:integration_test/integration_test.dart';
+
+import 'support/fake_bullnym_client.dart';
+import 'support/get_paid_fixtures.dart';
+
+// SPEC-FIAT-01 - the fake-backed Bull Bitcoin fiat-settlement lifecycle.
+//
+// AUTHORED-BUT-CI-ONLY (same rationale as payment_page_lifecycle_test.dart):
+// runs the REAL app stack (Bull.init locator graph, default-wallet xprv
+// signer, facade -> usecases -> BullnymFacade) against the in-memory
+// FakeBullnymClient, swapped in at the BullnymClientPort seam. It proves the
+// full DI wiring plus the issue #196 optimistic-save / key-on-demand contract
+// end-to-end in-process:
+//   - set/get/disable round-trip with server-confirmed configuration,
+//   - first attempt is ALWAYS keyless; the scoped key is transmitted at most
+//     once, only after BULL_BITCOIN_CREDENTIAL_REQUIRED, and only when present,
+//   - stable error codes map to the closed failure family (KYC / credential /
+//     dependency-503), with the exact action-set-relevant distinctions,
+//   - an old server (404 surface) degrades to an empty Bitcoin-only view on
+//     read and a typed failure on write - never a crash.
+// The signed BYTE contract (NUL-joined bullpay-la-v2 vectors, 0% omission) is
+// pinned separately by test/features/bullnym/bullnym_fiat_settlement_contract_test.dart.
+
+const _scopedKeyPlaintext =
+    // Well-formed test-only value (bbak- + 64 hex); never a real credential.
+    'bbak-0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
+
+Future<void> main({bool isInitialized = false}) async {
+  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+  if (!isInitialized) await Bull.init();
+
+  late FakeBullnymClient bullnym;
+
+  setUpAll(() async {
+    bullnym = FakeBullnymClient();
+    await locator.unregister<BullnymClientPort>();
+    locator.registerLazySingleton<BullnymClientPort>(() => bullnym);
+    await locator<CreateDefaultWalletsUsecase>().execute(
+      mnemonicWords: getPaidFixtureMnemonicWords,
+    );
+  });
+
+  setUp(() {
+    bullnym.fiatSettlementMode = FakeFiatSettlementMode.normal;
+    bullnym.setFiatSettlementCalls.clear();
+  });
+
+  Future<void> clearScopedKey() async {
+    final settings = await locator<GetSettingsUsecase>().execute();
+    await locator<BullbitcoinApiKeyDatasource>().deleteSellToFiatBalanceApiKey(
+      isTestnet: settings.environment.isTestnet,
+    );
+  }
+
+  Future<void> storeScopedKey() async {
+    final settings = await locator<GetSettingsUsecase>().execute();
+    await locator<BullbitcoinApiKeyDatasource>().storeSellToFiatBalanceApiKey(
+      const ScopedApiKeyModel(userId: 'qa-user', key: _scopedKeyPlaintext),
+      isTestnet: settings.environment.isTestnet,
+    );
+  }
+
+  test('set -> get -> disable round-trip; edits with an active server '
+      'credential transmit the scoped key zero times', () async {
+    bullnym.fiatCredentialStatus = BullnymCredentialStatus.active;
+    await clearScopedKey();
+
+    final facade = locator<FiatSettlementFacade>();
+    final set = await facade.set(
+      product: FiatSettlementProduct.paymentPage,
+      fiatPercentage: 50,
+      currency: FiatCurrency.cad,
+    );
+    final afterSet = switch (set) {
+      Ok(:final value) => value,
+      Err(:final failure) => fail('set failed: $failure'),
+    };
+    final config = afterSet.configFor(FiatSettlementProduct.paymentPage);
+    expect(config.mode, FiatSettlementMode.mixed);
+    expect(config.fiatPercentage, 50);
+    expect(config.currency, FiatCurrency.cad);
+
+    // Exactly one PUT, keyless: the server credential is the source of truth.
+    expect(bullnym.setFiatSettlementCalls, hasLength(1));
+    expect(bullnym.setFiatSettlementCalls.single.apiKey, isNull);
+    expect(bullnym.setFiatSettlementCalls.single.fiatCurrency, 'CAD');
+
+    final read = await facade.configuration();
+    final view = switch (read) {
+      Ok(:final value) => value,
+      Err(:final failure) => fail('configuration failed: $failure'),
+    };
+    expect(
+      view.configFor(FiatSettlementProduct.paymentPage).fiatPercentage,
+      50,
+    );
+    // Untouched products stay Bitcoin-only.
+    expect(view.configFor(FiatSettlementProduct.pos).isBitcoinOnly, isTrue);
+
+    final disabled = await facade.disable(
+      product: FiatSettlementProduct.paymentPage,
+    );
+    final afterDisable = switch (disabled) {
+      Ok(:final value) => value,
+      Err(:final failure) => fail('disable failed: $failure'),
+    };
+    expect(
+      afterDisable.configFor(FiatSettlementProduct.paymentPage).isBitcoinOnly,
+      isTrue,
+    );
+    // Disable is a keyless 0% PUT; the server credential is retained.
+    expect(bullnym.setFiatSettlementCalls.last.fiatPercentage, 0);
+    expect(bullnym.setFiatSettlementCalls.last.apiKey, isNull);
+    expect(bullnym.fiatCredentialStatus, BullnymCredentialStatus.active);
+  });
+
+  test(
+    'key-on-demand: BULL_BITCOIN_CREDENTIAL_REQUIRED triggers exactly one retry '
+    'carrying the locally stored scoped key',
+    () async {
+      bullnym.fiatSettlementMode = FakeFiatSettlementMode.credentialRequired;
+      bullnym.fiatCredentialStatus = BullnymCredentialStatus.absent;
+      await storeScopedKey();
+
+      final result = await locator<FiatSettlementFacade>().set(
+        product: FiatSettlementProduct.pos,
+        fiatPercentage: 100,
+        currency: FiatCurrency.usd,
+      );
+      final view = switch (result) {
+        Ok(:final value) => value,
+        Err(:final failure) => fail('set failed: $failure'),
+      };
+      expect(
+        view.configFor(FiatSettlementProduct.pos).mode,
+        FiatSettlementMode.fiatOnly,
+      );
+
+      // The wire order IS the contract: keyless first, keyed retry second,
+      // nothing after.
+      expect(bullnym.setFiatSettlementCalls, hasLength(2));
+      expect(bullnym.setFiatSettlementCalls[0].apiKey, isNull);
+      expect(bullnym.setFiatSettlementCalls[1].apiKey, _scopedKeyPlaintext);
+      expect(bullnym.fiatCredentialStatus, BullnymCredentialStatus.active);
+
+      await clearScopedKey();
+    },
+  );
+
+  test(
+    'no local key on BULL_BITCOIN_CREDENTIAL_REQUIRED -> credentialProblem with '
+    'no blind keyless retry',
+    () async {
+      bullnym.fiatSettlementMode = FakeFiatSettlementMode.credentialRequired;
+      bullnym.fiatCredentialStatus = BullnymCredentialStatus.absent;
+      await clearScopedKey();
+
+      final result = await locator<FiatSettlementFacade>().set(
+        product: FiatSettlementProduct.lightningAddress,
+        fiatPercentage: 25,
+        currency: FiatCurrency.crc,
+      );
+      expect(result, isA<Err<dynamic, dynamic>>());
+      expect(
+        (result as Err).failure,
+        const FiatSettlementFailure.credentialProblem(),
+      );
+      expect(bullnym.setFiatSettlementCalls, hasLength(1));
+    },
+  );
+
+  test(
+    'rejected key (BULL_BITCOIN_CREDENTIAL_INVALID) -> credentialProblem after '
+    'exactly one keyed retry',
+    () async {
+      bullnym.fiatSettlementMode = FakeFiatSettlementMode.credentialInvalid;
+      await storeScopedKey();
+
+      final result = await locator<FiatSettlementFacade>().set(
+        product: FiatSettlementProduct.invoice,
+        fiatPercentage: 10,
+        currency: FiatCurrency.eur,
+      );
+      expect(
+        (result as Err).failure,
+        const FiatSettlementFailure.credentialProblem(),
+      );
+      expect(bullnym.setFiatSettlementCalls, hasLength(2));
+      expect(bullnym.setFiatSettlementCalls[1].apiKey, _scopedKeyPlaintext);
+
+      await clearScopedKey();
+    },
+  );
+
+  test('stable code mapping: KYC and dependency-503 map to their exact '
+      'failures (distinct action sets)', () async {
+    final facade = locator<FiatSettlementFacade>();
+
+    bullnym.fiatSettlementMode = FakeFiatSettlementMode.kycRequired;
+    final kyc = await facade.set(
+      product: FiatSettlementProduct.paymentPage,
+      fiatPercentage: 50,
+      currency: FiatCurrency.cad,
+    );
+    expect((kyc as Err).failure, const FiatSettlementFailure.kycRequired());
+
+    bullnym.fiatSettlementMode = FakeFiatSettlementMode.dependencyUnavailable;
+    final dep = await facade.set(
+      product: FiatSettlementProduct.paymentPage,
+      fiatPercentage: 50,
+      currency: FiatCurrency.cad,
+    );
+    expect(
+      (dep as Err).failure,
+      const FiatSettlementFailure.dependencyUnavailable(),
+    );
+  });
+
+  test('old server without fiat endpoints: read degrades to an all-Bitcoin '
+      'view, write surfaces a typed failure - never a crash', () async {
+    bullnym.fiatSettlementMode = FakeFiatSettlementMode.unsupported;
+    final facade = locator<FiatSettlementFacade>();
+
+    final read = await facade.configuration();
+    final view = switch (read) {
+      Ok(:final value) => value,
+      Err(:final failure) => fail('degraded read failed: $failure'),
+    };
+    for (final product in FiatSettlementProduct.values) {
+      expect(view.configFor(product).isBitcoinOnly, isTrue);
+    }
+    expect(view.credentialActive, isFalse);
+
+    final write = await facade.set(
+      product: FiatSettlementProduct.pos,
+      fiatPercentage: 50,
+      currency: FiatCurrency.cad,
+    );
+    expect((write as Err).failure, const FiatSettlementFailure.unexpected());
+  });
+}