Automated Integration Tests Flows (#1686)

* feat: Integration tests setup and tests for Disclaimer, Welcome and Setup Pin Code pages

* feat: Integration test flow from start to restoring a wallet successfully done

* test: Dashboard view test and linking to flow

* feat: Testing the Exchange flow section, selecting sending and receiving currencies

* test: Successfully create an exchange section

* feat: Implement flow up to sending section

* test: Complete Exchange flow

* fix dependency issue

* test: Final cleanups

* feat: Add CI to run automated integration tests withan android emulator

* feat: Adjust Automated integration test CI to run on ubuntu 20.04-a

* fix: Move integration test CI into PR test build CI

* ci: Add automated test ci which is a streamlined replica of pr test build ci

* ci: Re-add step to access branch name

* ci: Add KVM

* ci: Add filepath to trigger the test run from

* ci: Add required key

* ci: Add required key

* ci: Add missing secret key

* ci: Add missing secret key

* ci: Add nano secrets to workflow

* ci: Switch step to free space on runner

* ci: Remove timeout from workflow

* ci: Confirm impact that removing copy_monero_deps would have on entire workflow time

* ci: Update CI and temporarily remove cache related to emulator

* ci: Remove dynamic java version

* ci: Temporarily switch CI

* ci: Switch to 11.x jdk

* ci: Temporarily switch CI

* ci: Revert ubuntu version

* ci: Add more api levels

* ci: Add more target options

* ci: Settled on stable emulator matrix options

* ci: Add more target options

* ci: Modify flow

* ci: Streamline api levels to 28 and 29

* ci: One more trial

* ci: Switch to flutter drive

* ci: Reduce options

* ci: Remove haven from test

* ci: Check for solana in list

* ci: Adjust amounts and currencies for exchange flow

* ci: Set write response on failure to true

* ci: Split ci to funds and non funds related tests

* test: Test for Send flow scenario and minor restructuring for test folders and files

* chore: cleanup

* ci: Pause CI for now

* ci: Pause CI for now

* ci: Pause CI for now

* test: Restore wallets integration automated tests

* Fix: Add keys back to currency amount textfield widget

* fix: Switch variable name

* fix: remove automation for now

* tests: Automated tests for Create wallets flow

* tests: Further optimize common flows

* tests: Add missing await for call

* tests: Confirm Seeds Display Properly WIP

* tests: Confirm Seeds Display Correctly Automated Tests

* fix: Add missing pubspec params for bitcoin and bitcoin_cash

* feat: Automated Tests for Transaction History Flow

* fix: Add missing pubspec parameter

* feat: Automated Integration Tests for Transaction History flow

* test: Updating send page robot and also syncing branch with main

* test: Modifying tests to flow with wallet grouping implementation

* fix: Issue with transaction history test

* fix: Modifications to the PR and add automated confirmation for checking that all wallet types are restored or created correctly

* test: Attempting automation for testing

* fix: Issue from merge conflicts

* test: Remove automation of test in this PR

---------

Co-authored-by: OmarHatem <omarh.ismail1@gmail.com>

integration_test/robots/dashboard_menu_widget_robot.dart

@@ -0,0 +1,39 @@
+import 'package:cake_wallet/src/screens/dashboard/widgets/menu_widget.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../components/common_test_cases.dart';
+
+class DashboardMenuWidgetRobot {
+  DashboardMenuWidgetRobot(this.tester) : commonTestCases = CommonTestCases(tester);
+
+  final WidgetTester tester;
+  late CommonTestCases commonTestCases;
+
+  Future<void> hasMenuWidget() async {
+    commonTestCases.hasType<MenuWidget>();
+  }
+
+  void displaysTheCorrectWalletNameAndSubName() {
+    final menuWidgetState = tester.state<MenuWidgetState>(find.byType(MenuWidget));
+
+    final walletName = menuWidgetState.widget.dashboardViewModel.name;
+    commonTestCases.hasText(walletName);
+
+    final walletSubName = menuWidgetState.widget.dashboardViewModel.subname;
+    if (walletSubName.isNotEmpty) {
+      commonTestCases.hasText(walletSubName);
+    }
+  }
+
+  Future<void> navigateToWalletMenu() async {
+    await commonTestCases.tapItemByKey('dashboard_page_menu_widget_wallet_menu_button_key');
+    await commonTestCases.defaultSleepTime();
+  }
+
+  Future<void> navigateToSecurityAndBackupPage() async {
+    await commonTestCases.tapItemByKey(
+      'dashboard_page_menu_widget_security_and_backup_button_key',
+    );
+    await commonTestCases.defaultSleepTime();
+  }
+}

integration_test/robots/dashboard_page_robot.dart

@@ -1,20 +1,44 @@
 import 'package:cake_wallet/generated/i18n.dart';
 import 'package:cake_wallet/src/screens/dashboard/dashboard_page.dart';
+import 'package:cake_wallet/src/screens/dashboard/pages/balance_page.dart';
 import 'package:cw_core/wallet_type.dart';
 import 'package:flutter_test/flutter_test.dart';
 
 import '../components/common_test_cases.dart';
+import 'dashboard_menu_widget_robot.dart';
 
 class DashboardPageRobot {
-  DashboardPageRobot(this.tester) : commonTestCases = CommonTestCases(tester);
+  DashboardPageRobot(this.tester)
+      : commonTestCases = CommonTestCases(tester),
+        dashboardMenuWidgetRobot = DashboardMenuWidgetRobot(tester);
 
   final WidgetTester tester;
+  final DashboardMenuWidgetRobot dashboardMenuWidgetRobot;
   late CommonTestCases commonTestCases;
 
   Future<void> isDashboardPage() async {
     await commonTestCases.isSpecificPage<DashboardPage>();
   }
 
+  Future<void> confirmWalletTypeIsDisplayedCorrectly(
+    WalletType type, {
+    bool isHaven = false,
+  }) async {
+    final cryptoBalanceWidget =
+        tester.widget<CryptoBalanceWidget>(find.byType(CryptoBalanceWidget));
+    final hasAccounts = cryptoBalanceWidget.dashboardViewModel.balanceViewModel.hasAccounts;
+
+    if (hasAccounts) {
+      final walletName = cryptoBalanceWidget.dashboardViewModel.name;
+      commonTestCases.hasText(walletName);
+    } else {
+      final walletName = walletTypeToString(type);
+      final assetName = isHaven ? '$walletName Assets' : walletName;
+      commonTestCases.hasText(assetName);
+    }
+    await commonTestCases.defaultSleepTime(seconds: 5);
+  }
+
   void confirmServiceUpdateButtonDisplays() {
     commonTestCases.hasValueKey('dashboard_page_services_update_button_key');
   }
@@ -27,30 +51,40 @@ class DashboardPageRobot {
     commonTestCases.hasValueKey('dashboard_page_wallet_menu_button_key');
   }
 
-  Future<void> confirmRightCryptoAssetTitleDisplaysPerPageView(WalletType type,
-      {bool isHaven = false}) async {
+  Future<void> confirmRightCryptoAssetTitleDisplaysPerPageView(
+    WalletType type, {
+    bool isHaven = false,
+  }) async {
     //Balance Page
-    final walletName = walletTypeToString(type);
-    final assetName = isHaven ? '$walletName Assets' : walletName;
-    commonTestCases.hasText(assetName);
+    await confirmWalletTypeIsDisplayedCorrectly(type, isHaven: isHaven);
 
     // Swipe to Cake features Page
-    await commonTestCases.swipeByPageKey(key: 'dashboard_page_view_key', swipeRight: false);
-    await commonTestCases.defaultSleepTime();
+    await swipeDashboardTab(false);
     commonTestCases.hasText('Cake ${S.current.features}');
 
     // Swipe back to balance
-    await commonTestCases.swipeByPageKey(key: 'dashboard_page_view_key');
-    await commonTestCases.defaultSleepTime();
+    await swipeDashboardTab(true);
 
     // Swipe to Transactions Page
-    await commonTestCases.swipeByPageKey(key: 'dashboard_page_view_key');
-    await commonTestCases.defaultSleepTime();
+    await swipeDashboardTab(true);
     commonTestCases.hasText(S.current.transactions);
 
     // Swipe back to balance
-    await commonTestCases.swipeByPageKey(key: 'dashboard_page_view_key', swipeRight: false);
-    await commonTestCases.defaultSleepTime(seconds: 5);
+    await swipeDashboardTab(false);
+    await commonTestCases.defaultSleepTime(seconds: 3);
+  }
+
+  Future<void> swipeDashboardTab(bool swipeRight) async {
+    await commonTestCases.swipeByPageKey(
+      key: 'dashboard_page_view_key',
+      swipeRight: swipeRight,
+    );
+    await commonTestCases.defaultSleepTime();
+  }
+
+  Future<void> openDrawerMenu() async {
+    await commonTestCases.tapItemByKey('dashboard_page_wallet_menu_button_key');
+    await commonTestCases.defaultSleepTime();
   }
 
   Future<void> navigateToBuyPage() async {

integration_test/robots/exchange_page_robot.dart

@@ -123,7 +123,7 @@ class ExchangePageRobot {
       return;
     }
 
-    await commonTestCases.scrollUntilVisible(
+    await commonTestCases.dragUntilVisible(
       'picker_items_index_${depositCurrency.name}_button_key',
       'picker_scrollbar_key',
     );
@@ -149,7 +149,7 @@ class ExchangePageRobot {
       return;
     }
 
-    await commonTestCases.scrollUntilVisible(
+    await commonTestCases.dragUntilVisible(
       'picker_items_index_${receiveCurrency.name}_button_key',
       'picker_scrollbar_key',
     );

integration_test/robots/new_wallet_page_robot.dart

@@ -0,0 +1,35 @@
+import 'package:cake_wallet/src/screens/new_wallet/new_wallet_page.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../components/common_test_cases.dart';
+
+class NewWalletPageRobot {
+  NewWalletPageRobot(this.tester) : commonTestCases = CommonTestCases(tester);
+
+  final WidgetTester tester;
+  late CommonTestCases commonTestCases;
+
+  Future<void> isNewWalletPage() async {
+    await commonTestCases.isSpecificPage<NewWalletPage>();
+  }
+
+  Future<void> enterWalletName(String walletName) async {
+    await commonTestCases.enterText(
+      walletName,
+      'new_wallet_page_wallet_name_textformfield_key',
+    );
+    await commonTestCases.defaultSleepTime();
+  }
+
+  Future<void> generateWalletName() async {
+    await commonTestCases.tapItemByKey(
+      'new_wallet_page_wallet_name_textformfield_generate_name_button_key',
+    );
+    await commonTestCases.defaultSleepTime();
+  }
+
+  Future<void> onNextButtonPressed() async {
+    await commonTestCases.tapItemByKey('new_wallet_page_confirm_button_key');
+    await commonTestCases.defaultSleepTime();
+  }
+}

integration_test/robots/pin_code_widget_robot.dart

@@ -24,13 +24,12 @@ class PinCodeWidgetRobot {
     commonTestCases.hasValueKey('pin_code_button_0_key');
   }
 
-  Future<void> pushPinButton(int index) async {
-    await commonTestCases.tapItemByKey('pin_code_button_${index}_key');
-  }
-
-  Future<void> enterPinCode(List<int> pinCode, bool isFirstEntry) async {
+  Future<void> enterPinCode(List<int> pinCode, {int pumpDuration = 100}) async {
     for (int pin in pinCode) {
-      await pushPinButton(pin);
+      await commonTestCases.tapItemByKey(
+        'pin_code_button_${pin}_key',
+        pumpDuration: pumpDuration,
+      );
     }
 
     await commonTestCases.defaultSleepTime();

integration_test/robots/pre_seed_page_robot.dart

@@ -0,0 +1,20 @@
+import 'package:cake_wallet/src/screens/seed/pre_seed_page.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../components/common_test_cases.dart';
+
+class PreSeedPageRobot {
+  PreSeedPageRobot(this.tester) : commonTestCases = CommonTestCases(tester);
+
+  final WidgetTester tester;
+  late CommonTestCases commonTestCases;
+
+  Future<void> isPreSeedPage() async {
+    await commonTestCases.isSpecificPage<PreSeedPage>();
+  }
+
+  Future<void> onConfirmButtonPressed() async {
+    await commonTestCases.tapItemByKey('pre_seed_page_button_key');
+    await commonTestCases.defaultSleepTime();
+  }
+}

integration_test/robots/restore_from_seed_or_key_robot.dart

@@ -1,3 +1,4 @@
+import 'package:cake_wallet/entities/seed_type.dart';
 import 'package:cake_wallet/generated/i18n.dart';
 import 'package:cake_wallet/src/screens/restore/wallet_restore_page.dart';
 import 'package:cake_wallet/src/widgets/validable_annotated_editable_text.dart';
@@ -70,6 +71,22 @@ class RestoreFromSeedOrKeysPageRobot {
     await tester.pumpAndSettle();
   }
 
+  Future<void> enterBlockHeightForWalletRestore(String blockHeight) async {
+    await commonTestCases.enterText(
+      blockHeight,
+      'wallet_restore_from_seed_blockheight_textfield_key',
+    );
+    await tester.pumpAndSettle();
+  }
+
+  Future<void> chooseSeedTypeForMoneroOrWowneroWallets(MoneroSeedType selectedType) async {
+    await commonTestCases.tapItemByKey('wallet_restore_from_seed_seedtype_picker_button_key');
+
+    await commonTestCases.defaultSleepTime();
+
+    await commonTestCases.tapItemByKey('picker_items_index_${selectedType.title}_button_key');
+  }
+
   Future<void> onPasteSeedPhraseButtonPressed() async {
     await commonTestCases.tapItemByKey('wallet_restore_from_seed_wallet_seeds_paste_button_key');
   }

integration_test/robots/restore_options_page_robot.dart

@@ -14,14 +14,14 @@ class RestoreOptionsPageRobot {
   }
 
   void hasRestoreOptionsButton() {
-    commonTestCases.hasValueKey('restore_options_from_seeds_button_key');
+    commonTestCases.hasValueKey('restore_options_from_seeds_or_keys_button_key');
     commonTestCases.hasValueKey('restore_options_from_backup_button_key');
     commonTestCases.hasValueKey('restore_options_from_hardware_wallet_button_key');
     commonTestCases.hasValueKey('restore_options_from_qr_button_key');
   }
 
-  Future<void> navigateToRestoreFromSeedsPage() async {
-    await commonTestCases.tapItemByKey('restore_options_from_seeds_button_key');
+  Future<void> navigateToRestoreFromSeedsOrKeysPage() async {
+    await commonTestCases.tapItemByKey('restore_options_from_seeds_or_keys_button_key');
     await commonTestCases.defaultSleepTime();
   }
 

integration_test/robots/security_and_backup_page_robot.dart

@@ -0,0 +1,24 @@
+import 'package:cake_wallet/generated/i18n.dart';
+import 'package:cake_wallet/src/screens/settings/security_backup_page.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../components/common_test_cases.dart';
+
+class SecurityAndBackupPageRobot {
+  SecurityAndBackupPageRobot(this.tester) : commonTestCases = CommonTestCases(tester);
+
+  final WidgetTester tester;
+  final CommonTestCases commonTestCases;
+
+  Future<void> isSecurityAndBackupPage() async {
+    await commonTestCases.isSpecificPage<SecurityBackupPage>();
+  }
+
+  void hasTitle() {
+    commonTestCases.hasText(S.current.security_and_backup);
+  }
+
+  Future<void> navigateToShowKeysPage() async {
+    await commonTestCases.tapItemByKey('security_backup_page_show_keys_button_key');
+  }
+}

integration_test/robots/send_page_robot.dart

@@ -84,7 +84,7 @@ class SendPageRobot {
       return;
     }
 
-    await commonTestCases.scrollUntilVisible(
+    await commonTestCases.dragUntilVisible(
       'picker_items_index_${receiveCurrency.name}_button_key',
       'picker_scrollbar_key',
     );
@@ -117,7 +117,7 @@ class SendPageRobot {
       return;
     }
 
-    await commonTestCases.scrollUntilVisible(
+    await commonTestCases.dragUntilVisible(
       'picker_items_index_${priority.title}_button_key',
       'picker_scrollbar_key',
     );
@@ -198,7 +198,7 @@ class SendPageRobot {
       tester.printToConsole('Starting inner _handleAuth loop checks');
 
       try {
-        await authPageRobot.enterPinCode(CommonTestConstants.pin, false);
+        await authPageRobot.enterPinCode(CommonTestConstants.pin, pumpDuration: 500);
         tester.printToConsole('Auth done');
 
         await tester.pump();
@@ -213,6 +213,7 @@ class SendPageRobot {
   }
 
   Future<void> handleSendResult() async {
+    await tester.pump();
     tester.printToConsole('Inside handle function');
 
     bool hasError = false;
@@ -287,6 +288,8 @@ class SendPageRobot {
       // Loop to wait for the operation to commit transaction
       await _waitForCommitTransactionCompletion();
 
+      await tester.pump();
+
       await commonTestCases.defaultSleepTime(seconds: 4);
     } else {
       await commonTestCases.defaultSleepTime();

integration_test/robots/transactions_page_robot.dart

@@ -0,0 +1,286 @@
+import 'dart:async';
+
+import 'package:cake_wallet/generated/i18n.dart';
+import 'package:cake_wallet/src/screens/dashboard/pages/transactions_page.dart';
+import 'package:cake_wallet/utils/date_formatter.dart';
+import 'package:cake_wallet/view_model/dashboard/action_list_item.dart';
+import 'package:cake_wallet/view_model/dashboard/anonpay_transaction_list_item.dart';
+import 'package:cake_wallet/view_model/dashboard/dashboard_view_model.dart';
+import 'package:cake_wallet/view_model/dashboard/date_section_item.dart';
+import 'package:cake_wallet/view_model/dashboard/order_list_item.dart';
+import 'package:cake_wallet/view_model/dashboard/trade_list_item.dart';
+import 'package:cake_wallet/view_model/dashboard/transaction_list_item.dart';
+import 'package:cw_core/crypto_currency.dart';
+import 'package:cw_core/sync_status.dart';
+import 'package:cw_core/transaction_direction.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:intl/intl.dart';
+
+import '../components/common_test_cases.dart';
+
+class TransactionsPageRobot {
+  TransactionsPageRobot(this.tester) : commonTestCases = CommonTestCases(tester);
+
+  final WidgetTester tester;
+  late CommonTestCases commonTestCases;
+
+  Future<void> isTransactionsPage() async {
+    await commonTestCases.isSpecificPage<TransactionsPage>();
+  }
+
+  Future<void> confirmTransactionsPageConstantsDisplayProperly() async {
+    await commonTestCases.defaultSleepTime();
+
+    final transactionsPage = tester.widget<TransactionsPage>(find.byType(TransactionsPage));
+    final dashboardViewModel = transactionsPage.dashboardViewModel;
+    if (dashboardViewModel.status is SyncingSyncStatus) {
+      commonTestCases.hasValueKey('transactions_page_syncing_alert_card_key');
+      commonTestCases.hasText(S.current.syncing_wallet_alert_title);
+      commonTestCases.hasText(S.current.syncing_wallet_alert_content);
+    }
+
+    commonTestCases.hasValueKey('transactions_page_header_row_key');
+    commonTestCases.hasText(S.current.transactions);
+    commonTestCases.hasValueKey('transactions_page_header_row_transaction_filter_button_key');
+  }
+
+  Future<void> confirmTransactionHistoryListDisplaysCorrectly(bool hasTxHistoryWhileSyncing) async {
+    // Retrieve the TransactionsPage widget and its DashboardViewModel
+    final transactionsPage = tester.widget<TransactionsPage>(find.byType(TransactionsPage));
+    final dashboardViewModel = transactionsPage.dashboardViewModel;
+
+    // Define a timeout to prevent infinite loops
+    // Putting at one hour for cases like monero that takes time to sync
+    final timeout = Duration(hours: 1);
+    final pollingInterval = Duration(seconds: 2);
+    final endTime = DateTime.now().add(timeout);
+
+    while (DateTime.now().isBefore(endTime)) {
+      final isSynced = dashboardViewModel.status is SyncedSyncStatus;
+      final itemsLoaded = dashboardViewModel.items.isNotEmpty;
+
+      // Perform item checks if items are loaded
+      if (itemsLoaded) {
+        await _performItemChecks(dashboardViewModel);
+      } else {
+        // Verify placeholder when items are not loaded
+        _verifyPlaceholder();
+      }
+
+      // Determine if we should exit the loop
+      if (_shouldExitLoop(hasTxHistoryWhileSyncing, isSynced, itemsLoaded)) {
+        break;
+      }
+
+      // Pump the UI and wait for the next polling interval
+      await tester.pump(pollingInterval);
+    }
+
+    // After the loop, verify that both status is synced and items are loaded
+    if (!_isFinalStateValid(dashboardViewModel)) {
+      throw TimeoutException('Dashboard did not sync and load items within the allotted time.');
+    }
+  }
+
+  bool _shouldExitLoop(bool hasTxHistoryWhileSyncing, bool isSynced, bool itemsLoaded) {
+    if (hasTxHistoryWhileSyncing) {
+      // When hasTxHistoryWhileSyncing is true, exit when status is synced
+      return isSynced;
+    } else {
+      // When hasTxHistoryWhileSyncing is false, exit when status is synced and items are loaded
+      return isSynced && itemsLoaded;
+    }
+  }
+
+  void _verifyPlaceholder() {
+    commonTestCases.hasValueKey('transactions_page_placeholder_transactions_text_key');
+    commonTestCases.hasText(S.current.placeholder_transactions);
+  }
+
+  bool _isFinalStateValid(DashboardViewModel dashboardViewModel) {
+    final isSynced = dashboardViewModel.status is SyncedSyncStatus;
+    final itemsLoaded = dashboardViewModel.items.isNotEmpty;
+    return isSynced && itemsLoaded;
+  }
+
+  Future<void> _performItemChecks(DashboardViewModel dashboardViewModel) async {
+    List<ActionListItem> items = dashboardViewModel.items;
+    for (var item in items) {
+      final keyId = (item.key as ValueKey<String>).value;
+      tester.printToConsole('\n');
+      tester.printToConsole(keyId);
+
+      await commonTestCases.dragUntilVisible(keyId, 'transactions_page_list_view_builder_key');
+      await tester.pump();
+
+      final isWidgetVisible = tester.any(find.byKey(ValueKey(keyId)));
+      if (!isWidgetVisible) {
+        tester.printToConsole('Moving to next visible item on list');
+        continue;
+      }
+      ;
+      await tester.pump();
+
+      if (item is DateSectionItem) {
+        await _verifyDateSectionItem(item);
+      } else if (item is TransactionListItem) {
+        tester.printToConsole(item.formattedTitle);
+        tester.printToConsole(item.formattedFiatAmount);
+        tester.printToConsole('\n');
+        await _verifyTransactionListItemDisplay(item, dashboardViewModel);
+      } else if (item is AnonpayTransactionListItem) {
+        await _verifyAnonpayTransactionListItemDisplay(item);
+      } else if (item is TradeListItem) {
+        await _verifyTradeListItemDisplay(item);
+      } else if (item is OrderListItem) {
+        await _verifyOrderListItemDisplay(item);
+      }
+    }
+  }
+
+  Future<void> _verifyDateSectionItem(DateSectionItem item) async {
+    final title = DateFormatter.convertDateTimeToReadableString(item.date);
+    tester.printToConsole(title);
+    await tester.pump();
+
+    commonTestCases.findWidgetViaDescendant(
+      of: find.byKey(item.key),
+      matching: find.text(title),
+    );
+  }
+
+  Future<void> _verifyTransactionListItemDisplay(
+    TransactionListItem item,
+    DashboardViewModel dashboardViewModel,
+  ) async {
+    final keyId =
+        '${dashboardViewModel.type.name}_transaction_history_item_${item.transaction.id}_key';
+
+    if (item.hasTokens && item.assetOfTransaction == null) return;
+
+    //* ==============Confirm it has the right key for this item ========
+    commonTestCases.hasValueKey(keyId);
+
+    //* ======Confirm it displays the properly formatted amount==========
+    commonTestCases.findWidgetViaDescendant(
+      of: find.byKey(ValueKey(keyId)),
+      matching: find.text(item.formattedCryptoAmount),
+    );
+
+    //* ======Confirm it displays the properly formatted title===========
+    final transactionType = dashboardViewModel.getTransactionType(item.transaction);
+
+    final title = item.formattedTitle + item.formattedStatus + transactionType;
+
+    commonTestCases.findWidgetViaDescendant(
+      of: find.byKey(ValueKey(keyId)),
+      matching: find.text(title),
+    );
+
+    //* ======Confirm it displays the properly formatted date============
+    final formattedDate = DateFormat('HH:mm').format(item.transaction.date);
+    commonTestCases.findWidgetViaDescendant(
+      of: find.byKey(ValueKey(keyId)),
+      matching: find.text(formattedDate),
+    );
+
+    //* ======Confirm it displays the properly formatted fiat amount=====
+    final formattedFiatAmount =
+        dashboardViewModel.balanceViewModel.isFiatDisabled ? '' : item.formattedFiatAmount;
+    if (formattedFiatAmount.isNotEmpty) {
+      commonTestCases.findWidgetViaDescendant(
+        of: find.byKey(ValueKey(keyId)),
+        matching: find.text(formattedFiatAmount),
+      );
+    }
+
+    //* ======Confirm it displays the right image based on the transaction direction=====
+    final imageToUse = item.transaction.direction == TransactionDirection.incoming
+        ? 'assets/images/down_arrow.png'
+        : 'assets/images/up_arrow.png';
+
+    find.widgetWithImage(Container, AssetImage(imageToUse));
+  }
+
+  Future<void> _verifyAnonpayTransactionListItemDisplay(AnonpayTransactionListItem item) async {
+    final keyId = 'anonpay_invoice_transaction_list_item_${item.transaction.invoiceId}_key';
+
+    //* ==============Confirm it has the right key for this item ========
+    commonTestCases.hasValueKey(keyId);
+
+    //* ==============Confirm it displays the correct provider =========================
+    commonTestCases.hasText(item.transaction.provider);
+
+    //* ===========Confirm it displays the properly formatted amount with currency ========
+    final currency = item.transaction.fiatAmount != null
+        ? item.transaction.fiatEquiv ?? ''
+        : CryptoCurrency.fromFullName(item.transaction.coinTo).name.toUpperCase();
+
+    final amount =
+        item.transaction.fiatAmount?.toString() ?? (item.transaction.amountTo?.toString() ?? '');
+
+    final amountCurrencyText = amount + ' ' + currency;
+
+    commonTestCases.hasText(amountCurrencyText);
+
+    //* ======Confirm it displays the properly formatted date=================
+    final formattedDate = DateFormat('HH:mm').format(item.transaction.createdAt);
+    commonTestCases.hasText(formattedDate);
+
+    //* ===============Confirm it displays the right image====================
+    find.widgetWithImage(ClipRRect, AssetImage('assets/images/trocador.png'));
+  }
+
+  Future<void> _verifyTradeListItemDisplay(TradeListItem item) async {
+    final keyId = 'trade_list_item_${item.trade.id}_key';
+
+    //* ==============Confirm it has the right key for this item ========
+    commonTestCases.hasValueKey(keyId);
+
+    //* ==============Confirm it displays the correct provider =========================
+    final conversionFlow = '${item.trade.from.toString()} → ${item.trade.to.toString()}';
+
+    commonTestCases.hasText(conversionFlow);
+
+    //* ===========Confirm it displays the properly formatted amount with its crypto tag ========
+
+    final amountCryptoText = item.tradeFormattedAmount + ' ' + item.trade.from.toString();
+
+    commonTestCases.hasText(amountCryptoText);
+
+    //* ======Confirm it displays the properly formatted date=================
+    final createdAtFormattedDate =
+        item.trade.createdAt != null ? DateFormat('HH:mm').format(item.trade.createdAt!) : null;
+
+    if (createdAtFormattedDate != null) {
+      commonTestCases.hasText(createdAtFormattedDate);
+    }
+
+    //* ===============Confirm it displays the right image====================
+    commonTestCases.hasValueKey(item.trade.provider.image);
+  }
+
+  Future<void> _verifyOrderListItemDisplay(OrderListItem item) async {
+    final keyId = 'order_list_item_${item.order.id}_key';
+
+    //* ==============Confirm it has the right key for this item ========
+    commonTestCases.hasValueKey(keyId);
+
+    //* ==============Confirm it displays the correct provider =========================
+    final orderFlow = '${item.order.from!} → ${item.order.to}';
+
+    commonTestCases.hasText(orderFlow);
+
+    //* ===========Confirm it displays the properly formatted amount with its crypto tag ========
+
+    final amountCryptoText = item.orderFormattedAmount + ' ' + item.order.to!;
+
+    commonTestCases.hasText(amountCryptoText);
+
+    //* ======Confirm it displays the properly formatted date=================
+    final createdAtFormattedDate = DateFormat('HH:mm').format(item.order.createdAt);
+
+    commonTestCases.hasText(createdAtFormattedDate);
+  }
+}

integration_test/robots/wallet_group_description_page_robot.dart

@@ -0,0 +1,32 @@
+import 'package:cake_wallet/generated/i18n.dart';
+import 'package:cake_wallet/src/screens/new_wallet/wallet_group_description_page.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../components/common_test_cases.dart';
+
+class WalletGroupDescriptionPageRobot {
+  WalletGroupDescriptionPageRobot(this.tester) : commonTestCases = CommonTestCases(tester);
+
+  final WidgetTester tester;
+  final CommonTestCases commonTestCases;
+
+  Future<void> isWalletGroupDescriptionPage() async {
+    await commonTestCases.isSpecificPage<WalletGroupDescriptionPage>();
+  }
+
+  void hasTitle() {
+    commonTestCases.hasText(S.current.wallet_group);
+  }
+
+  Future<void> navigateToCreateNewSeedPage() async {
+    await commonTestCases.tapItemByKey(
+      'wallet_group_description_page_create_new_seed_button_key',
+    );
+  }
+
+  Future<void> navigateToChooseWalletGroup() async {
+    await commonTestCases.tapItemByKey(
+      'wallet_group_description_page_choose_wallet_group_button_key',
+    );
+  }
+}

integration_test/robots/wallet_keys_robot.dart

@@ -0,0 +1,162 @@
+import 'package:cake_wallet/generated/i18n.dart';
+import 'package:cake_wallet/reactions/wallet_connect.dart';
+import 'package:cake_wallet/src/screens/wallet_keys/wallet_keys_page.dart';
+import 'package:cake_wallet/store/app_store.dart';
+import 'package:cw_core/monero_wallet_keys.dart';
+import 'package:cw_core/wallet_type.dart';
+import 'package:cw_monero/monero_wallet.dart';
+import 'package:cw_wownero/wownero_wallet.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:polyseed/polyseed.dart';
+
+import '../components/common_test_cases.dart';
+
+class WalletKeysAndSeedPageRobot {
+  WalletKeysAndSeedPageRobot(this.tester) : commonTestCases = CommonTestCases(tester);
+
+  final WidgetTester tester;
+  final CommonTestCases commonTestCases;
+
+  Future<void> isWalletKeysAndSeedPage() async {
+    await commonTestCases.isSpecificPage<WalletKeysPage>();
+  }
+
+  void hasTitle() {
+    final walletKeysPage = tester.widget<WalletKeysPage>(find.byType(WalletKeysPage));
+    final walletKeysViewModel = walletKeysPage.walletKeysViewModel;
+    commonTestCases.hasText(walletKeysViewModel.title);
+  }
+
+  void hasShareWarning() {
+    commonTestCases.hasText(S.current.do_not_share_warning_text.toUpperCase());
+  }
+
+  Future<void> confirmWalletCredentials(WalletType walletType) async {
+    final walletKeysPage = tester.widget<WalletKeysPage>(find.byType(WalletKeysPage));
+    final walletKeysViewModel = walletKeysPage.walletKeysViewModel;
+
+    final appStore = walletKeysViewModel.appStore;
+    final walletName = walletType.name;
+    bool hasSeed = appStore.wallet!.seed != null;
+    bool hasHexSeed = appStore.wallet!.hexSeed != null;
+    bool hasPrivateKey = appStore.wallet!.privateKey != null;
+
+    if (walletType == WalletType.monero) {
+      final moneroWallet = appStore.wallet as MoneroWallet;
+      final lang = PolyseedLang.getByPhrase(moneroWallet.seed);
+      final legacySeed = moneroWallet.seedLegacy(lang.nameEnglish);
+
+      _confirmMoneroWalletCredentials(
+        appStore,
+        walletName,
+        moneroWallet.seed,
+        legacySeed,
+      );
+    }
+
+    if (walletType == WalletType.wownero) {
+      final wowneroWallet = appStore.wallet as WowneroWallet;
+      final lang = PolyseedLang.getByPhrase(wowneroWallet.seed);
+      final legacySeed = wowneroWallet.seedLegacy(lang.nameEnglish);
+
+      _confirmMoneroWalletCredentials(
+        appStore,
+        walletName,
+        wowneroWallet.seed,
+        legacySeed,
+      );
+    }
+
+    if (walletType == WalletType.bitcoin ||
+        walletType == WalletType.litecoin ||
+        walletType == WalletType.bitcoinCash) {
+      commonTestCases.hasText(appStore.wallet!.seed!);
+      tester.printToConsole('$walletName wallet has seeds properly displayed');
+    }
+
+    if (isEVMCompatibleChain(walletType) ||
+        walletType == WalletType.solana ||
+        walletType == WalletType.tron) {
+      if (hasSeed) {
+        commonTestCases.hasText(appStore.wallet!.seed!);
+        tester.printToConsole('$walletName wallet has seeds properly displayed');
+      }
+      if (hasPrivateKey) {
+        commonTestCases.hasText(appStore.wallet!.privateKey!);
+        tester.printToConsole('$walletName wallet has private key properly displayed');
+      }
+    }
+
+    if (walletType == WalletType.nano || walletType == WalletType.banano) {
+      if (hasSeed) {
+        commonTestCases.hasText(appStore.wallet!.seed!);
+        tester.printToConsole('$walletName wallet has seeds properly displayed');
+      }
+      if (hasHexSeed) {
+        commonTestCases.hasText(appStore.wallet!.hexSeed!);
+        tester.printToConsole('$walletName wallet has hexSeed properly displayed');
+      }
+      if (hasPrivateKey) {
+        commonTestCases.hasText(appStore.wallet!.privateKey!);
+        tester.printToConsole('$walletName wallet has private key properly displayed');
+      }
+    }
+
+    await commonTestCases.defaultSleepTime(seconds: 5);
+  }
+
+  void _confirmMoneroWalletCredentials(
+    AppStore appStore,
+    String walletName,
+    String seed,
+    String legacySeed,
+  ) {
+    final keys = appStore.wallet!.keys as MoneroWalletKeys;
+
+    final hasPublicSpendKey = commonTestCases.isKeyPresent(
+      '${walletName}_wallet_public_spend_key_item_key',
+    );
+    final hasPrivateSpendKey = commonTestCases.isKeyPresent(
+      '${walletName}_wallet_private_spend_key_item_key',
+    );
+    final hasPublicViewKey = commonTestCases.isKeyPresent(
+      '${walletName}_wallet_public_view_key_item_key',
+    );
+    final hasPrivateViewKey = commonTestCases.isKeyPresent(
+      '${walletName}_wallet_private_view_key_item_key',
+    );
+    final hasSeeds = seed.isNotEmpty;
+    final hasSeedLegacy = Polyseed.isValidSeed(seed);
+
+    if (hasPublicSpendKey) {
+      commonTestCases.hasText(keys.publicSpendKey);
+      tester.printToConsole('$walletName wallet has public spend key properly displayed');
+    }
+    if (hasPrivateSpendKey) {
+      commonTestCases.hasText(keys.privateSpendKey);
+      tester.printToConsole('$walletName wallet has private spend key properly displayed');
+    }
+    if (hasPublicViewKey) {
+      commonTestCases.hasText(keys.publicViewKey);
+      tester.printToConsole('$walletName wallet has public view key properly displayed');
+    }
+    if (hasPrivateViewKey) {
+      commonTestCases.hasText(keys.privateViewKey);
+      tester.printToConsole('$walletName wallet has private view key properly displayed');
+    }
+    if (hasSeeds) {
+      commonTestCases.hasText(seed);
+      tester.printToConsole('$walletName wallet has seeds properly displayed');
+    }
+    if (hasSeedLegacy) {
+      commonTestCases.hasText(legacySeed);
+      tester.printToConsole('$walletName wallet has legacy seeds properly displayed');
+    }
+  }
+
+  Future<void> backToDashboard() async {
+    tester.printToConsole('Going back to dashboard from credentials page');
+    await commonTestCases.goBack();
+    await commonTestCases.goBack();
+  }
+}

integration_test/robots/wallet_list_page_robot.dart

@@ -0,0 +1,27 @@
+import 'package:cake_wallet/generated/i18n.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../components/common_test_cases.dart';
+
+class WalletListPageRobot {
+  WalletListPageRobot(this.tester) : commonTestCases = CommonTestCases(tester);
+
+  final WidgetTester tester;
+  late CommonTestCases commonTestCases;
+
+  Future<void> isWalletListPage() async {
+    await commonTestCases.isSpecificPage<WalletListPageRobot>();
+  }
+
+  void displaysCorrectTitle() {
+    commonTestCases.hasText(S.current.wallets);
+  }
+
+  Future<void> navigateToCreateNewWalletPage() async {
+    commonTestCases.tapItemByKey('wallet_list_page_create_new_wallet_button_key');
+  }
+
+  Future<void> navigateToRestoreWalletOptionsPage() async {
+    commonTestCases.tapItemByKey('wallet_list_page_restore_wallet_button_key');
+  }
+}

integration_test/robots/wallet_seed_page_robot.dart

@@ -0,0 +1,57 @@
+import 'package:cake_wallet/generated/i18n.dart';
+import 'package:cake_wallet/src/screens/seed/wallet_seed_page.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import '../components/common_test_cases.dart';
+
+class WalletSeedPageRobot {
+  WalletSeedPageRobot(this.tester) : commonTestCases = CommonTestCases(tester);
+
+  final WidgetTester tester;
+  late CommonTestCases commonTestCases;
+
+  Future<void> isWalletSeedPage() async {
+    await commonTestCases.isSpecificPage<WalletSeedPage>();
+  }
+
+  Future<void> onNextButtonPressed() async {
+    await commonTestCases.tapItemByKey('wallet_seed_page_next_button_key');
+    await commonTestCases.defaultSleepTime();
+  }
+
+  Future<void> onConfirmButtonOnSeedAlertDialogPressed() async {
+    await commonTestCases.tapItemByKey('wallet_seed_page_seed_alert_confirm_button_key');
+    await commonTestCases.defaultSleepTime();
+  }
+
+  Future<void> onBackButtonOnSeedAlertDialogPressed() async {
+    await commonTestCases.tapItemByKey('wallet_seed_page_seed_alert_back_button_key');
+    await commonTestCases.defaultSleepTime();
+  }
+
+  void confirmWalletDetailsDisplayCorrectly() {
+    final walletSeedPage = tester.widget<WalletSeedPage>(find.byType(WalletSeedPage));
+
+    final walletSeedViewModel = walletSeedPage.walletSeedViewModel;
+
+    final walletName = walletSeedViewModel.name;
+    final walletSeeds = walletSeedViewModel.seed;
+
+    commonTestCases.hasText(walletName);
+    commonTestCases.hasText(walletSeeds);
+  }
+
+  void confirmWalletSeedReminderDisplays() {
+    commonTestCases.hasText(S.current.seed_reminder);
+  }
+
+  Future<void> onSaveSeedsButtonPressed() async {
+    await commonTestCases.tapItemByKey('wallet_seed_page_save_seeds_button_key');
+    await commonTestCases.defaultSleepTime();
+  }
+
+  Future<void> onCopySeedsButtonPressed() async {
+    await commonTestCases.tapItemByKey('wallet_seed_page_copy_seeds_button_key');
+    await commonTestCases.defaultSleepTime();
+  }
+}