What changed, and why it matters
This commit is a large batch of new and updated automated tests for the send-money screens in Stack Wallet. It checks that fee estimates are displayed correctly, that users can pick custom fees, and that fees update when balances or sync status change. There are no changes to the actual wallet app code that users run—only test code.
No security action needed. Treat as normal test-only engineering work. Reviewers may verify the new tests pass in CI and that the shared harnesses do not accidentally mock security-critical behavior in a way that masks real bugs.
Security signals we found
No strong security signals were identified.
Evidence from the diff
The commit adds and refactors Flutter widget/unit tests under test/pages/send_view/, test/providers/wallet/, and related locations. It introduces shared test harnesses (fake_wallets.dart, send_view_cases.dart, send_view_harness.dart) and a comprehensive send_views_test.dart covering fee display, fee choice dialogs, prepared transaction fees, coin-control fee propagation, failed-fee retries, and rate/estimate caching. Existing tests are updated to use the shared fake wallet classes and to override the pWalletBalance provider. No production source files are modified.
Changed components
test/pages/send_view/send_views_test.darttest/pages/send_view/support/fake_wallets.darttest/pages/send_view/support/send_view_cases.darttest/pages/send_view/support/send_view_harness.darttest/providers/wallet/send_fee_providers_test.darttest/pages_desktop_specific/wallet/desktop_send_fee_form_test.darttest/widgets/custom_buttons/blue_text_button_test.dartInspect captured patch +2320 / −274
### test/pages/send_view/fiat_clear_unit_change_test.dart
@@ -130,6 +130,7 @@ void main() {
pWalletInfo(walletId).overrideWithValue(info),
pWalletCoin(walletId).overrideWithValue(coin),
pWalletName(walletId).overrideWithValue(info.name),
+ pWalletBalance(walletId).overrideWithValue(info.cachedBalance),
prefsChangeNotifierProvider.overrideWithValue(prefs),
localeServiceChangeNotifierProvider.overrideWithValue(_Locale()),
priceAnd24hChangeNotifierProvider.overrideWithValue(_Price()),
### test/pages/send_view/frost_ms/recipient_test.dart
@@ -17,18 +17,10 @@ import 'package:stackwallet/utilities/amount/amount_unit.dart';
import 'package:stackwallet/utilities/barcode_scanner_interface.dart';
import 'package:stackwallet/utilities/clipboard_interface.dart';
import 'package:stackwallet/utilities/util.dart';
-import 'package:stackwallet/wallets/crypto_currency/crypto_currency.dart';
import 'package:stackwallet/widgets/desktop/qr_code_scanner_dialog.dart';
import '../../../sample_data/theme_json.dart';
-
-/// Monero that validates addresses without the native library.
-class _TestMonero extends Monero {
- _TestMonero() : super(CryptoCurrencyNetwork.main);
-
- @override
- bool validateAddress(String address) => address.startsWith("address");
-}
+import '../support/fake_wallets.dart' show TestMonero;
class _TestLocaleService extends LocaleService {
String _locale = "en_US";
@@ -57,7 +49,7 @@ class _FakeScanner implements BarcodeScannerInterface {
}
void main() {
- final coin = _TestMonero();
+ final coin = TestMonero();
const RecipientId id = (walletId: "wallet", index: 1);
Amount xmr(String value) => Amount.tryParseCanonicalAmount(
### test/pages/send_view/send_views_test.dart
@@ -0,0 +1,920 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:stackwallet/models/balance.dart';
+import 'package:stackwallet/pages/send_view/frost_ms/recipient.dart';
+import 'package:stackwallet/pages/send_view/send_view.dart';
+import 'package:stackwallet/pages/send_view/sub_widgets/transaction_fee_selection_sheet.dart';
+import 'package:stackwallet/providers/ui/fee_rate_type_state_provider.dart';
+import 'package:stackwallet/providers/wallet/public_private_balance_state_provider.dart';
+import 'package:stackwallet/services/event_bus/events/global/wallet_sync_status_changed_event.dart';
+import 'package:stackwallet/services/event_bus/global_event_bus.dart';
+import 'package:stackwallet/utilities/amount/amount.dart';
+import 'package:stackwallet/utilities/enums/fee_rate_type_enum.dart';
+import 'package:stackwallet/utilities/stack_file_system.dart';
+import 'package:stackwallet/wallets/isar/providers/wallet_info_provider.dart';
+import 'package:stackwallet/wallets/wallet/wallet.dart';
+import 'package:stackwallet/widgets/custom_buttons/blue_text_button.dart';
+import 'package:stackwallet/widgets/desktop/desktop_fee_dialog.dart';
+import 'package:stackwallet/widgets/eth_fee_form.dart';
+import 'package:stackwallet/widgets/fee_slider.dart';
+import 'package:tuple/tuple.dart';
+
+import '../../support/isar_test_utils.dart';
+import 'support/fake_wallets.dart';
+import 'support/send_view_cases.dart';
+import 'support/send_view_harness.dart';
+
+void main() {
+ setUpAll(() async {
+ final dir = await Directory.systemTemp.createTemp("send_views_");
+ StackFileSystem.setDesktopOverrideDir(dir.path);
+ addTearDown(() => dir.delete(recursive: true));
+ await initializeTestIsar();
+ await loadButtonFont();
+ });
+
+ Future<void> settle(WidgetTester tester) async {
+ await tester.pump(const Duration(seconds: 1));
+ await tester.pumpAndSettle();
+ }
+
+ Future<void> enterAmount(
+ WidgetTester tester,
+ SendViewCase view,
+ String amount,
+ ) async {
+ await enterField(tester, view.cryptoAmountField, amount);
+ // Leaving the field applies the amount at once.
+ FocusManager.instance.primaryFocus?.unfocus();
+ await settle(tester);
+ }
+
+ Future<void> receive(
+ WidgetTester tester,
+ Wallet wallet,
+ Balance balance,
+ ) async {
+ (wallet.info as TestWalletInfo).balance = balance;
+ ProviderScope.containerOf(tester.element(find.byType(Scaffold).first))
+ .refresh(pWalletBalance(wallet.walletId));
+ await settle(tester);
+ }
+
+ Future<void> setSyncStatus(
+ WidgetTester tester,
+ FakeSyncDependentFeeWallet wallet,
+ WalletSyncStatus status,
+ ) async {
+ wallet.isSynced = status == WalletSyncStatus.synced;
+ GlobalEventBus.instance.fire(
+ WalletSyncStatusChangedEvent(
+ status,
+ wallet.walletId,
+ wallet.cryptoCurrency,
+ ),
+ );
+ await settle(tester);
+ }
+
+ Finder inFeeChoice(Finder finder) => find.descendant(
+ of: find.byWidgetPredicate(
+ (widget) =>
+ widget is TransactionFeeSelectionSheet || widget is DesktopFeeDialog,
+ ),
+ matching: finder,
+ );
+
+ Future<void> failHeldFeeRates(WidgetTester tester, FakeWallet fees) async {
+ final held = fees.holdFeeRateFetches!;
+ fees.holdFeeRateFetches = null;
+ held.completeError(Exception("node down"));
+ await settle(tester);
+ }
+
+ Future<RecordedRoutes> pumpCoinControl(WidgetTester tester) async {
+ final routes = RecordedRoutes();
+ await mobileCoin.pump(
+ tester,
+ balance: testBalance("1", 8),
+ prefs: HarnessPrefs(enableCoinControl: true),
+ onGenerateRoute: routes.generate,
+ );
+ await enterField(tester, mobileCoin.addressField, btcAddress);
+ return routes;
+ }
+
+ final ethFeeViews = [
+ (mobileCoin, "0.000042"),
+ (desktopCoin, ""),
+ (mobileEthToken, "0.00013"),
+ (desktopEthToken, ""),
+ ];
+
+ group("the fee shown", () {
+ for (final view in coinCases) {
+ testWithoutAnimation("covers the OP_RETURN output of a public Firo send "
+ "($view)", (tester) async {
+ await view.pump(
+ tester,
+ wallet: FakeFiroWallet(),
+ overrides: [
+ publicPrivateBalanceStateProvider.overrideWithProvider(
+ StateProvider((_) => BalanceType.public),
+ ),
+ ],
+ );
+ await enterField(
+ tester,
+ view.addressField,
+ "firo:$firoExchangeAddress?amount=0.1&op_return=68656c6c6f",
+ );
+ await settle(tester);
+ expect(find.textContaining("0.00001320"), findsOneWidget);
+
+ await view.openFeeChoice(tester, "0.00001320");
+
+ // Each rate's estimate plus its fee for the 16-vbyte OP_RETURN output.
+ expect(find.textContaining("0.00001980"), findsOneWidget);
+ expect(find.textContaining("0.00001320"), findsWidgets);
+ expect(find.textContaining("0.00000660"), findsOneWidget);
+ });
+
+ testWithoutAnimation("follows the balance sent from ($view Firo)", (
+ tester,
+ ) async {
+ await view.pump(tester, wallet: FakeFiroWallet());
+ await enterAmount(tester, view, "0.1");
+ expect(find.textContaining("0.00002000"), findsOneWidget);
+
+ await sendFrom(tester, "Public balance");
+ await settle(tester);
+
+ expect(find.textContaining("0.00001000"), findsOneWidget);
+ expect(find.textContaining("0.00002000"), findsNothing);
+ });
+
+ testWithoutAnimation("is calculated when reviewing ($view Xelis)", (
+ tester,
+ ) async {
+ final wallet = FakeXelisWallet();
+ await view.pump(tester, wallet: wallet);
+ await enterAmount(tester, view, "0.12345678");
+
+ await tester.tap(find.text("Calculated when reviewing"));
+ await tester.pumpAndSettle();
+
+ expect(find.text("Transaction fee"), findsOneWidget);
+ expect(find.text("Calculated when reviewing"), findsOneWidget);
+ expect(find.byType(TransactionFeeSelectionSheet), findsNothing);
+ expect(find.text("Edit", findRichText: true), findsNothing);
+ expect(wallet.feeRateFetches, 0);
+ expect(wallet.feeEstimates, 0);
+ });
+
+ testWithoutAnimation(
+ "is absent for a coin without fees ($view Epic Cash)",
+ (tester) async {
+ final wallet = FakeEpiccashWallet();
+ await view.pump(tester, wallet: wallet);
+ await enterField(tester, view.cryptoAmountField, "1");
+ await settle(tester);
+
+ expect(find.textContaining("Transaction fee"), findsNothing);
+ expect(wallet.feeRateFetches, 0);
+ },
+ );
+
+ testWithoutAnimation("is labelled as an estimate until Custom is picked "
+ "($view)", (tester) async {
+ await view.pump(tester);
+ expect(find.text("Transaction fee (estimated)"), findsOneWidget);
+
+ await view.openFeeChoice(tester, "0.00002000");
+ await pick(tester, "Custom");
+
+ expect(find.text("Transaction fee"), findsOneWidget);
+ });
+
+ testWithoutAnimation("is estimated for the whole balance with Send all "
+ "($view)", (tester) async {
+ final wallet = FakeBitcoinWallet();
+ await view.pump(tester, wallet: wallet, balance: testBalance("1", 8));
+
+ await tester.tap(find.text("Send all BTC", findRichText: true));
+ FocusManager.instance.primaryFocus?.unfocus();
+ await settle(tester);
+
+ expect(
+ wallet.feeEstimateAmounts.last,
+ Amount.tryParseCanonicalAmount("1", fractionDigits: 8),
+ );
+ });
+
+ testWithoutAnimation(
+ "is estimated for the amount at the picked level ($view)",
+ (tester) async {
+ final wallet = FakeBitcoinWallet();
+ await view.pump(tester, wallet: wallet);
+ await view.openFeeChoice(tester, "0.00002000");
+ await pick(tester, "Fast");
+
+ await enterAmount(tester, view, "0.2");
+
+ expect(
+ wallet.feeEstimateAmounts.last,
+ Amount.tryParseCanonicalAmount("0.2", fractionDigits: 8),
+ );
+ expect(find.textContaining("0.00003000"), findsOneWidget);
+ },
+ );
+
+ testWithoutAnimation(
+ "follows the funds the wallet can spend ($view Solana)",
+ (tester) async {
+ final wallet = FakeSolanaWallet();
+ await view.pump(tester, wallet: wallet);
+ await enterAmount(tester, view, "1");
+
+ await receive(tester, wallet, testBalance("1", 9));
+
+ expect(find.textContaining("0.000015000"), findsOneWidget);
+ },
+ );
+
+ for (final (coin, newWallet, fee, balance)
+ in <(String, FakeSyncDependentFeeWallet Function(), String, Balance)>[
+ ("Monero", FakeMoneroWallet.new, "0.00002", testBalance("10", 12)),
+ ("Wownero", FakeWowneroWallet.new, "0.0002", testBalance("10", 11)),
+ ]) {
+ testWithoutAnimation(
+ "follows the wallet once it has synchronized ($view $coin)",
+ (tester) async {
+ final wallet = newWallet()..isSynced = false;
+ await view.pump(tester, wallet: wallet, balance: balance);
+ await enterAmount(tester, view, "1");
+ expect(find.textContaining("Calculating"), findsOneWidget);
+
+ await setSyncStatus(tester, wallet, WalletSyncStatus.synced);
+
+ expect(find.textContaining(fee), findsOneWidget);
+ },
+ );
+ }
+
+ testWithoutAnimation(
+ "stays while the synchronized wallet refreshes ($view Monero)",
+ (tester) async {
+ final wallet = FakeMoneroWallet();
+ await view.pump(
+ tester,
+ wallet: wallet,
+ balance: testBalance("10", 12),
+ );
+ await enterAmount(tester, view, "1");
+
+ await setSyncStatus(tester, wallet, WalletSyncStatus.syncing);
+ await enterAmount(tester, view, "1");
+
+ expect(find.textContaining("0.00002"), findsOneWidget);
+ },
+ );
+
+ testWithoutAnimation(
+ "is estimated for the recipients' total ($view Monero)",
+ (tester) async {
+ final wallet = FakeMoneroWallet();
+ await view.pump(tester, wallet: wallet);
+ await enterField(
+ tester,
+ view.addressField,
+ "monero:address0;address1?tx_amount=1;2",
+ );
+ await settle(tester);
+
+ await tester.enterText(
+ find.descendant(
+ of: find.byType(Recipient).first,
+ matching: find.byKey(view.cryptoAmountField),
+ ),
+ "5",
+ );
+ await settle(tester);
+
+ expect(
+ wallet.feeEstimateAmounts.last,
+ Amount.tryParseCanonicalAmount("7", fractionDigits: 12),
+ );
+ },
+ );
+ }
+
+ testWithoutAnimation("is the slow rate's fee (mobile Solana token)", (
+ tester,
+ ) async {
+ await mobileSolToken.pump(tester, balance: testBalance("1", 9));
+ await enterField(tester, mobileSolToken.cryptoAmountField, "1");
+ await settle(tester);
+
+ expect(find.text("Slow"), findsOneWidget);
+ expect(find.text("~0.000010000 SOL"), findsOneWidget);
+ });
+ });
+
+ group("the fee choice", () {
+ for (final view in coinCases) {
+ testWithoutAnimation("shows each level's confirmation time ($view)", (
+ tester,
+ ) async {
+ await view.pump(tester);
+
+ await view.openFeeChoice(tester, "0.00002000");
+
+ expect(inFeeChoice(find.text("~10 minutes")), findsOneWidget);
+ expect(inFeeChoice(find.text("~30 minutes")), findsOneWidget);
+ expect(inFeeChoice(find.text("~1 hour")), findsOneWidget);
+ });
+
+ testWithoutAnimation(
+ "shows the fees once the wallet has synchronized ($view Monero)",
+ (tester) async {
+ final wallet = FakeMoneroWallet()..isSynced = false;
+ await view.pump(
+ tester,
+ wallet: wallet,
+ balance: testBalance("10", 12),
+ );
+ await enterAmount(tester, view, "1");
+ await view.openFeeChoice(tester, "Calculating");
+
+ await setSyncStatus(tester, wallet, WalletSyncStatus.synced);
+
+ expect(inFeeChoice(find.textContaining("0.00002")), findsOneWidget);
+ },
+ );
+
+ testWithoutAnimation("leaves the form at the picked level and its fee "
+ "($view)", (tester) async {
+ final wallet = FakeBitcoinWallet();
+ await view.pump(tester, wallet: wallet);
+ await enterAmount(tester, view, "0.1");
+ await view.openFeeChoice(tester, "0.00002000");
+ final estimates = wallet.feeEstimates;
+
+ await pick(tester, "Fast");
+
+ expect(find.textContaining("Fast"), findsOneWidget);
+ expect(find.textContaining("0.00003000"), findsOneWidget);
+ expect(wallet.feeEstimates, estimates);
+ });
+
+ testWithoutAnimation("offers no custom rate for Solana ($view)", (
+ tester,
+ ) async {
+ await view.pump(
+ tester,
+ wallet: FakeSolanaWallet(),
+ balance: testBalance("1", 9),
+ );
+ await enterAmount(tester, view, "1");
+
+ await view.openFeeChoice(tester, "0.000015000");
+
+ expect(inFeeChoice(find.textContaining("0.000020000")), findsOneWidget);
+ expect(find.text("Custom"), findsNothing);
+ });
+
+ testWithoutAnimation(
+ "offers the edit fees for cryptonote coins ($view)",
+ (tester) async {
+ await view.pump(tester, wallet: FakeMoneroWallet());
+ await enterAmount(tester, view, "1");
+
+ await view.openFeeChoice(tester, "0.00002");
+
+ expect(inFeeChoice(find.textContaining("0.00003")), findsOneWidget);
+ },
+ );
+
+ testWithoutAnimation("is absent for Spark ($view Firo)", (tester) async {
+ await view.pump(tester, wallet: FakeFiroWallet());
+ await enterAmount(tester, view, "0.1");
+
+ await tester.tap(find.textContaining("0.00002000").last);
+ await tester.pumpAndSettle();
+
+ expect(find.byType(TransactionFeeSelectionSheet), findsNothing);
+ expect(find.text("Edit", findRichText: true), findsNothing);
+ });
+ }
+
+ for (final (view, coin, wallet, fee, balance)
+ in <(SendViewCase, String, Wallet Function(), String, Balance)>[
+ (
+ mobileCoin,
+ "Stellar",
+ FakeStellarWallet.new,
+ "0.00001",
+ testBalance("10", 7),
+ ),
+ (
+ mobileCoin,
+ "Cardano",
+ FakeCardanoWallet.new,
+ "0.17",
+ testBalance("10", 6),
+ ),
+ (
+ desktopCoin,
+ "Cardano",
+ FakeCardanoWallet.new,
+ "0.17",
+ testBalance("10", 6),
+ ),
+ ]) {
+ testWithoutAnimation("is absent for $coin ($view)", (tester) async {
+ await view.pump(tester, wallet: wallet(), balance: balance);
+ await enterAmount(tester, view, "1");
+
+ await tester.tap(find.textContaining(fee).last);
+ await tester.pumpAndSettle();
+
+ expect(find.byType(TransactionFeeSelectionSheet), findsNothing);
+ expect(find.text("Edit", findRichText: true), findsNothing);
+ });
+ }
+
+ for (final (view, fee) in ethFeeViews) {
+ testWithoutAnimation("offers a custom Ethereum fee ($view)", (
+ tester,
+ ) async {
+ await view.pump(tester, wallet: FakeEthereumWallet());
+ await enterAmount(tester, view, "1");
+ await view.openFeeChoice(tester, fee);
+
+ await pick(tester, "Custom");
+
+ expect(find.byType(EthFeeForm), findsOneWidget);
+ });
+ }
+
+ testWithoutAnimation(
+ "offers no custom rate once sent from the private balance "
+ "(mobile Firo)",
+ (tester) async {
+ await mobileCoin.pump(tester, wallet: FakeFiroWallet());
+ await sendFrom(tester, "Public balance");
+ await settle(tester);
+ await mobileCoin.openFeeChoice(tester, "0.00001000");
+ await pick(tester, "Custom");
+
+ await sendFrom(tester, "Private balance");
+
+ expect(find.byType(FeeSlider), findsNothing);
+ },
+ );
+
+ testWithoutAnimation("opens from an Edit click that ends the amount typing "
+ "(desktop)", (tester) async {
+ await desktopCoin.pump(tester);
+ await enterField(tester, desktopCoin.cryptoAmountField, "0.01");
+ final edit = find.ancestor(
+ of: find.text("Edit", findRichText: true),
+ matching: find.byType(CustomTextButton),
+ );
+
+ FocusManager.instance.primaryFocus?.unfocus();
+ final click = await tester.startGesture(
+ tester.getRect(edit).centerLeft + const Offset(4, 0),
+ );
+ await tester.pump();
+ await click.up();
+ await tester.pumpAndSettle();
+
+ expect(find.byType(DesktopFeeDialog), findsOneWidget);
+ });
+ });
+
+ group("the fee sent", () {
+ for (final view in coinCases) {
+ testWithoutAnimation("is the custom rate picked ($view)", (tester) async {
+ final wallet = FakeBitcoinWallet();
+ await view.pump(tester, wallet: wallet, balance: testBalance("1", 8));
+ await enterField(tester, view.addressField, btcAddress);
+ await enterField(tester, view.cryptoAmountField, "0.1");
+ await settle(tester);
+ await view.openFeeChoice(tester, "0.00002000");
+ final rate = await setCustomRate(tester);
+ await view.preview(tester);
+
+ expect(rate, greaterThan(1));
+ expect(wallet.prepared!.feeRateType, FeeRateType.custom);
+ expect(wallet.prepared!.satsPerVByte, rate);
+ });
+
+ testWithoutAnimation(
+ "starts the custom rate over once a level was picked "
+ "($view)",
+ (tester) async {
+ final wallet = FakeBitcoinWallet();
+ await view.pump(tester, wallet: wallet, balance: testBalance("1", 8));
+ await enterField(tester, view.addressField, btcAddress);
+ await enterAmount(tester, view, "0.1");
+ await view.openFeeChoice(tester, "0.00002000");
+ await setCustomRate(tester);
+ await view.openFeeChoice(tester, "Custom");
+ await pick(tester, "Fast");
+ await view.openFeeChoice(tester, "0.00003000");
+
+ await pick(tester, "Custom");
+ final rate = sliderRate(tester);
+ await view.preview(tester);
+
+ expect(wallet.prepared!.satsPerVByte, rate);
+ },
+ );
+
+ testWithoutAnimation(
+ "starts the custom rate over once the private balance hid it "
+ "($view Firo)",
+ (tester) async {
+ final wallet = FakeFiroWallet();
+ await view.pump(tester, wallet: wallet, balance: testBalance("1", 8));
+ await sendFrom(tester, "Public balance");
+ await settle(tester);
+ await view.openFeeChoice(tester, "0.00001000");
+ await setCustomRate(tester);
+ await sendFrom(tester, "Private balance");
+ await sendFrom(tester, "Public balance");
+ await enterField(tester, view.addressField, firoAddress);
+ await enterAmount(tester, view, "0.1");
+
+ final rate = sliderRate(tester);
+ await view.preview(tester);
+
+ expect(wallet.prepared!.satsPerVByte, rate);
+ },
+ );
+
+ testWithoutAnimation(
+ "starts at the Average level in a new send form ($view)",
+ (tester) async {
+ final wallet = FakeBitcoinWallet();
+ await view.pump(tester, wallet: wallet, balance: testBalance("1", 8));
+ await view.openFeeChoice(tester, "0.00002000");
+ await pick(tester, "Fast");
+ final navigator = Navigator.of(
+ tester.element(find.byType(Scaffold).first),
+ );
+ unawaited(
+ navigator.pushReplacement(
+ MaterialPageRoute<void>(builder: (_) => const SizedBox()),
+ ),
+ );
+ await tester.pumpAndSettle();
+ unawaited(
+ navigator.pushReplacement(
+ MaterialPageRoute<void>(
+ builder: (_) => Scaffold(body: view.view(wallet)),
+ ),
+ ),
+ );
+ await tester.pumpAndSettle();
+
+ await enterField(tester, view.addressField, btcAddress);
+ await enterAmount(tester, view, "0.1");
+ await view.preview(tester);
+
+ expect(wallet.prepared!.feeRateType, FeeRateType.average);
+ },
+ );
+ }
+
+ for (final (view, fee) in ethFeeViews) {
+ Future<FakeWallet> pumpCustomEthFee(WidgetTester tester) async {
+ final wallet = FakeEthereumWallet();
+ await view.pump(tester, wallet: wallet, balance: testBalance("1", 18));
+ await enterField(tester, view.addressField, testEthContract.address);
+ await enterAmount(tester, view, "0.1");
+ await view.openFeeChoice(tester, fee);
+ await pick(tester, "Custom");
+ await enterField(tester, const Key("ethMaxFeePerGasField"), "50");
+ await enterField(
+ tester,
+ const Key("ethMaxPriorityFeePerGasField"),
+ "2",
+ );
+ return view.feeEstimator(wallet);
+ }
+
+ testWithoutAnimation(
+ "drops the custom Ethereum fee once a level is picked "
+ "($view)",
+ (tester) async {
+ final sender = await pumpCustomEthFee(tester);
+ await view.openFeeChoice(tester, "Custom");
+
+ await pick(tester, "Fast");
+ await view.preview(tester);
+
+ expect(sender.prepared!.ethEIP1559Fee, isNull);
+ },
+ );
+
+ testWithoutAnimation(
+ "drops the custom Ethereum fee once another send form sets "
+ "a level ($view)",
+ (tester) async {
+ final sender = await pumpCustomEthFee(tester);
+
+ ProviderScope.containerOf(tester.element(find.byType(EthFeeForm)))
+ .read(pFeeRateType.notifier)
+ .state =
+ FeeRateType.average;
+ await tester.pumpAndSettle();
+ await view.preview(tester);
+
+ expect(sender.prepared!.ethEIP1559Fee, isNull);
+ },
+ );
+ }
+ });
+
+ group("the fee sent to coin control", () {
+ /// The amount coin control is opened with.
+ Future<Object?> selectCoins(
+ WidgetTester tester,
+ RecordedRoutes routes,
+ ) async {
+ await tester.tap(find.text("Select coins", findRichText: true));
+ await settle(tester);
+ return (routes.arguments.single! as Tuple4).item3;
+ }
+
+ testWithoutAnimation("is the picked level's fee (mobile)", (tester) async {
+ final routes = await pumpCoinControl(tester);
+ await enterAmount(tester, mobileCoin, "0.1");
+ await mobileCoin.openFeeChoice(tester, "0.00002000");
+ await pick(tester, "Fast");
+
+ expect(
+ await selectCoins(tester, routes),
+ Amount.tryParseCanonicalAmount("0.10003", fractionDigits: 8),
+ );
+ });
+
+ testWithoutAnimation("is none with a custom fee (mobile)", (tester) async {
+ final routes = await pumpCoinControl(tester);
+ await enterAmount(tester, mobileCoin, "0.1");
+ await mobileCoin.openFeeChoice(tester, "0.00002000");
+ await pick(tester, "Custom");
+
+ expect(
+ await selectCoins(tester, routes),
+ Amount.tryParseCanonicalAmount("0.1", fractionDigits: 8),
+ );
+ });
+ });
+
+ group("a failed fee", () {
+ for (final (view, newWallet) in <(SendViewCase, Wallet Function())>[
+ (mobileCoin, FakeBitcoinWallet.new),
+ (desktopCoin, FakeBitcoinWallet.new),
+ (mobileEthToken, FakeEthereumWallet.new),
+ (desktopEthToken, FakeEthereumWallet.new),
+ ]) {
+ testWithoutAnimation("shows as calculating ($view)", (tester) async {
+ final wallet = newWallet();
+ final fees = view.feeEstimator(wallet)
+ ..feeError = Exception("node down");
+ await view.pump(tester, wallet: wallet);
+ await enterAmount(tester, view, "1");
+ final estimates = fees.feeEstimates;
+
+ await enterField(tester, view.addressField, "a");
+ await enterField(tester, view.addressField, "ab");
+
+ expect(estimates, greaterThan(0));
+ expect(fees.feeEstimates, estimates);
+ expect(find.textContaining("Calculating"), findsOneWidget);
+ });
+
+ testWithoutAnimation("is estimated again once typing pauses ($view)", (
+ tester,
+ ) async {
+ final wallet = newWallet();
+ final fees = view.feeEstimator(wallet)..feeError = Exception("down");
+ await view.pump(tester, wallet: wallet);
+ await enterAmount(tester, view, "1");
+ final estimates = fees.feeEstimates;
+
+ await enterField(tester, view.cryptoAmountField, "2");
+ await settle(tester);
+
+ expect(fees.feeEstimates, estimates + 1);
+ });
+
+ testWithoutAnimation(
+ "is estimated again when the amount field loses focus ($view)",
+ (tester) async {
+ final wallet = newWallet();
+ final fees = view.feeEstimator(wallet)..feeError = Exception("down");
+ await view.pump(tester, wallet: wallet);
+ await enterAmount(tester, view, "1");
+ final estimates = fees.feeEstimates;
+
+ await enterAmount(tester, view, "1");
+
+ expect(fees.feeEstimates, estimates + 1);
+ },
+ );
+ }
+
+ testWithoutAnimation("is fetched again by a balance switch (mobile Firo)", (
+ tester,
+ ) async {
+ final wallet = FakeFiroWallet()..holdFeeRateFetches = Completer<void>();
+ await mobileCoin.pump(tester, wallet: wallet);
+ await enterAmount(tester, mobileCoin, "0.1");
+ await sendFrom(tester, "Public balance");
+ await sendFrom(tester, "Private balance");
+ await failHeldFeeRates(tester, wallet);
+
+ await sendFrom(tester, "Public balance");
+
+ expect(find.textContaining("0.00001000"), findsOneWidget);
+ expect(wallet.feeRateFetches, 2);
+ });
+
+ testWithoutAnimation(
+ "is fetched again by a balance switch (desktop Firo)",
+ (tester) async {
+ final wallet = FakeFiroWallet()..failingFeeRateFetches = 2;
+ await desktopCoin.pump(tester, wallet: wallet);
+ await sendFrom(tester, "Public balance");
+ await sendFrom(tester, "Private balance");
+
+ await sendFrom(tester, "Public balance");
+
+ expect(find.textContaining("0.00001000"), findsOneWidget);
+ expect(wallet.feeRateFetches, 3);
+ },
+ );
+
+ testWithoutAnimation(
+ "falls back to the minimum fee (mobile Solana token)",
+ (tester) async {
+ final wallet = FakeSolanaWallet()..feeError = Exception("node down");
+ await mobileSolToken.pump(tester, wallet: wallet);
+
+ await enterField(tester, mobileSolToken.cryptoAmountField, "1");
+ await settle(tester);
+
+ expect(wallet.feeEstimates, greaterThan(0));
+ expect(find.textContaining("0.000005"), findsOneWidget);
+ },
+ );
+
+ testWithoutAnimation("is logged (mobile Solana token)", (tester) async {
+ final wallet = FakeSolanaWallet()..feeError = Exception("node down");
+
+ final logged = await logs(() async {
+ await mobileSolToken.pump(
+ tester,
+ wallet: wallet,
+ balance: testBalance("1", 9),
+ );
+ await enterAmount(tester, mobileSolToken, "1");
+ });
+
+ expect(
+ logged,
+ contains(contains("Failed to calculate Solana token fees")),
+ );
+ });
+
+ testWithoutAnimation(
+ "is fetched again once typing pauses (mobile Solana token)",
+ (tester) async {
+ final wallet = FakeSolanaWallet()..failingFeeRateFetches = 1;
+ await mobileSolToken.pump(
+ tester,
+ wallet: wallet,
+ balance: testBalance("1", 9),
+ );
+
+ await enterAmount(tester, mobileSolToken, "1");
+
+ expect(wallet.feeRateFetches, 2);
+ expect(find.text("~0.000010000 SOL"), findsOneWidget);
+ },
+ );
+ });
+
+ group("fee rates", () {
+ for (final view in coinCases) {
+ testWithoutAnimation("are fetched once for every amount ($view)", (
+ tester,
+ ) async {
+ final wallet = FakeBitcoinWallet();
+ await view.pump(tester, wallet: wallet);
+ await enterAmount(tester, view, "0.1");
+
+ await enterAmount(tester, view, "0.2");
+
+ expect(wallet.feeRateFetches, 1);
+ });
+
+ testWithoutAnimation(
+ "are fetched fresh each time the fee choice opens ($view)",
+ (tester) async {
+ final wallet = FakeBitcoinWallet();
+ await view.pump(tester, wallet: wallet);
+ await enterAmount(tester, view, "0.1");
+ await view.openFeeChoice(tester, "0.00002000");
+ await pick(tester, "Average");
+ final fetches = wallet.feeRateFetches;
+ wallet.feeRateFactor = 2;
+
+ await view.openFeeChoice(tester, "0.00002000");
+
+ expect(wallet.feeRateFetches, fetches + 1);
+ expect(
+ inFeeChoice(find.textContaining("0.00004000")),
+ findsOneWidget,
+ );
+ },
+ );
+ }
+ });
+
+ group("fee estimates", () {
+ for (final view in coinCases) {
+ testWithoutAnimation("follow the amount typed last ($view)", (
+ tester,
+ ) async {
+ final wallet = FakeBitcoinWallet();
+ await view.pump(tester, wallet: wallet);
+ final estimates = wallet.feeEstimateAmounts.length;
+
+ await tester.enterText(find.byKey(view.cryptoAmountField), "0.1");
+ await tester.pump(const Duration(milliseconds: 100));
+ await tester.enterText(find.byKey(view.cryptoAmountField), "0.2");
+ await settle(tester);
+
+ expect(wallet.feeEstimateAmounts.sublist(estimates), [
+ Amount.tryParseCanonicalAmount("0.2", fractionDigits: 8),
+ ]);
+ });
+
+ testWithoutAnimation(
+ "follow the recipients' total typed last ($view Monero)",
+ (tester) async {
+ final wallet = FakeMoneroWallet();
+ await view.pump(tester, wallet: wallet);
+ await enterField(
+ tester,
+ view.addressField,
+ "monero:address0;address1?tx_amount=1;2",
+ );
+ await settle(tester);
+ final estimates = wallet.feeEstimateAmounts.length;
+ final amountField = find.descendant(
+ of: find.byType(Recipient).first,
+ matching: find.byKey(view.cryptoAmountField),
+ );
+
+ await tester.enterText(amountField, "5");
+ await tester.pump(const Duration(milliseconds: 100));
+ await tester.enterText(amountField, "6");
+ await settle(tester);
+
+ expect(wallet.feeEstimateAmounts.sublist(estimates), [
+ Amount.tryParseCanonicalAmount("8", fractionDigits: 12),
+ ]);
+ },
+ );
+ }
+ });
+
+ group("the send view", () {
+ for (final (coin, wallet) in <(String, Wallet Function())>[
+ ("Epic Cash", FakeEpiccashWallet.new),
+ ("Xelis", FakeXelisWallet.new),
+ ]) {
+ testWithoutAnimation("rebuilds nothing for an amount without a fee "
+ "(mobile $coin)", (tester) async {
+ await mobileCoin.pump(tester, wallet: wallet());
+ await tester.enterText(find.byKey(mobileCoin.cryptoAmountField), "1");
+ await tester.pump();
+
+ await tester.binding.delayed(const Duration(seconds: 1));
+
+ expect(tester.element(find.byType(SendView)).dirty, isFalse);
+ });
+ }
+ });
+}
### test/pages/send_view/sol_token_send_locale_change_test.dart
@@ -164,6 +164,7 @@ void main() {
pWalletInfo(walletId).overrideWithValue(info),
pWalletCoin(walletId).overrideWithValue(coin),
pWalletName(walletId).overrideWithValue(info.name),
+ pWalletBalance(walletId).overrideWithValue(info.cachedBalance),
pSolanaTokenBalance((walletId: walletId, tokenMint: mint))
.overrideWithValue(
Balance(
### test/pages/send_view/sub_widgets/multi_recipient_test.dart
@@ -14,20 +14,12 @@ import 'package:stackwallet/utilities/amount/amount.dart';
import 'package:stackwallet/utilities/amount/amount_formatter.dart';
import 'package:stackwallet/utilities/amount/amount_unit.dart';
import 'package:stackwallet/utilities/util.dart';
-import 'package:stackwallet/wallets/crypto_currency/crypto_currency.dart';
import '../../../sample_data/theme_json.dart';
-
-/// Monero that validates addresses without the native library.
-class _TestMonero extends Monero {
- _TestMonero() : super(CryptoCurrencyNetwork.main);
-
- @override
- bool validateAddress(String address) => address.startsWith("address");
-}
+import '../support/fake_wallets.dart' show TestMonero;
void main() {
- final coin = _TestMonero();
+ final coin = TestMonero();
PaymentUriData uri(List<String?> amounts, {List<String>? addresses}) =>
PaymentUriData(
### test/pages/send_view/support/fake_wallets.dart
@@ -0,0 +1,350 @@
+import 'dart:async';
+
+import 'package:stackwallet/models/balance.dart';
+import 'package:stackwallet/models/isar/models/ethereum/eth_contract.dart';
+import 'package:stackwallet/models/isar/models/solana/sol_contract.dart';
+import 'package:stackwallet/models/paymint/fee_object_model.dart';
+import 'package:stackwallet/utilities/amount/amount.dart';
+import 'package:stackwallet/wallets/crypto_currency/crypto_currency.dart';
+import 'package:stackwallet/wallets/crypto_currency/intermediate/cryptonote_currency.dart';
+import 'package:stackwallet/wallets/isar/models/wallet_info.dart';
+import 'package:stackwallet/wallets/models/tx_data.dart';
+import 'package:stackwallet/wallets/wallet/impl/bitcoin_wallet.dart';
+import 'package:stackwallet/wallets/wallet/impl/cardano_wallet.dart';
+import 'package:stackwallet/wallets/wallet/impl/epiccash_wallet.dart';
+import 'package:stackwallet/wallets/wallet/impl/ethereum_wallet.dart';
+import 'package:stackwallet/wallets/wallet/impl/firo_wallet.dart';
+import 'package:stackwallet/wallets/wallet/impl/monero_wallet.dart';
+import 'package:stackwallet/wallets/wallet/impl/solana_wallet.dart';
+import 'package:stackwallet/wallets/wallet/impl/stellar_wallet.dart';
+import 'package:stackwallet/wallets/wallet/impl/sub_wallets/eth_token_wallet.dart';
+import 'package:stackwallet/wallets/wallet/impl/sub_wallets/solana_token_wallet.dart';
+import 'package:stackwallet/wallets/wallet/impl/wownero_wallet.dart';
+import 'package:stackwallet/wallets/wallet/wallet.dart';
+
+/// A wallet answering what the send views read. It records the fee requests
+/// and the prepared send.
+abstract class FakeWallet<T extends CryptoCurrency> {
+ FakeWallet(this.cryptoCurrency, [this.feeRates]);
+
+ final T cryptoCurrency;
+
+ /// Scaled by [feeRateFactor].
+ FeeObject? feeRates;
+ int feeRateFactor = 1;
+
+ int feeEstimates = 0;
+ final feeEstimateAmounts = <Amount>[];
+ Object? feeError;
+ int feeRateFetches = 0;
+ int failingFeeRateFetches = 0;
+ Completer<void>? holdFeeRateFetches;
+ TxData? prepared;
+
+ String get walletId => cryptoCurrency.identifier;
+
+ late final WalletInfo info = TestWalletInfo(walletId, cryptoCurrency);
+
+ bool get supportsMultiRecipient => false;
+
+ bool get hasFunds => info.cachedBalance.spendable.raw > BigInt.zero;
+
+ /// In the coin's smallest unit. The fee rate itself unless a fake overrides
+ /// it.
+ BigInt rawFee(Amount amount, BigInt feeRate) => feeRate;
+
+ Future<FeeObject> get fees => recordFeeRateFetch(
+ FeeObject(
+ numberOfBlocksFast: feeRates!.numberOfBlocksFast,
+ numberOfBlocksAverage: feeRates!.numberOfBlocksAverage,
+ numberOfBlocksSlow: feeRates!.numberOfBlocksSlow,
+ fast: feeRates!.fast * BigInt.from(feeRateFactor),
+ medium: feeRates!.medium * BigInt.from(feeRateFactor),
+ slow: feeRates!.slow * BigInt.from(feeRateFactor),
+ ),
+ );
+
+ Future<Amount> estimateFeeFor(Amount amount, BigInt feeRate) {
+ feeEstimateAmounts.add(amount);
+ return recordFeeEstimate(
+ Amount(
+ rawValue: rawFee(amount, feeRate),
+ fractionDigits: cryptoCurrency.fractionDigits,
+ ),
+ );
+ }
+
+ Future<Amount> recordFeeEstimate(Amount fee) async {
+ feeEstimates++;
+ if (feeError != null) throw feeError!;
+ return fee;
+ }
+
+ Future<R> recordFeeRateFetch<R>(R rates) async {
+ final fails = ++feeRateFetches <= failingFeeRateFetches;
+ await holdFeeRateFetches?.future;
+ if (fails) throw Exception("node down");
+ return rates;
+ }
+
+ Future<TxData> prepareSend({required TxData txData}) async {
+ prepared = txData;
+ return txData.copyWith(
+ fee: Amount(
+ rawValue: BigInt.from(1000),
+ fractionDigits: cryptoCurrency.fractionDigits,
+ ),
+ );
+ }
+
+ Future<void> cancelSend({required TxData txData}) async {}
+
+ @override
+ dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+/// Rates in sats per kB, as the UTXO wallets give them.
+final testFees = FeeObject(
+ numberOfBlocksFast: 1,
+ numberOfBlocksAverage: 3,
+ numberOfBlocksSlow: 6,
+ fast: BigInt.from(30000),
+ medium: BigInt.from(20000),
+ slow: BigInt.from(10000),
+);
+
+FeeObject _feeRates(int slow, int medium, int fast) => FeeObject(
+ numberOfBlocksFast: 1,
+ numberOfBlocksAverage: 1,
+ numberOfBlocksSlow: 1,
+ fast: BigInt.from(fast),
+ medium: BigInt.from(medium),
+ slow: BigInt.from(slow),
+);
+
+class TestWalletInfo extends WalletInfo {
+ TestWalletInfo(String walletId, this._coin)
+ : super(
+ walletId: walletId,
+ name: "${_coin.prettyName} test wallet",
+ mainAddressType: _coin.defaultAddressType,
+ coinName: _coin.identifier,
+ );
+
+ final CryptoCurrency _coin;
+
+ // Desktop send takes its coin from the wallet info.
+ @override
+ CryptoCurrency get coin => _coin;
+
+ Balance? balance;
+
+ @override
+ Balance get cachedBalance => balance ?? Balance.zeroFor(currency: _coin);
+}
+
+Balance testBalance(String spendable, int fractionDigits) {
+ final amount = Amount.tryParseCanonicalAmount(
+ spendable,
+ fractionDigits: fractionDigits,
+ )!;
+ final zero = Amount.zeroWith(fractionDigits: fractionDigits);
+ return Balance(
+ total: amount,
+ spendable: amount,
+ blockedTotal: zero,
+ pendingSpendable: zero,
+ );
+}
+
+const btcAddress = "bc1qu58svs9983e2vuyqh7gq7ratf8k5qehz5k0cn5";
+const firoAddress = "a6ESWKz7szru5syLtYAPRhHLdKvMq3Yt1j";
+const firoExchangeAddress = "EXXMGtieRLNGfgewJ4jJCN4kZFTUcjYMDdHs";
+
+class FakeBitcoinWallet extends FakeWallet<Bitcoin>
+ implements BitcoinWallet<Bitcoin> {
+ FakeBitcoinWallet() : super(Bitcoin(CryptoCurrencyNetwork.main), testFees);
+
+ /// A 100-vbyte transaction.
+ @override
+ BigInt rawFee(Amount amount, BigInt feeRate) =>
+ feeRate * BigInt.from(100) ~/ BigInt.from(1000);
+}
+
+final testEthFees = EthFeeObject(
+ suggestBaseFee: BigInt.from(1000000000),
+ numberOfBlocksFast: 1,
+ numberOfBlocksAverage: 3,
+ numberOfBlocksSlow: 6,
+ fast: BigInt.from(3000000000),
+ medium: BigInt.from(2000000000),
+ slow: BigInt.from(1000000000),
+);
+
+final testEthContract = EthContract(
+ address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+ name: "Tether USD",
+ symbol: "USDT",
+ decimals: 6,
+ type: EthContractType.erc20,
+);
+
+final testSolContract = SolContract(
+ address: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+ name: "Tether USD",
+ symbol: "USDT",
+ decimals: 6,
+);
+
+class FakeEthereumWallet extends FakeWallet<Ethereum>
+ implements EthereumWallet {
+ FakeEthereumWallet() : super(Ethereum(CryptoCurrencyNetwork.main));
+
+ late final tokenWallet = FakeEthTokenWallet(this);
+
+ @override
+ Future<EthFeeObject> get fees => recordFeeRateFetch(testEthFees);
+
+ /// A 21000-gas transfer.
+ @override
+ BigInt rawFee(Amount amount, BigInt feeRate) => BigInt.from(21000) * feeRate;
+}
+
+class FakeEthTokenWallet extends FakeWallet<Ethereum>
+ implements EthTokenWallet {
+ FakeEthTokenWallet(FakeEthereumWallet ethWallet)
+ : super(ethWallet.cryptoCurrency);
+
+ @override
+ EthContract get tokenContract => testEthContract;
+
+ @override
+ Future<EthFeeObject> get fees => recordFeeRateFetch(testEthFees);
+
+ /// A 65000-gas transfer.
+ @override
+ BigInt rawFee(Amount amount, BigInt feeRate) => BigInt.from(65000) * feeRate;
+}
+
+class FakeSolanaWallet extends FakeWallet<Solana> implements SolanaWallet {
+ /// The fee of each priority, in lamports.
+ FakeSolanaWallet()
+ : super(Solana(CryptoCurrencyNetwork.main), _feeRates(10000, 15000, 20000));
+
+ late final tokenWallet = FakeSolanaTokenWallet(this);
+
+ @override
+ BigInt rawFee(Amount amount, BigInt feeRate) =>
+ hasFunds ? feeRate : BigInt.zero;
+}
+
+class FakeSolanaTokenWallet extends FakeWallet<Solana>
+ implements SolanaTokenWallet {
+ FakeSolanaTokenWallet(FakeSolanaWallet parentSolanaWallet)
+ : super(parentSolanaWallet.cryptoCurrency);
+
+ @override
+ SolContract get solContract => testSolContract;
+
+ @override
+ String get tokenMint => testSolContract.address;
+
+ @override
+ String get tokenSymbol => testSolContract.symbol;
+
+ @override
+ int get tokenDecimals => testSolContract.decimals;
+}
+
+class FakeFiroWallet extends FakeWallet<Firo> implements FiroWallet<Firo> {
+ FakeFiroWallet() : super(Firo(CryptoCurrencyNetwork.main), testFees);
+
+ /// A 50-vbyte transaction.
+ @override
+ BigInt rawFee(Amount amount, BigInt feeRate) =>
+ feeRate * BigInt.from(50) ~/ BigInt.from(1000);
+
+ @override
+ int estimateTxFee({required int vSize, required BigInt feeRatePerKB}) =>
+ (feeRatePerKB * BigInt.from(vSize) ~/ BigInt.from(1000)).toInt();
+
+ @override
+ Future<Amount> estimateFeeForSpark(Amount amount) => recordFeeEstimate(
+ Amount(
+ rawValue: BigInt.from(amount.raw > BigInt.zero ? 2000 : 0),
+ fractionDigits: 8,
+ ),
+ );
+}
+
+class FakeEpiccashWallet extends FakeWallet<Epiccash>
+ implements EpiccashWallet {
+ FakeEpiccashWallet() : super(Epiccash(CryptoCurrencyNetwork.main), testFees);
+}
+
+/// Monero checking only an address prefix, as tests lack its native library.
+class TestMonero extends Monero {
+ TestMonero() : super(CryptoCurrencyNetwork.main);
+
+ @override
+ bool validateAddress(String address) => address.startsWith("address");
+}
+
+abstract class FakeSyncDependentFeeWallet<T extends CryptonoteCurrency>
+ extends FakeWallet<T>
+ implements Wallet<CryptonoteCurrency> {
+ /// Cryptonote wallets give their tx priorities as fee rates.
+ FakeSyncDependentFeeWallet(T coin) : super(coin, _feeRates(1, 2, 3));
+
+ // The send views of the test-first commit take the Average priority from
+ // the wallet.
+ int getTxPriorityMedium() => 2;
+
+ /// The real wallet estimates a zero fee until it has synchronized.
+ bool isSynced = true;
+
+ bool get canEstimateFee => isSynced;
+
+ @override
+ BigInt rawFee(Amount amount, BigInt feeRate) =>
+ isSynced && amount.raw > BigInt.zero
+ ? feeRate * BigInt.from(10000000)
+ : BigInt.zero;
+}
+
+class FakeMoneroWallet extends FakeSyncDependentFeeWallet<Monero>
+ implements MoneroWallet {
+ FakeMoneroWallet() : super(TestMonero());
+
+ @override
+ bool get supportsMultiRecipient => true;
+}
+
+class FakeWowneroWallet extends FakeSyncDependentFeeWallet<Wownero>
+ implements WowneroWallet {
+ FakeWowneroWallet() : super(Wownero(CryptoCurrencyNetwork.main));
+}
+
+// XelisWallet's fee estimate takes more parameters.
+class FakeXelisWallet extends FakeWallet<Xelis> implements Wallet<Xelis> {
+ FakeXelisWallet() : super(Xelis(CryptoCurrencyNetwork.main), testFees);
+}
+
+class FakeStellarWallet extends FakeWallet<Stellar> implements StellarWallet {
+ /// The base fee at every rate, in stroops.
+ FakeStellarWallet()
+ : super(Stellar(CryptoCurrencyNetwork.main), _feeRates(100, 100, 100));
+}
+
+class FakeCardanoWallet extends FakeWallet<Cardano> implements CardanoWallet {
+ /// The fee of a basic transaction at every rate, in lovelace.
+ FakeCardanoWallet()
+ : super(
+ Cardano(CryptoCurrencyNetwork.main),
+ _feeRates(170000, 170000, 170000),
+ );
+
+ @override
+ BigInt rawFee(Amount amount, BigInt feeRate) =>
+ hasFunds ? feeRate : BigInt.zero;
+}
### test/pages/send_view/support/send_view_cases.dart
@@ -0,0 +1,204 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:stackwallet/models/balance.dart';
+import 'package:stackwallet/pages/send_view/frost_ms/recipient.dart';
+import 'package:stackwallet/pages/send_view/send_view.dart';
+import 'package:stackwallet/pages/send_view/sol_token_send_view.dart';
+import 'package:stackwallet/pages/send_view/token_send_view.dart';
+import 'package:stackwallet/pages_desktop_specific/my_stack_view/wallet_view/sub_widgets/desktop_send.dart';
+import 'package:stackwallet/pages_desktop_specific/my_stack_view/wallet_view/sub_widgets/desktop_token_send.dart';
+import 'package:stackwallet/wallets/wallet/wallet.dart';
+import 'package:stackwallet/widgets/fee_slider.dart';
+
+import 'fake_wallets.dart';
+import 'send_view_harness.dart';
+
+class SendViewCase {
+ const SendViewCase({
+ required this.name,
+ required this.desktop,
+ required this.view,
+ required this.addressField,
+ required this.cryptoAmountField,
+ required this.defaultWallet,
+ required this.feeEstimator,
+ this.tokenOverrides,
+ });
+
+ final String name;
+ final bool desktop;
+ final Widget Function(Wallet wallet) view;
+ final Key addressField;
+ final Key cryptoAmountField;
+
+ final List<Override> Function(Wallet wallet)? tokenOverrides;
+
+ final Wallet Function() defaultWallet;
+
+ final FakeWallet Function(Wallet wallet) feeEstimator;
+
+ String get previewLabel => desktop ? "Preview send" : "Preview";
+
+ Future<void> pump(
+ WidgetTester tester, {
+ Wallet? wallet,
+ List<Override> overrides = const [],
+ Balance? balance,
+ HarnessPrefs? prefs,
+ RouteFactory? onGenerateRoute,
+ }) async {
+ final w = wallet ?? defaultWallet();
+ await pumpSendView(
+ tester,
+ wallet: w,
+ desktop: desktop,
+ view: view(w),
+ balance: balance,
+ prefs: prefs,
+ onGenerateRoute: onGenerateRoute,
+ overrides: [...?tokenOverrides?.call(w), ...overrides],
+ );
+ }
+
+ Future<void> preview(WidgetTester tester) async {
+ await tester.tap(find.text(previewLabel));
+ // The views keep the building dialog up for at least 2.5 s.
+ await tester.pump(const Duration(seconds: 3));
+ await tester.pumpAndSettle();
+ }
+
+ Future<void> openFeeChoice(WidgetTester tester, String fee) async {
+ await tester.tap(
+ desktop
+ ? find.text("Edit", findRichText: true)
+ : find.textContaining(fee).last,
+ );
+ await tester.pumpAndSettle();
+ }
+
+ @override
+ String toString() => name;
+}
+
+const _cryptoAmountField = Key("amountInputFieldCryptoTextFieldKey");
+
+final mobileCoin = SendViewCase(
+ name: "mobile",
+ desktop: false,
+ view: (wallet) =>
+ SendView(walletId: wallet.walletId, coin: wallet.cryptoCurrency),
+ addressField: const Key("sendViewAddressFieldKey"),
+ cryptoAmountField: _cryptoAmountField,
+ defaultWallet: FakeBitcoinWallet.new,
+ feeEstimator: (wallet) => wallet as FakeWallet,
+);
+
+final desktopCoin = SendViewCase(
+ name: "desktop",
+ desktop: true,
+ view: (wallet) => DesktopSend(walletId: wallet.walletId),
+ addressField: const Key("sendViewAddressFieldKey"),
+ cryptoAmountField: _cryptoAmountField,
+ defaultWallet: FakeBitcoinWallet.new,
+ feeEstimator: (wallet) => wallet as FakeWallet,
+);
+
+final coinCases = [mobileCoin, desktopCoin];
+
+List<Override> _ethToken(Wallet wallet) =>
+ ethTokenOverrides((wallet as FakeEthereumWallet).tokenWallet);
+
+List<Override> _solToken(Wallet wallet) =>
+ solTokenOverrides((wallet as FakeSolanaWallet).tokenWallet);
+
+FakeWallet _ethTokenFees(Wallet wallet) =>
+ (wallet as FakeEthereumWallet).tokenWallet;
+
+// Solana token fees are the parent wallet's.
+FakeWallet _solTokenFees(Wallet wallet) => wallet as FakeSolanaWallet;
+
+final mobileEthToken = SendViewCase(
+ name: "mobile Ethereum token",
+ desktop: false,
+ view: (wallet) => TokenSendView(
+ walletId: wallet.walletId,
+ coin: wallet.cryptoCurrency,
+ tokenContract: testEthContract,
+ ),
+ addressField: const Key("tokenSendViewAddressFieldKey"),
+ cryptoAmountField: _cryptoAmountField,
+ tokenOverrides: _ethToken,
+ defaultWallet: FakeEthereumWallet.new,
+ feeEstimator: _ethTokenFees,
+);
+
+final desktopEthToken = SendViewCase(
+ name: "desktop Ethereum token",
+ desktop: true,
+ view: (wallet) => DesktopTokenSend(walletId: wallet.walletId),
+ addressField: const Key("sendViewAddressFieldKey"),
+ cryptoAmountField: _cryptoAmountField,
+ tokenOverrides: _ethToken,
+ defaultWallet: FakeEthereumWallet.new,
+ feeEstimator: _ethTokenFees,
+);
+
+final mobileSolToken = SendViewCase(
+ name: "mobile Solana token",
+ desktop: false,
+ view: (wallet) => SolTokenSendView(
+ walletId: wallet.walletId,
+ tokenMint: testSolContract.address,
+ ),
+ addressField: const Key("solTokenSendViewAddressFieldKey"),
+ cryptoAmountField: const Key("solAmountInputFieldCryptoTextFieldKey"),
+ tokenOverrides: _solToken,
+ defaultWallet: FakeSolanaWallet.new,
+ feeEstimator: _solTokenFees,
+);
+
+/// Recipient forms reuse the view's keys.
+Finder _inView(Key key) => find.byElementPredicate(
+ (element) =>
+ element.widget.key == key &&
+ element.findAncestorWidgetOfExactType<Recipient>() == null,
+);
+
+Future<void> enterField(WidgetTester tester, Key key, String text) async {
+ await tester.enterText(_inView(key), text);
+ await tester.pumpAndSettle();
+}
+
+Future<void> sendFrom(WidgetTester tester, String balance) async {
+ await tester.tap(
+ find.textContaining(RegExp(r"^(Public|Private) balance$")).last,
+ );
+ await tester.pumpAndSettle();
+ await tester.tap(find.text(balance).last);
+ await tester.pumpAndSettle();
+}
+
+Future<void> pick(WidgetTester tester, String feeRate) async {
+ await tester.tap(find.textContaining(feeRate).last);
+ await tester.pumpAndSettle();
+}
+
+int sliderRate(WidgetTester tester) => int.parse(
+ tester
+ .widget<Text>(
+ find.descendant(
+ of: find.byType(FeeSlider),
+ matching: find.textContaining(RegExp(r"^[0-9]+$")),
+ ),
+ )
+ .data!,
+);
+
+Future<int> setCustomRate(WidgetTester tester) async {
+ await tester.tap(find.text("Custom").last);
+ await tester.pumpAndSettle();
+ await tester.drag(find.byType(Slider), const Offset(2000, 0));
+ await tester.pumpAndSettle();
+ return sliderRate(tester);
+}
### test/pages/send_view/support/send_view_harness.dart
@@ -0,0 +1,216 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:decimal/decimal.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter/scheduler.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:meta/meta.dart';
+import 'package:platform/platform.dart';
+import 'package:stackwallet/models/balance.dart';
+import 'package:stackwallet/models/isar/stack_theme.dart';
+import 'package:stackwallet/providers/global/prefs_provider.dart';
+import 'package:stackwallet/providers/global/price_provider.dart';
+import 'package:stackwallet/providers/global/wallets_provider.dart';
+import 'package:stackwallet/services/price_service.dart';
+import 'package:stackwallet/themes/coin_icon_provider.dart';
+import 'package:stackwallet/themes/stack_colors.dart';
+import 'package:stackwallet/themes/theme_providers.dart';
+import 'package:stackwallet/utilities/amount/amount_unit.dart';
+import 'package:stackwallet/utilities/util.dart';
+import 'package:stackwallet/wallets/crypto_currency/crypto_currency.dart';
+import 'package:stackwallet/wallets/isar/providers/eth/current_token_wallet_provider.dart';
+import 'package:stackwallet/wallets/isar/providers/eth/token_balance_provider.dart';
+import 'package:stackwallet/wallets/isar/providers/solana/current_sol_token_wallet_provider.dart';
+import 'package:stackwallet/wallets/isar/providers/solana/sol_token_balance_provider.dart';
+import 'package:stackwallet/wallets/isar/providers/wallet_info_provider.dart';
+import 'package:stackwallet/wallets/wallet/impl/sub_wallets/eth_token_wallet.dart';
+import 'package:stackwallet/wallets/wallet/impl/sub_wallets/solana_token_wallet.dart';
+import 'package:stackwallet/wallets/wallet/wallet.dart';
+
+import '../../../sample_data/theme_json.dart';
+import '../../../wallets/support/xelis_test_fakes.dart';
+import 'fake_wallets.dart';
+
+class HarnessPrefs extends ConfirmationPrefs {
+ HarnessPrefs({this.enableCoinControl = false});
+
+ @override
+ final bool enableCoinControl;
+
+ @override
+ AmountUnit amountUnit(CryptoCurrency coin) => AmountUnit.normal;
+
+ @override
+ int maxDecimals(CryptoCurrency coin) => coin.fractionDigits;
+}
+
+/// A test tapping a CustomTextButton needs its font loaded before the first
+/// paint.
+Future<void> loadButtonFont() async {
+ final font = FontLoader('Inter_500');
+ font.addFont(rootBundle.load('google_fonts/Inter-Medium.ttf'));
+ await font.load();
+}
+
+/// A faster widget test: semantics are off and animations end on their first
+/// frame.
+@isTest
+void testWithoutAnimation(String description, WidgetTesterCallback callback) =>
+ testWidgets(description, (tester) async {
+ // Timers keep the fake clock. testWidgets checks the dilation is back to
+ // 1 before the test ends.
+ timeDilation = 0.001;
+ try {
+ await callback(tester);
+ } finally {
+ timeDilation = 1;
+ }
+ }, semanticsEnabled: false);
+
+Future<void> pumpSendView(
+ WidgetTester tester, {
+ required Wallet wallet,
+ required bool desktop,
+ required Widget view,
+ List<Override> overrides = const [],
+ Balance? balance,
+ HarnessPrefs? prefs,
+ RouteFactory? onGenerateRoute,
+}) async {
+ tester.view.physicalSize = desktop
+ ? const Size(1600, 1200)
+ : const Size(800, 1600);
+ tester.view.devicePixelRatio = 1;
+ addTearDown(tester.view.reset);
+ final previousPlatform = Util.layoutPlatform;
+ addTearDown(() => Util.layoutPlatform = previousPlatform);
+ Util.layoutPlatform = FakePlatform(
+ operatingSystem: desktop ? "linux" : "android",
+ );
+
+ final coin = wallet.cryptoCurrency;
+ final walletId = wallet.walletId;
+ final info = wallet.info;
+ (info as TestWalletInfo).balance = balance;
+ final harnessPrefs = prefs ?? HarnessPrefs();
+ final theme = StackTheme.fromJson(json: lightThemeJsonMap);
+ await tester.pumpWidget(
+ ProviderScope(
+ overrides: [
+ pWallets.overrideWithValue(ConfirmationWallets(wallet)),
+ pWalletInfo(walletId).overrideWithValue(info),
+ pWalletCoin(walletId).overrideWithValue(coin),
+ pWalletName(walletId).overrideWithValue(info.name),
+ pWalletBalance(walletId)
+ .overrideWithProvider(Provider((_) => info.cachedBalance)),
+ pWalletBalanceTertiary(walletId)
+ .overrideWithValue(info.cachedBalanceTertiary),
+ prefsChangeNotifierProvider.overrideWithValue(harnessPrefs),
+ priceAnd24hChangeNotifierProvider.overrideWithValue(FakePriceService()),
+ themeProvider.overrideWithProvider(StateProvider((ref) => theme)),
+ coinIconProvider(coin).overrideWithValue(
+ File('test/sample_data/light/assets/dummy.svg').absolute.path,
+ ),
+ ...overrides,
+ ],
+ child: MaterialApp(
+ theme: ThemeData(extensions: [StackColors.fromStackColorTheme(theme)]),
+ onGenerateRoute: onGenerateRoute,
+ home: Scaffold(body: view),
+ ),
+ ),
+ );
+ await tester.pumpAndSettle();
+ expect(tester.takeException(), isNull);
+}
+
+List<Override> ethTokenOverrides(EthTokenWallet tokenWallet) => [
+ tokenServiceStateProvider.overrideWithProvider(
+ StateProvider<EthTokenWallet?>((ref) => tokenWallet),
+ ),
+ pTokenBalance.overrideWithProvider(
+ (_) => Provider<Balance>(
+ (_) =>
+ Balance.zeroWith(fractionDigits: tokenWallet.tokenContract.decimals),
+ ),
+ ),
+];
+
+List<Override> solTokenOverrides(SolanaTokenWallet tokenWallet) => [
+ solanaTokenServiceStateProvider.overrideWithProvider(
+ StateProvider<SolanaTokenWallet?>((ref) => tokenWallet),
+ ),
+ pSolanaTokenBalance.overrideWithProvider(
+ (_) => Provider<Balance>(
+ (_) => Balance.zeroWith(fractionDigits: tokenWallet.tokenDecimals),
+ ),
+ ),
+];
+
+class FakePriceService extends ChangeNotifier implements PriceService {
+ @override
+ ({Decimal value, double change24h})? getPrice(CryptoCurrency coin) => null;
+
+ @override
+ ({Decimal value, double change24h})? getTokenPrice(String contractAddress) =>
+ null;
+
+ @override
+ dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+class RecordedRoutes {
+ final arguments = <Object?>[];
+
+ Route<dynamic> generate(RouteSettings settings) {
+ arguments.add(settings.arguments);
+ return MaterialPageRoute<Object?>(
+ settings: settings,
+ builder: (_) => const _PopAtOnce(),
+ );
+ }
+}
+
+class _PopAtOnce extends StatefulWidget {
+ const _PopAtOnce();
+
+ @override
+ State<_PopAtOnce> createState() => _PopAtOnceState();
+}
+
+class _PopAtOnceState extends State<_PopAtOnce> {
+ @override
+ void initState() {
+ super.initState();
+ WidgetsBinding.instance.addPostFrameCallback(
+ (_) => Navigator.of(context).pop(),
+ );
+ }
+
+ @override
+ Widget build(BuildContext context) => const SizedBox.shrink();
+}
+
+Future<List<String?>> logs(Future<void> Function() body) async {
+ final messages = <String?>[];
+ final debugPrintBefore = debugPrint;
+ void restore() => debugPrint = debugPrintBefore;
+ // The finally restores it before testWidgets checks it, and the teardown
+ // when [body] never finishes.
+ addTearDown(restore);
+ debugPrint = (message, {wrapWidth}) => messages.add(message);
+ try {
+ await runZoned(
+ body,
+ zoneSpecification: ZoneSpecification(
+ print: (_, _, _, line) => messages.add(line),
+ ),
+ );
+ } finally {
+ restore();
+ }
+ return messages;
+}
### test/pages/send_view/token_amount_display_updates_test.dart
@@ -165,6 +165,7 @@ void main() {
pWalletInfo(walletId).overrideWithValue(info),
pWalletCoin(walletId).overrideWithValue(coin),
pWalletName(walletId).overrideWithValue(info.name),
+ pWalletBalance(walletId).overrideWithValue(info.cachedBalance),
pTokenBalance((
walletId: walletId,
contractAddress: contract.address,
### test/pages/send_view/xelis_send_view_test.dart
@@ -1,113 +0,0 @@
-import 'dart:io';
-
-import 'package:flutter/material.dart';
-import 'package:flutter_riverpod/flutter_riverpod.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:stackwallet/models/balance.dart';
-import 'package:stackwallet/models/isar/models/blockchain_data/address.dart';
-import 'package:stackwallet/models/isar/stack_theme.dart';
-import 'package:stackwallet/pages/send_view/send_view.dart';
-import 'package:stackwallet/pages/send_view/sub_widgets/transaction_fee_selection_sheet.dart';
-import 'package:stackwallet/providers/global/prefs_provider.dart';
-import 'package:stackwallet/providers/global/wallets_provider.dart';
-import 'package:stackwallet/themes/coin_icon_provider.dart';
-import 'package:stackwallet/themes/stack_colors.dart';
-import 'package:stackwallet/themes/theme_providers.dart';
-import 'package:stackwallet/utilities/amount/amount_formatter.dart';
-import 'package:stackwallet/utilities/amount/amount_unit.dart';
-import 'package:stackwallet/utilities/stack_file_system.dart';
-import 'package:stackwallet/wallets/crypto_currency/crypto_currency.dart';
-import 'package:stackwallet/wallets/isar/models/wallet_info.dart';
-import 'package:stackwallet/wallets/isar/providers/wallet_info_provider.dart';
-
-import '../../sample_data/theme_json.dart';
-import '../../wallets/support/xelis_test_fakes.dart';
-
-class SendPrefs extends ConfirmationPrefs {
- @override
- bool get enableCoinControl => false;
- @override
- AmountUnit amountUnit(CryptoCurrency coin) => AmountUnit.normal;
- @override
- int maxDecimals(CryptoCurrency coin) => coin.fractionDigits;
-}
-
-void main() {
- testWidgets('Xelis mobile form shows deferred fees without a fee selector', (
- tester,
- ) async {
- // This exercises SendView (the mobile form) on the host test runner.
- tester.view.physicalSize = const Size(800, 1200);
- tester.view.devicePixelRatio = 1;
- addTearDown(tester.view.resetPhysicalSize);
- addTearDown(tester.view.resetDevicePixelRatio);
- final previousThemesDir = StackFileSystem.themesDir;
- addTearDown(() => StackFileSystem.themesDir = previousThemesDir);
- StackFileSystem.themesDir = Directory('test/sample_data').absolute;
-
- final wallet = TestWallet(FakeNative());
- final coin = wallet.cryptoCurrency;
- const walletId = 'xelis-send-form';
- final info = WalletInfo(
- walletId: walletId,
- name: 'Xelis test wallet',
- mainAddressType: AddressType.xelis,
- coinName: coin.identifier,
- );
- final theme = StackTheme.fromJson(json: lightThemeJsonMap);
- await tester.pumpWidget(
- ProviderScope(
- overrides: [
- pWallets.overrideWithValue(ConfirmationWallets(wallet)),
- pWalletInfo(walletId).overrideWithValue(info),
- pWalletCoin(walletId).overrideWithValue(coin),
- pWalletName(walletId).overrideWithValue(info.name),
- pWalletBalance(walletId)
- .overrideWithValue(Balance.zeroFor(currency: coin)),
- prefsChangeNotifierProvider.overrideWithValue(SendPrefs()),
- themeProvider.overrideWithProvider(StateProvider((ref) => theme)),
- coinIconProvider(coin).overrideWithValue(
- File('test/sample_data/light/assets/dummy.svg').absolute.path,
- ),
- pAmountFormatter(coin).overrideWithValue(
- AmountFormatter(
- unit: AmountUnit.normal,
- locale: 'en_US',
- coin: coin,
- maxDecimals: 8,
- ),
- ),
- ],
- child: MaterialApp(
- theme: ThemeData(
- extensions: [StackColors.fromStackColorTheme(theme)],
- ),
- home: SendView(walletId: walletId, coin: coin),
- ),
- ),
- );
- await tester.pumpAndSettle();
- expect(tester.takeException(), isNull);
- final feeLabel = find.text('Calculated when reviewing');
- expect(feeLabel, findsOneWidget);
- expect(find.text('Transaction fee'), findsOneWidget);
- expect(find.text('Transaction fee (estimated)'), findsNothing);
-
- await tester.enterText(
- find.byKey(const Key('amountInputFieldCryptoTextFieldKey')),
- '0.12345678',
- );
- await tester.pump(const Duration(milliseconds: 600));
- await tester.pumpAndSettle();
- expect(tester.takeException(), isNull);
- expect(feeLabel, findsOneWidget);
-
- await tester.ensureVisible(feeLabel);
- await tester.tap(feeLabel);
- await tester.pumpAndSettle();
- expect(find.byType(TransactionFeeSelectionSheet), findsNothing);
- expect(tester.takeException(), isNull);
- await tester.pumpWidget(const SizedBox.shrink());
- await tester.pumpAndSettle();
- });
-}
### test/pages_desktop_specific/wallet/desktop_send_fee_form_test.dart
@@ -1,164 +1,97 @@
import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:flutter_test/flutter_test.dart';
-import 'package:stackwallet/models/isar/models/blockchain_data/address.dart';
-import 'package:stackwallet/models/isar/stack_theme.dart';
-import 'package:stackwallet/models/paymint/fee_object_model.dart';
import 'package:stackwallet/pages_desktop_specific/my_stack_view/wallet_view/sub_widgets/desktop_send_fee_form.dart';
-import 'package:stackwallet/providers/global/wallets_provider.dart';
-import 'package:stackwallet/providers/wallet/desktop_fee_providers.dart';
-import 'package:stackwallet/themes/stack_colors.dart';
+import 'package:stackwallet/providers/wallet/public_private_balance_state_provider.dart';
import 'package:stackwallet/utilities/amount/amount.dart';
-import 'package:stackwallet/utilities/amount/amount_formatter.dart';
-import 'package:stackwallet/utilities/amount/amount_unit.dart';
-import 'package:stackwallet/wallets/crypto_currency/crypto_currency.dart';
-import 'package:stackwallet/wallets/isar/models/wallet_info.dart';
-import 'package:stackwallet/wallets/isar/providers/wallet_info_provider.dart';
-import 'package:stackwallet/wallets/wallet/wallet.dart';
-import 'package:stackwallet/widgets/desktop/desktop_fee_dialog.dart';
+import 'package:stackwallet/utilities/enums/fee_rate_type_enum.dart';
+import 'package:stackwallet/widgets/fee_slider.dart';
-import '../../sample_data/theme_json.dart';
-import '../../wallets/support/xelis_test_fakes.dart';
+import '../../pages/send_view/support/fake_wallets.dart';
+import '../../pages/send_view/support/send_view_cases.dart';
+import '../../pages/send_view/support/send_view_harness.dart';
-const _walletId = "wallet id";
-final _coin = Bitcoin(CryptoCurrencyNetwork.main);
-final _info = WalletInfo(
- walletId: _walletId,
- name: "Bitcoin wallet",
- mainAddressType: AddressType.p2wpkh,
- coinName: _coin.identifier,
-);
+Amount _amount(String amount) =>
+ Amount.tryParseCanonicalAmount(amount, fractionDigits: 8)!;
-/// Bitcoin wallet counting its fee rate fetches, the first [failingFetches]
-/// of which fail.
-class _FeeWallet implements Wallet<Bitcoin> {
- _FeeWallet({this.failingFetches = 0});
-
- final int failingFetches;
- var feeFetches = 0;
+Future<void> _pickCustomFee(WidgetTester tester) async {
+ await desktopCoin.openFeeChoice(tester, "");
+ await pick(tester, FeeRateType.custom.prettyName);
+}
- @override
- WalletInfo get info => _info;
+void main() {
+ setUpAll(loadButtonFont);
- @override
- Future<FeeObject> get fees async {
- feeFetches++;
- if (feeFetches <= failingFetches) throw Exception("node unreachable");
- return FeeObject(
- numberOfBlocksFast: 1,
- numberOfBlocksAverage: 5,
- numberOfBlocksSlow: 20,
- fast: BigInt.from(20000),
- medium: BigInt.from(10000),
- slow: BigInt.from(5000),
+ Future<StateController<BalanceType>> pumpPublicFiroForm(
+ WidgetTester tester,
+ ) async {
+ final wallet = FakeFiroWallet();
+ await pumpSendView(
+ tester,
+ wallet: wallet,
+ desktop: true,
+ view: DesktopSendFeeForm(
+ walletId: wallet.walletId,
+ isToken: false,
+ amount: SendFeeAmount()..sync(_amount("1")),
+ onCustomFeeSliderChanged: (_) {},
+ ),
);
+ final balance = ProviderScope.containerOf(
+ tester.element(find.byType(DesktopSendFeeForm)),
+ ).read(publicPrivateBalanceStateProvider.state);
+ balance.state = BalanceType.public;
+ await tester.pumpAndSettle();
+ return balance;
}
- @override
- Future<Amount> estimateFeeFor(Amount amount, BigInt feeRate) async =>
- Amount(rawValue: BigInt.from(1410), fractionDigits: 8);
+ group("the fee shown", () {
+ testWithoutAnimation("is the estimated Spark fee after Custom (Firo)", (
+ tester,
+ ) async {
+ final balance = await pumpPublicFiroForm(tester);
+ await _pickCustomFee(tester);
- @override
- dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-}
+ balance.state = BalanceType.private;
+ await tester.pumpAndSettle();
-/// Pump the fee form for [wallet] and return its parent's setState.
-Future<StateSetter> _pumpForm(WidgetTester tester, _FeeWallet wallet) async {
- final theme = StackTheme.fromJson(json: lightThemeJsonMap);
- late StateSetter rebuild;
- await tester.pumpWidget(
- ProviderScope(
- overrides: [
- pWallets.overrideWithValue(ConfirmationWallets(wallet)),
- pWalletCoin(_walletId).overrideWithValue(_coin),
- pAmountFormatter(_coin).overrideWithValue(
- AmountFormatter(
- unit: AmountUnit.normal,
- locale: "en_US",
- coin: _coin,
- maxDecimals: 8,
- ),
- ),
- ],
- child: MaterialApp(
- theme: ThemeData(extensions: [StackColors.fromStackColorTheme(theme)]),
- home: Material(
- child: StatefulBuilder(
- builder: (context, setState) {
+ expect(find.text("Transaction fee (estimated)"), findsOneWidget);
+ expect(find.textContaining("0.00002000"), findsOneWidget);
+ expect(find.byType(FeeSlider), findsNothing);
+ });
+ });
+
+ group("the fee sent", () {
+ testWithoutAnimation(
+ "starts at the Average level in a form opened over another",
+ (tester) async {
+ final wallet = FakeBitcoinWallet();
+ final form = DesktopSendFeeForm(
+ walletId: wallet.walletId,
+ isToken: false,
+ amount: SendFeeAmount(),
+ onCustomFeeSliderChanged: (_) {},
+ );
+ var forms = [form];
+ late StateSetter rebuild;
+ await pumpSendView(
+ tester,
+ wallet: wallet,
+ desktop: true,
+ view: StatefulBuilder(
+ builder: (_, setState) {
rebuild = setState;
- return DesktopSendFeeForm(
- walletId: _walletId,
- isToken: false,
- onCustomFeeSliderChanged: (_) {},
- onCustomFeeOptionChanged: () {},
- );
+ return Column(children: forms);
},
),
- ),
- ),
- ),
- );
- await tester.pump();
- return rebuild;
-}
+ );
+ await _pickCustomFee(tester);
-void main() {
- testWidgets("a rebuild keeps the fee rates and the amount", (tester) async {
- final wallet = _FeeWallet();
- final rebuild = await _pumpForm(tester, wallet);
- final container = ProviderScope.containerOf(
- tester.element(find.byType(DesktopSendFeeForm)),
- );
- final amount = Amount(rawValue: BigInt.from(22000), fractionDigits: 8);
- container.read(sendAmountProvider.notifier).state = amount;
- await tester.pump();
+ rebuild(() => forms = [form, form]);
+ await tester.pumpAndSettle();
- rebuild(() {});
- await tester.pump();
- await tester.pump();
-
- expect(wallet.feeFetches, 1);
- expect(container.read(sendAmountProvider), amount);
- });
-
- testWidgets("a rebuild fetches the fee rates again after a failure", (
- tester,
- ) async {
- final wallet = _FeeWallet(failingFetches: 1);
- final rebuild = await _pumpForm(tester, wallet);
- expect(find.byType(DesktopFeeItem), findsNothing);
-
- rebuild(() {});
- await tester.pump();
- await tester.pump();
-
- expect(wallet.feeFetches, 2);
- expect(find.byType(DesktopFeeItem), findsOneWidget);
-
- rebuild(() {});
- await tester.pump();
-
- expect(wallet.feeFetches, 2);
- expect(find.byType(DesktopFeeItem), findsOneWidget);
- });
-
- testWidgets("the amount is kept while no fee estimate is shown", (
- tester,
- ) async {
- final wallet = _FeeWallet(failingFetches: 1);
- final rebuild = await _pumpForm(tester, wallet);
- final container = ProviderScope.containerOf(
- tester.element(find.byType(DesktopSendFeeForm)),
+ expect(find.text("Average (~0.00002000 BTC)"), findsNWidgets(2));
+ },
);
- final amount = Amount(rawValue: BigInt.from(22000), fractionDigits: 8);
- container.read(sendAmountProvider.notifier).state = amount;
- await tester.pump();
-
- rebuild(() {});
- await tester.pump();
- await tester.pump();
-
- expect(find.byType(DesktopFeeItem), findsOneWidget);
- expect(container.read(sendAmountProvider), amount);
});
}
### test/providers/wallet/send_fee_providers_test.dart
@@ -0,0 +1,476 @@
+import 'dart:async';
+
+import 'package:flutter/widgets.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:stackwallet/models/balance.dart';
+import 'package:stackwallet/models/paymint/fee_object_model.dart';
+import 'package:stackwallet/providers/global/wallets_provider.dart';
+import 'package:stackwallet/providers/ui/fee_rate_type_state_provider.dart';
+import 'package:stackwallet/providers/wallet/send_fee_providers.dart';
+import 'package:stackwallet/utilities/amount/amount.dart';
+import 'package:stackwallet/utilities/enums/fee_rate_type_enum.dart';
+import 'package:stackwallet/wallets/crypto_currency/crypto_currency.dart';
+import 'package:stackwallet/wallets/isar/providers/wallet_info_provider.dart';
+import 'package:stackwallet/wallets/wallet/wallet.dart';
+
+import '../../pages/send_view/support/fake_wallets.dart';
+import '../../pages/send_view/support/send_view_harness.dart';
+import '../../wallets/support/xelis_test_fakes.dart';
+
+Amount _btc(int satoshis) =>
+ Amount(rawValue: BigInt.from(satoshis), fractionDigits: 8);
+
+Amount _units(Wallet wallet, int raw) => Amount(
+ rawValue: BigInt.from(raw),
+ fractionDigits: wallet.cryptoCurrency.fractionDigits,
+);
+
+final _balance = StateProvider<Balance?>((_) => null);
+
+final _tertiaryBalance = StateProvider<Balance?>((_) => null);
+
+class _FeeForm extends ConsumerStatefulWidget {
+ const _FeeForm({required this.walletId});
+
+ final String walletId;
+
+ @override
+ ConsumerState<_FeeForm> createState() => _FeeFormState();
+}
+
+/// A send form showing its fee in raw units, as the send views show theirs.
+class _FeeFormState extends ConsumerState<_FeeForm> with SendFeeForm<_FeeForm> {
+ @override
+ void initState() {
+ super.initState();
+ fees = SendFeeRates(ref.read, walletId: widget.walletId, isToken: false);
+ }
+
+ @override
+ Widget build(BuildContext context) {
+ final estimate = watchFee();
+ return FutureBuilder<Amount>(
+ // The send views show "Calculating" until each new fee answers.
+ key: ObjectKey(estimate),
+ future: estimate,
+ builder: (_, fee) => Text(
+ "${fee.data?.raw ?? "Calculating"}",
+ textDirection: TextDirection.ltr,
+ ),
+ );
+ }
+}
+
+void main() {
+ (SendFeeRates, ProviderContainer) feesOf(Wallet wallet) {
+ final container = ProviderContainer(
+ overrides: [
+ pWallets.overrideWithValue(ConfirmationWallets(wallet)),
+ pWalletBalance.overrideWithProvider(
+ (_) => Provider(
+ (ref) => ref.watch(_balance) ?? wallet.info.cachedBalance,
+ ),
+ ),
+ pWalletBalanceTertiary.overrideWithProvider(
+ (_) => Provider(
+ (ref) =>
+ ref.watch(_tertiaryBalance) ??
+ wallet.info.cachedBalanceTertiary,
+ ),
+ ),
+ ],
+ );
+ addTearDown(container.dispose);
+ return (
+ SendFeeRates(container.read, walletId: wallet.walletId, isToken: false),
+ container,
+ );
+ }
+
+ Future<_FeeFormState> pumpForm(WidgetTester tester, Wallet wallet) async {
+ await tester.pumpWidget(
+ ProviderScope(
+ overrides: [
+ pWallets.overrideWithValue(ConfirmationWallets(wallet)),
+ pWalletBalance(wallet.walletId)
+ .overrideWithValue(wallet.info.cachedBalance),
+ pWalletBalanceTertiary(wallet.walletId)
+ .overrideWithValue(wallet.info.cachedBalanceTertiary),
+ ],
+ child: _FeeForm(walletId: wallet.walletId),
+ ),
+ );
+ return tester.state(find.byType(_FeeForm));
+ }
+
+ void pickLevel(_FeeFormState form, FeeRateType level) =>
+ ProviderScope.containerOf(form.context)
+ .read(pFeeRateType.notifier)
+ .state =
+ level;
+
+ // A fee choice closed at once.
+ void choose(_FeeFormState form) => unawaited(form.chooseFee((_, _) async {}));
+
+ void chooseLevel(_FeeFormState form, FeeRateType level) =>
+ unawaited(form.chooseFee((_, _) async => pickLevel(form, level)));
+
+ FeeObject testFeesTimes({
+ int fast = 1,
+ int medium = 1,
+ int slow = 1,
+ int blocks = 1,
+ }) => FeeObject(
+ numberOfBlocksFast: testFees.numberOfBlocksFast * blocks,
+ numberOfBlocksAverage: testFees.numberOfBlocksAverage * blocks,
+ numberOfBlocksSlow: testFees.numberOfBlocksSlow * blocks,
+ fast: testFees.fast * BigInt.from(fast),
+ medium: testFees.medium * BigInt.from(medium),
+ slow: testFees.slow * BigInt.from(slow),
+ );
+
+ Future<bool> showsInNextFrames(WidgetTester tester, Finder finder) async {
+ var isShown = false;
+ for (var frame = 0; frame < 30; frame++) {
+ await tester.pump(const Duration(milliseconds: 20));
+ isShown |= finder.evaluate().isNotEmpty;
+ }
+ return isShown;
+ }
+
+ group("the fee shown", () {
+ test("follows the private balance (Spark)", () async {
+ final wallet = FakeFiroWallet();
+ final (fees, container) = feesOf(wallet);
+ Future<Amount> fee() => fees.estimate(
+ container.read,
+ FeeRateType.average,
+ amount: _btc(100000),
+ );
+ await fee();
+
+ container.read(_tertiaryBalance.notifier).state = testBalance("1", 8);
+ await fee();
+
+ expect(wallet.feeEstimates, 2);
+ });
+
+ testWithoutAnimation("stays on screen through a retry", (tester) async {
+ final form = await pumpForm(tester, FakeBitcoinWallet());
+ form.setFeeAmount(_btc(10000000));
+ await tester.pumpAndSettle();
+
+ form.retryFee();
+
+ expect(
+ await showsInNextFrames(tester, find.text("Calculating")),
+ isFalse,
+ );
+ });
+ });
+
+ group("the fee choice", () {
+ test("gives each level the confirmation time of its own block count", () {
+ final coin = Bitcoin(CryptoCurrencyNetwork.main);
+
+ expect(sendFeeTime(coin, testFees, FeeRateType.fast), "~10 minutes");
+ expect(sendFeeTime(coin, testFees, FeeRateType.average), "~30 minutes");
+ expect(sendFeeTime(coin, testFees, FeeRateType.slow), "~1 hour");
+ });
+
+ testWithoutAnimation("shows its fresh fee once closed", (tester) async {
+ final wallet = FakeBitcoinWallet();
+ final form = await pumpForm(tester, wallet);
+ form.setFeeAmount(_btc(10000000));
+ await tester.pumpAndSettle();
+ wallet.feeRateFactor = 2;
+
+ choose(form);
+ await tester.pumpAndSettle();
+
+ expect(find.text("4000"), findsOneWidget);
+ });
+
+ testWithoutAnimation("offers the fees of the amount being typed", (
+ tester,
+ ) async {
+ final form = await pumpForm(tester, FakeBitcoinWallet());
+ final amounts = <Amount?>[];
+ form.followFeeAmount(_btc(10000000));
+
+ unawaited(form.chooseFee((_, amount) async => amounts.add(amount)));
+ await tester.pumpAndSettle();
+
+ expect(amounts, [_btc(10000000)]);
+ });
+
+ testWithoutAnimation("keeps the shown fee when its fresh rates fail", (
+ tester,
+ ) async {
+ final wallet = FakeBitcoinWallet();
+ final form = await pumpForm(tester, wallet);
+ form.setFeeAmount(_btc(10000000));
+ await tester.pumpAndSettle();
+ wallet.failingFeeRateFetches = wallet.feeRateFetches + 1;
+
+ choose(form);
+ await tester.pumpAndSettle();
+
+ expect(find.text("2000"), findsOneWidget);
+ });
+
+ testWithoutAnimation(
+ "keeps the shown fee once Custom was picked while its fresh rates "
+ "failed",
+ (tester) async {
+ final wallet = FakeBitcoinWallet();
+ final form = await pumpForm(tester, wallet);
+ form.setFeeAmount(_btc(10000000));
+ await tester.pumpAndSettle();
+ wallet.failingFeeRateFetches = wallet.feeRateFetches + 2;
+ unawaited(
+ form.chooseFee((fees, _) async {
+ fees.rates.ignore();
+ pickLevel(form, FeeRateType.custom);
+ }),
+ );
+ await tester.pumpAndSettle();
+
+ chooseLevel(form, FeeRateType.average);
+ await tester.pumpAndSettle();
+
+ expect(find.text("2000"), findsOneWidget);
+ },
+ );
+
+ testWithoutAnimation("shows a picked level's fee at once", (tester) async {
+ final form = await pumpForm(tester, FakeBitcoinWallet());
+ form.setFeeAmount(_btc(10000000));
+ await tester.pumpAndSettle();
+
+ chooseLevel(form, FeeRateType.fast);
+
+ expect(
+ await showsInNextFrames(tester, find.text("Calculating")),
+ isFalse,
+ );
+ });
+
+ testWithoutAnimation(
+ "leaves the rates of an amount typed while its fee was estimated",
+ (tester) async {
+ final wallet = FakeBitcoinWallet();
+ final form = await pumpForm(tester, wallet);
+ form.setFeeAmount(_btc(10000000));
+ await tester.pumpAndSettle();
+ final rates = Completer<void>();
+ wallet
+ ..feeRateFactor = 2
+ ..holdFeeRateFetches = rates;
+ choose(form);
+ await tester.pumpAndSettle();
+ form.setFeeAmount(_btc(20000000));
+ await tester.pumpAndSettle();
+
+ rates.complete();
+ await tester.pumpAndSettle();
+
+ expect(find.text("2000"), findsOneWidget);
+ },
+ );
+
+ testWithoutAnimation("wins over an earlier one still estimated", (
+ tester,
+ ) async {
+ final wallet = FakeBitcoinWallet();
+ final form = await pumpForm(tester, wallet);
+ form.setFeeAmount(_btc(10000000));
+ await tester.pumpAndSettle();
+ final rates = Completer<void>();
+ wallet
+ ..feeRateFactor = 2
+ ..holdFeeRateFetches = rates;
+ choose(form);
+ await tester.pumpAndSettle();
+ wallet
+ ..feeRateFactor = 3
+ ..holdFeeRateFetches = null;
+ choose(form);
+ await tester.pumpAndSettle();
+
+ rates.complete();
+ await tester.pumpAndSettle();
+
+ expect(find.text("6000"), findsOneWidget);
+ });
+
+ for (final (level, rates, fee) in [
+ (FeeRateType.fast, testFeesTimes(fast: 2), "6000"),
+ (FeeRateType.average, testFeesTimes(medium: 2), "4000"),
+ (FeeRateType.slow, testFeesTimes(slow: 2), "2000"),
+ ]) {
+ testWithoutAnimation("shows the new fee once closed when only the "
+ "${level.prettyName} rate changed", (tester) async {
+ final wallet = FakeBitcoinWallet();
+ final form = await pumpForm(tester, wallet);
+ form.setFeeAmount(_btc(10000000));
+ await tester.pumpAndSettle();
+ chooseLevel(form, level);
+ await tester.pumpAndSettle();
+ wallet.feeRates = rates;
+
+ choose(form);
+ await tester.pumpAndSettle();
+
+ expect(find.text(fee), findsOneWidget);
+ });
+ }
+
+ testWithoutAnimation(
+ "keeps the shown fee at the same rates with new confirmation "
+ "times",
+ (tester) async {
+ final wallet = FakeBitcoinWallet();
+ final form = await pumpForm(tester, wallet);
+ form.setFeeAmount(_btc(10000000));
+ await tester.pumpAndSettle();
+ wallet.feeRates = testFeesTimes(blocks: 2);
+
+ choose(form);
+
+ expect(
+ await showsInNextFrames(tester, find.text("Calculating")),
+ isFalse,
+ );
+ },
+ );
+ });
+
+ group("a failed fee", () {
+ test("is logged once when its rates fail", () async {
+ final wallet = FakeBitcoinWallet()..failingFeeRateFetches = 1;
+ final (fees, container) = feesOf(wallet);
+
+ final logged = await logs(
+ () => Future.wait([
+ fees.estimate(container.read, FeeRateType.fast),
+ fees.estimate(container.read, FeeRateType.average),
+ fees.estimate(container.read, FeeRateType.slow),
+ ]).then<void>((_) {}, onError: (Object _) {}),
+ );
+
+ expect("Failed to calculate".allMatches(logged.join()), hasLength(1));
+ });
+
+ testWithoutAnimation("shows once its rates answer, even a minute later", (
+ tester,
+ ) async {
+ final rates = Completer<void>();
+ final form = await pumpForm(
+ tester,
+ FakeBitcoinWallet()..holdFeeRateFetches = rates,
+ );
+ form.setFeeAmount(_btc(10000000));
+ await tester.pump(const Duration(minutes: 1));
+
+ rates.complete();
+ await tester.pumpAndSettle();
+
+ expect(find.text("2000"), findsOneWidget);
+ });
+ });
+
+ group("fee estimates", () {
+ test("reuse the fee of an unchanged rate once refreshed", () async {
+ final wallet = FakeBitcoinWallet();
+ final (fees, container) = feesOf(wallet);
+ await fees.estimate(container.read, FeeRateType.average);
+
+ await fees.refreshed().estimate(container.read, FeeRateType.average);
+
+ expect(wallet.feeEstimates, 1);
+ });
+
+ test("reuse the Spark fee at another level once refreshed", () async {
+ final wallet = FakeFiroWallet();
+ final (fees, container) = feesOf(wallet);
+ await fees.estimate(
+ container.read,
+ FeeRateType.average,
+ amount: _btc(100000),
+ );
+
+ await fees.refreshed().estimate(
+ container.read,
+ FeeRateType.fast,
+ amount: _btc(100000),
+ );
+
+ expect(wallet.feeEstimates, 1);
+ });
+
+ test("are asked by the fee choice once the wallet has synchronized "
+ "(Monero)", () async {
+ final wallet = FakeMoneroWallet()..isSynced = false;
+ final (fees, container) = feesOf(wallet);
+ container.read(_balance.notifier).state = testBalance("10", 12);
+ unawaited(
+ fees.estimate(
+ container.read,
+ FeeRateType.average,
+ amount: _units(wallet, 1),
+ ),
+ );
+ await pumpEventQueue();
+ wallet.isSynced = true;
+
+ final fee = await fees.refreshed().estimate(
+ container.read,
+ FeeRateType.average,
+ amount: _units(wallet, 1),
+ );
+
+ expect(fee, _units(wallet, 20000000));
+ });
+
+ for (final (coin, newWallet) in <(String, Wallet Function())>[
+ ("Ethereum", FakeEthereumWallet.new),
+ ("Solana", FakeSolanaWallet.new),
+ ("Stellar", FakeStellarWallet.new),
+ ("Cardano", FakeCardanoWallet.new),
+ ]) {
+ test("are asked once for every $coin amount", () async {
+ final wallet = newWallet();
+ final (fees, container) = feesOf(wallet);
+ await fees.estimate(
+ container.read,
+ FeeRateType.average,
+ amount: _units(wallet, 1),
+ );
+
+ await fees.estimate(
+ container.read,
+ FeeRateType.average,
+ amount: _units(wallet, 2),
+ );
+
+ expect((wallet as FakeWallet).feeEstimates, 1);
+ });
+ }
+
+ test("are asked again only once funds arrive when the fee ignores the "
+ "amount (Cardano)", () async {
+ final wallet = FakeCardanoWallet();
+ final (fees, container) = feesOf(wallet);
+ await fees.estimate(container.read, FeeRateType.average);
+ container.read(_balance.notifier).state = testBalance("10", 6);
+ await fees.estimate(container.read, FeeRateType.average);
+
+ container.read(_balance.notifier).state = testBalance("20", 6);
+ await fees.estimate(container.read, FeeRateType.average);
+
+ expect(wallet.feeEstimates, 2);
+ });
+ });
+}
### test/widgets/custom_buttons/blue_text_button_test.dart
@@ -0,0 +1,73 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:stackwallet/themes/stack_colors.dart';
+import 'package:stackwallet/widgets/custom_buttons/blue_text_button.dart';
+
+import '../../pages/send_view/support/fake_wallets.dart';
+import '../../pages/send_view/support/send_view_harness.dart';
+
+void main() {
+ testWithoutAnimation("a button takes the disabled color once disabled", (
+ tester,
+ ) async {
+ var enabled = true;
+ late StateSetter rebuild;
+ await pumpSendView(
+ tester,
+ wallet: FakeBitcoinWallet(),
+ desktop: true,
+ view: StatefulBuilder(
+ builder: (_, setState) {
+ rebuild = setState;
+ return CustomTextButton(text: "Edit", enabled: enabled);
+ },
+ ),
+ );
+
+ rebuild(() => enabled = false);
+ await tester.pump();
+
+ expect(
+ tester.widget<RichText>(find.byType(RichText)).text.style!.color,
+ Theme.of(tester.element(find.byType(CustomTextButton)))
+ .extension<StackColors>()!
+ .customTextButtonDisabledText,
+ );
+ });
+
+ testWithoutAnimation("a button takes the color of a new theme", (
+ tester,
+ ) async {
+ var color = const Color(0xFF112233);
+ late StateSetter rebuild;
+ await pumpSendView(
+ tester,
+ wallet: FakeBitcoinWallet(),
+ desktop: true,
+ view: StatefulBuilder(
+ builder: (context, setState) {
+ rebuild = setState;
+ final theme = Theme.of(context);
+ return Theme(
+ data: theme.copyWith(
+ extensions: [
+ theme.extension<StackColors>()!.copyWith(
+ customTextButtonEnabledText: color,
+ ),
+ ],
+ ),
+ child: const CustomTextButton(text: "Edit"),
+ );
+ },
+ ),
+ );
+
+ rebuild(() => color = const Color(0xFF445566));
+ await tester.pump();
+
+ expect(
+ tester.widget<RichText>(find.byType(RichText)).text.style!.color,
+ const Color(0xFF445566),
+ );
+ });
+}Why this scored 15/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.