status-desktop/test/e2e/gui/screens/settings_wallet.py

import time
import typing

import allure
from objectmaphelper import RegularExpression

import configs.timeouts
import constants
import driver
from constants import wallet_account_list_item
from constants.wallet import WalletNetworkSettings, WalletNetworkDefaultValues
from driver import objects_access
from driver.objects_access import walk_children
from gui.components.settings.rename_keypair_popup import RenameKeypairPopup
from gui.components.wallet.RPCChangeRestartPopup import RPCChangeRestartPopup
from gui.components.wallet.add_saved_address_popup import AddressPopup
from gui.components.wallet.popup_delete_account_from_settings import RemoveAccountConfirmationSettings
from gui.components.wallet.testnet_mode_popup import TestnetModePopup

from gui.components.wallet.wallet_account_popups import AccountPopup, EditAccountFromSettingsPopup
from gui.elements.button import Button
from gui.elements.check_box import CheckBox
from gui.elements.object import QObject
from gui.elements.scroll import Scroll
from gui.elements.text_edit import TextEdit
from gui.elements.text_label import TextLabel
from gui.objects_map import settings_names, wallet_names


class WalletSettingsView(QObject):

    def __init__(self):
        super().__init__(settings_names.mainWindow_WalletView)
        self._scroll = Scroll(settings_names.settingsContentBase_ScrollView)
        self._wallet_settings_add_new_account_button = Button(settings_names.settings_Wallet_MainView_AddNewAccountButton)
        self._wallet_network_button = Button(settings_names.settings_Wallet_MainView_Networks)
        self._wallet_manage_tokens_button = Button(settings_names.settings_Wallet_MainView_Manage_Tokens)
        self._account_order_button = Button(settings_names.settingsContentBaseScrollView_accountOrderItem_StatusListItem)
        self._saved_addresses_button = Button(settings_names.settingsContentBaseScrollView_savedAddressesItem_StatusListItem)
        self._status_account_in_keypair = QObject(settings_names.settingsWalletAccountDelegate_Status_account)
        self._wallet_account_from_keypair = QObject(settings_names.settingsWalletAccountDelegate)
        self._wallet_settings_keypair_item = QObject(settings_names.settingsWalletKeyPairDelegate)
        self._wallet_settings_total_balance_item = QObject(settings_names.settingsWalletAccountTotalBalance)
        self._wallet_settings_total_balance_toggle = CheckBox(settings_names.settingsWalletAccountTotalBalanceToggle)
        self._rename_keypair_menu_item = QObject(settings_names.rename_keypair_StatusMenuItem)

    @allure.step('Wait until appears {0}')
    def wait_until_appears(self, timeout_msec: int = configs.timeouts.UI_LOAD_TIMEOUT_MSEC):
        self._wallet_settings_add_new_account_button.wait_until_appears(timeout_msec)
        return self

    @allure.step('Open add account pop up in wallet settings')
    def open_add_account_pop_up(self, attempts: int = 2) -> 'AccountPopup':
        self._wallet_settings_add_new_account_button.click()
        try:
            return AccountPopup().verify_add_account_popup_present()
        except Exception as ex:
            if attempts:
                return self.open_add_account_pop_up(attempts - 1)
            else:
                raise ex

    @allure.step('Open saved addresses in wallet settings')
    def open_saved_addresses(self, attempts: int = 2) -> 'SavedAddressesWalletSettings':
        self._saved_addresses_button.click()
        try:
            return SavedAddressesWalletSettings()
        except Exception as ex:
            if attempts:
                return self.open_saved_addresses(attempts - 1)
            else:
                raise ex

    @allure.step('Open networks in wallet settings')
    def open_networks(self, attempts: int = 2) -> 'NetworkWalletSettings':
        self._wallet_network_button.click()
        try:
            return NetworkWalletSettings().wait_until_appears()
        except Exception as err:
            if attempts:
                return self.open_networks(attempts - 1)
            else:
                raise err

    @allure.step('Open manage tokens in wallet settings')
    def open_manage_tokens(self, attempts: int = 2) -> 'ManageTokensSettingsView':
        self._wallet_manage_tokens_button.click()
        try:
            return ManageTokensSettingsView().wait_until_appears()
        except Exception as err:
            if attempts:
                return self.open_manage_tokens(attempts - 1)
            else:
                raise err

    @allure.step('Open account order in wallet settings')
    def open_account_order(self, attempts: int = 2):
        self._account_order_button.click()
        try:
            return EditAccountOrderSettings().wait_until_appears()
        except Exception as err:
            if attempts:
                return self.open_account_order(attempts - 1)
            else:
                raise err

    @allure.step('Get keypair settings_names')
    def get_keypairs_names(self):
        keypair_names = []
        for item in driver.findAllObjects(self._wallet_settings_keypair_item.real_name):
            keypair_names.append(str(getattr(item, 'title', '')))
        if len(keypair_names) == 0:
            raise LookupError(
                'No keypairs found on the wallet settings screen')
        else:
            return keypair_names

    @allure.step('Open account view in wallet settings by name')
    def open_account_in_settings(self, name: str, index: int):
        self._wallet_account_from_keypair.real_name['objectName'] = name
        self._wallet_account_from_keypair.real_name['index'] = index
        self._wallet_account_from_keypair.click()
        return AccountDetailsView().wait_until_appears()

    @allure.step('Check Include in total balance item is visible')
    def is_include_in_total_balance_visible(self):
        return self._wallet_settings_total_balance_item.is_visible

    @allure.step('Interact with the total balance toggle')
    def toggle_total_balance(self, value: bool):
        self._wallet_settings_total_balance_toggle.set(value)

    @allure.step('Click open menu button')
    def click_open_menu_button(self, title: str):
        for item in driver.findAllObjects(self._wallet_settings_keypair_item.real_name):
            if str(getattr(item, 'title', '')) == title:
                for child in walk_children(item):
                    if getattr(child, 'objectName', '') == 'more-icon':
                        more_button = QObject(real_name=driver.objectMap.realName(child))
                        self._scroll.vertical_scroll_down(more_button)
                        more_button.click()
                        break

    @allure.step('Get visibility of rename keypair menu item')
    def is_rename_keypair_menu_item_visible(self):
        return self._rename_keypair_menu_item.is_visible

    @allure.step('Choose rename keypair option')
    def click_rename_keypair(self):
        self._rename_keypair_menu_item.click()
        return RenameKeypairPopup().wait_until_appears()


class AccountDetailsView(WalletSettingsView):
    def __init__(self):
        super(AccountDetailsView, self).__init__()
        self._back_button = Button(settings_names.main_toolBar_back_button)
        self._edit_account_button = Button(settings_names.walletAccountViewEditAccountButton)
        self._remove_account_button = Button(settings_names.walletAccountViewRemoveAccountButton)
        self._wallet_account_title = TextLabel(settings_names.walletAccountViewAccountName)
        self._wallet_account_emoji = QObject(settings_names.walletAccountViewAccountEmoji)
        self._wallet_account_details_label = TextLabel(settings_names.walletAccountViewDetailsLabel)
        self._wallet_account_balance = QObject(settings_names.walletAccountViewBalance)
        self._wallet_account_keypair_item = QObject(settings_names.walletAccountViewKeypairItem)
        self._wallet_account_address = QObject(settings_names.walletAccountViewAddress)
        self._wallet_account_origin = TextLabel(settings_names.walletAccountViewOrigin)
        self._wallet_account_derivation_path = QObject(settings_names.walletAccountViewDerivationPath)
        self._wallet_account_stored = TextLabel(settings_names.walletAccountViewStored)
        self._wallet_preferred_networks = QObject(settings_names.walletAccountViewPreferredNetworks)

    @allure.step('Wait until appears {0}')
    def wait_until_appears(self, timeout_msec: int = configs.timeouts.UI_LOAD_TIMEOUT_MSEC):
        self._edit_account_button.wait_until_appears(timeout_msec)
        return self

    @allure.step('Click Edit button')
    def click_edit_account_button(self):
        self._edit_account_button.click()
        return EditAccountFromSettingsPopup().wait_until_appears()

    @allure.step('Click Remove account button')
    def click_remove_account_button(self):
        self._remove_account_button.click()
        return RemoveAccountConfirmationSettings().wait_until_appears()

    @allure.step('Check if Remove account button is visible')
    def is_remove_account_button_visible(self):
        return self._remove_account_button.is_visible

    @allure.step('Get account name')
    def get_account_name_value(self):
        return self._wallet_account_title.text

    @allure.step('Get account balance value')
    def get_account_balance_value(self):
        balance = str(getattr(self._wallet_account_balance.object, 'subTitle'))[:-4]
        return balance

    @allure.step("Get account address value")
    def get_account_address_value(self):
        raw_value = str(getattr(self._wallet_account_address.object, 'subTitle'))
        address = raw_value.split(">")[-1]
        return address

    @allure.step('Get account color value')
    def get_account_color_value(self):
        color_name = str(getattr(self._wallet_account_title.object, 'color')['name'])
        return color_name

    @allure.step('Get account emoji id')
    def get_account_emoji_id(self):
        emoji_id = str(getattr(self._wallet_account_emoji.object, 'emojiId'))
        return emoji_id

    @allure.step('Get account origin value')
    def get_account_origin_value(self):
        return str(getattr(self._wallet_account_origin.object, 'subTitle'))

    @allure.step('Get account derivation path value')
    def get_account_derivation_path_value(self):
        return str(getattr(self._wallet_account_derivation_path.object, 'subTitle'))

    @allure.step('Get derivation path visibility')
    def is_derivation_path_visible(self):
        return self._wallet_account_derivation_path.is_visible

    @allure.step('Get account storage value')
    def get_account_storage_value(self):
        raw_value = str(getattr(self._wallet_account_stored.object, 'subTitle'))
        storage = raw_value.split(">")[-1]
        return storage

    @allure.step('Get account storage visibility')
    def is_account_storage_visible(self):
        return self._wallet_account_stored.is_visible

    @allure.step('Click back button')
    def click_back_button(self):
        self._back_button.click()


class SavedAddressesWalletSettings(WalletSettingsView):
    def __init__(self):
        super(SavedAddressesWalletSettings, self).__init__()
        self.add_new_address_button = Button(settings_names.settings_Wallet_SavedAddresses_AddAddressButton)
        self.saved_address_item = QObject(settings_names.settings_Wallet_SavedAddress_ItemDelegate)

    @allure.step('Wait until appears {0}')
    def wait_until_appears(self, timeout_msec: int = configs.timeouts.UI_LOAD_TIMEOUT_MSEC):
        self.add_new_address_button.wait_until_appears(timeout_msec)
        return self

    @allure.step('Click add new address button')
    def open_add_saved_address_popup(self, attempt: int = 2) -> 'AddressPopup':
        self.add_new_address_button.click()
        try:
            return AddressPopup()
        except AssertionError as err:
            if attempt:
                self.open_add_saved_address_popup(attempt - 1)
            else:
                raise err

    @allure.step('Get saved addresses settings_names list')
    def get_saved_address_names_list(self):
        settings_names = [str(address.name) for address in driver.findAllObjects(self.saved_address_item.real_name)]
        return settings_names


class NetworkWalletSettings(WalletSettingsView):

    def __init__(self):
        super(NetworkWalletSettings, self).__init__()
        self._testnet_text_item = QObject(settings_names.settingsContentBaseScrollView_Goerli_testnet_active_StatusBaseText)
        self._testnet_mode_toggle = Button(settings_names.settings_Wallet_NetworksView_TestNet_Toggle)
        self._testnet_mode_title = TextLabel(settings_names.settings_Wallet_NetworksView_TestNet_Toggle_Title)
        self._back_button = Button(settings_names.main_toolBar_back_button)
        self._mainnet_network_item = QObject(settings_names.networkSettingsNetworks_Mainnet)
        self._mainnet_goerli_network_item = QObject(settings_names.networkSettingsNetworks_Mainnet_Goerli)
        self._mainnet_goerli_network_item_test_label = TextLabel(settings_names.networkSettingsNetowrks_Mainnet_Testlabel)
        self._optimism_network_item = QObject(settings_names.networkSettingsNetworks_Optimism)
        self._optimism_goerli_network_item = QObject(settings_names.networkSettingsNetworks_Optimism_Goerli)
        self._arbitrum_network_item = QObject(settings_names.networkSettingsNetworks_Arbitrum)
        self._arbitrum__goerli_network_item = QObject(settings_names.networkSettingsNetworks_Arbitrum_Goerli)
        self._wallet_network_item_template = QObject(settings_names.settingsContentBaseScrollView_WalletNetworkDelegate_template)
        self._wallet_network_item_goerli_sensor = QObject(settings_names.networkSettingsNetworks_Mainnet_Goerli_sensor)
        self._wallet_network_item_goerli_testlabel = TextLabel(settings_names.networkSettingsNetowrks_Mainnet_Testlabel)

    @allure.step('Wait until appears {0}')
    def wait_until_appears(self):
        self._testnet_mode_toggle.wait_until_appears(10000)
        return self

    @allure.step('Check networks item title')
    def get_network_item_attribute_by_id_and_attr_name(self, attribute_name, network_id):
        self._wallet_network_item_template.real_name['objectName'] = RegularExpression(
            f'walletNetworkDelegate_.*_{network_id}')
        return str(getattr(self._wallet_network_item_template.object, attribute_name))

    @allure.step('Open network to check the details')
    def click_network_item_to_open_edit_view(self, network_id):
        self._wallet_network_item_template.real_name['objectName'] \
            = RegularExpression(f'walletNetworkDelegate_.*_{network_id}')
        self._wallet_network_item_template.click()
        return EditNetworkSettings().wait_until_appears()

    @allure.step('Verify Testnet toggle subtitle')
    def get_testnet_toggle_subtitle(self):
        return self._testnet_mode_title.text

    @allure.step('Verify back to Wallet settings button')
    def is_back_to_wallet_settings_button_present(self):
        return self._back_button.is_visible

    @property
    @allure.step('Get amount of testnet active items')
    def testnet_items_amount(self) -> int:
        items_amount = 0
        for item in driver.findAllObjects(self._testnet_text_item.real_name):
            if item.text == 'Goerli testnet active':
                items_amount += 1
        return items_amount

    @allure.step('Switch testnet mode toggle')
    def switch_testnet_mode_toggle(self) -> TestnetModePopup:
        self._testnet_mode_toggle.click()
        return TestnetModePopup().wait_until_appears()

    @allure.step('Get testnet mode toggle status')
    def is_testnet_mode_toggle_checked(self) -> bool:
        return self._testnet_mode_toggle.is_checked


class EditNetworkSettings(WalletSettingsView):
    def __init__(self):
        super(EditNetworkSettings, self).__init__()
        self._live_network_tab = Button(settings_names.editNetworkLiveButton)
        self._test_network_tab = Button(settings_names.editNetworkTestButton)
        self._network_name = TextEdit(settings_names.editNetworkNameInput)
        self._network_short_name = TextEdit(settings_names.editNetworkShortNameInput)
        self._network_chaid_id = TextEdit(settings_names.editNetworkChainIdInput)
        self._network_native_token_symbol = TextEdit(settings_names.editNetworkSymbolInput)
        self._network_main_json_rpc_url = TextEdit(settings_names.editNetworkMainRpcInput)
        self._network_failover_json_rpc_url = TextEdit(settings_names.editNetworkFailoverRpcUrlInput)
        self._network_block_explorer = TextEdit(settings_names.editNetworkExplorerInput)
        self._network_acknowledgment_checkbox = CheckBox(settings_names.editNetworkAknowledgmentCheckbox)
        self._network_revert_to_default = Button(settings_names.editNetworkRevertButton)
        self._network_save_changes = Button(settings_names.editNetworkSaveButton)
        self._network_edit_view_back_button = Button(settings_names.main_toolBar_back_button)
        self._network_edit_scroll = Scroll(settings_names.settingsContentBase_ScrollView)
        self._network_edit_main_rpc_url_error_message = QObject(settings_names.mainRpcUrlInputObject)
        self._network_edit_failover_rpc_url_error_message = QObject(settings_names.failoverRpcUrlInputObject)

    @allure.step('Click back button')
    def click_network_back(self):
        self._network_edit_view_back_button.click()
        return NetworkWalletSettings().wait_until_appears()

    @allure.step('Wait until appears {0}')
    def wait_until_appears(self, timeout_msec: int = configs.timeouts.UI_LOAD_TIMEOUT_MSEC):
        self._live_network_tab.wait_until_appears(timeout_msec)
        return self

    @allure.step('Select Live Network tab')
    def click_live_network_tab(self):
        self._live_network_tab.click()

    @allure.step('Select Test Network tab')
    def click_test_network_tab(self):
        self._test_network_tab.click()

    @allure.step('Check revert button state')
    def check_revert_button_state(self):
        return driver.waitForObjectExists(self._network_revert_to_default, configs.timeouts.UI_LOAD_TIMEOUT_MSEC).enabled

    @allure.step('Click Revert to default button and redirect to Networks screen')
    def click_revert_to_default_and_go_to_networks_main_screen(self, attempts: int = 2):
        self._network_edit_scroll.vertical_scroll_down(self._network_revert_to_default)
        self._network_revert_to_default.click()
        try:
            return RPCChangeRestartPopup().wait_until_appears()
        except AssertionError:
            if attempts:
                self.click_revert_to_default_and_go_to_networks_main_screen(attempts - 1)
            else:
                raise AssertionError(f'RPC change requires restart popup did not appear')

    @allure.step('Verify elements for the edit network view')
    def check_available_elements_on_edit_view(self, network_tab):
        match network_tab:
            case WalletNetworkSettings.EDIT_NETWORK_LIVE_TAB.value:
                self._live_network_tab.click()
                assert self._network_edit_view_back_button.exists, f"Back button is not present"
                assert self._live_network_tab.exists, f"Live tab is not present"
                assert self._test_network_tab.exists, f"Test tab is not present"
                assert self._network_name.exists, f"Network name input field is not present"
                assert self._network_short_name.exists, f"Short name input field is not present"
                assert self._network_chaid_id.exists, f"Chaid Id input field is not present"
                assert self._network_native_token_symbol.exists, f"Native token symbol input field is not present"
                assert self._network_main_json_rpc_url.exists, f"Main JSON RPC URL input field is not present"
                assert self._network_failover_json_rpc_url.exists, f"Failover JSON RPC URL input field is not present"
                assert self._network_block_explorer.exists, f"Block explorer input field is not present"

                self._network_edit_scroll.vertical_scroll_down(self._network_acknowledgment_checkbox)
                assert driver.waitFor(lambda: self._network_acknowledgment_checkbox.exists,
                                      configs.timeouts.UI_LOAD_TIMEOUT_MSEC), f"Acknowldegment checkbox is not present"

                assert not driver.waitForObjectExists(self._network_revert_to_default.real_name,
                                                      configs.timeouts.UI_LOAD_TIMEOUT_MSEC).enabled, \
                    f"Revert to default button is enabled"

                assert not driver.waitForObjectExists(self._network_save_changes.real_name,
                                                      configs.timeouts.UI_LOAD_TIMEOUT_MSEC).enabled, \
                    f"Save changes button is enabled"

            case WalletNetworkSettings.EDIT_NETWORK_TEST_TAB.value:
                self._test_network_tab.click()
                assert self._network_edit_view_back_button.exists, f"Back button is not present"
                assert self._live_network_tab.exists, f"Live tab is not present"
                assert self._test_network_tab.exists, f"Test tab is not present"
                assert self._network_name.exists, f"Network name input field is not present"
                assert self._network_short_name.exists, f"Short name input field is not present"
                assert self._network_chaid_id.exists, f"Chaid Id input field is not present"
                assert self._network_native_token_symbol.exists, f"Native token symbol input field is not present"
                assert self._network_main_json_rpc_url.exists, f"Main JSON RPC URL input field is not present"
                assert self._network_failover_json_rpc_url.exists, f"Failover JSON RPC URL input field is not present"
                assert self._network_block_explorer.exists, f"Block explorer input field is not present"

                self._network_edit_scroll.vertical_scroll_down(self._network_acknowledgment_checkbox)
                assert driver.waitFor(lambda: self._network_acknowledgment_checkbox.exists,
                                      configs.timeouts.UI_LOAD_TIMEOUT_MSEC), f"Acknowldegment checkbox is not present"

                assert not driver.waitForObjectExists(self._network_revert_to_default.real_name,
                                                      configs.timeouts.UI_LOAD_TIMEOUT_MSEC).enabled, \
                    f"Revert to default button is enabled"

                assert not driver.waitForObjectExists(self._network_save_changes.real_name,
                                                      configs.timeouts.UI_LOAD_TIMEOUT_MSEC).enabled, \
                    f"Save changes button is enabled"

    @allure.step('Edit Main RPC url input field')
    def edit_network_main_json_rpc_url_input(self, test_value, network_tab):
        match network_tab:
            case WalletNetworkSettings.EDIT_NETWORK_LIVE_TAB.value:
                self._live_network_tab.click()
                self._network_main_json_rpc_url.text = test_value
            case WalletNetworkSettings.EDIT_NETWORK_TEST_TAB.value:
                self._test_network_tab.click()
                self._network_main_json_rpc_url.text = test_value

    @allure.step('Edit Failover RPC url input field')
    def edit_network_failover_json_rpc_url_input(self, test_value, network_tab):
        match network_tab:
            case WalletNetworkSettings.EDIT_NETWORK_LIVE_TAB.value:
                self._live_network_tab.click()
                self._network_failover_json_rpc_url.text = test_value
            case WalletNetworkSettings.EDIT_NETWORK_TEST_TAB.value:
                self._test_network_tab.click()
                self._network_failover_json_rpc_url.text = test_value

    @allure.step('Check acknowledgment checkbox')
    def check_acknowledgement_checkbox(self, value: bool, network_tab):
        match network_tab:
            case WalletNetworkSettings.EDIT_NETWORK_LIVE_TAB.value:
                self._live_network_tab.click()
                self._network_edit_scroll.vertical_scroll_down(self._network_acknowledgment_checkbox)
                self._network_acknowledgment_checkbox.set(value)
            case WalletNetworkSettings.EDIT_NETWORK_TEST_TAB.value:
                self._test_network_tab.click()
                self._network_edit_scroll.vertical_scroll_down(self._network_acknowledgment_checkbox)
                self._network_acknowledgment_checkbox.set(value)
        return self

    @allure.step('Get the text for consent when changing RPC urls')
    def get_acknowledgement_checkbox_text(self, attr):
        text = str(getattr(self._network_acknowledgment_checkbox.object, attr))
        return text

    @allure.step('Get error message for Main RPC URL input')
    def get_main_rpc_url_error_message_text(self):
        error = str(self._network_edit_main_rpc_url_error_message.object.errorMessageCmp.text)
        return error

    @allure.step('Get error message for Failover RPC URL input')
    def get_failover_rpc_url_error_message_text(self):
        error = str(self._network_edit_failover_rpc_url_error_message.object.errorMessageCmp.text)
        return error

    @allure.step('Click Revert button and make sure values are reset')
    def revert_to_default(self, attempts=2):
        current_value_main = self._network_main_json_rpc_url.text
        current_value_failover = self._network_failover_json_rpc_url.text
        self._network_edit_scroll.vertical_scroll_down(self._network_revert_to_default)
        self._network_revert_to_default.click()
        if (current_value_main == self._network_main_json_rpc_url.text
                and current_value_failover == self._network_failover_json_rpc_url.text):
            assert attempts > 0, "value not reverted"
            time.sleep(1)
            self.revert_to_default(attempts - 1)

    @allure.step('Get value from Main json rpc input')
    def get_edit_network_main_json_rpc_url_value(self):
        return self._network_main_json_rpc_url.text

    @allure.step('Get value from Failover json rpc input')
    def get_edit_network_failover_json_rpc_url_value(self):
        return self._network_failover_json_rpc_url.text

    @allure.step('Verify value in Main JSON RPC input')
    def verify_edit_network_main_json_rpc_url_value(self, network_tab):
        match network_tab:
            case WalletNetworkSettings.EDIT_NETWORK_LIVE_TAB.value:
                self._live_network_tab.click()
                current_value = self.get_edit_network_main_json_rpc_url_value()
                return True if current_value.startswith(
                    WalletNetworkDefaultValues.ETHEREUM_LIVE_MAIN.value) and current_value.endswith("****") else False
            case WalletNetworkSettings.EDIT_NETWORK_TEST_TAB.value:
                self._test_network_tab.click()
                current_value = self.get_edit_network_main_json_rpc_url_value()
                return True if current_value.startswith(
                    WalletNetworkDefaultValues.ETHEREUM_TEST_MAIN.value) and current_value.endswith("****") else False

    @allure.step('Verify value in Failover JSON RPC input')
    def verify_edit_network_failover_json_rpc_url_value(self, network_tab):
        match network_tab:
            case WalletNetworkSettings.EDIT_NETWORK_LIVE_TAB.value:
                self._live_network_tab.click()
                current_value = self.get_edit_network_failover_json_rpc_url_value()
                return True if current_value.startswith(
                    WalletNetworkDefaultValues.ETHEREUM_LIVE_FAILOVER.value) and current_value.endswith(
                    "****") else False
            case WalletNetworkSettings.EDIT_NETWORK_TEST_TAB.value:
                self._test_network_tab.click()
                current_value = self.get_edit_network_failover_json_rpc_url_value()
                return True if current_value.startswith(
                    WalletNetworkDefaultValues.ETHEREUM_TEST_FAILOVER.value) and current_value.endswith(
                    "****") else False


class EditAccountOrderSettings(WalletSettingsView):

    def __init__(self):
        super(EditAccountOrderSettings, self).__init__()
        self._account_item = QObject(settings_names.settingsContentBaseScrollView_draggableDelegate_StatusDraggableListItem)
        self._accounts_list = QObject(settings_names.statusDesktop_mainWindow)
        self._text_item = QObject(settings_names.settingsContentBaseScrollView_StatusBaseText)
        self._back_button = Button(settings_names.main_toolBar_back_button)

    @allure.step('Wait until appears {0}')
    def wait_until_appears(self, timeout_msec: int = configs.timeouts.UI_LOAD_TIMEOUT_MSEC):
        self._account_item.wait_until_appears(timeout_msec)
        return self

    @property
    @allure.step('Get edit account order recommendations')
    def account_recommendations(self):
        account_recommendations = []
        for obj in driver.findAllObjects(self._text_item.real_name):
            account_recommendations.append(obj.text)
        return account_recommendations

    @property
    @allure.step('Get accounts')
    def accounts(self) -> typing.List[wallet_account_list_item]:
        _accounts = []
        for account_item in driver.findAllObjects(self._account_item.real_name):
            element = QObject(real_name=driver.objectMap.realName(account_item))
            name = str(account_item.title)
            icon_color = None
            icon_emoji = None
            for child in objects_access.walk_children(account_item):
                if getattr(child, 'objectName', '') == 'identicon':
                    icon_color = str(child.color.name)
                    icon_emoji = str(child.emoji)
                    break
            _accounts.append(wallet_account_list_item(name, icon_color, icon_emoji, element))

        return sorted(_accounts, key=lambda account: account.object.y)

    @allure.step('Get account in accounts list')
    def _get_account_item(self, name: str):
        for obj in driver.findAllObjects(self._account_item.real_name):
            if getattr(obj, 'title', '') == name:
                return obj
        raise LookupError(f'Account item: {name} not found')

    @allure.step('Get eye icon on watch-only account')
    def get_eye_icon(self, name: str):
        for child in objects_access.walk_children(self._get_account_item(name)):
            if getattr(child, 'objectName', '') == 'show-icon':
                return child
        raise LookupError(f'Eye icon not found on {name} account item')

    @allure.step('Drag account to change the order')
    def drag_account(self, name: str, index: int):
        assert driver.waitFor(lambda: len([account for account in self.accounts if account.name == name]) == 1), \
            'Account not found or found more then one'
        bounds = [account for account in self.accounts if account.name == name][0].object.bounds
        d_bounds = self.accounts[index].object.bounds
        driver.mouse.press_and_move(self._accounts_list.object, bounds.x, bounds.y, d_bounds.x, d_bounds.y)

    @allure.step('Verify that back button is present')
    def is_back_button_present(self) -> bool:
        return self._back_button.is_visible


class ManageTokensSettingsView(WalletSettingsView):

    def __init__(self):
        super(ManageTokensSettingsView, self).__init__()
        self._window_item = QObject(wallet_names.statusDesktop_mainWindow)
        self._token_item = QObject(wallet_names.settingsContentBaseScrollView_manageTokensDelegate_ManageTokensDelegate)
        self._assets_button = Button(wallet_names.tabBar_Assets_StatusTabButton)

    @allure.step('Wait until appears {0}')
    def wait_until_appears(self, timeout_msec: int = configs.timeouts.UI_LOAD_TIMEOUT_MSEC):
        self._assets_button.wait_until_appears(timeout_msec)
        return self

    @property
    @allure.step('Get tokens')
    def tokens(self) -> typing.List[constants.token_list_item]:
        _tokens = []
        for token_item in driver.findAllObjects(self._token_item.real_name):
            element = QObject(real_name=driver.objectMap.realName(token_item))
            name = str(token_item.title)
            _tokens.append(constants.token_list_item(name, element))

        return sorted(_tokens, key=lambda token: token.object.y)

    @allure.step('Drag token to change the order')
    def drag_token(self, name: str, index: int):
        assert driver.waitFor(lambda: len([token for token in self.tokens if token.title == name]) == 1), \
            'Token not found or found more then one'
        bounds = [token for token in self.tokens if token.title == name][0].object.bounds
        d_bounds = self.tokens[index].object.bounds
        driver.mouse.press_and_move(self._window_item.object, bounds.x, bounds.y, d_bounds.x, d_bounds.y + 1)