e2e: cleanup

ci/tests/Jenkinsfile.e2e-prs

@@ -12,7 +12,7 @@ pipeline {
     string(
       name: 'TEST_MARKERS',
       description: 'Marker expression for matching tests to run.',
-      defaultValue: 'critical or high',
+      defaultValue: 'critical',
     ) */
     string(
       name: 'APK_NAME',

test/appium/support/testrail_report.py

@@ -128,7 +128,7 @@ class TestrailReport(BaseTestReport):
                 key, value = arg.split('=')
                 case_ids = value.split(',')
         if len(case_ids) == 0:
-            if 'critical or high' in argv:
+            if 'critical' in argv:
                 for category in test_cases['pr']:
                     for case in self.get_cases([test_cases['pr'][category]]):
                         case_ids.append(case['id'])

test/appium/tests/atomic/account_management/test_keycard.py

@@ -1,455 +0,0 @@
-from tests import marks, pair_code, common_password
-from tests.base_test_case import SingleDeviceTestCase, MultipleDeviceTestCase
-from views.sign_in_view import SignInView
-from tests.users import basic_user, transaction_senders
-
-
-class TestCreateAccount(SingleDeviceTestCase):
-
-    @marks.testrail_id(5742)
-    @marks.medium
-    def test_keycard_interruption_creating_onboarding_flow(self):
-        sign_in = SignInView(self.driver)
-
-        sign_in.just_fyi('Cancel on PIN code setup stage')
-        sign_in.accept_tos_checkbox.enable()
-        sign_in.get_started_button.click()
-        sign_in.generate_key_button.click()
-        username = sign_in.first_username_on_choose_chat_name.text
-        sign_in.next_button.click()
-        keycard_flow = sign_in.keycard_storage_button.click()
-        keycard_flow.next_button.click()
-        keycard_flow.begin_setup_button.click()
-        keycard_flow.connect_card_button.wait_and_click()
-        keycard_flow.enter_another_pin()
-        keycard_flow.cancel_button.click()
-
-        sign_in.just_fyi('Cancel from Confirm seed phrase: initialized + 1 pairing slot is used')
-        keycard_flow.begin_setup_button.click()
-        keycard_flow.enter_default_pin()
-        keycard_flow.enter_default_pin()
-        seed_phrase = keycard_flow.get_seed_phrase()
-        keycard_flow.confirm_button.click()
-        keycard_flow.yes_button.click()
-        keycard_flow.cancel_button.click()
-        if not keycard_flow.element_by_text_part('Back up seed phrase').is_element_displayed():
-            self.driver.fail('On canceling setup from Confirm seed phrase was not redirected to expected screen')
-
-        sign_in.just_fyi('Cancel from Back Up seed phrase: initialized + 1 pairing slot is used')
-        keycard_flow.cancel_button.click()
-        keycard_flow.begin_setup_button.click()
-        keycard_flow.element_by_translation_id("back-up-seed-phrase").wait_for_element(10)
-        new_seed_phrase = keycard_flow.get_seed_phrase()
-        if new_seed_phrase != seed_phrase:
-            self.errors.append('Another seed phrase is shown after cancelling setup during Back up seed phrase')
-        keycard_flow.backup_seed_phrase()
-        keycard_flow.enter_default_pin()
-        for element in sign_in.maybe_later_button, sign_in.lets_go_button:
-            element.wait_for_visibility_of_element(30)
-            element.click()
-        sign_in.profile_button.wait_for_visibility_of_element(30)
-
-        sign_in.just_fyi('Check username and relogin')
-        profile = sign_in.get_profile_view()
-        public_key, real_username = profile.get_public_key_and_username(return_username=True)
-        if real_username != username:
-            self.errors.append('Username was changed after interruption of creating account')
-        profile.logout()
-        home = sign_in.sign_in(keycard=True)
-        if not home.wallet_button.is_element_displayed(10):
-            self.errors.append("Failed to login to Keycard account")
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6246)
-    @marks.medium
-    @marks.flaky
-    def test_keycard_interruption_access_key_onboarding_flow(self):
-        sign_in = SignInView(self.driver)
-        sign_in.accept_tos_checkbox.enable()
-        sign_in.get_started_button.click()
-
-        sign_in.access_key_button.click()
-        sign_in.enter_seed_phrase_button.click()
-        sign_in.seedphrase_input.click()
-        sign_in.seedphrase_input.set_value(basic_user['passphrase'])
-        sign_in.next_button.click()
-        sign_in.reencrypt_your_key_button.click()
-        keycard_flow = sign_in.keycard_storage_button.click()
-
-        sign_in.just_fyi('Cancel on PIN code setup stage')
-        keycard_flow.next_button.click()
-        keycard_flow.begin_setup_button.click()
-        keycard_flow.connect_card_button.wait_and_click()
-        keycard_flow.enter_another_pin()
-        keycard_flow.cancel_button.click()
-
-        sign_in.just_fyi('Finish setup and relogin')
-        keycard_flow.begin_setup_button.click()
-        keycard_flow.enter_default_pin()
-        keycard_flow.enter_default_pin()
-        for element in sign_in.maybe_later_button, sign_in.lets_go_button:
-            element.wait_for_visibility_of_element(30)
-            element.click()
-        sign_in.profile_button.wait_for_visibility_of_element(30)
-        public_key, default_username = sign_in.get_public_key_and_username(return_username=True)
-        profile_view = sign_in.get_profile_view()
-        if public_key != basic_user['public_key']:
-            self.errors.append('Public key %s does not match expected' % public_key)
-        if default_username != basic_user['username']:
-            self.errors.append('Default username %s does not match expected' % default_username)
-        profile_view.logout()
-        home = sign_in.sign_in(keycard=True)
-        if not home.wallet_button.is_element_displayed(10):
-            self.errors.append("Failed to login to Keycard account")
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6243)
-    @marks.medium
-    def test_keycard_can_recover_keycard_account_offline_and_add_watch_only_acc(self):
-        sign_in = SignInView(self.driver)
-        sign_in.toggle_airplane_mode()
-
-        sign_in.just_fyi('Recover multiaccount offline')
-        sign_in.accept_tos_checkbox.enable()
-        sign_in.get_started_button.click_until_presence_of_element(sign_in.access_key_button)
-        sign_in.access_key_button.click()
-        sign_in.recover_with_keycard_button.click()
-        keycard_view = sign_in.begin_recovery_button.click()
-        keycard_view.connect_pairing_card_button.click()
-        keycard_view.pair_code_input.set_value(pair_code)
-        keycard_view.confirm()
-        keycard_view.enter_default_pin()
-        sign_in.maybe_later_button.click_until_presence_of_element(sign_in.lets_go_button)
-        sign_in.lets_go_button.click_until_absense_of_element(sign_in.lets_go_button)
-        sign_in.home_button.wait_for_visibility_of_element(30)
-        wallet_view = sign_in.wallet_button.click()
-
-        sign_in.just_fyi('Relogin offline')
-        self.driver.close_app()
-        self.driver.launch_app()
-        sign_in.sign_in(keycard=True)
-        if not sign_in.home_button.is_element_displayed(10):
-            self.driver.fail('Keycard user is not logged in')
-
-        sign_in.just_fyi('Turn off airplane mode and turn on cellular network')
-        sign_in.toggle_airplane_mode()
-        sign_in.toggle_mobile_data()
-        sign_in.element_by_text_part('Stop syncing').wait_and_click(60)
-        sign_in.wallet_button.click()
-        if not wallet_view.element_by_text_part('LXS').is_element_displayed():
-            self.errors.append('Token balance is not fetched while on cellular network!')
-
-        wallet_view.just_fyi('Add watch-only account when on cellular network')
-        wallet_view.add_account_button.click()
-        wallet_view.add_watch_only_address_button.click()
-        wallet_view.enter_address_input.send_keys(basic_user['address'])
-        account_name = 'watch-only'
-        wallet_view.account_name_input.send_keys(account_name)
-        wallet_view.add_account_generate_account_button.click()
-        account_button = wallet_view.get_account_by_name(account_name)
-        if not account_button.is_element_displayed():
-            self.driver.fail('Account was not added')
-
-        wallet_view.just_fyi('Check that balance is changed after go back to WI-FI')
-        sign_in.toggle_mobile_data()
-        for asset in ('ADI', 'STT'):
-            wallet_view.asset_by_name(asset).scroll_to_element()
-            wallet_view.wait_balance_is_changed(asset, wait_time=60)
-
-        wallet_view.just_fyi('Delete watch-only account')
-        wallet_view.get_account_by_name(account_name).click()
-        wallet_view.get_account_options_by_name(account_name).click()
-        wallet_view.account_settings_button.click()
-        wallet_view.delete_account_button.click()
-        wallet_view.yes_button.click()
-        if wallet_view.get_account_by_name(account_name).is_element_displayed(20):
-            self.errors.append('Account was not deleted')
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6311)
-    @marks.medium
-    @marks.transaction
-    def test_same_seed_added_inside_multiaccount_and_keycard(self):
-        sign_in = SignInView(self.driver)
-        recipient = "0x" + transaction_senders['ETH_7']['address']
-        user = transaction_senders['ETH_ADI_STT_3']
-
-        sign_in.just_fyi('Restore keycard multiaccount and logout')
-        sign_in.recover_access(passphrase=user['passphrase'], keycard=True)
-        profile_view = sign_in.profile_button.click()
-        profile_view.logout()
-
-        sign_in.just_fyi('Create new multiaccount')
-        sign_in.close_button.click()
-        sign_in.your_keys_more_icon.click()
-        sign_in.generate_new_key_button.click()
-        sign_in.next_button.click()
-        sign_in.next_button.click()
-        sign_in.create_password_input.set_value(common_password)
-        sign_in.next_button.click()
-        sign_in.confirm_your_password_input.set_value(common_password)
-        sign_in.next_button.click()
-        sign_in.maybe_later_button.click_until_presence_of_element(sign_in.lets_go_button)
-        sign_in.lets_go_button.click()
-
-        sign_in.just_fyi('Add to wallet seed phrase for restored multiaccount')
-        wallet = sign_in.wallet_button.click()
-        wallet.add_account_button.click()
-        wallet.enter_a_seed_phrase_button.click()
-        wallet.enter_your_password_input.send_keys(common_password)
-        account_name = 'subacc'
-        wallet.account_name_input.send_keys(account_name)
-        wallet.enter_seed_phrase_input.set_value(user['passphrase'])
-        wallet.add_account_generate_account_button.click()
-        wallet.get_account_by_name(account_name).click()
-
-        sign_in.just_fyi('Send transaction from added account and log out')
-        transaction_amount_added = wallet.get_unique_amount()
-        wallet.send_transaction(from_main_wallet=False, amount=transaction_amount_added, recipient=recipient,
-                                sign_transaction=True)
-        wallet.profile_button.click()
-        profile_view.logout()
-
-        sign_in.just_fyi('Login to keycard account and send another transaction')
-        sign_in.back_button.click()
-        sign_in.sign_in(position=2, keycard=True)
-        sign_in.wallet_button.click()
-        wallet.wait_balance_is_changed('ETH')
-        transaction_amount_keycard = wallet.get_unique_amount()
-        wallet.send_transaction(amount=transaction_amount_keycard, recipient=recipient, keycard=True,
-                                sign_transaction=True)
-
-        for amount in [transaction_amount_keycard, transaction_amount_added]:
-            sign_in.just_fyi("Checking '%s' tx" % amount)
-            self.network_api.find_transaction_by_unique_amount(user['address'], amount)
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(695841)
-    @marks.medium
-    def test_keycard_settings_pin_puk_pairing(self):
-        sign_in = SignInView(self.driver)
-        seed = basic_user['passphrase']
-        home = sign_in.recover_access(passphrase=seed, keycard=True)
-        profile = home.profile_button.click()
-
-        home.just_fyi("Checking changing PIN")
-        profile.keycard_button.scroll_and_click()
-        keycard = profile.change_pin_button.click()
-        keycard.enter_another_pin()
-        keycard.wait_for_element_starts_with_text('2 attempts left', 30)
-        keycard.enter_default_pin()
-        if not keycard.element_by_translation_id("new-pin-description").is_element_displayed():
-            self.driver.fail("Screen for setting new pin is not shown!")
-        [keycard.enter_another_pin() for _ in range(2)]
-        if not keycard.element_by_translation_id("pin-changed").is_element_displayed(30):
-            self.driver.fail("Popup about successful setting new PIN is not shown!")
-        keycard.ok_button.click()
-
-        home.just_fyi("Checking changing PUK with new PIN")
-        profile.change_puk_button.click()
-        keycard.enter_another_pin()
-        if not keycard.element_by_translation_id("new-puk-description").is_element_displayed():
-            self.driver.fail("Screen for setting new puk is not shown!")
-        [keycard.one_button.click() for _ in range(12)]
-        if not keycard.element_by_translation_id("repeat-puk").is_element_displayed():
-            self.driver.fail("Confirmation screen for setting new puk is not shown!")
-        [keycard.one_button.click() for _ in range(12)]
-        if not keycard.element_by_translation_id("puk-changed").is_element_displayed(30):
-            self.driver.fail("Popup about successful setting new PUK is not shown!")
-        keycard.ok_button.click()
-
-        home.just_fyi("Checking setting pairing with new PIN")
-        profile.change_pairing_code_button.click()
-        keycard.enter_another_pin()
-        sign_in.create_password_input.set_value(common_password)
-        sign_in.confirm_your_password_input.set_value(common_password + "1")
-        if not keycard.element_by_translation_id("pairing-code_error1").is_element_displayed():
-            self.errors.append("No error is shown when pairing codes don't match")
-        sign_in.confirm_your_password_input.delete_last_symbols(1)
-        sign_in.element_by_translation_id("change-pairing").click()
-        if not keycard.element_by_translation_id("pairing-changed").is_element_displayed(30):
-            self.driver.fail("Popup about successful setting new pairing is not shown!")
-        keycard.ok_button.click()
-
-        home.just_fyi("Checking backing up keycard")
-        profile.create_keycard_backup_button.scroll_and_click()
-        sign_in.seedphrase_input.set_value(seed)
-        sign_in.next_button.click()
-        keycard.return_card_to_factory_settings_checkbox.enable()
-        keycard.begin_setup_button.click()
-        keycard.yes_button.wait_and_click()
-        [keycard.enter_another_pin() for _ in range(2)]
-        keycard.element_by_translation_id("keycard-backup-success-title").wait_for_element(30)
-        keycard.ok_button.click()
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(695851)
-    @marks.medium
-    def test_keycard_frozen_card_flows(self):
-        sign_in = SignInView(self.driver)
-        seed = basic_user['passphrase']
-        home = sign_in.recover_access(passphrase=seed, keycard=True)
-        profile = home.profile_button.click()
-        profile.keycard_button.scroll_and_click()
-
-        home.just_fyi('Set new PUK')
-        keycard = profile.change_puk_button.click()
-        keycard.enter_default_pin()
-        [keycard.enter_default_puk() for _ in range(2)]
-        keycard.ok_button.click()
-
-        home.just_fyi("Checking reset with PUK when logged in")
-        keycard = profile.change_pin_button.click()
-        keycard.enter_another_pin()
-        keycard.wait_for_element_starts_with_text('2 attempts left', 30)
-        keycard.enter_another_pin()
-        keycard.element_by_text_part('one attempt').wait_for_element(30)
-        keycard.enter_another_pin()
-        if not home.element_by_translation_id("keycard-is-frozen-title").is_element_displayed(30):
-            self.driver.fail("No popup about frozen keycard is shown!")
-        home.element_by_translation_id("keycard-is-frozen-reset").click()
-        keycard.enter_another_pin()
-        home.element_by_text_part('2/2').wait_for_element(20)
-        keycard.enter_another_pin()
-        home.element_by_translation_id("enter-puk-code").click()
-        keycard.enter_default_puk()
-        home.element_by_translation_id("keycard-access-reset").wait_for_element(20)
-        home.profile_button.double_click()
-        profile.logout()
-
-        home.just_fyi("Checking reset with PUK when logged out")
-        keycard.enter_default_pin()
-        keycard.wait_for_element_starts_with_text('2 attempts left', 30)
-        keycard.enter_default_pin()
-        keycard.element_by_text_part('one attempt').wait_for_element(30)
-        keycard.enter_default_pin()
-        if not home.element_by_translation_id("keycard-is-frozen-title").is_element_displayed():
-            self.driver.fail("No popup about frozen keycard is shown!")
-        home.element_by_translation_id("keycard-is-frozen-reset").click()
-        keycard.enter_another_pin()
-        home.element_by_text_part('2/2').wait_for_element(20)
-        keycard.enter_another_pin()
-        home.element_by_translation_id("enter-puk-code").click()
-        keycard.enter_default_puk()
-        home.element_by_translation_id("keycard-access-reset").wait_for_element(20)
-        home.element_by_translation_id("open").click()
-
-        home.just_fyi("Checking reset with seed when logged in")
-        profile = home.profile_button.click()
-        profile.keycard_button.scroll_and_click()
-        profile.change_pin_button.click()
-        keycard.enter_default_pin()
-        keycard.wait_for_element_starts_with_text('2 attempts left', 30)
-        keycard.enter_default_pin()
-        keycard.element_by_text_part('one attempt').wait_for_element(30)
-        keycard.enter_default_pin()
-        if not home.element_by_translation_id("keycard-is-frozen-title").is_element_displayed():
-            self.driver.fail("No popup about frozen keycard is shown!")
-        home.element_by_translation_id("dismiss").click()
-        profile.profile_button.double_click()
-        profile.keycard_button.scroll_and_click()
-        profile.change_pin_button.click()
-        keycard.enter_default_pin()
-        if not home.element_by_translation_id("keycard-is-frozen-title").is_element_displayed(30):
-            self.driver.fail("No reset card flow is shown for frozen card")
-        home.element_by_translation_id("keycard-is-frozen-factory-reset").click()
-        sign_in.seedphrase_input.set_value(transaction_senders['A']['passphrase'])
-        sign_in.next_button.click()
-        if not home.element_by_translation_id("seed-key-uid-mismatch").is_element_displayed():
-            self.driver.fail("No popup about mismatch in seed phrase is shown!")
-        home.element_by_translation_id("try-again").click()
-        sign_in.seedphrase_input.clear()
-        sign_in.seedphrase_input.set_value(seed)
-        sign_in.next_button.click()
-        keycard.begin_setup_button.click()
-        keycard.yes_button.click()
-        keycard.enter_default_pin()
-        home.element_by_translation_id("intro-wizard-title5").wait_for_element(20)
-        keycard.enter_default_pin()
-        home.element_by_translation_id("keycard-access-reset").wait_for_element(30)
-        home.ok_button.click()
-        profile.profile_button.double_click()
-        profile.logout()
-
-        home.just_fyi("Checking reset with seed when logged out")
-        keycard.enter_another_pin()
-        keycard.wait_for_element_starts_with_text('2 attempts left', 30)
-        keycard.enter_another_pin()
-        keycard.element_by_text_part('one attempt').wait_for_element(30)
-        keycard.enter_another_pin()
-        if not home.element_by_translation_id("keycard-is-frozen-title").is_element_displayed():
-            self.driver.fail("No popup about frozen keycard is shown!")
-
-        sign_in.element_by_translation_id("keycard-is-frozen-factory-reset").click()
-        sign_in.seedphrase_input.set_value(seed)
-        sign_in.next_button.click()
-        keycard.begin_setup_button.click()
-        keycard.yes_button.click()
-        keycard.enter_default_pin()
-        home.element_by_translation_id("intro-wizard-title5").wait_for_element(20)
-        keycard.enter_default_pin()
-        home.element_by_translation_id("keycard-access-reset").wait_for_element(30)
-        home.ok_button.click()
-        keycard.enter_default_pin()
-        home.home_button.wait_for_element(30)
-
-    @marks.testrail_id(695852)
-    @marks.medium
-    def test_keycard_blocked_card_lost_or_frozen_flows(self):
-        sign_in = SignInView(self.driver)
-        seed = basic_user['passphrase']
-        home = sign_in.recover_access(passphrase=seed, keycard=True)
-        profile = home.profile_button.click()
-        profile.keycard_button.scroll_and_click()
-
-        home.just_fyi("Checking blocked card screen when entering 3 times invalid PIN + 5 times invalid PUK")
-        keycard = profile.change_pin_button.click()
-        keycard.enter_another_pin()
-        keycard.wait_for_element_starts_with_text('2 attempts left', 30)
-        keycard.enter_another_pin()
-        keycard.element_by_text_part('one attempt').wait_for_element(30)
-        keycard.enter_another_pin()
-        if not home.element_by_translation_id("keycard-is-frozen-title").is_element_displayed():
-            self.driver.fail("No popup about frozen keycard is shown!")
-        home.element_by_translation_id("keycard-is-frozen-reset").click()
-        keycard.enter_another_pin()
-        home.element_by_text_part('2/2').wait_for_element(20)
-        keycard.enter_another_pin()
-        home.element_by_translation_id("enter-puk-code").click()
-
-        for i in range(1, 4):
-            keycard.enter_default_puk()
-            sign_in.wait_for_element_starts_with_text('%s attempts left' % str(5 - i))
-            i += 1
-        keycard.enter_default_puk()
-        sign_in.element_by_text_part('one attempt').wait_for_element(30)
-        keycard.enter_default_puk()
-        keycard.element_by_translation_id("keycard-is-blocked-title").wait_for_element(30)
-        keycard.close_button.click()
-        if not keycard.element_by_translation_id("keycard-blocked").is_element_displayed():
-            self.errors.append("In keycard settings there is no info that card is blocked")
-        keycard.back_button.click()
-        profile.logout()
-
-        home.just_fyi("Check blocked card when user is logged out and use lost or frozen to restore access")
-        keycard.enter_another_pin()
-        keycard.element_by_translation_id("keycard-is-blocked-title").wait_for_element(30)
-        keycard.element_by_translation_id("keycard-recover").click()
-        keycard.yes_button.click()
-        sign_in.seedphrase_input.set_value(seed)
-        sign_in.next_button.click()
-        keycard.begin_setup_button.click()
-        keycard.yes_button.click()
-        keycard.enter_default_pin()
-        home.element_by_translation_id("intro-wizard-title5").wait_for_element(20)
-        keycard.enter_default_pin()
-        home.element_by_translation_id("keycard-access-reset").wait_for_element(30)
-        home.ok_button.click()
-        keycard.enter_default_pin()
-        home.home_button.wait_for_element(30)
-
-        self.errors.verify_no_errors()
-

test/appium/tests/atomic/chats/test_chats_management.py

@@ -1,763 +0,0 @@
-import time
-import random
-import emoji
-
-from tests import marks, background_service_message
-from tests.users import basic_user, dummy_user, ens_user_ropsten, ens_user
-from tests.base_test_case import SingleDeviceTestCase, MultipleDeviceTestCase
-from views.sign_in_view import SignInView
-from views.chat_view import ChatView
-
-
-class TestChatManagement(SingleDeviceTestCase):
-
-    @marks.testrail_id(5426)
-    @marks.medium
-    def test_public_clear_history_via_options_and_long_press(self):
-        home = SignInView(self.driver).create_user()
-
-        home.just_fyi("Creating 3 types of chats")
-        public_options, public_long_press = '#public-clear-options', '#public-long-options'
-        message = 'test message'
-        for pub_chat in [public_options[1:], public_long_press[1:]]:
-            chat = home.join_public_chat(pub_chat)
-            [chat.send_message(message) for _ in range(2)]
-            home.home_button.double_click()
-
-        home.just_fyi('Clearing history via long press')
-        home.clear_chat_long_press(public_long_press)
-
-        home.just_fyi('Clearing history via options')
-        chat = home.get_chat(public_options).click()
-        chat.clear_history()
-        if chat.element_by_text(message).is_element_displayed():
-            self.errors.append(
-                'Messages in %s chat are still shown after clearing history via options' % public_options)
-
-        home.just_fyi("Recheck that history won't reappear after relogin")
-        home.relogin()
-        for chat_name in public_options, public_long_press:
-            chat = home.get_chat(chat_name).click()
-            if chat.chat_element_by_text(message).is_element_displayed():
-                self.errors.append('Messages in %s chat are shown after clearing history and relaunch' % chat_name)
-            chat.home_button.click()
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6320)
-    @marks.medium
-    def test_can_start_chat_from_suggestions_using_search_chat(self):
-        sign_in = SignInView(self.driver)
-        home = sign_in.create_user()
-        chat = ChatView(self.driver)
-        ens_name_status, ens_name_another_domain, public_chat_name = ens_user_ropsten['ens'], \
-                                                                     ens_user['ens_another'], 'some-pub-chat'
-        search_list = {
-            ens_name_status: {
-                'home': {
-                    'Start a new private chat',
-                    'Join a public chat',
-                    '%s.stateofus.eth' % ens_name_status,
-                    '#%s' % ens_name_status
-                },
-                'navigate_to': '%s.stateofus.eth' % ens_name_status,
-                'chat': {
-                    chat.add_to_contacts,
-                    chat.element_by_text('@%s' % ens_name_status),
-                    chat.chat_message_input
-                }
-            },
-            ens_name_another_domain: {
-                'home': {
-                    'Start a new private chat',
-                },
-                'home_not_shown': 'Join a public chat',
-                'navigate_to': 'Start a new private chat',
-                'chat': {
-                    chat.add_to_contacts,
-                    chat.element_by_text('@%s' % ens_name_another_domain),
-                    chat.chat_message_input
-                },
-            },
-            public_chat_name: {
-                'home': {
-                    'Join a public chat',
-                },
-                'home_not_shown': 'Start a new private chat',
-                'navigate_to': '#%s' % public_chat_name,
-                'chat': {
-                    chat.element_by_text('#%s' % public_chat_name),
-                    chat.chat_message_input
-                },
-            },
-
-        }
-
-        home.just_fyi('Join public chat to have search input on home view')
-        chat_name = home.get_random_chat_name()
-        public_chat = home.join_public_chat(chat_name)
-        public_chat.get_back_to_home_view()
-        home.swipe_down()
-
-        for keyword in search_list:
-            home.just_fyi('Can start chat from searching for %s' % keyword)
-            home.search_by_keyword(keyword)
-            if not home.element_by_text_part('No search results. Do you mean').is_element_displayed():
-                self.errors.append('"No search results" is not shown')
-            if 'home_not_shown' in search_list[keyword]:
-                if home.element_by_text(search_list[keyword]['home_not_shown']).is_element_displayed():
-                    self.errors.append('%s is shown on home view while searching for %s' % (
-                        search_list[keyword]['home_not_shown'], keyword))
-            for text in search_list[keyword]['home']:
-                if not home.element_by_text(text).is_element_displayed():
-                    self.errors.append('%s is not shown on home view while searching for %s' % (text, keyword))
-            home.element_by_text(search_list[keyword]['navigate_to']).click()
-            for element in search_list[keyword]['chat']:
-                if not element.is_element_displayed():
-                    self.errors.append(
-                        'Requested %s element is not shown on chat view after navigating from suggestion '
-                        'for %s' % (element.name, keyword))
-            home.back_button.click()
-
-        home.just_fyi('No suggestion at attempt to search for invalid data')
-        invalid_data = ['   ', 'ab;', '.6', '@ana']
-        for text in invalid_data:
-            home.search_by_keyword(text)
-            if home.element_by_text_part('No search results. Do you mean').is_element_displayed():
-                self.errors.append('"No search results" is shown when searching for invalid value %s' % text)
-            home.cancel_button.click()
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6319)
-    @marks.medium
-    def test_deny_access_camera_and_gallery(self):
-        home = SignInView(self.driver).create_user()
-        general_camera_error = home.element_by_translation_id("camera-access-error")
-
-        home.just_fyi("Denying access to camera in universal qr code scanner")
-        home.plus_button.click()
-        home.universal_qr_scanner_button.click()
-        home.deny_button.click()
-        general_camera_error.wait_for_visibility_of_element(3)
-        home.ok_button.click()
-        home.get_back_to_home_view()
-
-        home.just_fyi("Denying access to camera in scan chat key view")
-        home.plus_button.click()
-        chat = home.start_new_chat_button.click()
-        chat.scan_contact_code_button.click()
-        chat.deny_button.click()
-        general_camera_error.wait_for_visibility_of_element(3)
-        chat.ok_button.click()
-        home.get_back_to_home_view()
-
-        home.just_fyi("Denying access to gallery at attempt to send image")
-        home.add_contact(basic_user['public_key'])
-        chat.show_images_button.click()
-        chat.deny_button.click()
-        chat.element_by_translation_id("external-storage-denied").wait_for_visibility_of_element(3)
-        chat.ok_button.click()
-
-        home.just_fyi("Denying access to audio at attempt to record audio")
-        chat.audio_message_button.click()
-        chat.deny_button.click()
-        chat.element_by_translation_id("audio-recorder-permissions-error").wait_for_visibility_of_element(3)
-        chat.ok_button.click()
-        home.get_back_to_home_view()
-
-        home.just_fyi("Denying access to camera in wallet view")
-        wallet = home.wallet_button.click()
-        wallet.scan_qr_button.click()
-        wallet.deny_button.click()
-        general_camera_error.wait_for_visibility_of_element(3)
-        wallet.ok_button.click()
-
-        home.just_fyi("Denying access to camera in send transaction > scan address view")
-        wallet.accounts_status_account.click()
-        send_transaction = wallet.send_transaction_button.click()
-        send_transaction.chose_recipient_button.scroll_and_click()
-        send_transaction.scan_qr_code_button.click()
-        send_transaction.deny_button.click()
-        general_camera_error.wait_for_visibility_of_element(3)
-        send_transaction.ok_button.click()
-        wallet.close_button.click()
-        wallet.close_send_transaction_view_button.click()
-
-        home.just_fyi("Allow access to camera in universal qr code scanner and check it in other views")
-        wallet.home_button.click()
-        home.plus_button.click()
-        home.universal_qr_scanner_button.click()
-        home.allow_button.click()
-        if not home.element_by_text('Scan QR code').is_element_displayed():
-            self.errors.append('Scan QR code is not opened after denying and allowing permission to the camera')
-        home.cancel_button.click()
-        wallet = home.wallet_button.click()
-        wallet.scan_qr_button.click()
-        if not home.element_by_text('Scan QR code').is_element_displayed():
-            self.errors.append(
-                'Scan QR code is not opened after allowing permission to the camera from univesal QR code'
-                ' scanner view')
-        wallet.cancel_button.click()
-        wallet.home_button.click()
-        home.get_chat(basic_user['username']).click()
-        chat.show_images_button.click()
-        chat.allow_button.click()
-        if not chat.first_image_from_gallery.is_element_displayed():
-            self.errors.append('Image previews are not shown after denying and allowing access to gallery')
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(5757)
-    @marks.medium
-    def test_search_chat_on_home(self):
-        sign_in = SignInView(self.driver)
-        home = sign_in.create_user()
-
-        home.just_fyi('Join public chat, start 1-1 with username and with ENS')
-        chat_name = home.get_random_chat_name()
-        public_chat = home.join_public_chat(chat_name)
-        public_chat.get_back_to_home_view()
-        for public_key in (basic_user['public_key'], ens_user_ropsten['ens'], dummy_user['public_key']):
-            chat = home.add_contact(public_key)
-            chat.get_back_to_home_view()
-        profile = home.profile_button.click()
-        profile.open_contact_from_profile(dummy_user['username'])
-        nickname = 'dummy_user'
-        public_chat.set_nickname(nickname)
-        public_chat.home_button.click()
-
-        search_list = {
-            basic_user['username']: basic_user['username'],
-            ens_user_ropsten['username']: ens_user_ropsten['ens'],
-            chat_name: chat_name,
-            nickname: nickname,
-            dummy_user['username']: nickname,
-            ens_user_ropsten['ens']: ens_user_ropsten['ens']
-        }
-
-        home.just_fyi('Can search for public chat name, ens name, username')
-        home.swipe_down()
-        for keyword in search_list:
-            home.search_by_keyword(keyword)
-            search_results = home.chat_name_text.find_elements()
-            if not search_results:
-                self.errors.append('No search results after searching by %s keyword' % keyword)
-            for element in search_results:
-                if search_list[keyword] not in element.text:
-                    self.errors.append("'%s' is shown on the home screen after searching by '%s' keyword" %
-                                       (element.text, keyword))
-            home.cancel_button.click()
-
-        home.just_fyi('Can search for public chat while offline')
-        home.toggle_airplane_mode()
-        home.search_input.click()
-        home.search_input.send_keys(chat_name)
-        search_results = home.chat_name_text.find_elements()
-        if not search_results:
-            self.errors.append('No search results after searching by %s keyword' % chat_name)
-        for element in search_results:
-            if search_list[chat_name] not in element.text:
-                self.errors.append("'%s' is shown on the home screen after searching by '%s' keyword" %
-                                   (element.text, chat_name))
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6221)
-    @marks.medium
-    def test_app_on_background_by_back_button(self):
-        sign_in = SignInView(self.driver)
-        home = sign_in.create_user()
-        home.click_system_back_button()
-        home.driver.press_keycode(187)
-        if self.driver.current_activity != '.NexusLauncherActivity':
-            self.driver.fail('App is not in background! Current activity is: %s' % self.driver.current_activity)
-        home.status_in_background_button.click()
-        if not home.plus_button.is_element_displayed():
-            self.driver.fail('Chats view was not opened')
-
-    @marks.testrail_id(6213)
-    @marks.medium
-    def test_unblocked_user_is_not_added_in_contacts(self):
-        home = SignInView(self.driver).create_user()
-        chat = home.add_contact(basic_user["public_key"], add_in_contacts=False)
-
-        chat.just_fyi('Block user not added as contact from chat view')
-        chat.chat_options.click()
-        chat.view_profile_button.click()
-        chat.block_contact()
-        chat.get_back_to_home_view()
-
-        chat.just_fyi('Unblock user not added as contact from chat view')
-        profile = home.profile_button.click()
-        profile.contacts_button.click()
-        profile.blocked_users_button.click()
-        profile.element_by_text(basic_user["username"]).click()
-        chat.unblock_contact_button.click()
-
-        profile.just_fyi('Navigating to contact list and check that user is not in list')
-        profile.close_button.click()
-        profile.back_button.click()
-        if profile.element_by_text(basic_user["username"]).is_element_displayed():
-            self.driver.fail("Unblocked user not added previously in contact list added in contacts!")
-
-    @marks.testrail_id(5498)
-    @marks.medium
-    def test_share_user_profile_url_public_chat(self):
-        home = SignInView(self.driver).create_user()
-
-        home.just_fyi('Join to one-to-one chat and share link to other user profile via messenger')
-        chat = home.add_contact(dummy_user["public_key"])
-        chat.chat_options.click()
-        chat.view_profile_button.click_until_presence_of_element(chat.remove_from_contacts)
-        chat.profile_details.click()
-        chat.share_button.click()
-        chat.share_via_messenger()
-        if not chat.element_by_text_part(
-                'https://join.status.im/u/%s' % dummy_user["public_key"]).is_element_present():
-            self.errors.append("Can't share public key of contact")
-        for _ in range(2):
-            chat.click_system_back_button()
-
-        home.just_fyi('Join to public chat and share link to it via messenger')
-        chat.get_back_to_home_view()
-        public_chat_name = 'pubchat'
-        public_chat = home.join_public_chat(public_chat_name)
-        public_chat.chat_options.click()
-        public_chat.share_chat_button.click()
-        public_chat.share_via_messenger()
-        if not chat.element_by_text_part('https://join.status.im/%s' % public_chat_name).is_element_present():
-            self.errors.append("Can't share link to public chat")
-        for _ in range(2):
-            chat.click_system_back_button()
-        chat.get_back_to_home_view()
-
-        home.just_fyi('Open URL and share link to it via messenger')
-        daap = home.dapp_tab_button.click()
-        browser = daap.open_url('dap.ps')
-        browser.options_button.click()
-        browser.share_url_button.click()
-        browser.share_via_messenger()
-        expeceted_text_1 = 'https://join.status.im/b/https://dap.ps'
-        expeceted_text_2 = 'https://join.status.im/b/http://dap.ps'
-
-        if not (chat.element_by_text_part(expeceted_text_1).is_element_present() or
-                chat.element_by_text_part(expeceted_text_2).is_element_present()):
-            self.errors.append("Can't share link to URL")
-
-        self.errors.verify_no_errors()
-
-
-class TestChatManagementMultipleDevice(MultipleDeviceTestCase):
-
-
-
-    @marks.testrail_id(5763)
-    @marks.medium
-    def test_block_user_from_one_to_one_header_check_push_notification_service(self):
-        self.create_drivers(2)
-        device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
-        message_before_block_1 = "Before block from %s" % device_1.driver.number
-        message_before_block_2 = "Before block from %s" % device_2.driver.number
-        message_after_block_2 = "After block from %s" % device_2.driver.number
-        home_1, home_2 = device_1.create_user(enable_notifications=True), device_2.create_user()
-        profile_1 = home_1.profile_button.click()
-        device_2_public_key = home_2.get_public_key_and_username()
-        home_2.home_button.click()
-        default_username_1 = profile_1.default_username_text.text
-        profile_1.home_button.click()
-
-        device_1.just_fyi('both devices joining the same public chat and send messages')
-        chat_name = device_1.get_random_chat_name()
-        for home in home_1, home_2:
-            home.join_public_chat(chat_name)
-        chat_public_1, chat_public_2 = home_1.get_chat_view(), home_2.get_chat_view()
-        for chat in chat_public_1, chat_public_2:
-            chat.chat_message_input.send_keys("Before block from %s" % chat.driver.number)
-            chat.send_message_button.click()
-
-        chat_public_1.get_back_to_home_view()
-        chat_public_2.get_back_to_home_view()
-
-        device_1.just_fyi('both devices joining 1-1 chat and exchanging several messages')
-        chat_1 = home_1.add_contact(device_2_public_key)
-        for _ in range(2):
-            chat_1.chat_message_input.send_keys(message_before_block_1)
-            chat_1.send_message_button.click()
-
-        chat_2 = home_2.get_chat(default_username_1).click()
-        for _ in range(2):
-            chat_2.chat_message_input.send_keys(message_before_block_2)
-            chat_2.send_message_button.click()
-
-        device_1.just_fyi('block user')
-        chat_1.chat_options.click()
-        chat_1.view_profile_button.click()
-        chat_1.block_contact()
-        chat_1.get_back_to_home_view()
-        chat_1.home_button.click()
-
-        device_1.just_fyi('no 1-1, messages from blocked user are hidden in public chat')
-        from views.home_view import ChatElement
-        blocked_chat_user = ChatElement(self.drivers[0], basic_user['username'])
-
-        if blocked_chat_user.is_element_displayed():
-            home_1.driver.fail("Chat with blocked user '%s' is not deleted" % device_2.driver.number)
-        public_chat_after_block_1 = home_1.join_public_chat(chat_name)
-        if public_chat_after_block_1.chat_element_by_text(message_before_block_2).is_element_displayed():
-            self.errors.append(
-                "Messages from blocked user '%s' are not cleared in public chat '%s'" % (device_2.driver.number,
-                                                                                         chat_name))
-        device_1.click_system_home_button()
-
-        device_2.just_fyi('send messages to 1-1 and public chat')
-        for _ in range(2):
-            chat_2.chat_message_input.send_keys(message_after_block_2)
-            chat_2.send_message_button.click()
-        chat_2.get_back_to_home_view()
-        home_2.join_public_chat(chat_name)
-        chat_public_2 = home_2.get_chat_view()
-        [chat_public_2.send_message(message_after_block_2) for _ in range(2)]
-
-        device_1.just_fyi("check that new messages and push notifications don't arrive from blocked user")
-        device_1.open_notification_bar()
-        if device_1.element_by_text_part(message_after_block_2).is_element_displayed():
-            self.errors.append("Push notification is received from blocked user")
-        device_1.element_by_text_part(background_service_message).click()
-
-        if public_chat_after_block_1.chat_element_by_text(message_after_block_2).is_element_displayed():
-            self.errors.append("Message from blocked user '%s' is received" % device_2.driver.number)
-        if home_1.notifications_unread_badge.is_element_displayed():
-            device_1.driver.fail("Unread badge is shown after receiving new message from blocked user")
-        if blocked_chat_user.is_element_displayed():
-            device_2.driver.fail("Chat with blocked user is reappeared after receiving new messages in home view")
-        device_1.open_notification_bar()
-        home_1.stop_status_service_button.click()
-
-        device_2.just_fyi("send messages when device 1 is offline")
-        for _ in range(2):
-            chat_public_2.chat_message_input.send_keys(message_after_block_2)
-            chat_public_2.send_message_button.click()
-        chat_public_2.get_back_to_home_view()
-        home_2.get_chat(default_username_1).click()
-        for _ in range(2):
-            chat_2.chat_message_input.send_keys(message_after_block_2)
-            chat_2.send_message_button.click()
-
-        device_1.just_fyi("reopen app and check that messages from blocked user are not fetched")
-        device_1.click_system_home_button()
-        self.drivers[0].launch_app()
-        device_1.sign_in()
-        public_chat_after_block_1.home_button.double_click()
-        if home_1.notifications_unread_badge.is_element_displayed():
-            device_1.driver.fail("Unread badge is shown after after fetching new messages from offline")
-        if blocked_chat_user.is_element_displayed():
-            self.errors.append("Chat with blocked user is reappeared after fetching new messages from offline")
-        home_1.join_public_chat(chat_name)
-        home_1.get_chat_view()
-        if chat_public_1.chat_element_by_text(message_after_block_2).is_element_displayed():
-            self.errors.append("Message from blocked user '%s' is received after fetching new messages from offline"
-                               % device_2.driver.number)
-
-        device_1.just_fyi("check that PNs are still enabled in profile after closing 'background notification centre' "
-                          "message and relogin")
-        device_1.open_notification_bar()
-        if not device_1.element_by_text_part(background_service_message).is_element_displayed():
-            self.errors.append("Background notification service is not started after relogin")
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6233)
-    @marks.medium
-    def test_reply_to_message_in_chats(self):
-        self.create_drivers(2)
-        device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
-        message_from_sender = "Message sender"
-        message_from_receiver = "Message receiver"
-        home_1, home_2 = device_1.create_user(), device_2.create_user()
-
-        device_1.just_fyi('Both devices join to 1-1 chat')
-        device_2_public_key = home_2.get_public_key_and_username()
-        device_1_profile = home_1.profile_button.click()
-        device_1_username = device_1_profile.default_username_text.text
-        home_1.home_button.click()
-
-        device_1.just_fyi("Sender adds receiver and quotes own message")
-        device_1_chat = home_1.add_contact(device_2_public_key)
-        device_1_chat.send_message(message_from_sender)
-        device_1_chat.quote_message(message_from_sender)
-        if device_1_chat.quote_username_in_message_input.text != "↪ You":
-            self.errors.append("'You' is not displayed in reply quote snippet replying to own message")
-
-        device_1_chat.just_fyi("Clear quote and check there is not snippet anymore")
-        device_1_chat.cancel_reply_button.click()
-        if device_1_chat.cancel_reply_button.is_element_displayed():
-            self.errors.append("Message quote kept in public chat input after it's cancelation")
-
-        device_1_chat.just_fyi("Send reply")
-        device_1_chat.quote_message(message_from_sender)
-        reply_to_message_from_sender = message_from_sender + " reply"
-        device_1_chat.send_message(reply_to_message_from_sender)
-
-        device_1.just_fyi("Receiver verifies received reply...")
-        home_2.home_button.click()
-        device_2_chat_item = home_2.get_chat(device_1_username)
-        device_2_chat_item.wait_for_visibility_of_element(20)
-        device_2_chat = device_2_chat_item.click()
-        if device_2_chat.chat_element_by_text(reply_to_message_from_sender).replied_message_text != message_from_sender:
-            self.errors.append("No reply received in 1-1 chat")
-
-        device_1_chat.back_button.click()
-        device_2_chat.back_button.click()
-
-        device_1.just_fyi('both devices joining the same public chat and send messages')
-        chat_name = device_1.get_random_chat_name()
-        for home in home_1, home_2:
-            home.join_public_chat(chat_name)
-        chat_public_1, chat_public_2 = home_1.get_chat_view(), home_2.get_chat_view()
-        chat_public_1.send_message(message_from_sender)
-        chat_public_2.quote_message(message_from_sender)
-        if chat_public_2.quote_username_in_message_input.text != ("↪ Replying to " + device_1_username):
-            self.errors.append(
-                " %s is not displayed in reply quote snippet replying to own message " % device_1_username)
-
-        device_1.just_fyi('Message receiver verifies reply is present in received message')
-        chat_public_2.send_message(message_from_receiver)
-        public_replied_message = chat_public_1.chat_element_by_text(message_from_receiver)
-        if public_replied_message.replied_message_text != message_from_sender:
-            self.errors.append("Reply is not present in message received in public chat")
-
-        device_1.just_fyi('Can reply to link')
-        link_message, reply = 'Test with link: https://status.im/ here should be nothing unusual.' \
-                              ' Just a regular reply.', 'reply to link'
-        chat_public_1.send_message(link_message)
-        chat_public_2.quote_message(link_message[:10])
-        chat_public_2.send_message(reply)
-        public_replied_message = chat_public_1.chat_element_by_text(reply)
-        if public_replied_message.replied_message_text != link_message:
-            self.errors.append("Reply for '%s' not present in message received in public chat" % link_message)
-
-        device_1.just_fyi('Can reply to emoji message')
-        reply = 'reply to emoji'
-        emoji_message = random.choice(list(emoji.EMOJI_UNICODE))
-        emoji_unicode = emoji.EMOJI_UNICODE[emoji_message]
-        chat_public_1.send_message(emoji.emojize(emoji_message))
-        chat_public_2.quote_message(emoji.emojize(emoji_message))
-        chat_public_2.send_message(reply)
-        public_replied_message = chat_public_1.chat_element_by_text(reply)
-        if public_replied_message.replied_message_text != emoji_unicode:
-            self.errors.append("Reply for '%s' emoji not present in message received in public chat" % emoji_unicode)
-
-        self.errors.verify_no_errors()
-
-
-    @marks.testrail_id(6326)
-    @marks.medium
-    def test_mention_users_not_in_chats_if_not_in_contacts(self):
-        self.create_drivers(2)
-        device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
-        sender = ens_user
-        home_1, home_2 = device_1.create_user(), device_2.recover_access(passphrase=sender['passphrase'])
-        profile_2 = home_2.profile_button.click()
-        profile_2.connect_existing_ens(sender['ens'])
-        profile_2.home_button.double_click()
-
-        device_1.just_fyi('Both devices joining the same public chat and send messages')
-        chat_name = device_1.get_random_chat_name()
-        [chat_1, chat_2] = [home.join_public_chat(chat_name) for home in (home_1, home_2)]
-        message = 'From ' + sender['ens'] + ' message'
-        chat_2.send_message(message)
-        username_value = '@' + sender['ens']
-
-        self.drivers[1].close_app()
-        self.drivers[1].launch_app()
-        device_2.back_button.click()
-        device_2.your_keys_more_icon.click()
-        device_2.generate_new_key_button.click()
-        device_2.create_user(second_user=True)
-        home_2.join_public_chat(chat_name)
-        newusermessage = 'Newusermessage2'
-        chat_2.send_message(newusermessage)
-        random_username = chat_1.chat_element_by_text(newusermessage).username.text
-        chat_1.wait_ens_name_resolved_in_chat(message=message, username_value=username_value)
-
-        device_1.just_fyi('Set nickname for ENS user')
-        chat_1.view_profile_long_press(message)
-        nickname = 'nicknamefortestuser'
-        chat_1.set_nickname(nickname)
-        ens_nickname_value = nickname + " @" + sender['ens']
-        chat_1.wait_ens_name_resolved_in_chat(message=message, username_value=ens_nickname_value)
-
-        device_1.just_fyi('Check there is ENS+Nickname user in separate 1-1 chat')
-        chat_1.get_back_to_home_view()
-        home_1.add_contact(public_key=basic_user['public_key'])
-        chat_1.chat_message_input.send_keys('@')
-        if (chat_1.search_user_in_mention_suggestion_list(ens_nickname_value).is_element_displayed() or
-                chat_1.search_user_in_mention_suggestion_list(
-                    sender['username']).is_element_displayed()):
-            self.errors.append('ENS-owner user who is not in 1-1 chat is  available in mention suggestion list')
-
-        device_1.just_fyi('Check there is no random user in different public chat')
-        chat_1.get_back_to_home_view()
-        chat_1 = home_1.join_public_chat(chat_name + "2")
-        chat_1.chat_message_input.send_keys('@')
-        if chat_1.search_user_in_mention_suggestion_list(random_username).is_element_displayed():
-            self.errors.append('Random user from public chat is in mention suggestion list another public chat')
-
-        device_1.just_fyi('Check there is ENS+Nickname user in Group chat and no random user')
-        chat_1.get_back_to_home_view()
-        home_1.add_contact(sender['public_key'])
-        chat_1.get_back_to_home_view()
-        home_1.create_group_chat(user_names_to_add=[nickname])
-        chat_1.chat_message_input.send_keys('@')
-        if chat_1.search_user_in_mention_suggestion_list(random_username).is_element_displayed():
-            self.errors.append('Random user from public chat is in mention suggestion list of Group chat')
-        if not (chat_1.search_user_in_mention_suggestion_list(ens_nickname_value).is_element_displayed() or
-                chat_1.search_user_in_mention_suggestion_list(sender['username']).is_element_displayed()):
-            self.errors.append('ENS-owner user is not available in mention suggestion list of Group chat')
-
-        device_1.just_fyi('Check there is no blocked user in mentions Group/Public chat ')
-        home_1.home_button.click()
-        public_1 = home_1.join_public_chat(chat_name)
-        public_1.chat_element_by_text(message).member_photo.click()
-        public_1.block_contact()
-        public_1.chat_message_input.send_keys('@')
-        if (chat_1.search_user_in_mention_suggestion_list(ens_nickname_value).is_element_displayed() or
-                chat_1.search_user_in_mention_suggestion_list(sender['username']).is_element_displayed()):
-            self.errors.append('Blocked user is available in mention suggestion list')
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(695771)
-    @marks.medium
-    def test_activity_center_group_chats_trusted_contacts(self):
-        self.create_drivers(2)
-        device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
-        message_from_sender = "Message sender"
-        group_chat_name_1 = "GroupChat1"
-        group_chat_name_2 = "GroupChat2"
-        home_1, home_2 = device_1.create_user(), device_2.create_user()
-
-        device_1.just_fyi('Device1 sets permissions to accept chat requests only from trusted contacts')
-        profile_1 = home_1.profile_button.click()
-        profile_1.privacy_and_security_button.click()
-        profile_1.accept_new_chats_from.click()
-        profile_1.accept_new_chats_from_contacts_only.click()
-        profile_1.profile_button.click()
-        public_key_user_1, username_1 = profile_1.get_public_key_and_username(return_username=True)
-        public_key_user_2, username_2 = home_2.get_public_key_and_username(return_username=True)
-
-        device_1.just_fyi('Device2 creates 1-1 chat Group chats')
-        home_2.home_button.click()
-        one_to_one_device_2 = home_2.add_contact(public_key_user_1)
-        one_to_one_device_2.send_message(message_from_sender)
-        one_to_one_device_2.home_button.click()
-        home_2.create_group_chat([username_1], group_chat_name=group_chat_name_1)
-
-        device_1.just_fyi('Device1 check there are no any chats in Activity Center nor Chats view')
-
-        home_1.home_button.click()
-        if home_1.element_by_text_part(username_2).is_element_displayed() or home_1.element_by_text_part(
-                group_chat_name_1).is_element_displayed():
-            self.errors.append("Chats are present on Chats view despite they created by non-contact")
-        home_1.notifications_button.click()
-        if home_1.element_by_text_part(username_2).is_element_displayed() or home_1.element_by_text_part(
-                group_chat_name_1).is_element_displayed():
-            self.errors.append("Chats are present in Activity Center view despite they created by non-contact")
-
-        device_1.just_fyi('Device1 adds Device2 in Contacts so chat requests should be visible now')
-        home_1.home_button.click()
-        home_1.add_contact(public_key_user_2)
-
-        device_1.just_fyi('Device2 creates 1-1 chat Group chats once again')
-        home_2.home_button.click()
-        home_2.get_chat_from_home_view(username_1).click()
-        one_to_one_device_2.send_message(message_from_sender)
-        one_to_one_device_2.home_button.click()
-        home_2.create_group_chat([username_1], group_chat_name=group_chat_name_2)
-
-        device_1.just_fyi('Device1 verifies 1-1 chat Group chats are visible')
-
-        home_1.home_button.click()
-        if not home_1.element_by_text_part(username_2).is_element_displayed() or not home_1.element_by_text_part(
-                group_chat_name_2).is_element_displayed():
-            self.errors.append("Chats are not present on Chats view while they have to!")
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(695782)
-    @marks.medium
-    def test_can_accept_or_reject_multiple_chats_from_activity_center(self):
-        self.create_drivers(2)
-        device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
-        message_from_sender = "Message sender"
-        group_chat_name_1 = "GroupChat1"
-        group_chat_name_2 = "GroupChat2"
-        home_1, home_2 = device_1.create_user(), device_2.create_user()
-
-        device_1.just_fyi('Device1 adds Devices and creates 1-1 and Group chat with it')
-        public_key_user_1, username_1 = home_1.get_public_key_and_username(return_username=True)
-        public_key_user_2, username_2 = home_2.get_public_key_and_username(return_username=True)
-        home_1.home_button.click()
-        device_1_one_to_one_chat = home_1.add_contact(public_key_user_2)
-        device_1_one_to_one_chat.send_message(message_from_sender)
-        device_1_one_to_one_chat.home_button.click()
-
-        home_1.create_group_chat([username_2], group_chat_name=group_chat_name_1)
-        home_1.home_button.click()
-        home_2.home_button.click()
-
-        device_1.just_fyi('Device2 rejects both chats and verifies they disappeared and not in Chats too')
-        home_2.notifications_button.click()
-        home_2.notifications_select_button.click()
-        home_2.element_by_text_part(username_1[:10]).click()
-        home_2.element_by_text_part(group_chat_name_1).click()
-        home_2.notifications_reject_and_delete_button.click()
-
-        if home_2.element_by_text_part(username_1[:20]).is_element_displayed(2):
-            self.errors.append("1-1 chat is on Activity Center view after action made on it")
-        if home_2.element_by_text_part(group_chat_name_1).is_element_displayed(2):
-            self.errors.append("Group chat is on Activity Center view after action made on it")
-        home_2.home_button.click()
-        if home_2.element_by_text_part(username_1[:20]).is_element_displayed(2):
-            self.errors.append("1-1 chat is added on home after rejection")
-        if home_2.element_by_text_part(group_chat_name_1).is_element_displayed(2):
-            self.errors.append("Group chat is added on home after rejection")
-
-        home_2.just_fyi("Verify there are still no chats after relogin")
-        home_2.relogin()
-        if home_2.element_by_text_part(username_1[:20]).is_element_displayed(2):
-            self.errors.append("1-1 chat appears on Chats view after relogin")
-        if home_2.element_by_text_part(group_chat_name_1).is_element_displayed(2):
-            self.errors.append("Group chat appears on Chats view after relogin")
-        home_2.notifications_button.click()
-        if home_2.element_by_text_part(username_1[:20]).is_element_displayed(2):
-            self.errors.append("1-1 chat request reappears back in Activity Center view after relogin")
-        if home_2.element_by_text_part(group_chat_name_1).is_element_displayed(2):
-            self.errors.append("Group chat request reappears back in Activity Center view after relogin")
-        home_2.home_button.click()
-
-        device_1.just_fyi('Device1 creates 1-1 and Group chat again')
-        home_1.get_chat_from_home_view(username_2).click()
-        device_1_one_to_one_chat.send_message('Some text here')
-        device_1_one_to_one_chat.home_button.click()
-        home_1.create_group_chat([username_2], group_chat_name=group_chat_name_2)
-
-        device_1.just_fyi('Device2 accepts both chats (via Select All button) and verifies they disappeared '
-                          'from activity center view but present on Chats view')
-        home_2.notifications_button.click()
-        home_2.notifications_select_button.click()
-        home_2.notifications_select_all.click()
-        home_2.notifications_accept_and_add_button.click()
-
-        if home_2.element_by_text_part(username_1[:20]).is_element_displayed(2):
-            self.errors.append("1-1 chat request stays on Activity Center view after it was accepted")
-        if home_2.element_by_text_part(group_chat_name_2).is_element_displayed(2):
-            self.errors.append("Group chat request stays on Activity Center view after it was accepted")
-        home_2.home_button.click()
-
-        if not home_2.element_by_text_part(username_1[:20]).is_element_displayed(2):
-            self.errors.append("1-1 chat is not added on home after accepted from Activity Center")
-        if not home_2.element_by_text_part(group_chat_name_2).is_element_displayed(2):
-            self.errors.append("Group chat is not added on home after accepted from Activity Center")
-
-        self.errors.verify_no_errors()

test/appium/tests/atomic/chats/test_commands.py

@@ -1,260 +0,0 @@
-import time
-import pytest
-from tests import marks
-from tests.users import transaction_senders, ens_user
-from tests.base_test_case import MultipleDeviceTestCase, MultipleSharedDeviceTestCase, create_shared_drivers
-from views.sign_in_view import SignInView
-
-
-@pytest.mark.xdist_group(name="commands_2")
-@marks.critical
-class TestCommandsMultipleDevicesMerged(MultipleSharedDeviceTestCase):
-
-    @classmethod
-    def setup_class(cls):
-        cls.drivers, cls.loop = create_shared_drivers(2)
-        cls.device_1, cls.device_2 = SignInView(cls.drivers[0]), SignInView(cls.drivers[1])
-        cls.sender = transaction_senders['ETH_STT_3']
-        cls.home_1 = cls.device_1.recover_access(passphrase=cls.sender['passphrase'], enable_notifications=True)
-        cls.home_2 = cls.device_2.create_user()
-        for home in cls.home_1, cls.home_2:
-            profile = home.profile_button.click()
-            profile.profile_notifications_button.scroll_and_click()
-            profile.wallet_push_notifications.click()
-        cls.recipient_public_key, cls.recipient_username = cls.home_2.get_public_key_and_username(return_username=True)
-        cls.wallet_1, cls.wallet_2 = cls.home_1.wallet_button.click(), cls.home_2.wallet_button.click()
-        [wallet.home_button.click() for wallet in (cls.wallet_1, cls.wallet_2)]
-        cls.chat_1 = cls.home_1.add_contact(cls.recipient_public_key)
-        cls.chat_1.send_message("hello!")
-        cls.account_name_1 = cls.wallet_1.status_account_name
-
-    @marks.testrail_id(6253)
-    @marks.transaction
-    def test_1_1_chat_command_send_eth_outgoing_tx_push(self):
-        amount = self.chat_1.get_unique_amount()
-        self.home_1.just_fyi('Send %s ETH in 1-1 chat and check it for sender and receiver: Address requested' % amount)
-        self.chat_1.commands_button.click()
-        send_transaction = self.chat_1.send_command.click()
-        send_transaction.get_username_in_transaction_bottom_sheet_button(self.recipient_username).click()
-        if send_transaction.scan_qr_code_button.is_element_displayed():
-            self.drivers[0].fail('Recipient is editable in bottom sheet when send ETH from 1-1 chat')
-        send_transaction.amount_edit_box.set_value(amount)
-        send_transaction.confirm()
-        send_transaction.sign_transaction_button.click()
-        sender_message = self.chat_1.get_outgoing_transaction(self.account_name_1)
-        if not sender_message.is_element_displayed():
-            self.drivers[0].fail('No message is shown after sending ETH in 1-1 chat for sender')
-        sender_message.transaction_status.wait_for_element_text(sender_message.address_requested)
-
-        chat_2 = self.home_2.get_chat(self.sender['username']).click()
-        receiver_message = chat_2.get_incoming_transaction(self.account_name_1)
-        timestamp_sender = sender_message.timestamp_command_message.text
-        if not receiver_message.is_element_displayed():
-            self.drivers[0].fail('No message about incoming transaction in 1-1 chat is shown for receiver')
-        receiver_message.transaction_status.wait_for_element_text(receiver_message.address_requested)
-
-        self.home_2.just_fyi('Accept and share address for sender and receiver')
-        for option in (receiver_message.decline_transaction, receiver_message.accept_and_share_address):
-            if not option.is_element_displayed():
-                self.drivers[0].fail("Required options accept or share are not shown")
-
-        select_account_bottom_sheet = receiver_message.accept_and_share_address.click()
-        if not select_account_bottom_sheet.get_account_in_select_account_bottom_sheet_button(
-                self.account_name_1).is_element_displayed():
-            self.errors.append('Not expected value in "From" in "Select account": "Status" is expected')
-        select_account_bottom_sheet.select_button.click()
-        receiver_message.transaction_status.wait_for_element_text(receiver_message.shared_account)
-        sender_message.transaction_status.wait_for_element_text(sender_message.address_request_accepted)
-
-        self.home_1.just_fyi("Sign and send transaction and check that timestamp on message is updated")
-        time.sleep(20)
-        send_bottom_sheet = sender_message.sign_and_send.click()
-        send_bottom_sheet.next_button.click()
-        send_bottom_sheet.sign_transaction()
-        updated_timestamp_sender = sender_message.timestamp_command_message.text
-        if updated_timestamp_sender == timestamp_sender:
-            self.errors.append("Timestamp of message is not updated after signing transaction")
-        self.chat_1.wallet_button.click()
-        self.wallet_1.find_transaction_in_history(amount=amount)
-
-        [wallet.put_app_to_background() for wallet in (self.wallet_1, self.wallet_2)]
-        self.device_1.open_notification_bar()
-        self.network_api.wait_for_confirmation_of_transaction(self.sender['address'], amount)
-        pn = self.home_1.get_pn('You sent %s ETH' % amount)
-        if pn:
-            pn.click()
-            if not self.wallet_1.transaction_history_button.is_element_displayed():
-                self.errors.append('Was not redirected to transaction history after tapping on PN')
-        else:
-            self.home_1.click_system_back_button()
-            self.home_1.status_in_background_button.click_if_shown()
-        self.wallet_1.home_button.click(desired_view="chat")
-
-        self.home_1.just_fyi("Check 'Confirmed' state for sender and receiver(use pull-to-refresh to update history)")
-        chat_2.status_in_background_button.click()
-        chat_2.wallet_button.click()
-        self.wallet_2.wait_balance_is_changed()
-        self.wallet_2.find_transaction_in_history(amount=amount)
-        self.wallet_2.home_button.click()
-        self.home_2.get_chat(self.sender['username']).click()
-        [message.transaction_status.wait_for_element_text(message.confirmed, 60) for message in
-         (sender_message, receiver_message)]
-
-        # TODO: should be added PNs for receiver after getting more stable feature (rechecked 23.11.21, valid)
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6265)
-    def test_1_1_chat_command_decline_eth_push_changing_state(self):
-        [home.driver.background_app(3) for home in (self.home_1, self.home_2)]
-        self.home_1.home_button.double_click()
-        self.home_1.get_chat(username=self.recipient_username).click()
-
-        self.home_1.just_fyi('Decline transaction before sharing address and check that state is changed')
-        self.chat_1.commands_button.click()
-        send_transaction = self.chat_1.send_command.click()
-        amount = self.chat_1.get_unique_amount()
-        send_transaction.amount_edit_box.set_value(amount)
-        send_transaction.confirm()
-        send_transaction.sign_transaction_button.click()
-        chat_1_sender_message = self.chat_1.get_outgoing_transaction()
-        self.home_1.click_system_home_button()
-
-        self.home_2.home_button.double_click()
-        chat_2 = self.home_2.get_chat(self.sender['username']).click()
-        chat_2_receiver_message = chat_2.get_incoming_transaction()
-        chat_2_receiver_message.decline_transaction.click()
-        self.home_1.open_notification_bar()
-        self.home_1.element_by_text_part('Request address for transaction declined').wait_and_click()
-
-        [message.transaction_status.wait_for_element_text(message.declined) for message in
-         (chat_1_sender_message, chat_2_receiver_message)]
-
-        self.home_1.just_fyi('Decline transaction request and check that state is changed')
-        request_amount = self.chat_1.get_unique_amount()
-        self.chat_1.commands_button.click()
-        request_transaction = self.chat_1.request_command.click()
-        request_transaction.amount_edit_box.set_value(request_amount)
-        request_transaction.confirm()
-        request_transaction.request_transaction_button.click()
-        chat_1_request_message = self.chat_1.get_incoming_transaction()
-        chat_2_sender_message = chat_2.get_outgoing_transaction()
-        chat_2_sender_message.decline_transaction.click()
-        [message.transaction_status.wait_for_element_text(message.declined) for message in
-         (chat_2_sender_message, chat_1_request_message)]
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6263)
-    @marks.transaction
-    def test_1_1_chat_command_request_and_receive_stt_in_1_1_chat_offline(self):
-        [home.driver.background_app(2) for home in (self.home_1, self.home_2)]
-        asset_name = 'STT'
-        amount = self.device_1.get_unique_amount()
-
-        self.device_1.just_fyi('Grab user data for transactions and public chat, set up wallets')
-        self.home_2.get_back_to_home_view()
-        self.home_2.wallet_button.click()
-        self.wallet_2.select_asset(asset_name)
-        self.wallet_2.home_button.click()
-        self.home_1.wallet_button.double_click()
-        initial_amount_stt = self.wallet_1.get_asset_amount_by_name('STT')
-        self.home_1.driver.close_app()
-
-        self.home_2.just_fyi('Request %s STT in 1-1 chat and check it is visible for sender and receiver' % amount)
-        chat_2 = self.home_2.get_chat(username=self.sender['username']).click()
-        chat_2.commands_button.click()
-        request_transaction = chat_2.request_command.click()
-        request_transaction.amount_edit_box.set_value(amount)
-        request_transaction.confirm()
-        asset_button = request_transaction.asset_by_name(asset_name)
-        request_transaction.select_asset_button.click_until_presence_of_element(asset_button)
-        asset_button.click()
-        request_transaction.request_transaction_button.click()
-        chat_2_request_message = chat_2.get_incoming_transaction()
-        if not chat_2_request_message.is_element_displayed():
-            self.drivers[1].fail('No incoming transaction in 1-1 chat is shown for recipient after requesting STT')
-
-        self.home_1.just_fyi('Check that transaction message is fetched from offline and sign transaction')
-        self.device_1.driver.launch_app()
-        self.device_1.sign_in()
-        self.home_1.connection_offline_icon.wait_for_invisibility_of_element(30)
-        self.home_1.get_chat(self.recipient_username).click()
-        chat_1_sender_message = self.chat_1.get_outgoing_transaction()
-        if not chat_1_sender_message.is_element_displayed():
-            self.drivers[0].fail('No outgoing transaction in 1-1 chat is shown for sender after requesting STT')
-        chat_1_sender_message.transaction_status.wait_for_element_text(chat_1_sender_message.address_received)
-        send_message = chat_1_sender_message.sign_and_send.click()
-        send_message.next_button.click()
-        send_message.sign_transaction()
-
-        self.home_2.just_fyi('Check that transaction message is updated with new status after offline')
-        [chat.toggle_airplane_mode() for chat in (self.chat_1, chat_2)]
-        self.network_api.wait_for_confirmation_of_transaction(self.sender['address'], amount, token=True)
-        for home in (self.home_1, self.home_2):
-            home.toggle_airplane_mode()
-            home.home_button.double_click()
-            home.connection_offline_icon.wait_for_invisibility_of_element(100)
-        self.home_2.get_chat(self.sender['username']).click()
-        self.home_1.get_chat(self.recipient_username).click()
-        [message.transaction_status.wait_for_element_text(message.confirmed, wait_time=120) for message in
-         (chat_1_sender_message, chat_2_request_message)]
-
-        self.home_1.just_fyi('Check that can find tx in history and balance is updated after offline')
-        self.home_1.wallet_button.click()
-        self.wallet_1.wait_balance_is_changed('STT', initial_amount_stt)
-        self.wallet_1.find_transaction_in_history(amount=amount, asset=asset_name)
-
-        self.errors.verify_no_errors()
-
-
-class TestCommandsMultipleDevices(MultipleDeviceTestCase):
-
-    @marks.testrail_id(6257)
-    @marks.medium
-    @marks.transaction
-    def test_network_mismatch_for_send_request_in_1_1_chat(self):
-        sender = transaction_senders['ETH_1']
-        self.create_drivers(2)
-        sign_in_1, sign_in_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
-        sign_in_1.recover_access(passphrase=sender['passphrase'])
-        sign_in_2.create_user()
-        home_1, home_2 = sign_in_1.get_home_view(), sign_in_2.get_home_view()
-        wallet_1 = home_1.wallet_button.click()
-        wallet_1.home_button.click()
-        profile_2 = home_2.profile_button.click()
-        username_2 = profile_2.default_username_text.text
-        profile_2.switch_network()
-
-        chat_2 = home_2.add_contact(sender['public_key'])
-        chat_2.send_message("Hey there!")
-        amount = chat_2.get_unique_amount()
-
-        chat_2.commands_button.click()
-        request_transaction = chat_2.request_command.click()
-        request_transaction.amount_edit_box.set_value(amount)
-        request_transaction.confirm()
-        request_transaction.request_transaction_button.click()
-        chat_2_request_message = chat_2.get_incoming_transaction()
-
-        chat_2_request_message.long_press_element()
-        if chat_2.reply_message_button.is_element_displayed():
-            self.errors.append('Reply is available on long-tap on Incoming transaction message!')
-
-        chat_1 = home_1.get_chat(username_2).click()
-        chat_1_sender_message = chat_1.get_outgoing_transaction()
-        chat_1_sender_message.long_press_element()
-        if chat_1.reply_message_button.is_element_displayed():
-            self.errors.append('Reply is available on long-tap on Outgoing transaction message!')
-        send_message = chat_1_sender_message.sign_and_send.click()
-        send_message.next_button.click()
-        send_message.sign_transaction()
-        self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount)
-        chat_1_sender_message.transaction_status.wait_for_element_text(chat_1_sender_message.confirmed)
-        wallet_2 = chat_2.wallet_button.click()
-        wallet_2.accounts_status_account.click()
-        wallet_2.swipe_down()
-        wallet_2.home_button.click(desired_view="chat")
-        if chat_2_request_message.transaction_status == chat_1_sender_message.confirmed:
-            self.errors.append("Transaction is shown as confirmed on mainnet, but was sent on ropsten!")
-        self.errors.verify_no_errors()
-

test/appium/tests/atomic/chats/test_communities.py

@@ -1,173 +0,0 @@
-from tests import marks
-from tests.base_test_case import MultipleDeviceTestCase
-from views.sign_in_view import SignInView
-from views.chat_view import CommunityView
-
-
-class TestCommunitiesMultipleDevices(MultipleDeviceTestCase):
-
-    @marks.testrail_id(695842)
-    @marks.medium
-    @marks.flaky
-    def test_creating_community_accept_membership(self):
-        self.create_drivers(2)
-        home_1, home_2 = SignInView(self.drivers[0]).create_user(), SignInView(self.drivers[1]).create_user()
-        community_name, pub_chat_name, channel_name = "some name", home_1.get_random_chat_name(), "first_channel"
-        community_description, community_pic = "something in community", 'sauce_logo.png'
-        message, message_member = "message", "from member"
-        userkey_2, username_2 = home_2.get_public_key_and_username(return_username=True)
-        home_2.home_button.click()
-        community_1 = home_1.create_community(community_name, community_description, set_image=True,
-                                              file_name=community_pic)
-        channel_1 = community_1.add_channel(channel_name)
-        channel_1.send_message(message)
-        home_1.home_button.double_click()
-
-        home_1.just_fyi("Sending community link to public chat")
-        community_1 = home_1.get_chat(community_name, community=True).click()
-        community_link_text = community_1.copy_community_link()
-        pub_1 = home_1.join_public_chat(pub_chat_name)
-        pub_1.chat_message_input.paste_text_from_clipboard()
-        pub_1.send_message_button.click()
-        pub_1.get_back_to_home_view()
-
-        home_2.just_fyi("Tapping on community link and request membership")
-        pub_2 = home_2.join_public_chat(pub_chat_name)
-        pub_2.element_by_text(community_name).wait_for_element(100)
-        community_message_2 = pub_2.get_community_link_preview_by_text(community_link_text)
-        if community_message_2.community_description != community_description:
-            self.errors.append(
-                "Community description '%s' does not match expected" % community_message_2.community_description)
-        if community_message_2.community_members_amount != 1:
-            self.errors.append("Members amount in resolved message '%s' does not match expected" % str(
-                community_message_2.community_members_amount))
-        community_message_2.view()
-        community_2 = CommunityView(self.drivers[1])
-        community_2.request_access_button.click()
-        if not community_2.membership_request_pending_text.is_element_displayed():
-            self.errors.append("Membership request is not pending")
-
-        home_1.just_fyi("Checking pending membership")
-        community_1 = home_1.get_chat(community_name, community=True).click()
-        community_1.community_options_button.click()
-        community_1.community_info_button.click()
-        community_1.community_membership_request_value.wait_for_element(60)
-        if community_1.community_membership_request_value.text != '1':
-            self.drivers[0].fail(
-                "Membership request value '%s' is not equal expected" % community_1.community_membership_request_value)
-
-        home_1.just_fyi("Approve membership")
-        community_1.handle_membership_request(username_2, approve=True)
-        if not community_1.element_by_text(username_2).is_element_displayed():
-            self.errors.append("New member %s is not shown as added to community on info page!" % username_2)
-        if not community_2.community_info_picture.is_element_image_similar_to_template(community_pic):
-            self.errors.append("Community image is different!")
-        channel_2 = community_2.get_chat(channel_name).click()
-        if not channel_2.chat_element_by_text(message).is_element_displayed(30):
-            self.errors.append("Message was not received in community channel!")
-        channel_2.send_message(message_member)
-        community_1.home_button.double_click()
-        home_1.get_chat(community_name, community=True).click()
-        chat_element_1 = community_1.get_chat(channel_name)
-        if not chat_element_1.new_messages_public_chat.is_element_displayed():
-            self.errors.append("Unread messages counter is not shown for community channel!")
-        if not community_1.element_by_text(message_member).is_element_displayed():
-            self.errors.append("Message from member is not shown for community channel!")
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(695845)
-    @marks.medium
-    def test_notification_in_activity_center_for_mention_in_community_and_group_chat(self):
-        self.create_drivers(2)
-        home_1, home_2 = SignInView(self.drivers[0]).create_user(), SignInView(self.drivers[1]).create_user()
-        community_name, gr_chat_name, channel_name = "some name", home_1.get_random_chat_name(), "first_channel"
-        community_description = "something in community"
-        message, message_member = "message", "from member"
-        userkey_2, username_2 = home_2.get_public_key_and_username(return_username=True)
-        userkey_1, username_1 = home_1.get_public_key_and_username(return_username=True)
-        home_1.home_button.click()
-        one_to_one_1 = home_1.add_contact(userkey_2)
-        one_to_one_1.home_button.click()
-        home_2.home_button.click()
-        home_1.just_fyi("Create community on Device_1")
-
-        community_1 = home_1.create_community(community_name, community_description, set_image=True)
-        channel_1 = community_1.add_channel(channel_name)
-        channel_1.send_message(message)
-        home_1.home_button.double_click()
-
-        home_1.just_fyi("Joining Group chat, receiving community link in there")
-        one_to_one_2 = home_2.add_contact(userkey_1)
-        one_to_one_2.home_button.click()
-        community_1 = home_1.get_chat(community_name, community=True).click()
-        community_link_text = community_1.copy_community_link()
-        pub_1 = home_1.create_group_chat(user_names_to_add=[username_2], group_chat_name=gr_chat_name)
-
-        pub_2 = home_2.get_chat(gr_chat_name).click()
-        pub_2.join_chat_button.click()
-        pub_1.chat_message_input.paste_text_from_clipboard()
-        pub_1.send_message_button.click()
-        pub_1.get_back_to_home_view()
-
-        home_2.just_fyi("Tapping on community link and request membership")
-        pub_2.element_by_text(community_name).wait_for_element(60)
-        community_message_2 = pub_2.get_community_link_preview_by_text(community_link_text)
-        community_2 = community_message_2.view()
-        community_2.request_access_button.click()
-        if not community_2.membership_request_pending_text.is_element_displayed():
-            self.errors.append("Membership request is not pending")
-
-        home_1.just_fyi("Checking pending membership")
-        community_1 = home_1.get_chat(community_name, community=True).click()
-        community_1.community_options_button.click()
-        community_1.community_info_button.click()
-        community_1.community_membership_request_value.wait_for_element(60)
-
-        home_1.just_fyi("Approve membership")
-        community_1.handle_membership_request(username_2, approve=True)
-        channel_2 = community_2.get_chat(channel_name).click()
-        channel_2.select_mention_from_suggestion_list(username_1, username_1[:2])
-        channel_2.send_as_keyevent("community")
-        channel_mesage = username_1 + " community"
-        channel_2.send_message_button.click()
-        community_1.home_button.double_click()
-        channel_2.home_button.click()
-        home_2.get_chat_from_home_view(gr_chat_name).click()
-        pub_2.select_mention_from_suggestion_list(username_1, username_1[:2])
-        pub_2.send_as_keyevent("group")
-        group_chat_message = username_1 + " group"
-        pub_2.send_message_button.click()
-
-        if not home_1.notifications_unread_badge.is_element_displayed():
-            self.errors.append("Unread badge is NOT shown after receiving mentions from Group and Community")
-        home_1.notifications_unread_badge.wait_and_click(30)
-
-        home_1.just_fyi("Check there are two notifications from two chats are present in Activity Center")
-        if home_1.get_chat_from_activity_center_view(username_2).chat_message_preview == group_chat_message:
-            home_1.just_fyi("Open group chat where user mentioned and return to Activity Center")
-            home_1.get_chat_from_activity_center_view(username_2).click()
-            home_1.home_button.click()
-            home_1.notifications_button.click()
-        else:
-            self.errors.append("No mention in Activity Center for Group Chat")
-
-        if home_1.get_chat_from_activity_center_view(username_2).chat_message_preview == channel_mesage:
-            home_1.just_fyi("Open community chat where user mentioned and return to Activity Center")
-            home_1.get_chat_from_activity_center_view(username_2).click()
-            home_1.home_button.click()
-        else:
-            self.errors.append("No mention in Activity Center for community chat")
-
-        home_1.just_fyi("Check there are no unread messages counters on chats after message read")
-        if (home_1.notifications_unread_badge.is_element_present() or
-                home_1.get_chat_from_home_view(gr_chat_name).new_messages_counter.text == "1" or
-                home_1.get_chat_from_home_view(community_name).new_messages_counter.text == "1"):
-            self.errors.append("Unread message indicator is kept after all messages read in chats")
-
-        home_1.just_fyi("Check there is an empty view on Activity Center")
-        home_1.notifications_button.click()
-        if not home_1.element_by_translation_id('empty-activity-center').is_element_present():
-            self.errors.append("It appears Activity Center still has some chats after user opened all of them")
-
-        self.errors.verify_no_errors()

test/appium/tests/atomic/chats/test_group_chat.py

@@ -1,222 +0,0 @@
-from tests import marks
-from tests.base_test_case import MultipleDeviceTestCase, SingleDeviceTestCase, MultipleSharedDeviceTestCase, create_shared_drivers
-from tests.users import transaction_senders, ens_user, chat_users
-from views.sign_in_view import SignInView
-import random
-import emoji
-
-
-class TestGroupChatMultipleDevice(MultipleDeviceTestCase):
-
-    @marks.testrail_id(5694)
-    @marks.medium
-    def test_make_admin_member_of_group_chat(self):
-        self.create_drivers(2)
-        device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
-        home_1, home_2 = device_1.create_user(), device_2.create_user()
-        public_key_1, username_1 = device_1.get_public_key_and_username(True)
-        device_1.home_button.click()
-        chat_name = home_1.get_random_chat_name()
-
-        device_2.just_fyi('Create and join to group chat')
-        device_2_key, device_2_username = device_2.get_public_key_and_username(True)
-        device_2.home_button.click()
-        home_1.add_contact(device_2_key)
-        home_1.get_back_to_home_view()
-        chat_1 = home_1.create_group_chat([device_2_username], chat_name)
-        chat_2 = home_2.get_chat(chat_name).click()
-        chat_2.join_chat_button.click()
-
-        device_1.just_fyi('Check group info view and options of users')
-        chat_1.chat_options.click()
-        group_info_1 = chat_1.group_info.click()
-        if not group_info_1.user_admin(username_1).is_element_displayed():
-            self.errors.append("Admin user is not marked as admin")
-        group_info_1.get_user_from_group_info(username_1).click()
-        if chat_1.profile_block_contact.is_element_displayed():
-            self.errors.append("Admin is redirected to own profile on tapping own username from group info")
-        group_info_1.get_user_from_group_info(device_2_username).click()
-        if not chat_1.profile_block_contact.is_element_displayed():
-            self.errors.append("Admin is not redirected to user profile on tapping member username from group info")
-        chat_1.close_button.click()
-
-        device_1.just_fyi('Made admin another user and check system message')
-        options = group_info_1.get_username_options(device_2_username).click()
-        options.make_admin_button.click()
-        admin_system_message = chat_1.has_been_made_admin_system_message(username_1, device_2_username)
-        for chat in (chat_1, chat_2):
-            if not chat.chat_element_by_text(admin_system_message).is_element_displayed():
-                self.errors.append("Message with test '%s' was not received" % admin_system_message)
-
-        device_2.just_fyi('Check Admin in group info and that "add members" is available')
-        chat_2.chat_options.click()
-        group_info_1 = chat_2.group_info.click()
-        for username in (username_1, device_2_username):
-            if not group_info_1.user_admin(username).is_element_displayed():
-                self.errors.append("Admin user is not marked as admin")
-        if not group_info_1.add_members.is_element_displayed():
-            self.errors.append("Add member button is not available for new admin")
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6327)
-    @marks.medium
-    def test_nicknames_ens_group_chats(self):
-        self.create_drivers(2)
-        home_1 = SignInView(self.drivers[0]).create_user()
-        home_2 = SignInView(self.drivers[1]).recover_access(ens_user['passphrase'])
-        profile_1, profile_2 = [home.profile_button.click() for home in (home_1, home_2)]
-        key_1, username_1 = profile_1.get_public_key_and_username(return_username=True)
-        ens, full_ens, username_2 = ens_user['ens'], '@%s' % ens_user['ens'], ens_user['username']
-        profile_2.connect_existing_ens(ens)
-        [profile.home_button.click() for profile in (profile_1, profile_2)]
-
-        home_1.just_fyi('Set nickname, using emojis, special chars and cyrrilic chars without adding to contact')
-        emoji_message = random.choice(list(emoji.EMOJI_UNICODE))
-        emoji_unicode = emoji.EMOJI_UNICODE[emoji_message]
-        special_char, cyrrilic = '"£¢€¥~`•|√π¶∆×°™®©%$@', 'стат'
-        nickname_to_set = emoji.emojize(emoji_message) + special_char + cyrrilic
-        nickname_expected = emoji_unicode + special_char + cyrrilic
-        chat_1 = home_1.add_contact(ens, add_in_contacts=False, nickname=nickname_to_set)
-        if chat_1.user_name_text.text != nickname_expected:
-            self.errors.append('Expected special char nickname %s does not match actual %s' % (nickname_expected, chat_1.user_name_text.text))
-
-        home_1.just_fyi('Can remove nickname without adding to contact')
-        chat_1.chat_options.click()
-        chat_1.view_profile_button.click()
-        chat_1.profile_nickname_button.click()
-        chat_1.nickname_input_field.clear()
-        chat_1.element_by_text('Done').click()
-        chat_1.close_button.click()
-        if chat_1.user_name_text.text != full_ens:
-            self.errors.append(
-                'Nickname was not removed! real chat name is %s instead of %s' % (chat_1.user_name_text.text, full_ens))
-
-        home_1.just_fyi('Adding ENS user to contacts and start group chat with him')
-        group_name = 'ens_group'
-        chat_1.add_to_contacts.click()
-        chat_2 = home_2.add_contact(key_1)
-        chat_2.send_message("first")
-        chat_2.home_button.click()
-        chat_1.home_button.click()
-        chat_1 = home_1.create_group_chat([full_ens], group_name)
-        chat_2 = home_2.get_chat(group_name).click()
-        chat_2.join_chat_button.click()
-
-        home_1.just_fyi('Check ENS and in group chat and suggestions list')
-        chat_1.element_by_text_part(full_ens).wait_for_visibility_of_element(60)
-        chat_1.select_mention_from_suggestion_list(ens, typed_search_pattern=ens[:2])
-        if chat_1.chat_message_input.text != '@' + ens + ' ':
-            self.errors.append(
-                'ENS username is not resolved in chat input after selecting it in mention suggestions list!')
-        additional_text = 'and more'
-        chat_1.send_as_keyevent(additional_text)
-        chat_1.send_message_button.click()
-        message_text = '%s %s' % (full_ens, additional_text)
-        if not chat_1.chat_element_by_text(message_text).is_element_displayed():
-            self.errors.append("ENS name is not resolved on sent message")
-        chat_1 = home_1.get_chat_view()
-
-        home_1.just_fyi('Set nickname via group info and check that can mention by nickname /username in group chat')
-        nickname = 'funny_bunny'
-        device_2_options = chat_1.get_user_options(full_ens)
-        device_2_options.view_profile_button.click()
-        chat_1.set_nickname(nickname, close_profile=False)
-        if not chat_1.element_by_text(nickname).is_element_displayed():
-            self.errors.append('Nickname is not shown in profile view after setting from group info')
-        chat_1.close_button.click()
-        chat_1.element_by_text(nickname).scroll_to_element()
-        chat_1.close_button.click()
-        message_text = '%s %s' % (nickname, additional_text)
-        if not chat_1.chat_element_by_text(message_text).is_element_displayed():
-            self.errors.append("ENS name was not replaced with nickname on sent message")
-        chat_1.chat_message_input.send_keys('@')
-        if not chat_1.element_by_text('%s %s' % (nickname, full_ens)).is_element_displayed():
-            self.errors.append("ENS name with nickname is not shown in mention input after set")
-        if not chat_1.element_by_text(username_2).is_element_displayed():
-            self.errors.append("3-random name is not shown in mention input after set from group info")
-        chat_1.chat_message_input.clear()
-        chat_1.select_mention_from_suggestion_list('%s %s' % (nickname, full_ens), typed_search_pattern=username_2[:2])
-        if chat_1.chat_message_input.text != '@' + ens + ' ':
-            self.errors.append(
-                'ENS is not resolved in chat input after setting nickname in mention suggestions list (search by 3-random name)!')
-        chat_1.chat_message_input.clear()
-        chat_1.select_mention_from_suggestion_list('%s %s' % (nickname, full_ens), typed_search_pattern=nickname[:2])
-        if chat_1.chat_message_input.text != '@' + ens + ' ':
-            self.errors.append(
-                'ENS is not resolved in chat input after setting nickname in mention suggestions list (search by nickname)!')
-        chat_1.chat_message_input.clear()
-
-        home_1.just_fyi('Can delete nickname via group info and recheck received messages')
-        device_2_options = chat_1.get_user_options(full_ens)
-        device_2_options.view_profile_button.click()
-        chat_1.profile_nickname_button.click()
-        chat_1.nickname_input_field.clear()
-        chat_1.element_by_text('Done').click()
-        chat_1.close_button.click()
-        chat_1.close_button.click()
-        message_text = '%s %s' % (full_ens, additional_text)
-        if not chat_1.chat_element_by_text(message_text).is_element_displayed():
-            self.errors.append("ENS name is not resolved on sent message after removing nickname")
-        chat_1.chat_message_input.send_keys('@')
-        if chat_1.element_by_text_part(nickname).is_element_displayed():
-            self.errors.append("Nickname is shown in group chat after removing!")
-
-        self.errors.verify_no_errors()
-
-
-class TestCommandsSingleDevices(SingleDeviceTestCase):
-
-    @marks.testrail_id(5721)
-    @marks.medium
-    def test_cant_add_more_twenty_participants_to_group_chat(self):
-        sign_in = SignInView(self.driver)
-        home = sign_in.create_user()
-        users = [chat_users['A'],
-                 chat_users['B'],
-                 transaction_senders['ETH_8'],
-                 transaction_senders['ETH_1'],
-                 transaction_senders['ETH_2'],
-                 transaction_senders['ETH_7'],
-                 transaction_senders['ETH_STT_3'],
-                 transaction_senders['ETH_STT_ADI_1'],
-                 transaction_senders['C'],
-                 transaction_senders['F'],
-                 transaction_senders['G'],
-                 transaction_senders['H'],
-                 transaction_senders['I'],
-                 transaction_senders['M'],
-                 transaction_senders['N'],
-                 transaction_senders['Q'],
-                 transaction_senders['R'],
-                 transaction_senders['S'],
-                 transaction_senders['T'],
-                 transaction_senders['U']]
-        usernames = []
-
-        home.just_fyi('Add 20 users to contacts')
-        profile = home.profile_button.click()
-        profile.contacts_button.click()
-        chat = home.get_chat_view()
-        for user in users:
-            profile.add_new_contact_button.click()
-            chat.public_key_edit_box.click()
-            chat.public_key_edit_box.set_value(user['public_key'])
-            chat.confirm_until_presence_of_element(profile.add_new_contact_button)
-            usernames.append(user['username'])
-
-        home.just_fyi('Create group chat with max amount of users')
-        profile.home_button.click()
-        chat = home.create_group_chat(usernames, 'some_group_chat')
-
-        home.just_fyi('Verify that can not add more users via group info')
-        chat.get_back_to_home_view()
-        home.get_chat('some_group_chat').click()
-        chat.chat_options.click()
-        group_info_view = chat.group_info.click()
-        if group_info_view.add_members.is_element_displayed():
-            self.errors.append('Add members button is displayed when max users are added in chat')
-        if not group_info_view.element_by_text_part('20 members').is_element_displayed():
-            self.errors.append('Amount of users is not shown on Group info screen')
-
-        self.errors.verify_no_errors()

test/appium/tests/atomic/chats/test_keycard_commands.py

@@ -1,118 +0,0 @@
-import time
-
-from tests import marks
-from tests.users import transaction_senders, ens_user_ropsten
-from tests.base_test_case import MultipleDeviceTestCase, SingleDeviceTestCase
-from views.sign_in_view import SignInView
-
-
-class TestCommandsMultipleDevices(MultipleDeviceTestCase):
-
-    @marks.testrail_id(6294)
-    @marks.medium
-    @marks.transaction
-    def test_keycard_request_and_receive_stt_in_1_1_chat_offline_opened_from_push(self):
-        sender = transaction_senders['ETH_STT_1']
-        self.create_drivers(2)
-        device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
-
-        device_1.just_fyi('Grab user data for transactions and public chat, set up wallets')
-        home_1 = device_1.create_user(keycard=True)
-        recipient_public_key, recipient_username = home_1.get_public_key_and_username(return_username=True)
-        amount = device_1.get_unique_amount()
-        asset_name = 'STT'
-        wallet_1 = home_1.wallet_button.click()
-        wallet_1.select_asset(asset_name)
-        wallet_1.home_button.click()
-
-        home_2 = device_2.recover_access(passphrase=sender['passphrase'], keycard=True, enable_notifications=True)
-        wallet_2 = home_2.wallet_button.click()
-        initial_amount_stt = wallet_2.get_asset_amount_by_name('STT')
-        wallet_2.home_button.click()
-
-        device_2.just_fyi('Add recipient to contact and send 1 message')
-        chat_2 = home_2.add_contact(recipient_public_key)
-        chat_2.send_message("Hey there!")
-
-        profile_2 = wallet_2.profile_button.click()
-        profile_2.airplane_mode_button.click()
-        device_2.home_button.double_click()
-        chat_element = home_1.get_chat(sender['username'])
-        chat_element.wait_for_visibility_of_element(30)
-        chat_1 = chat_element.click()
-
-        home_1.just_fyi('Request %s STT in 1-1 chat and check it is visible for sender and receiver' % amount)
-        chat_1.commands_button.click()
-        request_transaction = chat_1.request_command.click()
-        request_transaction.amount_edit_box.set_value(amount)
-        request_transaction.confirm()
-        asset_button = request_transaction.asset_by_name(asset_name)
-        request_transaction.select_asset_button.click_until_presence_of_element(asset_button)
-        asset_button.click()
-        request_transaction.request_transaction_button.click()
-        chat_1_request_message = chat_1.get_incoming_transaction()
-        if not chat_1_request_message.is_element_displayed():
-            self.drivers[0].fail('No incoming transaction in 1-1 chat is shown for recipient after requesting STT')
-
-        home_2.just_fyi('Check that transaction message is fetched from offline and sign transaction')
-        profile_2.airplane_mode_button.click()
-        transaction_request_pn = 'Request transaction'
-        device_2.open_notification_bar()
-        if not device_2.element_by_text(transaction_request_pn).is_element_displayed(60):
-            self.errors.append("Push notification is not received after going back from offline")
-        device_2.element_by_text(transaction_request_pn).click()
-        home_2.connection_offline_icon.wait_for_invisibility_of_element(120)
-        home_2.get_chat(recipient_username).click()
-        chat_2_sender_message = chat_2.get_outgoing_transaction()
-        chat_2_sender_message.wait_for_visibility_of_element(60)
-        chat_2_sender_message.transaction_status.wait_for_element_text(chat_2_sender_message.address_received)
-        send_message = chat_2_sender_message.sign_and_send.click()
-        send_message.next_button.click()
-        send_message.sign_transaction(keycard=True)
-        chat_1.toggle_airplane_mode()
-
-        home_2.just_fyi('Check that transaction message is updated with new status after offline')
-        [chat.toggle_airplane_mode() for chat in (chat_1, chat_2)]
-        self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount, token=True)
-        for home in (home_1, home_2):
-            home.toggle_airplane_mode()
-            home.home_button.double_click()
-        home_1.get_chat(sender['username']).click()
-        home_2.get_chat(recipient_username).click()
-        chat_2_sender_message.transaction_status.wait_for_element_text(chat_2_sender_message.confirmed, wait_time=120)
-
-        home_1.just_fyi('Check that can find tx in history and balance is updated after offline')
-        [home.wallet_button.click() for home in (home_1, home_2)]
-        wallet_2.wait_balance_is_changed('STT', initial_amount_stt)
-        wallet_1.wait_balance_is_changed('STT', scan_tokens=True)
-        [wallet.find_transaction_in_history(amount=amount, asset='STT') for wallet in (wallet_1, wallet_2)]
-        self.errors.verify_no_errors()
-
-
-class TestCommandsSingleDevices(SingleDeviceTestCase):
-
-    @marks.testrail_id(6295)
-    @marks.medium
-    @marks.transaction
-    def test_keycard_send_eth_to_ens(self):
-        sign_in = SignInView(self.driver)
-        sender = transaction_senders['ETH_4']
-        home = sign_in.recover_access(sender['passphrase'], keycard=True)
-        wallet = home.wallet_button.click()
-        wallet.home_button.click()
-
-        chat = home.add_contact(ens_user_ropsten['ens'])
-        chat.commands_button.click()
-        amount = chat.get_unique_amount()
-
-        send_message = chat.send_command.click()
-        send_message.amount_edit_box.set_value(amount)
-        send_message.confirm()
-        send_message.next_button.click()
-
-        from views.send_transaction_view import SendTransactionView
-        send_transaction = SendTransactionView(self.driver)
-        send_transaction.sign_transaction(keycard=True)
-        chat_sender_message = chat.get_outgoing_transaction()
-        self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount)
-        chat_sender_message.transaction_status.wait_for_element_text(chat_sender_message.confirmed)

test/appium/tests/atomic/dapps_and_browsing/test_browsing.py

@@ -1,47 +0,0 @@
-from tests import marks
-from tests.base_test_case import SingleDeviceTestCase
-from views.sign_in_view import SignInView
-
-
-class TestBrowsing(SingleDeviceTestCase):
-
-    # TODO: waiting mode (rechecked 23.11.21, valid)
-    @marks.testrail_id(6300)
-    @marks.skip
-    @marks.medium
-    def test_webview_security(self):
-        home_view = SignInView(self.driver).create_user()
-        daap_view = home_view.dapp_tab_button.click()
-
-        browsing_view = daap_view.open_url('https://simpledapp.status.im/webviewtest/url-spoof-ssl.html')
-        browsing_view.url_edit_box_lock_icon.click()
-        if not browsing_view.element_by_translation_id("browser-not-secure").is_element_displayed():
-            self.errors.append("Broken certificate displayed as secure connection \n")
-
-        browsing_view.cross_icon.click()
-        daap_view.open_url('https://simpledapp.status.im/webviewtest/webviewtest.html')
-        browsing_view.element_by_text_part('204').click()
-        if browsing_view.element_by_text_part('google.com').is_element_displayed():
-            self.errors.append("URL changed on attempt to redirect to no-content page \n")
-
-        browsing_view.cross_icon.click()
-        daap_view.open_url('https://simpledapp.status.im/webviewtest/webviewtest.html')
-        browsing_view.element_by_text_part('XSS check').click()
-        browsing_view.open_in_status_button.click()
-        if browsing_view.element_by_text_part('simpledapp.status.im').is_element_displayed():
-            self.errors.append("XSS attemp succedded \n")
-            browsing_view.ok_button.click()
-
-        browsing_view.cross_icon.click()
-        daap_view.open_url('https://simpledapp.status.im/webviewtest/url-blank.html')
-        if daap_view.edit_url_editbox.text == '':
-            self.errors.append("Blank URL value. Must show the actual URL \n")
-
-        browsing_view.cross_icon.click()
-        daap_view.open_url('https://simpledapp.status.im/webviewtest/port-timeout.html')
-        # wait up  ~2.5 mins for port time out
-        if daap_view.element_by_text_part('example.com').is_element_displayed(150):
-            self.errors.append("URL spoof due to port timeout \n")
-
-        self.errors.verify_no_errors()
-

test/appium/tests/atomic/dapps_and_browsing/test_dapps.py

@@ -1,126 +0,0 @@
-from tests import marks, test_dapp_name
-from tests.base_test_case import SingleDeviceTestCase
-from tests.users import basic_user
-from views.sign_in_view import SignInView
-
-
-class TestDApps(SingleDeviceTestCase):
-
-    @marks.testrail_id(6635)
-    @marks.medium
-    def test_webview_camera_permission(self):
-        web_view_camera_url = 'https://simpledapp.status.im/webviewtest/webviewcamera.html'
-        home = SignInView(self.driver).create_user()
-        self.driver.set_clipboard_text(web_view_camera_url)
-        dapp = home.dapp_tab_button.click()
-        dapp.enter_url_editbox.click()
-        dapp.paste_text()
-        dapp.confirm()
-
-        from views.web_views.base_web_view import BaseWebView
-        camera_dapp = BaseWebView(self.driver)
-        camera_dapp.just_fyi("Check camera request blocked (because it's not enabled in app yet)")
-        camera_request_blocked = home.get_translation_by_key("page-camera-request-blocked")
-        if not dapp.element_by_text_part(camera_request_blocked).is_element_displayed():
-            self.driver.fail("There is no pop-up notifying that camera access need to be granted in app")
-        camera_dapp.swipe_down()
-        if not camera_dapp.camera_image_in_dapp.is_element_image_similar_to_template('blank_camera_image.png'):
-            self.driver.fail("Even camera permissions not allowed - acccess to camera granted")
-
-        profile = home.profile_button.click()
-        profile.privacy_and_security_button.click()
-
-        camera_dapp.just_fyi("Enable camera requests in Dapps")
-        profile.element_by_translation_id("webview-camera-permission-requests").scroll_and_click()
-        home.dapp_tab_button.click(desired_element_text='webview')
-
-        camera_dapp.just_fyi("Check DApp asks now to allow camera aceess but Deny in DApp")
-        camera_dapp.browser_refresh_page_button.click()
-        camera_dapp.deny_button.click()
-        if not camera_dapp.camera_image_in_dapp.is_element_image_similar_to_template('blank_camera_image.png'):
-            self.driver.fail("Even camera access Denied to Dapp, - acccess to camera granted")
-
-        camera_dapp.just_fyi("Check DApp asks now to allow camera aceess and Allow access to DApp")
-        camera_dapp.browser_refresh_page_button.click()
-        camera_dapp.allow_button.click()
-        if camera_dapp.camera_image_in_dapp.is_element_image_similar_to_template('blank_camera_image.png'):
-            self.driver.fail("Even camera access Accepted to Dapp, - camera view is not shown")
-
-        camera_dapp.just_fyi("Relogin and check camera access still needs to be allowed")
-        home.profile_button.click()
-        profile.relogin()
-        home.dapp_tab_button.click()
-        camera_dapp.open_tabs_button.click()
-        dapp.element_by_text_part("https").click()
-        if not camera_dapp.allow_button.is_element_displayed():
-            self.driver.fail("No request to camera access after relogin")
-
-    @marks.testrail_id(6232)
-    @marks.medium
-    @marks.flaky
-    # TODO: due to 13011
-    def test_switching_accounts_in_dapp(self):
-        home = SignInView(self.driver).create_user()
-        wallet = home.wallet_button.click()
-
-        wallet.just_fyi('create new account in multiaccount')
-        status_account = home.status_account_name
-        account_name = 'Subaccount'
-        wallet.add_account(account_name)
-        address = wallet.get_wallet_address(account_name)
-
-        home.just_fyi('can see two accounts in DApps')
-        dapp = home.dapp_tab_button.click()
-        dapp.select_account_button.click()
-        for text in 'Select the account', status_account, account_name:
-            if not dapp.element_by_text_part(text).is_element_displayed():
-                self.driver.fail("No expected element %s is shown in menu" % text)
-
-        home.just_fyi('add permission to Status account')
-        dapp.enter_url_editbox.click()
-        status_test_dapp = home.open_status_test_dapp()
-
-        home.just_fyi('check that permissions from previous account was removed once you choose another')
-        dapp.select_account_button.click()
-        dapp.select_account_by_name(account_name).wait_for_element(30)
-        dapp.select_account_by_name(account_name).click()
-        profile = dapp.profile_button.click()
-        profile.privacy_and_security_button.click()
-        profile.dapp_permissions_button.click()
-        if profile.element_by_text(test_dapp_name).is_element_displayed():
-            self.errors.append("Permissions for %s are not removed" % test_dapp_name)
-
-        home.just_fyi('check that can change account')
-        profile.dapp_tab_button.click()
-        if not status_test_dapp.element_by_text_part(account_name).is_element_displayed():
-            self.errors.append("No expected account %s is shown in authorize web3 popup for wallet" % account_name)
-        status_test_dapp.allow_button.click()
-        dapp.profile_button.click(desired_element_text='DApp permissions')
-        profile.element_by_text(test_dapp_name).click()
-        for text in 'Chat key', account_name:
-            if not dapp.element_by_text_part(text).is_element_displayed():
-                self.errors.append("Access is not granted to %s" % text)
-
-        home.just_fyi('check correct account is shown for transaction if sending from DApp')
-        profile.dapp_tab_button.click(desired_element_text='Accounts')
-        status_test_dapp.assets_button.click()
-        send_transaction = status_test_dapp.request_stt_button.click()
-        send_transaction.ok_got_it_button.wait_and_click()
-        address = send_transaction.get_formatted_recipient_address(address)
-        if not send_transaction.element_by_text(address).is_element_displayed():
-            self.errors.append("Wallet address %s in not shown in 'From' on Send Transaction screen" % address)
-
-        home.just_fyi('Relogin and check multiaccount loads fine')
-        send_transaction.cancel_button.click()
-        home.profile_button.click()
-        home.relogin()
-        home.wallet_button.click()
-        if not wallet.element_by_text(account_name).is_element_displayed():
-            self.errors.append("Subaccount is gone after relogin in Wallet!")
-        home.profile_button.click()
-        profile.privacy_and_security_button.click()
-        profile.dapp_permissions_button.click()
-        profile.element_by_text(test_dapp_name).click()
-        if not profile.element_by_text(account_name).is_element_displayed():
-            self.errors.append("Subaccount is not selected after relogin in Dapps!")
-        self.errors.verify_no_errors()

test/appium/tests/atomic/dapps_and_browsing/test_deep_links.py

@@ -1,65 +0,0 @@
-from selenium.common.exceptions import NoSuchElementException
-
-from tests import marks, test_dapp_url
-from tests.base_test_case import SingleDeviceTestCase
-from tests.users import basic_user, ens_user
-from views.sign_in_view import SignInView
-
-
-class TestDeepLinks(SingleDeviceTestCase):
-
-    @marks.testrail_id(5441)
-    @marks.medium
-    def test_open_user_profile_using_deep_link(self):
-        sign_in = SignInView(self.driver)
-        sign_in.create_user()
-        for user_ident in ens_user['ens'], ens_user['ens_another'], ens_user['public_key']:
-            self.driver.close_app()
-            deep_link = 'status-im://u/%s' % user_ident
-            sign_in.open_weblink_and_login(deep_link)
-            chat = sign_in.get_chat_view()
-            for text in ens_user['username'], sign_in.get_translation_by_key("add-to-contacts"):
-                if not chat.element_by_text(text).scroll_to_element(10):
-                    self.driver.fail("User profile screen is not opened")
-
-    @marks.testrail_id(5442)
-    @marks.medium
-    def test_open_dapp_using_deep_link(self):
-        sign_in_view = SignInView(self.driver)
-        sign_in_view.create_user()
-        self.driver.close_app()
-        dapp_name = test_dapp_url
-        dapp_deep_link = 'status-im://b/%s' % dapp_name
-        sign_in_view.open_weblink_and_login(dapp_deep_link)
-        web_view = sign_in_view.get_chat_view()
-        try:
-            test_dapp_view = web_view.open_in_status_button.click()
-            test_dapp_view.allow_button.is_element_present()
-        except NoSuchElementException:
-            self.driver.fail("DApp '%s' is not opened!" % dapp_name)
-
-    @marks.testrail_id(5781)
-    @marks.medium
-    def test_deep_link_with_invalid_user_public_key_own_profile_key(self):
-        sign_in = SignInView(self.driver)
-        sign_in.recover_access(passphrase=basic_user['passphrase'])
-        self.driver.close_app()
-
-        sign_in.just_fyi('Check that no error when opening invalid deep link')
-        deep_link = 'status-im://u/%s' % basic_user['public_key'][:-10]
-        sign_in.open_weblink_and_login(deep_link)
-        home = sign_in.get_home_view()
-        home.plus_button.click_until_presence_of_element(home.start_new_chat_button)
-        if not home.start_new_chat_button.is_element_present():
-            self.errors.append(
-                "Can't navigate to start new chat after app opened from deep link with invalid public key")
-        self.driver.close_app()
-
-        sign_in.just_fyi('Check that no error when opening invalid deep link')
-        deep_link = 'status-im://u/%s' % basic_user['public_key']
-        sign_in.open_weblink_and_login(deep_link)
-        from views.profile_view import ProfileView
-        profile = ProfileView(self.driver)
-        if not profile.default_username_text != basic_user['username']:
-            self.errors.append("Can't navigate to profile from deep link with own public key")
-        self.errors.verify_no_errors()

test/appium/tests/atomic/transactions/test_keycard_wallet.py

@@ -1,343 +0,0 @@
-import time
-
-import pytest
-from support.utilities import get_merged_txs_list
-from tests import marks, pin, puk, pair_code
-from tests.base_test_case import SingleDeviceTestCase, MultipleSharedDeviceTestCase, create_shared_drivers
-from tests.users import transaction_senders, basic_user, wallet_users
-from views.sign_in_view import SignInView
-
-
-@pytest.mark.xdist_group(name="keycard_tx_1")
-@marks.critical
-class TestKeycardTxOneDeviceMerged(MultipleSharedDeviceTestCase):
-    @classmethod
-    def setup_class(cls):
-        cls.user = transaction_senders['ETH_STT_ADI_1']
-        cls.address = '0x%s' % transaction_senders['ETH_7']['address']
-        cls.drivers, cls.loop = create_shared_drivers(1)
-        cls.sign_in = SignInView(cls.drivers[0])
-
-        cls.home = cls.sign_in.recover_access(passphrase=cls.user['passphrase'], keycard=True)
-        cls.wallet = cls.home.wallet_button.click()
-        cls.assets = ('ETH', 'ADI', 'STT')
-        [cls.wallet.wait_balance_is_changed(asset) for asset in cls.assets]
-        cls.initial_balances = dict()
-        for asset in cls.assets:
-            cls.initial_balances[asset] = cls.wallet.get_asset_amount_by_name(asset)
-
-    @marks.testrail_id(700767)
-    def test_keycard_send_tx_eth(self):
-        wallet = self.home.wallet_button.click()
-        transaction_amount = wallet.get_unique_amount()
-        wallet.send_transaction(amount=transaction_amount, sign_transaction=True, keycard=True,
-                                recipient=self.address)
-
-        wallet.just_fyi('Check that transaction is appeared in transaction history')
-        transaction = wallet.find_transaction_in_history(amount=transaction_amount, return_hash=True)
-        self.wallet.wallet_button.double_click()
-        self.network_api.find_transaction_by_hash(transaction)
-        self.network_api.wait_for_confirmation_of_transaction(self.user['address'], transaction_amount)
-        self.wallet.wait_balance_is_changed('ETH', initial_balance=self.initial_balances['ETH'])
-
-    @marks.testrail_id(700768)
-    def test_keycard_relogin_after_restore(self):
-        self.sign_in.just_fyi('Check that username and public key match expected')
-        public_key, default_username = self.sign_in.get_public_key_and_username(return_username=True)
-        profile = self.sign_in.get_profile_view()
-        if public_key != self.user['public_key']:
-            self.errors.append('Public key %s does not match expected' % public_key)
-        if default_username != self.user['username']:
-            self.errors.append('Default username %s does not match expected' % default_username)
-        profile.logout()
-
-        self.sign_in.just_fyi('Check that can login with restored from mnemonic keycard account')
-        self.sign_in.sign_in(keycard=True)
-        if not self.sign_in.home_button.is_element_displayed(10):
-            self.sign_in.driver.fail('Keycard user is not logged in')
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(700769)
-    @marks.transaction
-    def test_keycard_send_tx_sign_message_request_stt_testdapp(self):
-        self.home.home_button.double_click()
-        status_test_dapp = self.home.open_status_test_dapp()
-        status_test_dapp.wait_for_d_aap_to_load()
-
-        self.wallet.just_fyi("Requesting STT in dapp")
-        status_test_dapp.assets_button.click()
-        send_tx = status_test_dapp.request_stt_button.click()
-        send_tx.sign_transaction(keycard=True)
-
-        self.wallet.just_fyi("Checking signing message")
-        status_test_dapp.transactions_button.click()
-        status_test_dapp.sign_message_button.click()
-        if not send_tx.element_by_text("Test message").is_element_displayed():
-            self.errors.append("No message shown when signing!")
-        keycard = send_tx.sign_with_keycard_button.click()
-        keycard.enter_default_pin()
-        if not keycard.element_by_text_part('Signed message').is_element_displayed():
-            self.errors.append('Message was not signed')
-
-        keycard.just_fyi('Check logcat for sensitive data')
-        values_in_logcat = send_tx.find_values_in_logcat(pin=pin, puk=puk, password=pair_code)
-        if values_in_logcat:
-            self.sign_in.driver.fail("After signing message: %s" % values_in_logcat)
-
-        self.wallet.just_fyi("Check send 2 txs in batch")
-        status_test_dapp.send_two_tx_in_batch_button.scroll_to_element()
-        send_tx = status_test_dapp.send_two_tx_in_batch_button.click()
-        send_tx.sign_transaction(keycard=True)
-        if not send_tx.sign_with_keycard_button.is_element_displayed(10):
-            self.sign_in.driver.fail('Second send transaction screen did not appear!')
-        send_tx.sign_transaction(keycard=True)
-
-        self.wallet.just_fyi("Checking send 2 txs one after another")
-        status_test_dapp.send_two_tx_one_by_one_button.scroll_to_element()
-        send_tx = status_test_dapp.send_two_tx_one_by_one_button.click()
-        send_tx.sign_transaction(keycard=True)
-        if not send_tx.sign_with_keycard_button.is_element_displayed(20):
-            self.sign_in.driver.fail('Second send transaction screen did not appear!')
-        send_tx.sign_transaction(keycard=True)
-
-        self.wallet.just_fyi('Verify that wallet balance is updated after receiving money from faucet')
-        self.home.wallet_button.click()
-        self.wallet.wait_balance_is_changed('STT', initial_balance=self.initial_balances['STT'])
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(700770)
-    def test_keycard_wallet_recover_pairing_check_balance_after_offline_tx_history(self):
-        user = transaction_senders['A']
-        self.sign_in.toggle_airplane_mode()
-        self.sign_in.driver.reset()
-
-        self.sign_in.just_fyi('Keycard: recover multiaccount with pairing code ')
-        self.sign_in.accept_tos_checkbox.enable()
-        self.sign_in.get_started_button.click_until_presence_of_element(self.sign_in.access_key_button)
-        self.sign_in.access_key_button.click()
-        self.sign_in.recover_with_keycard_button.click()
-        keycard = self.sign_in.begin_recovery_button.click()
-        keycard.connect_pairing_card_button.click()
-        keycard.pair_code_input.set_value(pair_code)
-        self.sign_in.pair_to_this_device_button.click()
-        keycard.enter_default_pin()
-        self.sign_in.maybe_later_button.click_until_presence_of_element(self.sign_in.lets_go_button)
-        self.sign_in.lets_go_button.click_until_absense_of_element(self.sign_in.lets_go_button)
-        self.sign_in.home_button.wait_for_visibility_of_element(30)
-
-        self.sign_in.just_fyi("Check balance will be restored after going back online")
-        self.sign_in.toggle_airplane_mode()
-        wallet = self.home.wallet_button.click()
-        [wallet.wait_balance_is_changed(asset) for asset in ("ETH", "LXS")]
-
-        self.wallet.just_fyi("Checking whole tx history after backing from offline")
-        self.wallet.accounts_status_account.click()
-        address = user['address']
-        ropsten_txs = self.network_api.get_transactions(address)
-        ropsten_tokens = self.network_api.get_token_transactions(address)
-        expected_txs_list = get_merged_txs_list(ropsten_txs, ropsten_tokens)
-        transactions = self.wallet.transaction_history_button.click()
-        if self.wallet.element_by_translation_id("transactions-history-empty").is_element_displayed():
-            self.wallet.pull_to_refresh()
-        status_tx_number = transactions.transactions_table.get_transactions_number()
-        if status_tx_number < 1:
-            self.errors.append('No transactions found')
-        for n in range(status_tx_number):
-            transactions_details = transactions.transactions_table.transaction_by_index(n).click()
-            tx_hash = transactions_details.get_transaction_hash()
-            tx_from = transactions_details.get_sender_address()
-            tx_to = transactions_details.get_recipient_address()
-            if tx_from != expected_txs_list[tx_hash]['from']:
-                self.errors.append('Transactions senders do not match!')
-            if tx_to != expected_txs_list[tx_hash]['to']:
-                self.errors.append('Transactions recipients do not match!')
-            transactions_details.close_button.click()
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(5689)
-    def test_keycard_create_account_unlock_same_seed(self):
-        self.sign_in.driver.reset()
-        self.sign_in.just_fyi("Create keycard account and save seed phrase")
-        self.sign_in.accept_tos_checkbox.enable()
-        self.sign_in.get_started_button.click()
-        self.sign_in.generate_key_button.click_until_presence_of_element(self.sign_in.next_button)
-        self.sign_in.next_button.click_until_absense_of_element(self.sign_in.element_by_translation_id("intro-wizard-title2"))
-        keycard_flow = self.sign_in.keycard_storage_button.click()
-        keycard_flow.confirm_pin_and_proceed()
-        seed_phrase = keycard_flow.backup_seed_phrase()
-        self.sign_in.maybe_later_button.wait_for_visibility_of_element(30)
-        self.sign_in.maybe_later_button.click_until_presence_of_element(self.sign_in.lets_go_button)
-        self.sign_in.lets_go_button.click_until_absense_of_element(self.sign_in.lets_go_button)
-        self.sign_in.profile_button.wait_for_visibility_of_element(30)
-
-        self.sign_in.just_fyi('Check that after creating keycard account balance is 0, not ...')
-        wallet_1 = self.sign_in.wallet_button.click()
-        wallet_address = wallet_1.get_wallet_address()
-        wallet_1.wallet_button.double_click()
-        if wallet_1.status_account_total_usd_value.text != '0':
-            self.errors.append("Account USD value is not 0, it is %s" % wallet_1.status_account_total_usd_value.text)
-        public_key, default_username = self.sign_in.get_public_key_and_username(return_username=True)
-        profile_1 = self.sign_in.get_profile_view()
-        profile_1.logout()
-
-        profile_1.just_fyi('Check that can re-login with keycard account after account creation')
-        self.sign_in.multi_account_on_login_button.wait_for_visibility_of_element(5)
-        self.sign_in.multi_account_on_login_button.click()
-        if not keycard_flow.element_by_text_part(default_username).is_element_displayed():
-            self.errors.append("%s is not found on keycard login screen!" % default_username)
-        keycard_flow.enter_default_pin()
-        if not self.sign_in.home_button.is_element_displayed(10):
-            self.errors.append('Keycard user is not logged in')
-
-        self.sign_in.just_fyi('Unlock keycard multiaccount at attempt to restore same multiaccount from seed')
-        self.sign_in.profile_button.click()
-        profile_1.logout()
-        self.sign_in.access_key_button.click()
-        self.sign_in.enter_seed_phrase_button.click()
-        self.sign_in.seedphrase_input.click()
-        self.sign_in.seedphrase_input.set_value(seed_phrase)
-        self.sign_in.next_button.click()
-        self.sign_in.element_by_translation_id("unlock", uppercase=True).click()
-        keycard_flow.enter_default_pin()
-        device_1_home = self.sign_in.home_button.click()
-        device_1_home.plus_button.click()
-        if not device_1_home.start_new_chat_button.is_element_displayed():
-            self.errors.append("Can't proceed using account after it's re-recover twice.")
-
-        self.sign_in.just_fyi("Restore same multiaccount from backed up seed phrase on another device")
-        self.sign_in.driver.reset()
-        self.sign_in.recover_access(seed_phrase)
-
-        self.sign_in.just_fyi("Check username and wallet address on restored account")
-        wallet_2 = self.sign_in.wallet_button.click()
-        wallet_address_2 = wallet_2.get_wallet_address()
-        wallet_2.wallet_button.double_click()
-        if wallet_address != wallet_address_2:
-            self.errors.append('Wallet address on restored multiaccount is not equal to created keycard multiaccount')
-        public_key_2, default_username_2 = self.sign_in.get_public_key_and_username(return_username=True)
-        if public_key != public_key_2:
-            self.errors.append('Public key on restored multiaccount is not equal to created keycard multiaccount')
-        if default_username_2 != default_username:
-            self.errors.append('Username on restored multiaccount is not equal to created keycard multiaccount')
-        self.errors.verify_no_errors()
-
-
-class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
-
-    @marks.testrail_id(6292)
-    @marks.transaction
-    @marks.medium
-    def test_keycard_send_funds_between_accounts_set_max_in_multiaccount_instance(self):
-        sign_in_view = SignInView(self.driver).create_user(keycard=True)
-        wallet = sign_in_view.wallet_button.click()
-        status_account_address = wallet.get_wallet_address()[2:]
-        self.network_api.get_donate(status_account_address, external_faucet=True)
-        wallet.wait_balance_is_changed()
-        account_name = 'subaccount'
-        wallet.add_account(account_name, keycard=True)
-        wallet.get_account_by_name(account_name).click()
-        wallet.get_account_options_by_name(account_name).click()
-        wallet.account_settings_button.click()
-        wallet.swipe_up()
-
-        wallet.just_fyi("Checking that delete account and importing account are not available on keycard")
-        if wallet.delete_account_button.is_element_displayed(10):
-            self.errors.append('Delete account option is shown on added account "On Status Tree"!')
-        wallet.wallet_button.double_click()
-        wallet.add_account_button.click()
-        if wallet.enter_a_seed_phrase_button.is_element_displayed():
-            self.errors.append('Importing account option is available on keycard!')
-        wallet.click_system_back_button()
-
-        wallet.just_fyi("Send transaction to new account")
-        transaction_amount = '0.004'
-        initial_balance = self.network_api.get_balance(status_account_address)
-        wallet.send_transaction(account_name=account_name, amount=transaction_amount, keycard=True)
-        self.network_api.wait_for_confirmation_of_transaction(status_account_address, transaction_amount)
-        self.network_api.verify_balance_is_updated(str(initial_balance), status_account_address)
-
-        wallet.just_fyi("Verifying previously sent transaction in new account")
-        wallet.get_account_by_name(account_name).click()
-        wallet.send_transaction_button.click()
-        wallet.close_send_transaction_view_button.click()
-        balance_after_receiving_tx = float(wallet.get_asset_amount_by_name('ETH'))
-        expected_balance = self.network_api.get_rounded_balance(balance_after_receiving_tx, transaction_amount)
-        if balance_after_receiving_tx != expected_balance:
-            self.driver.fail('New account balance %s does not match expected %s after receiving a transaction' % (
-                balance_after_receiving_tx, transaction_amount))
-
-        wallet.just_fyi("Sending eth from new account to main account")
-        updated_balance = self.network_api.get_balance(status_account_address)
-        transaction_amount_1 = round(float(transaction_amount) * 0.2, 11)
-        wallet.wait_balance_is_changed()
-        wallet.get_account_by_name(account_name).click()
-        send_transaction = wallet.send_transaction(from_main_wallet=False, account_name=wallet.status_account_name,
-                                                   amount=transaction_amount_1, keycard=True)
-        wallet.close_button.click()
-        sub_account_address = wallet.get_wallet_address(account_name)[2:]
-        self.network_api.wait_for_confirmation_of_transaction(sub_account_address, transaction_amount_1)
-        wallet.find_transaction_in_history(amount=format(float(transaction_amount_1), '.11f').rstrip('0'))
-
-        wallet.just_fyi("Check transactions on subaccount")
-        self.network_api.verify_balance_is_updated(updated_balance, status_account_address)
-
-        wallet.just_fyi("Verify total ETH on main wallet view")
-        self.network_api.wait_for_confirmation_of_transaction(status_account_address, transaction_amount_1)
-        self.network_api.verify_balance_is_updated((updated_balance + transaction_amount_1), status_account_address)
-        wallet.close_button.click()
-        balance_of_sub_account = float(self.network_api.get_balance(sub_account_address)) / 1000000000000000000
-        balance_of_status_account = float(self.network_api.get_balance(status_account_address)) / 1000000000000000000
-        wallet.scan_tokens()
-        total_eth_from_two_accounts = float(wallet.get_asset_amount_by_name('ETH'))
-        expected_balance = self.network_api.get_rounded_balance(total_eth_from_two_accounts,
-                                                                (balance_of_status_account + balance_of_sub_account))
-
-        if total_eth_from_two_accounts != expected_balance:
-            self.driver.fail('Total wallet balance %s != of Status account (%s) + SubAccount (%s)' % (
-                total_eth_from_two_accounts, balance_of_status_account, balance_of_sub_account))
-
-        wallet.just_fyi("Check that can set max and send transaction with max amount from subaccount")
-        wallet.get_account_by_name(account_name).click()
-        wallet.send_transaction_button.click()
-        send_transaction.set_max_button.click()
-        set_amount = float(send_transaction.amount_edit_box.text)
-        if set_amount == 0.0 or set_amount >= balance_of_sub_account:
-            self.driver.fail('Value after setting up max amount is set to %s' % str(set_amount))
-        send_transaction.confirm()
-        send_transaction.chose_recipient_button.click()
-        send_transaction.accounts_button.click()
-        send_transaction.element_by_text(wallet.status_account_name).click()
-        send_transaction.sign_transaction_button.click()
-        send_transaction.sign_transaction(keycard=True)
-        wallet.element_by_text('Assets').click()
-        wallet.wait_balance_is_equal_expected_amount(asset='ETH', expected_balance=0, main_screen=False)
-
-    @marks.testrail_id(6310)
-    @marks.medium
-    @marks.transaction
-    def test_keycard_sign_typed_message_deploy_simple_contract(self):
-        sender = transaction_senders['ETH_6']
-        home = SignInView(self.driver).recover_access(sender['passphrase'], keycard=True)
-        wallet = home.wallet_button.click()
-        status_test_dapp = home.open_status_test_dapp()
-        status_test_dapp.wait_for_d_aap_to_load()
-        status_test_dapp.transactions_button.click_until_presence_of_element(status_test_dapp.sign_typed_message_button)
-
-        wallet.just_fyi("Checking sign typed message")
-        send_transaction = status_test_dapp.sign_typed_message_button.click()
-        send_transaction.sign_with_keycard_button.click()
-        keycard_view = send_transaction.sign_with_keycard_button.click()
-        keycard_view.enter_default_pin()
-        if not keycard_view.element_by_text_part('0x6df0ce').is_element_displayed():
-            self.errors.append('Typed message was not signed')
-
-        wallet.just_fyi("Checking deploy simple contract")
-        send_transaction_view = status_test_dapp.deploy_contract_button.click()
-        send_transaction_view.sign_transaction(keycard=True)
-        if not status_test_dapp.element_by_text('Contract deployed at: ').is_element_displayed(300):
-            self.driver.fail('Contract was not created or tx taking too long')
-        for text in ['Call contract get function',
-                     'Call contract set function', 'Call function 2 times in a row']:
-            status_test_dapp.element_by_text(text).scroll_to_element()
-        self.errors.verify_no_errors()

test/appium/tests/atomic/transactions/test_wallet_dapp_tx.py

@@ -1,795 +0,0 @@
-import random
-import string
-import pytest
-
-from tests import marks, common_password
-from tests.base_test_case import SingleDeviceTestCase, MultipleDeviceTestCase, MultipleSharedDeviceTestCase,\
-    create_shared_drivers
-from tests.users import transaction_senders, basic_user, wallet_users, ens_user_ropsten, ens_user
-from views.send_transaction_view import SendTransactionView
-from views.sign_in_view import SignInView
-
-
-@pytest.mark.xdist_group(name="send_tx_1")
-@marks.critical
-class TestSendTxDeviceMerged(MultipleSharedDeviceTestCase):
-    @classmethod
-    def setup_class(cls):
-        cls.user = transaction_senders['ETH_ADI_STT_3']
-        cls.recipient_address = '0x%s' % transaction_senders['ETH_7']['address']
-        cls.drivers, cls.loop = create_shared_drivers(1)
-        [cls.amount_adi, cls.amount_eth, cls.amount_stt] = ['0.000%s' % str(random.randint(100, 999)) + '1' for _ in range(3)]
-        cls.sign_in = SignInView(cls.drivers[0])
-        cls.home = cls.sign_in.recover_access(cls.user['passphrase'])
-        cls.wallet = cls.home.wallet_button.click()
-        cls.assets = ('ETH', 'ADI', 'STT')
-        [cls.wallet.wait_balance_is_changed(asset) for asset in cls.assets]
-        cls.initial_balances = dict()
-        for asset in cls.assets:
-            cls.initial_balances[asset] = cls.wallet.get_asset_amount_by_name(asset)
-        cls.wallet.send_transaction(amount=cls.amount_eth, recipient=cls.recipient_address)
-        cls.wallet.send_transaction(amount=cls.amount_adi, recipient=cls.recipient_address, asset_name='ADI')
-
-    @marks.testrail_id(700763)
-    @marks.transaction
-    def test_send_tx_eth_check_logcat(self):
-        self.wallet.just_fyi('Check that transaction is appeared in tx history')
-        self.wallet.find_transaction_in_history(amount=self.amount_eth)
-        self.wallet.wallet_button.double_click()
-        self.network_api.wait_for_confirmation_of_transaction(self.user['address'], self.amount_eth)
-        self.wallet.wait_balance_is_changed('ETH', initial_balance=self.initial_balances['ETH'])
-
-        self.wallet.just_fyi('Check logcat for sensitive data')
-        values_in_logcat = self.wallet.find_values_in_logcat(password=common_password)
-        if values_in_logcat:
-            self.wallet.driver.fail(values_in_logcat)
-
-    @marks.testrail_id(700764)
-    @marks.transaction
-    def test_send_tx_token_7_decimals(self):
-        asset = 'ADI'
-        self.wallet.just_fyi("Checking tx with 7 decimals")
-        transaction_adi = self.wallet.find_transaction_in_history(amount=self.amount_adi, asset=asset, return_hash=True)
-        self.wallet.wallet_button.double_click()
-        self.network_api.find_transaction_by_hash(transaction_adi)
-        self.wallet.wait_balance_is_changed(asset, initial_balance=self.initial_balances[asset])
-
-    @marks.testrail_id(5342)
-    @marks.transaction
-    def test_send_tx_sign_message_2tx_in_batch_tx_filters_request_stt_testdapp(self):
-        self.wallet.home_button.click()
-        status_test_dapp = self.home.open_status_test_dapp()
-        status_test_dapp.wait_for_d_aap_to_load()
-
-        self.wallet.just_fyi("Checking request STT")
-        status_test_dapp.assets_button.click()
-        status_test_dapp.request_stt_button.wait_for_element(60)
-        send_transaction = status_test_dapp.request_stt_button.click()
-        send_transaction.sign_transaction()
-
-        self.wallet.just_fyi("Checking signing message")
-        status_test_dapp.transactions_button.click()
-        send_transaction = status_test_dapp.sign_message_button.click()
-        send_transaction.enter_password_input.set_value(common_password)
-        send_transaction.sign_button.click()
-        if not status_test_dapp.element_by_text_part('Signed message').is_element_displayed():
-            self.errors.append('Message was not signed')
-
-        send_transaction.just_fyi('Check logcat for sensitive data')
-        values_in_logcat = send_transaction.find_values_in_logcat(password=common_password)
-        if values_in_logcat:
-            self.errors.append("When signing message from dapp: %s" % values_in_logcat)
-
-        self.wallet.just_fyi("Checking send 2 txs in batch")
-        status_test_dapp.send_two_tx_in_batch_button.scroll_to_element()
-        send_transaction = status_test_dapp.send_two_tx_in_batch_button.click()
-        send_transaction.sign_transaction()
-        if not send_transaction.sign_with_password.is_element_displayed(10):
-            self.errors.append('Second send transaction screen did not appear!')
-        send_transaction.sign_transaction()
-
-        self.wallet.just_fyi("Checking send 2 txs one after another")
-        status_test_dapp.send_two_tx_one_by_one_button.scroll_to_element()
-        send_transaction = status_test_dapp.send_two_tx_one_by_one_button.click()
-        send_transaction.sign_transaction()
-        if not send_transaction.sign_with_password.is_element_displayed(20):
-            self.errors.append('Second send transaction screen did not appear!')
-        send_transaction.sign_transaction()
-
-        self.wallet.just_fyi("Checking test filters")
-        status_test_dapp.test_filters_button.scroll_and_click()
-        for element in status_test_dapp.element_by_text('eth_uninstallFilter'), status_test_dapp.ok_button:
-            if element.is_element_displayed(10):
-                self.errors.append("'Test filters' button produced an error")
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(700765)
-    @marks.transaction
-    def test_send_tx_custom_token_18_decimals_invalid_password(self):
-        contract_address, name, symbol, decimals = '0x101848D5C5bBca18E6b4431eEdF6B95E9ADF82FA', 'Weenus 💪', 'WEENUS', '18'
-        self.home.wallet_button.double_click()
-
-        self.wallet.just_fyi("Check that can add custom token")
-        self.wallet.multiaccount_more_options.click()
-        self.wallet.manage_assets_button.click()
-        token_view = self.wallet.add_custom_token_button.click()
-        token_view.contract_address_input.send_keys(contract_address)
-        if token_view.name_input.text != name:
-            self.errors.append('Name for custom token was not set')
-        if token_view.symbol_input.text != symbol:
-            self.errors.append('Symbol for custom token was not set')
-        if token_view.decimals_input.text != decimals:
-            self.errors.append('Decimals for custom token was not set')
-        token_view.add_button.click()
-        token_view.close_button.click()
-        self.wallet.asset_by_name(symbol).scroll_to_element()
-        if not self.wallet.asset_by_name(symbol).is_element_displayed():
-            self.errors.append('Custom token is not shown on Wallet view')
-        send_tx = self.wallet.send_transaction_from_main_screen.click()
-        send_tx.select_asset_button.click()
-        asset_button = send_tx.asset_by_name(symbol)
-        send_tx.select_asset_button.click_until_presence_of_element(
-            send_tx.eth_asset_in_select_asset_bottom_sheet_button)
-        asset_button.click()
-        send_tx.amount_edit_box.click()
-        send_tx.amount_edit_box.set_value(self.amount_eth)
-        send_tx.set_recipient_address(self.recipient_address)
-        send_tx.sign_transaction_button.click()
-        if self.wallet.sign_in_phrase.is_element_displayed():
-            self.wallet.set_up_wallet_when_sending_tx()
-
-        send_tx.just_fyi('Check that can not sign tx with invalid password')
-        self.wallet.next_button.click_if_shown()
-        self.wallet.ok_got_it_button.click_if_shown()
-        send_tx.sign_with_password.click_until_presence_of_element(send_tx.enter_password_input)
-        send_tx.enter_password_input.click()
-        send_tx.enter_password_input.send_keys('wrong_password')
-        send_tx.sign_button.click()
-        if send_tx.element_by_text_part('Transaction sent').is_element_displayed():
-            self.errors.append('Transaction was sent with a wrong password')
-
-        self.wallet.just_fyi("Check that can send tx with custom token")
-        send_tx.enter_password_input.click()
-        send_tx.enter_password_input.clear()
-        send_tx.enter_password_input.send_keys(common_password)
-        send_tx.sign_button.click_until_absense_of_element(send_tx.sign_button)
-        send_tx.ok_button.wait_for_element(120)
-        if not self.wallet.element_by_translation_id("transaction-sent").is_element_displayed():
-            self.errors.append("Tx is not sent!")
-        send_tx.ok_button.click()
-
-        # TODO: disabled due to 10838 (rechecked 23.11.21, valid)
-        # transactions_view = wallet.transaction_history_button.click()
-        # transactions_view.transactions_table.find_transaction(amount=amount, asset=symbol)
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(700757)
-    def test_send_tx_set_recipient_options(self):
-        nickname = 'my_some_nickname'
-        account_name = 'my_acc_name'
-        account_address = '0x8c2E3Cd844848E79cFd4671cE45C12F210b630d7'
-        recent_add_to_fav_name = 'my_Recent_STT'
-        recent_add_to_fav_address = '0x58d8c3d70ce4fa4b9fb10a665c8712238746f2ff'
-        ens_status, ens_other = ens_user_ropsten, ens_user
-
-        basic_add_to_fav_name = 'my_basic_address'
-        self.drivers[0].reset()
-        self.home = self.sign_in.recover_access(wallet_users['D']['passphrase'])
-
-        self.home.just_fyi('Add new account and new ENS contact for recipient')
-        chat = self.home.add_contact(ens_status['ens'])
-        chat.chat_options.click()
-        chat.view_profile_button.click_until_presence_of_element(chat.remove_from_contacts)
-        chat.set_nickname(nickname)
-        wallet = self.home.wallet_button.click()
-        wallet.add_account(account_name=account_name)
-        wallet.accounts_status_account.click()
-        send_tr = wallet.send_transaction_button.click()
-
-        wallet.just_fyi("Check that can't send to invalid address")
-        send_tr.amount_edit_box.click()
-        send_tr.amount_edit_box.set_value(send_tr.get_unique_amount())
-        send_tr.chose_recipient_button.click()
-        for address in (basic_user['public_key'], '0xDE709F2102306220921060314715629080E2fB77'):
-            send_tr.enter_recipient_address_input.set_value(address)
-            send_tr.enter_recipient_address_input.click()
-            send_tr.done_button.click()
-            if send_tr.set_max_button.is_element_displayed():
-                self.errors.append('Can proceed with wrong address %s in recipient' % address)
-
-        send_tr.just_fyi('Set one of my accounts')
-        send_tr.chose_recipient_button.click_if_shown()
-        send_tr.element_by_translation_id("my-accounts").click()
-        send_tr.element_by_text(account_name).click()
-        if send_tr.enter_recipient_address_text.text != send_tr.get_formatted_recipient_address(account_address):
-            self.errors.append('Added account is not resolved as recipient')
-
-        send_tr.just_fyi('Set contract address from recent and check smart contract error')
-        send_tr.chose_recipient_button.click()
-        send_tr.element_by_translation_id("recent").click()
-        send_tr.element_by_text('↓ 1000 MDS').click()
-        if not send_tr.element_by_translation_id("warning-sending-to-contract-descr").is_element_displayed():
-            self.driver.fail('No warning is shown at attempt to set as recipient smart contract')
-        send_tr.ok_button.click()
-        send_tr.element_by_text('↑ 0.001 ETHro').scroll_and_click()
-        send_tr.add_to_favorites(recent_add_to_fav_name)
-        wallet.element_by_translation_id("recent").click()
-
-        send_tr.just_fyi('Scan invalid QR')
-        send_tr.scan_qr_code_button.click()
-        send_tr.allow_button.click(1)
-        wallet.enter_qr_edit_box.scan_qr('something%s' % basic_user['address'])
-        if not send_tr.element_by_text_part('Invalid address').is_element_displayed(10):
-            self.driver.fail('No error is shown at attempt to scan invalid address')
-        wallet.ok_button.click()
-
-        send_tr.just_fyi('Scan code, add it to favorites and recheck that it is preserved')
-        send_tr.scan_qr_code_button.click()
-        wallet.enter_qr_edit_box.scan_qr(basic_user['address'])
-        send_tr.add_to_favorites(basic_add_to_fav_name)
-        send_tr.element_by_translation_id("favourites").scroll_and_click()
-        for name in (recent_add_to_fav_name, basic_add_to_fav_name):
-            wallet.element_by_text(name).scroll_to_element()
-
-        send_tr.element_by_text(recent_add_to_fav_name).scroll_and_click()
-        if str(send_tr.enter_recipient_address_text.text).lower() != send_tr.get_formatted_recipient_address(
-                recent_add_to_fav_address):
-            self.errors.append('Recent address that was added to favourites was not resolved correctly')
-
-        send_tr.just_fyi('Set contact')
-        send_tr.chose_recipient_button.click()
-        send_tr.element_by_translation_id("contacts").scroll_and_click()
-        send_tr.element_by_text(nickname).scroll_and_click()
-        send_tr.recipient_done.click()
-        if send_tr.enter_recipient_address_text.text != send_tr.get_formatted_recipient_address(ens_status['address']):
-            self.errors.append('ENS from contact is not resolved as recipient')
-
-        send_tr.just_fyi('Set different ENS options')
-        send_tr.set_recipient_address(ens_other['ens_another'])
-        if send_tr.enter_recipient_address_text.text != send_tr.get_formatted_recipient_address(ens_other['address']):
-            self.errors.append('ENS address on another domain is not resolved as recipient')
-        send_tr.set_recipient_address('%s.stateofus.eth' % ens_status['ens'])
-        if send_tr.enter_recipient_address_text.text != send_tr.get_formatted_recipient_address(ens_status['address']):
-            self.errors.append('ENS address on stateofus.eth is not resolved as recipient')
-
-        send_tr.just_fyi('Check search and set address from search')
-        send_tr.chose_recipient_button.click()
-        send_tr.search_by_keyword(ens_status['ens'][:2])
-        if not send_tr.element_by_text('@' + ens_status['ens']).is_element_displayed():
-            self.errors.append('ENS address from contacts is not shown in search')
-        send_tr.cancel_button.click()
-        send_tr.search_by_keyword('my')
-        for name in (nickname, account_name, recent_add_to_fav_name, basic_add_to_fav_name):
-            if not send_tr.element_by_text(name).is_element_displayed():
-                self.errors.append('%s is not shown in search when searching by namepart' % name)
-        send_tr.element_by_text(basic_add_to_fav_name).click()
-        if send_tr.enter_recipient_address_text.text != send_tr.get_formatted_recipient_address(
-                '0x' + basic_user['address']):
-            self.errors.append('QR scanned address that was added to favourites was not resolved correctly')
-        self.errors.verify_no_errors()
-
-
-class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
-
-    @marks.testrail_id(5784)
-    @marks.medium
-    @marks.transaction
-    def test_sign_typed_message_deploy_simple_contract_request_pub_key_from_dapp(self):
-        user = transaction_senders['ETH_5']
-        home = SignInView(self.driver).recover_access(passphrase=user['passphrase'])
-
-        home.just_fyi("Checking requesting public key from dapp")
-        status_test_dapp = home.open_status_test_dapp(allow_all=False)
-        status_test_dapp.status_api_button.click_until_presence_of_element(status_test_dapp.request_contact_code_button)
-        status_test_dapp.request_contact_code_button.click_until_presence_of_element(status_test_dapp.deny_button)
-        status_test_dapp.deny_button.click()
-        if status_test_dapp.element_by_text(user['public_key']).is_element_displayed():
-            self.errors.append('Public key is returned but access was not allowed')
-        status_test_dapp.request_contact_code_button.click_until_presence_of_element(status_test_dapp.deny_button)
-        status_test_dapp.allow_button.click()
-        if not status_test_dapp.element_by_text(user['public_key']).is_element_displayed():
-            self.errors.append('Public key is not returned')
-        status_test_dapp.get_empty_dapp_tab()
-        home.wallet_button.click()
-
-        home.just_fyi("Checking sign typed message")
-        home.open_status_test_dapp(allow_all=True)
-        status_test_dapp.transactions_button.click_until_presence_of_element(status_test_dapp.sign_typed_message_button)
-        send_transaction = status_test_dapp.sign_typed_message_button.click()
-        send_transaction.enter_password_input.send_keys(common_password)
-        send_transaction.sign_button.click_until_absense_of_element(send_transaction.sign_button)
-        if not status_test_dapp.element_by_text_part('0x1673d96e836').is_element_displayed(30):
-            self.errors.append("Hash of signed typed message is not shown!")
-
-        home.just_fyi("Checking deploy simple contract")
-        send_transaction = status_test_dapp.deploy_contract_button.click()
-        send_transaction.sign_transaction()
-        if not status_test_dapp.element_by_text('Contract deployed at: ').is_element_displayed(240):
-            self.errors.append('Contract was not created')
-        for text in ['Call contract get function',
-                     'Call contract set function', 'Call function 2 times in a row']:
-            status_test_dapp.element_by_text(text).scroll_to_element()
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(5429)
-    @marks.medium
-    def test_set_currency(self):
-        home = SignInView(self.driver).create_user()
-        user_currency = 'Euro (EUR)'
-        wallet = home.wallet_button.click()
-        wallet.set_currency(user_currency)
-        if not wallet.element_by_text_part('EUR').is_element_displayed(20):
-            self.driver.fail('EUR currency is not displayed')
-
-    @marks.testrail_id(5358)
-    @marks.medium
-    def test_backup_recovery_phrase_warning_from_wallet(self):
-        sign_in = SignInView(self.driver)
-        sign_in.create_user()
-        wallet = sign_in.wallet_button.click()
-        if wallet.backup_recovery_phrase_warning_text.is_element_present():
-            self.driver.fail("'Back up your seed phrase' warning is shown on Wallet while no funds are present")
-        address = wallet.get_wallet_address()
-        self.network_api.get_donate(address[2:], external_faucet=True, wait_time=200)
-        wallet.close_button.click()
-        wallet.wait_balance_is_changed(scan_tokens=True)
-        if not wallet.backup_recovery_phrase_warning_text.is_element_present(30):
-            self.driver.fail("'Back up your seed phrase' warning is not shown on Wallet with funds")
-        profile = wallet.get_profile_view()
-        wallet.backup_recovery_phrase_warning_text.click()
-        profile.backup_recovery_phrase()
-
-    @marks.testrail_id(5407)
-    @marks.medium
-    @marks.transaction
-    def test_offline_can_login_cant_send_transaction(self):
-        home = SignInView(self.driver).create_user()
-        wallet = home.wallet_button.click()
-        wallet.toggle_airplane_mode()
-        wallet.accounts_status_account.click_until_presence_of_element(wallet.send_transaction_button)
-        send_transaction = wallet.send_transaction_button.click()
-        send_transaction.set_recipient_address('0x%s' % basic_user['address'])
-        send_transaction.amount_edit_box.set_value("0")
-        send_transaction.confirm()
-        send_transaction.sign_transaction_button.click()
-        if send_transaction.sign_with_password.is_element_displayed():
-            self.driver.fail("Sign transaction button is active in offline mode")
-        self.driver.close_app()
-        self.driver.launch_app()
-        SignInView(self.driver).sign_in()
-        home.home_button.wait_for_visibility_of_element()
-        home.connection_offline_icon.wait_for_visibility_of_element(20)
-
-    @marks.testrail_id(6225)
-    @marks.transaction
-    @marks.medium
-    def test_send_funds_between_accounts_in_multiaccount_instance(self):
-        sign_in = SignInView(self.driver)
-        sign_in.create_user()
-        wallet = sign_in.wallet_button.click()
-        status_account_address = wallet.get_wallet_address()[2:]
-        self.network_api.get_donate(status_account_address, external_faucet=True)
-        wallet.wait_balance_is_changed()
-
-        account_name = 'subaccount'
-        wallet.add_account(account_name)
-
-        wallet.just_fyi("Send transaction to new account")
-        initial_balance = self.network_api.get_balance(status_account_address)
-
-        transaction_amount = '0.003%s' % str(random.randint(10000, 99999)) + '1'
-        wallet.send_transaction(account_name=account_name, amount=transaction_amount)
-        self.network_api.wait_for_confirmation_of_transaction(status_account_address, transaction_amount)
-        self.network_api.verify_balance_is_updated(str(initial_balance), status_account_address)
-
-        wallet.just_fyi("Verifying previously sent transaction in new account")
-        wallet.get_account_by_name(account_name).click()
-        wallet.send_transaction_button.click()
-        wallet.close_send_transaction_view_button.click()
-        balance_after_receiving_tx = float(wallet.get_asset_amount_by_name('ETH'))
-        expected_balance = self.network_api.get_rounded_balance(balance_after_receiving_tx, transaction_amount)
-        if balance_after_receiving_tx != expected_balance:
-            self.driver.fail('New account balance %s does not match expected %s after receiving a transaction' % (
-                balance_after_receiving_tx, transaction_amount))
-
-        wallet.just_fyi("Sending eth from new account to main account")
-        updated_balance = self.network_api.get_balance(status_account_address)
-        transaction_amount_1 = round(float(transaction_amount) * 0.2, 12)
-        wallet.send_transaction(from_main_wallet=False, account_name=wallet.status_account_name,
-                                amount=transaction_amount_1)
-        wallet.close_button.click()
-        sub_account_address = wallet.get_wallet_address(account_name)[2:]
-        self.network_api.wait_for_confirmation_of_transaction(status_account_address, transaction_amount_1)
-        self.network_api.verify_balance_is_updated(updated_balance, status_account_address)
-        wallet.find_transaction_in_history(amount=transaction_amount)
-        wallet.find_transaction_in_history(amount=format(float(transaction_amount_1), '.11f').rstrip('0'))
-
-        wallet.just_fyi("Check transactions on subaccount")
-        self.network_api.verify_balance_is_updated(updated_balance, status_account_address)
-
-        wallet.just_fyi("Verify total ETH on main wallet view")
-        self.network_api.wait_for_confirmation_of_transaction(status_account_address, transaction_amount_1)
-        self.network_api.verify_balance_is_updated((updated_balance + transaction_amount_1), status_account_address)
-        wallet.close_button.click()
-        balance_of_sub_account = float(self.network_api.get_balance(sub_account_address)) / 1000000000000000000
-        balance_of_status_account = float(self.network_api.get_balance(status_account_address)) / 1000000000000000000
-        wallet.scan_tokens()
-        total_eth_from_two_accounts = float(wallet.get_asset_amount_by_name('ETH'))
-        expected_balance = self.network_api.get_rounded_balance(total_eth_from_two_accounts,
-                                                                (balance_of_status_account + balance_of_sub_account))
-
-        if total_eth_from_two_accounts != expected_balance:
-            self.driver.fail('Total wallet balance %s != of Status account (%s) + SubAccount (%s)' % (
-                total_eth_from_two_accounts, balance_of_status_account, balance_of_sub_account))
-
-    @marks.testrail_id(6235)
-    @marks.medium
-    def test_can_change_account_settings(self):
-        sign_in_view = SignInView(self.driver)
-        sign_in_view.create_user()
-        wallet_view = sign_in_view.wallet_button.click()
-        status_account_address = wallet_view.get_wallet_address()
-        wallet_view.get_account_options_by_name().click()
-
-        wallet_view.just_fyi('open Account Settings screen and check that all elements are shown')
-        wallet_view.account_settings_button.click()
-        for text in 'On Status tree', status_account_address, "m/44'/60'/0'/0/0":
-            if not wallet_view.element_by_text(text).is_element_displayed():
-                self.errors.append("'%s' text is not shown on Account Settings screen!" % text)
-
-        wallet_view.just_fyi('change account name/color and verified applied changes')
-        account_name = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(10))
-        wallet_view.account_name_input.clear()
-        wallet_view.account_name_input.send_keys(account_name)
-        wallet_view.account_color_button.select_color_by_position(1)
-        wallet_view.apply_settings_button.click()
-        wallet_view.element_by_text('This device').scroll_to_element()
-        wallet_view.close_button.click()
-        wallet_view.close_button.click()
-        account_button = wallet_view.get_account_by_name(account_name)
-        if not account_button.is_element_displayed():
-            self.driver.fail('Account name was not changed')
-        if not account_button.color_matches('multi_account_color.png'):
-            self.driver.fail('Account color does not match expected')
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6282)
-    @marks.medium
-    def test_can_scan_eip_681_links(self):
-        sign_in = SignInView(self.driver)
-        sign_in.recover_access(transaction_senders['C']['passphrase'])
-        wallet = sign_in.wallet_button.click()
-        wallet.wait_balance_is_changed()
-        send_transaction_view = SendTransactionView(self.driver)
-
-        sign_in.just_fyi("Setting up wallet")
-        wallet.accounts_status_account.click_until_presence_of_element(wallet.send_transaction_button)
-        send_transaction = wallet.send_transaction_button.click()
-        send_transaction.set_recipient_address('0x%s' % basic_user['address'])
-        send_transaction.amount_edit_box.set_value("0")
-        send_transaction.confirm()
-        send_transaction.sign_transaction_button.click()
-        wallet.set_up_wallet_when_sending_tx()
-        wallet.cancel_button.click()
-        wallet.close_button.click()
-
-        url_data = {
-            'ens_for_receiver': {
-                'url': 'ethereum:0xc55cf4b03948d7ebc8b9e8bad92643703811d162@3/transfer?address=nastya.stateofus.eth&uint256=1e-1',
-                'data': {
-                    'asset': 'STT',
-                    'amount': '0.1',
-                    'address': '0x58d8…F2ff',
-                },
-            },
-            # 'gas_settings': {
-            #     'url': 'ethereum:0x3d597789ea16054a084ac84ce87f50df9198f415@3?value=1e16&gasPrice=1000000000&gasLimit=100000',
-            #     'data': {
-            #         'amount': '0.01',
-            #         'asset': 'ETHro',
-            #         'address': '0x3D59…F415',
-            #         'gas_limit': '100000',
-            #         'gas_price': '1',
-            #     },
-            # },
-            'payment_link': {
-                'url': 'ethereum:pay-0xc55cf4b03948d7ebc8b9e8bad92643703811d162@3/transfer?address=0x3d597789ea16054a084ac84ce87f50df9198f415&uint256=1e1',
-                'data': {
-                    'amount': '10',
-                    'asset': 'STT',
-                    'address': '0x3D59…F415',
-                },
-            },
-            'validation_amount_too_presize': {
-                'url': 'ethereum:0xc55cf4b03948d7ebc8b9e8bad92643703811d162@3/transfer?address=0x101848D5C5bBca18E6b4431eEdF6B95E9ADF82FA&uint256=1e-19',
-                'data': {
-                    'amount': '1e-19',
-                    'asset': 'STT',
-                    'address': '0x1018…82FA',
-
-                },
-                'send_transaction_validation_error': 'Amount is too precise',
-            },
-            'validation_amount_too_big': {
-                'url': 'ethereum:0x101848D5C5bBca18E6b4431eEdF6B95E9ADF82FA@3?value=1e25',
-                'data': {
-                    'amount': '10000000',
-                    'asset': 'ETHro',
-                    'address': '0x1018…82FA',
-
-                },
-                'send_transaction_validation_error': 'Insufficient funds',
-            },
-            'validation_wrong_chain_id': {
-                'url': 'ethereum:0x101848D5C5bBca18E6b4431eEdF6B95E9ADF82FA?value=1e17',
-                'error': 'Network does not match',
-                'data': {
-                    'amount': '0.1',
-                    'asset': 'ETHro',
-                    'address': '0x1018…82FA',
-                },
-            },
-            'validation_wrong_address': {
-                'url': 'ethereum:0x744d70fdbe2ba4cf95131626614a1763df805b9e@3/transfer?address=blablabla&uint256=1e10',
-                'error': 'Invalid address',
-            },
-        }
-
-        for key in url_data:
-            wallet.just_fyi('Checking %s case' % key)
-            wallet.scan_qr_button.click()
-            if wallet.allow_button.is_element_displayed():
-                wallet.allow_button.click()
-            wallet.enter_qr_edit_box.scan_qr(url_data[key]['url'])
-            if url_data[key].get('error'):
-                if not wallet.element_by_text_part(url_data[key]['error']).is_element_displayed():
-                    self.errors.append('Expected error %s is not shown' % url_data[key]['error'])
-                wallet.ok_button.click()
-            if url_data[key].get('data'):
-                actual_data = send_transaction_view.get_values_from_send_transaction_bottom_sheet()
-                difference_in_data = url_data[key]['data'].items() - actual_data.items()
-                if difference_in_data:
-                    self.errors.append(
-                        'In %s case returned value does not match expected in %s' % (key, repr(difference_in_data)))
-                if url_data[key].get('send_transaction_validation_error'):
-                    error = url_data[key]['send_transaction_validation_error']
-                    if not wallet.element_by_text_part(error).is_element_displayed():
-                        self.errors.append(
-                            'Expected error %s is not shown' % error)
-                if wallet.close_send_transaction_view_button.is_element_displayed():
-                    wallet.close_send_transaction_view_button.wait_and_click()
-                else:
-                    wallet.cancel_button.wait_and_click()
-
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(5437)
-    @marks.medium
-    def test_validation_amount_errors(self):
-        sender = wallet_users['C']
-        sign_in = SignInView(self.driver)
-
-        errors = {'send_transaction_screen': {
-            'too_precise': 'Amount is too precise. Max number of decimals is 7.',
-            'insufficient_funds': 'Insufficient funds'
-        },
-            'sending_screen': {
-                'Amount': 'Insufficient funds',
-                'Network fee': 'Not enough ETH for gas'
-            },
-        }
-        warning = 'Warning %s is not shown on %s'
-
-        sign_in.recover_access(sender['passphrase'])
-        wallet = sign_in.wallet_button.click()
-        wallet.wait_balance_is_changed('ADI')
-        wallet.accounts_status_account.click()
-
-        screen = 'send transaction screen from wallet'
-        sign_in.just_fyi('Checking %s on %s' % (errors['send_transaction_screen']['too_precise'], screen))
-        initial_amount_adi = wallet.get_asset_amount_by_name('ADI')
-        send_transaction = wallet.send_transaction_button.click()
-        adi_button = send_transaction.asset_by_name('ADI')
-        send_transaction.select_asset_button.click_until_presence_of_element(
-            send_transaction.eth_asset_in_select_asset_bottom_sheet_button)
-        adi_button.click()
-        send_transaction.amount_edit_box.click()
-        amount = '0.000%s' % str(random.randint(100000, 999999)) + '1'
-        send_transaction.amount_edit_box.set_value(amount)
-        if not send_transaction.element_by_text(
-                errors['send_transaction_screen']['too_precise']).is_element_displayed():
-            self.errors.append(warning % (errors['send_transaction_screen']['too_precise'], screen))
-
-        sign_in.just_fyi('Checking %s on %s' % (errors['send_transaction_screen']['insufficient_funds'], screen))
-        send_transaction.amount_edit_box.clear()
-        send_transaction.amount_edit_box.set_value(str(initial_amount_adi) + '1')
-        if not send_transaction.element_by_text(
-                errors['send_transaction_screen']['insufficient_funds']).is_element_displayed():
-            self.errors.append(warning % (errors['send_transaction_screen']['insufficient_funds'], screen))
-        wallet.close_send_transaction_view_button.click()
-        wallet.close_button.click()
-
-        screen = 'sending screen from wallet'
-        sign_in.just_fyi('Checking %s on %s' % (errors['sending_screen']['Network fee'], screen))
-        account_name = 'new'
-        wallet.add_account(account_name)
-        wallet.get_account_by_name(account_name).click()
-        wallet.send_transaction_button.click()
-        send_transaction.amount_edit_box.set_value('0')
-        send_transaction.set_recipient_address(ens_user_ropsten['ens'])
-        send_transaction.next_button.click()
-        wallet.ok_got_it_button.wait_and_click(30)
-        if not send_transaction.validation_error_element.is_element_displayed(10):
-            self.errors.append('Validation icon is not shown when testing %s on %s' % (errors['sending_screen']['Network fee'], screen))
-        if not wallet.element_by_translation_id("tx-fail-description2").is_element_displayed():
-            self.errors.append("No warning about failing tx is shown!")
-        send_transaction.cancel_button.click()
-
-        screen = 'sending screen from DApp'
-        sign_in.just_fyi('Checking %s on %s' % (errors['sending_screen']['Network fee'], screen))
-        home = wallet.home_button.click()
-        dapp = sign_in.dapp_tab_button.click()
-        dapp.select_account_button.click()
-        dapp.select_account_by_name(account_name).wait_for_element(30)
-        dapp.select_account_by_name(account_name).click()
-        status_test_dapp = home.open_status_test_dapp()
-        status_test_dapp.wait_for_d_aap_to_load()
-        status_test_dapp.transactions_button.click_until_presence_of_element(
-            status_test_dapp.send_two_tx_in_batch_button)
-        status_test_dapp.send_two_tx_in_batch_button.click()
-        if not send_transaction.validation_error_element.is_element_displayed(10):
-            self.errors.append(warning % (errors['sending_screen']['Network fee'], screen))
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(695855)
-    @marks.transaction
-    @marks.medium
-    def test_custom_gas_settings(self):
-        sender = transaction_senders['ETH_7']
-        sign_in = SignInView(self.driver)
-        sign_in.recover_access(sender['passphrase'])
-        wallet = sign_in.wallet_button.click()
-        wallet.wait_balance_is_changed()
-        wallet.accounts_status_account.click()
-
-        send_transaction = wallet.send_transaction_button.click()
-        amount = '0.000%s' % str(random.randint(100000, 999999)) + '1'
-        send_transaction.amount_edit_box.set_value(amount)
-        send_transaction.set_recipient_address(ens_user_ropsten['ens'])
-        send_transaction.next_button.click()
-        wallet.ok_got_it_button.wait_and_click(30)
-        send_transaction.network_fee_button.click()
-        send_transaction = wallet.get_send_transaction_view()
-        fee_fields = (send_transaction.per_gas_tip_limit_input, send_transaction.per_gas_price_limit_input)
-        [default_tip, default_price] = [field.text for field in fee_fields]
-        default_limit = '21000'
-
-        wallet.just_fyi("Check basic validation")
-        values = {
-            send_transaction.gas_limit_input:
-                {
-                    'default': default_limit,
-                    'value': '22000',
-                    '20999': 'wallet-send-min-units',
-                    '@!': 'invalid-number',
-                },
-            send_transaction.per_gas_tip_limit_input:
-                {
-                    'default': default_tip,
-                    'value': '2.5',
-                    'aaaa': 'invalid-number',
-                },
-            send_transaction.per_gas_price_limit_input:
-                {
-                    'default': default_price,
-                    'value': str(round(float(default_price)+3, 9)),
-                    '-2': 'invalid-number',
-                }
-        }
-        for field in values:
-            for key in values[field]:
-                if key != 'default' and key != 'value':
-                    field.clear()
-                    field.send_keys(key)
-                    if not send_transaction.element_by_translation_id(values[field][key]).is_element_displayed(10):
-                        self.errors.append("%s is not shown for %s" % (values[field][key], field.accessibility_id))
-                    field.clear()
-                    field.set_value(values[field]['value'])
-
-        wallet.just_fyi("Set custom fee and check that it will be applied")
-        send_transaction.save_fee_button.scroll_and_click()
-        if wallet.element_by_translation_id("change-tip").is_element_displayed():
-            wallet.element_by_translation_id("continue-anyway").click()
-        send_transaction.sign_transaction()
-        self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount, confirmations=3)
-        transaction = wallet.find_transaction_in_history(amount=amount, return_hash=True)
-        expected_params = {
-            'fee_cap': values[send_transaction.per_gas_price_limit_input]['value'],
-            'tip_cap': '2.5',
-            'gas_limit': '22000'
-        }
-        actual_params = self.network_api.get_custom_fee_tx_params(transaction)
-        if actual_params != expected_params:
-            self.errors.append('Real params %s for tx do not match expected %s' % (str(actual_params), str(expected_params)))
-
-        wallet.just_fyi('Verify custom fee data on tx screen')
-        wallet.swipe_up()
-        for key in expected_params:
-            if not wallet.element_by_text_part(expected_params[key]).is_element_displayed():
-                self.errors.append("Custom tx param %s is not shown on tx history screen" % key)
-
-        wallet.just_fyi("Check below fee popup on mainnet")
-        profile = wallet.profile_button.click()
-        profile.switch_network()
-        sign_in.wallet_button.click()
-        wallet.accounts_status_account.click()
-
-        send_transaction = wallet.send_transaction_button.click_until_presence_of_element(send_transaction.amount_edit_box)
-        send_transaction.amount_edit_box.set_value(0)
-        send_transaction.set_recipient_address(ens_user_ropsten['ens'])
-        send_transaction.next_button.click()
-        wallet.element_by_translation_id("network-fee").click()
-        if not wallet.element_by_translation_id("tx-fail-description2").is_element_displayed():
-            self.errors.append("Tx is likely to fail is not shown!")
-        if send_transaction.network_fee_button.is_element_displayed():
-            self.errors.append("Still can set tx fee when balance is not enough")
-
-        ##  TODO: should be moved to another test after 8f52b9b63ccd9a52b7fe37ab4f89a2e7b6721fcd
-        # send_transaction = wallet.get_send_transaction_view()
-        # send_transaction.gas_limit_input.clear()
-        # send_transaction.gas_limit_input.set_value(default_limit)
-        # send_transaction.per_gas_price_limit_input.clear()
-        # send_transaction.per_gas_price_limit_input.click()
-        # send_transaction.per_gas_price_limit_input.send_keys('1')
-        # if not wallet.element_by_translation_id("below-base-fee").is_element_displayed(10):
-        #     self.errors.append("Fee is below error is not shown")
-        # send_transaction.save_fee_button.scroll_and_click()
-        # if not wallet.element_by_translation_id("change-tip").is_element_displayed():
-        #     self.errors.append("Popup about changing fee error is not shown")
-        # wallet.element_by_translation_id("continue-anyway").click()
-        # if not send_transaction.element_by_text_part('0.000021 ETH').is_element_displayed():
-        #     self.driver.fail("Custom fee is not applied!")
-        self.errors.verify_no_errors()
-
-
-class TestTransactionWalletMultipleDevice(MultipleDeviceTestCase):
-
-    @marks.testrail_id(6330)
-    @marks.medium
-    @marks.transaction
-    def test_can_send_all_tokens_via_max_option(self):
-        sender = transaction_senders['ETH_STT_2']
-        receiver = transaction_senders['ETH_1']
-        self.create_drivers(2)
-        device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
-        home_1, home_2 = device_1.recover_access(sender['passphrase']), device_2.recover_access(receiver['passphrase'])
-        wallet_sender = home_1.wallet_button.click()
-        wallet_receiver = home_2.wallet_button.click()
-
-        if wallet_receiver.asset_by_name('STT').is_element_present(10):
-            initial_balance = wallet_receiver.get_asset_amount_by_name("STT")
-        else:
-            initial_balance = '0'
-
-        device_1.just_fyi("Sending token amount to device who will use Set Max option for token")
-        amount = '0.012345678912345678'
-        wallet_sender.send_transaction(asset_name='STT', amount=amount, recipient=receiver['address'])
-        wallet_receiver.wait_balance_is_changed(asset='STT', initial_balance=initial_balance, scan_tokens=True)
-        wallet_receiver.accounts_status_account.click()
-
-        device_1.just_fyi("Send all tokens via Set Max option")
-        send_transaction = wallet_receiver.send_transaction_button.click()
-        send_transaction.select_asset_button.click()
-        asset_name = 'STT'
-        asset_button = send_transaction.asset_by_name(asset_name)
-        send_transaction.select_asset_button.click_until_presence_of_element(
-            send_transaction.eth_asset_in_select_asset_bottom_sheet_button)
-        asset_button.click()
-        send_transaction.set_max_button.click()
-        send_transaction.set_recipient_address(sender['address'])
-        send_transaction.sign_transaction_button.click()
-        send_transaction.sign_transaction()
-        wallet_receiver.close_button.click()
-        initial_balance = float(initial_balance) + float(amount)
-        wallet_receiver.wait_balance_is_changed(asset='STT', initial_balance=str(initial_balance), scan_tokens=True)

test/appium/tests/atomic/zzz_multiple_drivers_tests/test_multiple_driver_tests.py

@@ -1,565 +0,0 @@
-import pytest
-from tests import marks
-from tests.base_test_case import MultipleDeviceTestCase, MultipleSharedDeviceTestCase, create_shared_drivers
-from tests.users import transaction_senders, basic_user, ens_user, ens_user_ropsten
-from views.sign_in_view import SignInView
-from views.chat_view import ChatView
-
-# TODO: moved here until resolve of 13048
-@pytest.mark.xdist_group(name="group_chat_3")
-@marks.critical
-class TestGroupChatMultipleDeviceMerged(MultipleSharedDeviceTestCase):
-
-    @classmethod
-    def setup_class(cls):
-        cls.drivers, cls.loop = create_shared_drivers(3)
-        cls.message_before_adding = 'message before adding new user'
-        cls.message_to_admin = 'Hey, admin!'
-
-        cls.homes, cls.public_keys, cls.usernames, cls.chats = {}, {}, {}, {}
-        for key in cls.drivers:
-            sign_in = SignInView(cls.drivers[key])
-            cls.homes[key] = sign_in.create_user(enable_notifications=True)
-            cls.public_keys[key], cls.usernames[key] = sign_in.get_public_key_and_username(True)
-            sign_in.home_button.click()
-        cls.chat_name = cls.homes[0].get_random_chat_name()
-
-        cls.homes[0].just_fyi('Admin adds future members to contacts')
-        for i in range(1, 3):
-            cls.homes[0].add_contact(cls.public_keys[i])
-            cls.homes[0].home_button.double_click()
-
-        cls.homes[0].just_fyi('Member adds admin to contacts to see PNs and put app in background')
-        cls.homes[1].add_contact(cls.public_keys[0])
-        cls.homes[1].home_button.double_click()
-
-        cls.homes[0].just_fyi('Admin creates group chat')
-        cls.chats[0] = cls.homes[0].create_group_chat([cls.usernames[1]], cls.chat_name)
-        for i in range(1, 3):
-            cls.chats[i] = ChatView(cls.drivers[i])
-
-        cls.chats[0].send_message(cls.message_before_adding)
-
-    @marks.testrail_id(3994)
-    def test_group_chat_push_system_messages_when_invited(self):
-        self.homes[1].just_fyi("Check system messages in PNs")
-        self.homes[1].put_app_to_background()
-        self.homes[1].open_notification_bar()
-        pns = [self.chats[0].pn_invited_to_group_chat(self.usernames[0], self.chat_name),
-               self.chats[0].pn_wants_you_to_join_to_group_chat(self.usernames[0], self.chat_name)]
-        for pn in pns:
-            if not self.homes[1].get_pn(pn):
-                self.errors.append('%s is not shown after invite to group chat' % pn)
-        if self.homes[1].get_pn(pns[0]):
-            group_invite_pn = self.homes[1].get_pn(pns[0])
-            group_invite_pn.click()
-        else:
-            self.homes[1].click_system_back_button(2)
-            self.homes[1].get_chat(self.chat_name).click()
-
-        self.homes[1].just_fyi("Check system messages in group chat for admin and member")
-        create_system_message = self.chats[0].create_system_message(self.usernames[0], self.chat_name)
-        invite_system_message = self.chats[0].invite_system_message(self.usernames[0], self.usernames[1])
-
-        invited_to_join = self.chats[0].invited_to_join_system_message(self.usernames[0], self.chat_name)
-        create_for_admin_system_message = self.chats[0].create_for_admin_system_message(self.chat_name)
-        for message in [create_for_admin_system_message, create_system_message, invite_system_message]:
-            if not self.chats[0].chat_element_by_text(message):
-                self.errors.append('%s system message is not shown' % message)
-        for message in [invited_to_join, create_system_message, invite_system_message]:
-            if not self.chats[1].chat_element_by_text(message):
-                self.errors.append('%s system message is not shown' % message)
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(700731)
-    def test_group_chat_join_send_text_messages_push(self):
-        message_to_admin = self.message_to_admin
-        [self.homes[i].home_button.double_click() for i in range(3)]
-        self.homes[1].get_chat(self.chat_name).click()
-
-        self.chats[1].just_fyi('Join to group chat')
-        join_system_message = self.chats[1].join_system_message(self.usernames[1])
-        self.chats[1].join_chat_button.click()
-        if not self.chats[1].chat_element_by_text(join_system_message).is_element_displayed(30):
-            self.drivers[1].fail('System message after joining group chat is not shown')
-        self.chats[1].send_message(message_to_admin)
-
-        self.chats[0].just_fyi('check that PN is received and after tap you are redirected to group chat')
-        self.chats[0].open_notification_bar()
-        pn = self.homes[0].get_pn(message_to_admin)
-        if pn:
-            pn.click()
-        else:
-            self.homes[0].click_system_back_button()
-            self.homes[0].get_chat(self.chat_name).click()
-
-        self.chats[1].just_fyi('Check message status and message delivery')
-        message_status = self.chats[1].chat_element_by_text(message_to_admin).status
-        if message_status != 'delivered':
-            self.errors.append('Message status is not delivered, it is %s!' % message_status)
-        for message in (join_system_message, message_to_admin):
-            if not self.chats[0].chat_element_by_text(message).is_element_displayed(30):
-                self.drivers[0].fail('Message %s was not received by admin' % message)
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(700732)
-    def test_group_chat_add_new_member_activity_centre(self):
-        [self.homes[i].home_button.double_click() for i in range(3)]
-        self.homes[0].get_chat(self.chat_name).click()
-        self.chats[0].add_members_to_group_chat([self.usernames[2]])
-
-        self.chats[2].just_fyi("Check there will be no PN but unread in AC if got invite from non-contact")
-        if not self.homes[2].notifications_unread_badge.is_element_displayed(60):
-            self.drivers[2].fail("Group chat is not appeared in AC!")
-        self.homes[2].open_notification_bar()
-        if self.homes[2].element_by_text_part(self.usernames[0]).is_element_displayed():
-            self.errors.append("PN about group chat invite is shown when invited by non-contact")
-        self.homes[2].click_system_back_button()
-        self.homes[2].get_chat(self.chat_name).click()
-        self.chats[2].join_chat_button.click()
-        for message in (self.message_to_admin, self.message_before_adding):
-            if self.chats[2].chat_element_by_text(message).is_element_displayed():
-                self.errors.append('%s is shown for new user' % message)
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(3998)
-    def test_group_chat_offline_pn(self):
-        [self.homes[i].home_button.double_click() for i in range(3)]
-        chat_name = 'for_offline_pn'
-        self.homes[0].create_group_chat([self.usernames[1], self.usernames[2]], chat_name)
-        self.homes[0].home_button.double_click()
-        for i in range(1, 3):
-            self.homes[i].get_chat(chat_name).click()
-            self.chats[i].join_chat_button.click()
-        message_1, message_2 = 'message from old member', 'message from new member'
-
-        self.homes[0].just_fyi("Put admin device to offline and send messages from members")
-        self.homes[0].toggle_airplane_mode()
-        self.chats[1].send_message(message_1)
-        self.chats[2].send_message(message_2)
-
-        self.homes[0].just_fyi("Put admin device to online and check that messages and PNs will be fetched")
-        self.homes[0].toggle_airplane_mode()
-        self.homes[0].connection_offline_icon.wait_for_invisibility_of_element(60)
-        self.homes[0].open_notification_bar()
-        for message in (message_1, message_2):
-            if not self.homes[0].get_pn(message):
-                self.errors.append('%s PN was not fetched from offline' % message)
-        self.homes[0].click_system_back_button()
-        unread_group = self.homes[0].get_chat(chat_name)
-        if not unread_group.new_messages_counter.text == '2':
-            self.errors.append('%s does not match unread messages' % unread_group.new_messages_counter.text)
-        unread_group.click()
-
-        self.homes[0].just_fyi("check that messages are shown for every member")
-        for i in range(3):
-            for message in (message_1, message_2):
-                if not self.chats[i].chat_element_by_text(message).is_element_displayed():
-                    self.errors.append('%s if not shown for device %s' % (message, str(i)))
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(5756)
-    def test_group_chat_decline_invite_chat_highligted(self):
-        chat_name = 'for_invited'
-        left_system_message = self.chats[0].leave_system_message(self.usernames[1])
-        [self.homes[i].home_button.double_click() for i in range(3)]
-        self.homes[0].create_group_chat([self.usernames[1]], chat_name)
-
-        self.homes[1].just_fyi("Check that new group chat from contact is highlited")
-        chat_2_element = self.homes[1].get_chat(chat_name)
-        if chat_2_element.no_message_preview.is_element_differs_from_template('highligted_preview_group.png', 0):
-            self.errors.append("Preview message is not hightligted or text is not shown! ")
-        chat_2 = self.homes[1].get_chat(chat_name).click()
-        chat_2.home_button.click()
-        if not chat_2_element.no_message_preview.is_element_differs_from_template('highligted_preview_group.png', 0):
-            self.errors.append("Preview message is still hightligted after opening! ")
-        self.homes[1].get_chat(chat_name).click()
-        chat_2.decline_invitation_button.click()
-        if self.chats[0].chat_element_by_text(left_system_message).is_element_displayed():
-            self.errors.append('System message when user declined invite is shown')
-        if self.homes[1].element_by_text(chat_name).is_element_displayed():
-            self.errors.append("Group chat '%s' is shown, but user declined invite" % chat_name)
-
-        self.homes[0].just_fyi('Send message after invite is declined and check that it is not reappeared')
-        message = 'sent after leaving'
-        self.chats[0].send_message(message)
-        if self.homes[1].element_by_text(chat_name).is_element_displayed():
-            self.errors.append("Group chat '%s' reappeared when new message is sent" % chat_name)
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(3997)
-    def test_group_chat_leave_relogin(self):
-        self.drivers[2].quit()
-        [self.homes[i].home_button.double_click() for i in range(2)]
-        self.homes[0].home_button.double_click()
-        self.homes[1].get_chat(self.chat_name).click()
-        join_button = self.chats[1].join_chat_button
-        if join_button.is_element_displayed():
-            join_button.click()
-
-        self.homes[0].just_fyi("Admin deleted chat via long press")
-        self.homes[0].leave_chat_long_press(self.chat_name)
-
-        self.homes[0].just_fyi("Member sends some message, admin relogins and check chat does not reappear")
-        self.chats[1].send_message(self.message_to_admin)
-        self.homes[0].relogin()
-        if self.homes[0].get_chat_from_home_view(self.chat_name).is_element_displayed():
-            self.drivers[0].fail('Deleted %s is present after relaunch app' % self.chat_name)
-
-@pytest.mark.xdist_group(name="sync_2")
-@marks.critical
-class TestSyncMultipleDevicesMerged(MultipleSharedDeviceTestCase):
-
-    @classmethod
-    def setup_class(cls):
-        cls.drivers, cls.loop = create_shared_drivers(2)
-        cls.no_contact_nickname = 'no_contact_nickname'
-        cls.device_1, cls.device_2 = SignInView(cls.drivers[0]), SignInView(cls.drivers[1])
-        cls.home_1 = cls.device_1.create_user()
-
-        cls.name_1, cls.name_2 = 'device_%s' % cls.drivers[0].number, 'device_%s' % cls.drivers[1].number
-        cls.message_before_sync, cls.message_after_sync = 'sent before sync', 'sent after sync'
-        cls.contact_before_sync = basic_user
-        cls.public_chat_before_sync, cls.public_chat_after_sync = cls.home_1.get_random_chat_name(), 'after-pairing'
-
-        cls.home_1.just_fyi("(main device): get recovery phrase")
-        cls.profile_1 = cls.home_1.profile_button.click()
-        cls.profile_1.privacy_and_security_button.click()
-        cls.profile_1.backup_recovery_phrase_button.click()
-        cls.profile_1.ok_continue_button.click()
-        cls.recovery_phrase = cls.profile_1.get_recovery_phrase()
-        cls.profile_1.close_button.click()
-        cls.profile_1.home_button.click()
-        cls.profile_1.get_recovery_phrase()
-
-        cls.home_1.just_fyi('Add contact, 1-1 chat (main device): 3-random, contact with ENS, start 1-1')
-        cls.chat_1 = cls.home_1.add_contact(cls.contact_before_sync['public_key'])
-        cls.chat_1.send_message(cls.message_before_sync)
-        cls.chat_1.home_button.click()
-        cls.home_1.add_contact(ens_user['ens'])
-        cls.chat_1.home_button.click()
-
-        cls.home_1.just_fyi('Chats, contacts (main device): join public chat, block user, set nickname')
-        public_chat_1 = cls.home_1.join_public_chat(cls.public_chat_before_sync)
-        public_chat_1.home_button.click()
-        cls.home_1.add_contact(transaction_senders['A']['public_key'], add_in_contacts=False,
-                               nickname=cls.no_contact_nickname)
-        cls.chat_1.open_user_profile_from_1_1_chat()
-        cls.chat_1.block_contact()
-
-        cls.device_2.just_fyi("(secondary device): restore same multiaccount on another device")
-        cls.home_2 = cls.device_2.recover_access(passphrase=' '.join(cls.recovery_phrase.values()))
-        cls.profile_1, cls.profile_2 = cls.home_1.profile_button.click(), cls.home_2.profile_button.click()
-
-        cls.device_2.just_fyi('Nicknames (main device): set nickname for contact')
-        cls.profile_1.open_contact_from_profile(cls.contact_before_sync['username'])
-        cls.nickname = 'my_basic_user'
-        cls.chat_1.set_nickname(cls.nickname)
-        cls.device_1.back_button.click()
-
-        cls.device_2.just_fyi('Pair main and secondary devices')
-        cls.profile_2.discover_and_advertise_device(cls.name_2)
-        cls.profile_1.discover_and_advertise_device(cls.name_1)
-        cls.profile_1.get_toggle_device_by_name(cls.name_2).wait_and_click()
-        cls.profile_1.sync_all_button.click()
-        cls.profile_1.sync_all_button.wait_for_visibility_of_element(20)
-        [device.profile_button.double_click() for device in (cls.profile_1, cls.profile_2)]
-
-    @marks.testrail_id(702194)
-    def test_sync_initial_contacts_blocked_users(self):
-        self.profile_2.contacts_button.scroll_to_element(9, 'up')
-        self.profile_2.contacts_button.click()
-        if not self.profile_2.blocked_users_button.is_element_displayed(30):
-            self.errors.append('Blocked users are not synced after initial sync')
-        for name in (basic_user['username'], self.nickname, '@%s' % ens_user['ens']):
-            if not self.profile_2.element_by_text(name).is_element_displayed():
-                self.errors.append('"%s" is not found in Contacts on initial sync' % name)
-        self.profile_2.blocked_users_button.click()
-        if not self.profile_2.element_by_text(self.no_contact_nickname).is_element_displayed():
-            self.errors.append(
-                "'%s' nickname without adding to contacts is not synced on initial sync" % self.no_contact_nickname)
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(702195)
-    def test_sync_initial_public_chats(self):
-        [device.home_button.double_click() for device in (self.profile_1, self.profile_2)]
-        if not self.home_2.element_by_text_part(self.public_chat_before_sync).is_element_displayed():
-            self.errors.append(
-                "'%s' public chat is not appeared on secondary device on initial sync" % self.public_chat_before_sync)
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(702196)
-    def test_sync_contacts_block_unblock(self):
-        [device.profile_button.double_click() for device in (self.profile_1, self.profile_2)]
-        new_user_for_block = transaction_senders['C']
-
-        self.profile_1.just_fyi("Contacts(main device): block and unblock user")
-        self.profile_1.profile_button.click()
-        self.profile_1.contacts_button.scroll_to_element(direction='up')
-        self.profile_1.contacts_button.click()
-        self.profile_1.blocked_users_button.click()
-        self.profile_1.element_by_text(self.no_contact_nickname).click()
-        self.chat_1.unblock_contact_button.click()
-        self.profile_1.close_button.click()
-        self.home_1.home_button.click()
-        self.home_1.add_contact(new_user_for_block['public_key'], add_in_contacts=False)
-        self.chat_1.open_user_profile_from_1_1_chat()
-        self.chat_1.block_contact()
-
-        self.device_2.just_fyi('Contacts (secondary device): check unblocked and blocked user')
-        self.profile_2.contacts_button.click()
-        self.profile_2.blocked_users_button.click()
-        if self.profile_2.element_by_text(self.no_contact_nickname).is_element_displayed():
-            self.errors.append("'%s' unblocked user is not synced!" % self.no_contact_nickname)
-        if not self.profile_2.element_by_text(new_user_for_block['username']).is_element_displayed():
-            self.errors.append("'%s' blocked user is not synced!" % new_user_for_block['username'])
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(702197)
-    def test_sync_contacts_add_remove_set_nickname_ens(self):
-        [device.home_button.double_click() for device in (self.profile_1, self.profile_2)]
-        new_contact, new_nickname = transaction_senders['F'], "completely_new_nick"
-        self.home_1.add_contact(ens_user_ropsten['ens'])
-        self.home_1.home_button.click()
-        self.home_1.add_contact(new_contact['public_key'])
-
-        self.device_2.just_fyi('Contacts (secondary device):check new contact')
-        self.profile_2.profile_button.double_click()
-        self.profile_2.contacts_button.scroll_to_element(direction='up')
-        self.profile_2.contacts_button.click()
-        for contact in (new_contact['username'], '@%s' % ens_user_ropsten['ens']):
-            if not self.profile_2.element_by_text(contact).is_element_displayed():
-                self.errors.append("'%s' new contact is not synced!" % contact)
-
-        self.device_1.just_fyi('(Main device): set nickname, (secondary device): check nickname')
-        self.chat_1.open_user_profile_from_1_1_chat()
-        self.chat_1.set_nickname(new_nickname)
-        if not self.profile_2.element_by_text(new_nickname).is_element_displayed():
-            self.errors.append("'%s' new nickname is not synced!" % new_nickname)
-
-        self.device_1.just_fyi('(Main device): remove contact, (secondary device): check removed contact')
-        self.chat_1.open_user_profile_from_1_1_chat()
-        self.chat_1.remove_from_contacts.click()
-        self.chat_1.close_button.click()
-        self.profile_2.element_by_text(new_nickname).is_element_disappeared(40)
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(702198)
-    def test_sync_1_1_chat_message(self):
-        [device.home_button.double_click() for device in (self.profile_1, self.profile_2)]
-        self.home_1.get_chat(self.nickname).click()
-        self.chat_1.send_message(self.message_after_sync)
-
-        self.home_2.just_fyi("Chats (secondary device): check messages in 1-1")
-        chat = self.home_2.get_chat(self.nickname).click()
-        if chat.chat_element_by_text(self.message_before_sync).is_element_displayed():
-            self.errors.append('"%s" message sent before pairing is synced' % self.message_before_sync)
-        if not chat.chat_element_by_text(self.message_after_sync).is_element_displayed(60):
-            self.errors.append('"%s" message in 1-1 is not synced' % self.message_after_sync)
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(702199)
-    def test_sync_public_chat_add_remove(self):
-        [device.home_button.double_click() for device in (self.profile_1, self.profile_2)]
-        self.home_1.join_public_chat(self.public_chat_after_sync)
-        if not self.home_2.element_by_text("#%s" % self.public_chat_after_sync).is_element_displayed(10):
-            self.errors.append('Public chat "%s" is not synced' % self.public_chat_after_sync)
-        self.home_1.home_button.click()
-        self.home_1.delete_chat_long_press('#%s' % self.public_chat_after_sync)
-        if not self.home_2.element_by_text('#%s' % self.public_chat_after_sync).is_element_disappeared(60):
-            self.errors.append('Remove of "%s" public chat is not synced!' % self.public_chat_after_sync)
-        self.errors.verify_no_errors()
-
-class TestGroupChatMultipleDevice(MultipleDeviceTestCase):
-
-    @marks.testrail_id(6324)
-    @marks.medium
-    def test_invite_to_group_chat_handling(self):
-        self.create_drivers(3)
-        sign_ins, homes, public_keys, usernames, chats = {}, {}, {}, {}, {}
-        for key in self.drivers:
-            sign_ins[key] = SignInView(self.drivers[key])
-            homes[key] = sign_ins[key].create_user()
-            public_keys[key], usernames[key] = sign_ins[key].get_public_key_and_username(True)
-            sign_ins[key].home_button.click()
-        [driver.close_app() for driver in (self.drivers[1], self.drivers[2])]
-        chat_name = homes[0].get_random_chat_name()
-
-        homes[0].just_fyi('Create group chats without members')
-        chats[0] = homes[0].create_group_chat([], chat_name)
-        link = chats[0].get_group_invite_via_group_info()
-        chats[0].get_back_to_home_view()
-        chats[0].just_fyi('Member_1, member_2: both users send requests to join group chat')
-        [sign_in.open_weblink_and_login(link) for sign_in in (sign_ins[1], sign_ins[2])]
-        introduction_messages = ['message for retrying']
-        for i in range(1, 3):
-            homes[i].element_by_text_part(chat_name).click()
-            chats[i] = ChatView(self.drivers[i])
-            introduction_messages.append('Please add me, member_%s to your gorgeous group chat' % str(i))
-            chats[i].request_membership_for_group_chat(introduction_messages[i])
-
-        chats[0].just_fyi('Admin: accept request for Member_1 and decline for Member_2')
-        homes[0].get_chat(chat_name).click()
-        chats[0].group_membership_request_button.wait_and_click()
-        chats[0].element_by_text(usernames[1]).click()
-        if not chats[0].element_by_text_part(introduction_messages[1]).is_element_displayed():
-            self.errors.append('Introduction message is not shown!')
-        chats[0].accept_group_invitation_button.wait_and_click()
-        chats[0].accept_membership_for_group_chat_via_chat_view(usernames[2], accept=False)
-        chats[0].click_system_back_button()
-
-        chats[2].just_fyi('Member_2: retry request')
-        chats[2].retry_group_invite_button.wait_and_click()
-        chats[2].request_membership_for_group_chat(introduction_messages[0])
-
-        chats[2].just_fyi('Admin: decline request for Member_2')
-        chats[0].group_membership_request_button.wait_and_click()
-        chats[0].element_by_text(usernames[2]).click()
-        if not chats[0].element_by_text_part(introduction_messages[0]).is_element_displayed():
-            self.errors.append('Introduction message that was set after retrying attempt is not shown for admin!')
-        chats[0].decline_group_invitation_button.wait_and_click()
-        chats[0].click_system_back_button()
-
-        chats[2].just_fyi('Member_2: remove chat')
-        chats[2].remove_group_invite_button.wait_and_click()
-
-        chats[2].just_fyi('Double check after relogin')
-        if chats[0].group_membership_request_button.is_element_displayed():
-            self.errors.append('Group membership request is still shown when there are no pending requests anymore')
-        [homes[i].relogin() for i in range(0, 3)]
-        if homes[2].element_by_text_part(chat_name).is_element_displayed():
-            self.errors.append('Group chat was not removed when removing after declining group invite')
-        [home.get_chat(chat_name).click() for home in (homes[0], homes[1])]
-        if chats[0].group_membership_request_button.is_element_displayed():
-            self.errors.append(
-                'Group membership request is shown after relogin when there are no pending requests anymore')
-        join_system_message = chats[0].join_system_message(usernames[1])
-        for chat in (chats[1], chats[0]):
-            if not chat.chat_element_by_text(join_system_message).is_element_displayed():
-                self.errors.append('%s is not shown after joining to group chat via invite' % join_system_message)
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(4001)
-    @marks.medium
-    def test_remove_member_from_group_chat(self):
-        self.create_drivers(3)
-        homes, public_keys, usernames, chats = {}, {}, {}, {}
-        for key in self.drivers:
-            sign_in_view = SignInView(self.drivers[key])
-            homes[key] = sign_in_view.create_user()
-            public_keys[key], usernames[key] = sign_in_view.get_public_key_and_username(True)
-            sign_in_view.home_button.click()
-        chat_name = homes[0].get_random_chat_name()
-        for i in range(1, 3):
-            homes[0].add_contact(public_keys[i])
-            homes[0].get_back_to_home_view()
-        chats[0] = homes[0].create_group_chat([usernames[1],
-                                               usernames[2]], chat_name)
-        chats[0].just_fyi('Member_1, member_2: both users join to group chat')
-        for i in range(1, 3):
-            chats[i] = homes[i].get_chat(chat_name).click()
-            chats[i].join_chat_button.click()
-        chats[0].just_fyi("Admin: get options for device 2 in group chat and remove him")
-        options = chats[0].get_user_options(usernames[1])
-        options.remove_user_button.click()
-        left_message = chats[0].leave_system_message(usernames[1])
-        for key in chats:
-            if not chats[key].chat_element_by_text(left_message).is_element_displayed():
-                self.errors.append("Message with text '%s' was not received" % left_message)
-
-        chats[0].just_fyi("Check that input field is not available after removing")
-        if chats[1].chat_message_input.is_element_displayed():
-            self.errors.append("Message input is still available for removed user")
-        chats[0].just_fyi("Send message and check that it is available only for remaining users")
-        message = 'after removing member'
-        chats[0].send_message(message)
-        for chat in (chats[0], chats[2]):
-            if not chat.chat_element_by_text(message).is_element_displayed(30):
-                self.errors.append("Message '%s' was not received after removing member" % message)
-        if chats[1].chat_element_by_text(message).is_element_displayed():
-            self.errors.append("Message '%s' was received by removed member" % message)
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6317)
-    @marks.medium
-    def test_pair_devices_group_chat_different_messages_nicknames(self):
-        self.create_drivers(3)
-        device_1, device_2, device_3 = SignInView(self.drivers[0]), SignInView(self.drivers[1]), SignInView(
-            self.drivers[2])
-        home_1 = device_1.create_user()
-        profile_1 = home_1.profile_button.click()
-        profile_1.privacy_and_security_button.click()
-        profile_1.backup_recovery_phrase_button.click()
-        profile_1.ok_continue_button.click()
-        recovery_phrase = profile_1.get_recovery_phrase()
-        profile_1.close_button.click()
-        profile_1.home_button.click()
-        home_3 = device_3.create_user()
-        public_key_3, username_3 = home_3.get_public_key_and_username(return_username=True)
-        device_3.home_button.click()
-        device_1_name, device_2_name, group_chat_name = 'creator', 'paired', 'some group chat'
-        home_2 = device_2.recover_access(passphrase=' '.join(recovery_phrase.values()))
-
-        device_1.just_fyi('Add contact, start group chat')
-        nickname = 'my_tester'
-        home_1.add_contact(public_key_3, nickname=nickname)
-        home_1.get_back_to_home_view()
-        chat_1 = home_1.create_group_chat([username_3], group_chat_name)
-        chat_3 = home_3.get_chat(group_chat_name).click()
-        chat_3.join_chat_button.click()
-
-        device_2.just_fyi('Go to profile > Devices, set device name, discover device 2 to device 1')
-        profile_2 = home_2.profile_button.click()
-        profile_2.discover_and_advertise_device(device_2_name)
-        device_1.profile_button.click()
-        profile_1.discover_and_advertise_device(device_1_name)
-        profile_1.get_toggle_device_by_name(device_2_name).click()
-        profile_1.sync_all_button.click()
-        profile_1.sync_all_button.wait_for_visibility_of_element(15)
-        profile_1.click_system_back_button(2)
-
-        device_1.just_fyi('Send message to group chat and verify it on all devices')
-        text_message = 'some text'
-        profile_1.home_button.click(desired_view='chat')
-        profile_2.home_button.click()
-        chat_1.send_message(text_message)
-        chat_2 = home_2.get_chat(group_chat_name).click()
-        for chat in chat_1, chat_2, chat_3:
-            if not chat.chat_element_by_text(text_message).is_element_displayed():
-                self.errors.append('Message was sent, but it is not shown')
-
-        device_3.just_fyi('Send message to group chat as member and verify nickname on it')
-        message_from_member = 'member1'
-        chat_3.send_message(message_from_member)
-        chat_1.chat_element_by_text(message_from_member).wait_for_visibility_of_element(20)
-        for chat in chat_1, chat_2:
-            if not chat.chat_element_by_text(message_from_member).username != '%s %s' % (nickname, username_3):
-                self.errors.append('Nickname is not shown in group chat')
-
-        device_1.just_fyi('Send image to group chat and verify it on all devices')
-        chat_1.show_images_button.click()
-        chat_1.allow_button.click()
-        chat_1.first_image_from_gallery.click()
-        chat_1.send_message_button.click()
-        chat_1.chat_message_input.click()
-        for chat in chat_1, chat_2, chat_3:
-            if not chat.image_message_in_chat.is_element_displayed(60):
-                self.errors.append('Image is not shown in chat after sending for %s' % chat.driver.number)
-
-        device_1.just_fyi('Send audio message to group chat and verify it on all devices')
-        chat_1.record_audio_message(message_length_in_seconds=3)
-        device_1.send_message_button.click()
-        chat_1.chat_message_input.click()
-        for chat in chat_1, chat_2, chat_3:
-            if not chat.play_pause_audio_message_button.is_element_displayed(30):
-                self.errors.append('Audio message is not shown in chat after sending!')
-
-        device_1.just_fyi('Send sticker to group chat and verify it on all devices')
-        chat_1.profile_button.click()
-        profile_1.switch_network()
-        home_1.get_chat(group_chat_name).click()
-        chat_1.install_sticker_pack_by_name()
-        chat_1.sticker_icon.click()
-        if not chat_1.sticker_message.is_element_displayed(30):
-            self.errors.append('Sticker was not sent')
-        self.errors.verify_no_errors()

test/appium/tests/critical/chats/test_1_1_public_chats.py

@@ -1,13 +1,211 @@
 import emoji
 import random
-import pytest
+import time
 
-from time import sleep
 from tests import marks, common_password
-from tests.base_test_case import MultipleDeviceTestCase, SingleDeviceTestCase, MultipleSharedDeviceTestCase, create_shared_drivers
+from tests.base_test_case import MultipleSharedDeviceTestCase, create_shared_drivers
 from tests.users import transaction_senders, basic_user, ens_user, ens_user_ropsten
 from views.sign_in_view import SignInView
-from views.send_transaction_view import SendTransactionView
+import pytest
+
+
+@pytest.mark.xdist_group(name="commands_2")
+@marks.critical
+class TestCommandsMultipleDevicesMerged(MultipleSharedDeviceTestCase):
+
+    @classmethod
+    def setup_class(cls):
+        cls.drivers, cls.loop = create_shared_drivers(2)
+        cls.device_1, cls.device_2 = SignInView(cls.drivers[0]), SignInView(cls.drivers[1])
+        cls.sender = transaction_senders['ETH_STT_3']
+        cls.home_1 = cls.device_1.recover_access(passphrase=cls.sender['passphrase'], enable_notifications=True)
+        cls.home_2 = cls.device_2.create_user()
+        for home in cls.home_1, cls.home_2:
+            profile = home.profile_button.click()
+            profile.profile_notifications_button.scroll_and_click()
+            profile.wallet_push_notifications.click()
+        cls.recipient_public_key, cls.recipient_username = cls.home_2.get_public_key_and_username(return_username=True)
+        cls.wallet_1, cls.wallet_2 = cls.home_1.wallet_button.click(), cls.home_2.wallet_button.click()
+        [wallet.home_button.click() for wallet in (cls.wallet_1, cls.wallet_2)]
+        cls.chat_1 = cls.home_1.add_contact(cls.recipient_public_key)
+        cls.chat_1.send_message("hello!")
+        cls.account_name_1 = cls.wallet_1.status_account_name
+
+    @marks.testrail_id(6253)
+    def test_1_1_chat_command_send_tx_eth_outgoing_tx_push(self):
+        amount = self.chat_1.get_unique_amount()
+        self.home_1.just_fyi('Send %s ETH in 1-1 chat and check it for sender and receiver: Address requested' % amount)
+        self.chat_1.commands_button.click()
+        send_transaction = self.chat_1.send_command.click()
+        send_transaction.get_username_in_transaction_bottom_sheet_button(self.recipient_username).click()
+        if send_transaction.scan_qr_code_button.is_element_displayed():
+            self.drivers[0].fail('Recipient is editable in bottom sheet when send ETH from 1-1 chat')
+        send_transaction.amount_edit_box.set_value(amount)
+        send_transaction.confirm()
+        send_transaction.sign_transaction_button.click()
+        sender_message = self.chat_1.get_outgoing_transaction(self.account_name_1)
+        if not sender_message.is_element_displayed():
+            self.drivers[0].fail('No message is shown after sending ETH in 1-1 chat for sender')
+        sender_message.transaction_status.wait_for_element_text(sender_message.address_requested)
+
+        chat_2 = self.home_2.get_chat(self.sender['username']).click()
+        receiver_message = chat_2.get_incoming_transaction(self.account_name_1)
+        timestamp_sender = sender_message.timestamp_command_message.text
+        if not receiver_message.is_element_displayed():
+            self.drivers[0].fail('No message about incoming transaction in 1-1 chat is shown for receiver')
+        receiver_message.transaction_status.wait_for_element_text(receiver_message.address_requested)
+
+        self.home_2.just_fyi('Accept and share address for sender and receiver')
+        for option in (receiver_message.decline_transaction, receiver_message.accept_and_share_address):
+            if not option.is_element_displayed():
+                self.drivers[0].fail("Required options accept or share are not shown")
+
+        select_account_bottom_sheet = receiver_message.accept_and_share_address.click()
+        if not select_account_bottom_sheet.get_account_in_select_account_bottom_sheet_button(
+                self.account_name_1).is_element_displayed():
+            self.errors.append('Not expected value in "From" in "Select account": "Status" is expected')
+        select_account_bottom_sheet.select_button.click()
+        receiver_message.transaction_status.wait_for_element_text(receiver_message.shared_account)
+        sender_message.transaction_status.wait_for_element_text(sender_message.address_request_accepted)
+
+        self.home_1.just_fyi("Sign and send transaction and check that timestamp on message is updated")
+        time.sleep(20)
+        send_bottom_sheet = sender_message.sign_and_send.click()
+        send_bottom_sheet.next_button.click()
+        send_bottom_sheet.sign_transaction()
+        updated_timestamp_sender = sender_message.timestamp_command_message.text
+        if updated_timestamp_sender == timestamp_sender:
+            self.errors.append("Timestamp of message is not updated after signing transaction")
+        self.chat_1.wallet_button.click()
+        self.wallet_1.find_transaction_in_history(amount=amount)
+
+        [wallet.put_app_to_background() for wallet in (self.wallet_1, self.wallet_2)]
+        self.device_1.open_notification_bar()
+        self.network_api.wait_for_confirmation_of_transaction(self.sender['address'], amount)
+        pn = self.home_1.get_pn('You sent %s ETH' % amount)
+        if pn:
+            pn.click()
+            if not self.wallet_1.transaction_history_button.is_element_displayed():
+                self.errors.append('Was not redirected to transaction history after tapping on PN')
+        else:
+            self.home_1.click_system_back_button()
+            self.home_1.status_in_background_button.click_if_shown()
+        self.wallet_1.home_button.click(desired_view="chat")
+
+        self.home_1.just_fyi("Check 'Confirmed' state for sender and receiver(use pull-to-refresh to update history)")
+        chat_2.status_in_background_button.click()
+        chat_2.wallet_button.click()
+        self.wallet_2.wait_balance_is_changed()
+        self.wallet_2.find_transaction_in_history(amount=amount)
+        self.wallet_2.home_button.click()
+        self.home_2.get_chat(self.sender['username']).click()
+        [message.transaction_status.wait_for_element_text(message.confirmed, 60) for message in
+         (sender_message, receiver_message)]
+
+        # TODO: should be added PNs for receiver after getting more stable feature (rechecked 23.11.21, valid)
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(6265)
+    def test_1_1_chat_command_decline_eth_push_changing_state(self):
+        [home.driver.background_app(3) for home in (self.home_1, self.home_2)]
+        self.home_1.home_button.double_click()
+        self.home_1.get_chat(username=self.recipient_username).click()
+
+        self.home_1.just_fyi('Decline transaction before sharing address and check that state is changed')
+        self.chat_1.commands_button.click()
+        send_transaction = self.chat_1.send_command.click()
+        amount = self.chat_1.get_unique_amount()
+        send_transaction.amount_edit_box.set_value(amount)
+        send_transaction.confirm()
+        send_transaction.sign_transaction_button.click()
+        chat_1_sender_message = self.chat_1.get_outgoing_transaction()
+        self.home_1.click_system_home_button()
+
+        self.home_2.home_button.double_click()
+        chat_2 = self.home_2.get_chat(self.sender['username']).click()
+        chat_2_receiver_message = chat_2.get_incoming_transaction()
+        chat_2_receiver_message.decline_transaction.click()
+        self.home_1.open_notification_bar()
+        self.home_1.element_by_text_part('Request address for transaction declined').wait_and_click()
+
+        [message.transaction_status.wait_for_element_text(message.declined) for message in
+         (chat_1_sender_message, chat_2_receiver_message)]
+
+        self.home_1.just_fyi('Decline transaction request and check that state is changed')
+        request_amount = self.chat_1.get_unique_amount()
+        self.chat_1.commands_button.click()
+        request_transaction = self.chat_1.request_command.click()
+        request_transaction.amount_edit_box.set_value(request_amount)
+        request_transaction.confirm()
+        request_transaction.request_transaction_button.click()
+        chat_1_request_message = self.chat_1.get_incoming_transaction()
+        chat_2_sender_message = chat_2.get_outgoing_transaction()
+        chat_2_sender_message.decline_transaction.click()
+        [message.transaction_status.wait_for_element_text(message.declined) for message in
+         (chat_2_sender_message, chat_1_request_message)]
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(6263)
+    def test_1_1_chat_command_request_and_send_tx_stt_in_1_1_chat_offline(self):
+        [home.driver.background_app(2) for home in (self.home_1, self.home_2)]
+        asset_name = 'STT'
+        amount = self.device_1.get_unique_amount()
+
+        self.device_1.just_fyi('Grab user data for transactions and public chat, set up wallets')
+        self.home_2.get_back_to_home_view()
+        self.home_2.wallet_button.click()
+        self.wallet_2.select_asset(asset_name)
+        self.wallet_2.home_button.click()
+        self.home_1.wallet_button.double_click()
+        initial_amount_stt = self.wallet_1.get_asset_amount_by_name('STT')
+        self.home_1.driver.close_app()
+
+        self.home_2.just_fyi('Request %s STT in 1-1 chat and check it is visible for sender and receiver' % amount)
+        chat_2 = self.home_2.get_chat(username=self.sender['username']).click()
+        chat_2.commands_button.click()
+        request_transaction = chat_2.request_command.click()
+        request_transaction.amount_edit_box.set_value(amount)
+        request_transaction.confirm()
+        asset_button = request_transaction.asset_by_name(asset_name)
+        request_transaction.select_asset_button.click_until_presence_of_element(asset_button)
+        asset_button.click()
+        request_transaction.request_transaction_button.click()
+        chat_2_request_message = chat_2.get_incoming_transaction()
+        if not chat_2_request_message.is_element_displayed():
+            self.drivers[1].fail('No incoming transaction in 1-1 chat is shown for recipient after requesting STT')
+
+        self.home_1.just_fyi('Check that transaction message is fetched from offline and sign transaction')
+        self.device_1.driver.launch_app()
+        self.device_1.sign_in()
+        self.home_1.connection_offline_icon.wait_for_invisibility_of_element(30)
+        self.home_1.get_chat(self.recipient_username).click()
+        chat_1_sender_message = self.chat_1.get_outgoing_transaction()
+        if not chat_1_sender_message.is_element_displayed():
+            self.drivers[0].fail('No outgoing transaction in 1-1 chat is shown for sender after requesting STT')
+        chat_1_sender_message.transaction_status.wait_for_element_text(chat_1_sender_message.address_received)
+        send_message = chat_1_sender_message.sign_and_send.click()
+        send_message.next_button.click()
+        send_message.sign_transaction()
+
+        self.home_2.just_fyi('Check that transaction message is updated with new status after offline')
+        [chat.toggle_airplane_mode() for chat in (self.chat_1, chat_2)]
+        self.network_api.wait_for_confirmation_of_transaction(self.sender['address'], amount, token=True)
+        for home in (self.home_1, self.home_2):
+            home.toggle_airplane_mode()
+            home.home_button.double_click()
+            home.connection_offline_icon.wait_for_invisibility_of_element(100)
+        self.home_2.get_chat(self.sender['username']).click()
+        self.home_1.get_chat(self.recipient_username).click()
+        [message.transaction_status.wait_for_element_text(message.confirmed, wait_time=120) for message in
+         (chat_1_sender_message, chat_2_request_message)]
+
+        self.home_1.just_fyi('Check that can find tx in history and balance is updated after offline')
+        self.home_1.wallet_button.click()
+        self.wallet_1.wait_balance_is_changed('STT', initial_amount_stt)
+        self.wallet_1.find_transaction_in_history(amount=amount, asset=asset_name)
+
+        self.errors.verify_no_errors()
 
 
 @pytest.mark.xdist_group(name="1_1_chat_2")
@@ -434,7 +632,7 @@ class TestContactBlockMigrateKeycardMultipleSharedDevices(MultipleSharedDeviceTe
         [home.home_button.click() for home in [cls.home_1, cls.home_2]]
 
     @marks.testrail_id(702186)
-    def test_keycard_command_send_eth_1_1_chat(self):
+    def test_keycard_command_send_tx_eth_1_1_chat(self):
         self.home_2.get_chat(self.sender['username']).click()
         self.chat_2.send_message("hey on kk!")
         self.chat_2.home_button.click()
@@ -479,7 +677,7 @@ class TestContactBlockMigrateKeycardMultipleSharedDevices(MultipleSharedDeviceTe
         sender_message.transaction_status.wait_for_element_text(sender_message.address_request_accepted)
 
         self.chat_1.just_fyi("Sign and send transaction and check that timestamp on message is updated")
-        sleep(20)
+        time.sleep(20)
         send_message = sender_message.sign_and_send.click()
         send_message.next_button.click()
         send_message.sign_transaction(keycard=True)
@@ -527,10 +725,10 @@ class TestContactBlockMigrateKeycardMultipleSharedDevices(MultipleSharedDeviceTe
         self.chat_1.chat_message_input.clear()
         for pattern in (self.nick[0:2], self.default_username_2[0:4]):
             self.chat_1.select_mention_from_suggestion_list(username_in_list=self.nick + ' ' + self.default_username_2,
-                                                            typed_search_pattern=self.default_username_2[0:4])
+                                                            typed_search_pattern=pattern)
             if self.chat_1.chat_message_input.text != '@' + self.default_username_2 + ' ':
-                self.errors.append('Username is not resolved in chat input after selecting it in mention '
+                self.errors.append('Username is not resolved in chat input after selecting it in mention suggestions '
-                               'suggestions list by default username!')
+                                   'list by default username!')
         additional_text = 'and more'
         self.chat_1.send_as_keyevent(additional_text)
         self.chat_1.send_message_button.click()
@@ -608,7 +806,7 @@ class TestContactBlockMigrateKeycardMultipleSharedDevices(MultipleSharedDeviceTe
         for message in self.message, message_blocked:
             if self.chat_1.chat_element_by_text(message).is_element_displayed():
                 self.errors.append(
-                    "'%s' from blocked user is fetched from offline in public chat" % (message))
+                    "'%s' from blocked user is fetched from offline in public chat" % message)
 
         self.chat_2.just_fyi('Unblock user and check that can see further messages')
         profile_1 = self.home_1.get_profile_view()
@@ -741,257 +939,247 @@ class TestContactBlockMigrateKeycardMultipleSharedDevices(MultipleSharedDeviceTe
         self.errors.verify_no_errors()
 
 
-class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
+@pytest.mark.xdist_group(name="ens_stickers_mention_2")
-    @marks.testrail_id(5362)
+@marks.critical
-    @marks.medium
+class TestEnsStickersMultipleDevicesMerged(MultipleSharedDeviceTestCase):
-    def test_unread_messages_counter_preview_highlited_1_1_chat(self):
-        self.create_drivers(2)
-        device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
-        home_1, home_2 = device_1.create_user(), device_2.create_user()
-        profile_2 = home_2.profile_button.click()
-        default_username_2 = profile_2.default_username_text.text
-        home_2 = profile_2.home_button.click()
-        public_key_1 = home_1.get_public_key_and_username()
-        home_1.home_button.click()
-        chat_2 = home_2.add_contact(public_key_1)
 
-        message, message_2, message_3 = 'test message', 'test message2', 'test'
+    @classmethod
-        chat_2.send_message(message)
+    def setup_class(cls):
-        chat_element = home_1.get_chat(default_username_2)
+        cls.drivers, cls.loop = create_shared_drivers(2)
-        home_1.dapp_tab_button.click()
+        cls.device_1, cls.device_2 = SignInView(cls.drivers[0]), SignInView(cls.drivers[1])
-        chat_2.send_message(message_2)
+        cls.sender, cls.reciever = transaction_senders['ETH_3'], ens_user
+        cls.home_1 = cls.device_1.recover_access(passphrase=cls.sender['passphrase'])
+        cls.home_2 = cls.device_2.recover_access(ens_user['passphrase'], enable_notifications=True)
+        cls.ens = '@%s' % cls.reciever['ens']
+        cls.pub_chat_name = cls.home_1.get_random_chat_name()
+        cls.chat_1 = cls.home_1.join_public_chat(cls.pub_chat_name)
+        cls.chat_2 = cls.home_2.join_public_chat(cls.pub_chat_name)
+        [home.home_button.double_click() for home in (cls.home_1, cls.home_2)]
+        cls.profile_2 = cls.home_2.profile_button.click()
+        cls.profile_2.connect_existing_ens(cls.reciever['ens'])
+        cls.home_1.add_contact(cls.reciever['ens'])
+        cls.home_2.home_button.click()
+        cls.home_2.add_contact(cls.sender['public_key'])
+        # To avoid activity centre for restored users
+        [chat.send_message("hey!") for chat in (cls.chat_1, cls.chat_2)]
+        [home.home_button.double_click() for home in (cls.home_1, cls.home_2)]
 
-        if home_1.home_button.counter.text != '1':
+    @marks.testrail_id(702152)
-            self.errors.append('New messages counter is not shown on Home button')
+    def test_ens_purchased_in_profile(self):
-        device_1.home_button.click()
+        self.home_2.profile_button.double_click()
-        if chat_element.new_messages_counter.text != '1':
+        ens_name_after_adding = self.profile_2.default_username_text.text
-            self.errors.append('New messages counter is not shown on chat element')
+        if ens_name_after_adding != '@%s' % ens_user['ens']:
-        chat_1 = chat_element.click()
+            self.errors.append('ENS name is not shown as default in user profile after adding, "%s" instead' %
-        chat_1.add_to_contacts.click()
+                               ens_name_after_adding)
 
-        home_1.home_button.double_click()
+        self.home_2.just_fyi('check ENS name wallet address and public key')
+        self.home_2.element_by_text(self.reciever['ens']).click()
+        self.home_2.element_by_text(self.reciever['ens']).click()
+        for text in (self.reciever['address'].lower(), self.reciever['public_key']):
+            if not self.home_2.element_by_text_part(text).is_element_displayed(40):
+                self.errors.append('%s text is not shown' % text)
+        self.home_2.profile_button.double_click()
 
-        if home_1.home_button.counter.is_element_displayed():
+        self.home_2.just_fyi('check ENS name is shown on share my profile window')
-            self.errors.append('New messages counter is shown on Home button for already seen message')
+        self.profile_2.share_my_profile_button.click()
-        if chat_element.new_messages_counter.text == '1':
+        if self.profile_2.ens_name_in_share_chat_key_text.text != '%s' % ens_user['ens']:
-            self.errors.append('New messages counter is shown on chat element for already seen message')
+            self.errors.append('No ENS name is shown on tapping on share icon in Profile')
-        home_1.delete_chat_long_press(default_username_2)
+        self.profile_2.close_share_popup()
-
-        home_1.just_fyi("Checking preview of message and chat highlighting")
-        chat_2.send_message(message_3)
-        chat_1_element = home_1.get_chat(default_username_2)
-        if chat_1_element.chat_preview.is_element_differs_from_template('highligted_preview.png', 0):
-            self.errors.append("Preview message is not hightligted or text is not shown! ")
-        home_1.get_chat(default_username_2).click()
-        home_1.home_button.double_click()
-        if not home_1.get_chat(default_username_2).chat_preview.is_element_differs_from_template('highligted_preview.png', 0):
-            self.errors.append("Preview message is still highlighted after opening ")
         self.errors.verify_no_errors()
 
+    @marks.testrail_id(702153)
+    def test_ens_command_send_tx_eth_1_1_chat(self):
+        [home.home_button.double_click() for home in (self.home_1, self.home_2)]
+        wallet_1 = self.home_1.wallet_button.click()
+        wallet_1.wait_balance_is_changed()
+        wallet_1.home_button.click()
+        self.home_1.get_chat(self.ens).click()
+        self.chat_1.commands_button.click()
+        amount = self.chat_1.get_unique_amount()
 
-class TestMessagesOneToOneChatSingle(SingleDeviceTestCase):
+        self.chat_1.just_fyi("Check sending assets to ENS name from sender side")
+        send_message = self.chat_1.send_command.click()
+        send_message.amount_edit_box.set_value(amount)
+        send_message.confirm()
+        send_message.next_button.click()
+        from views.send_transaction_view import SendTransactionView
+        send_transaction = SendTransactionView(self.drivers[0])
+        send_transaction.ok_got_it_button.click()
+        send_transaction.sign_transaction()
+        chat_1_sender_message = self.chat_1.get_outgoing_transaction(transaction_value=amount)
+        self.network_api.wait_for_confirmation_of_transaction(self.sender['address'], amount, confirmations=3)
+        chat_1_sender_message.transaction_status.wait_for_element_text(chat_1_sender_message.confirmed)
 
-    @marks.testrail_id(5322)
+        self.chat_2.just_fyi("Check that message is fetched for receiver")
-    @marks.medium
+        self.home_2.get_chat(self.sender['username']).click()
-    def test_delete_cut_and_paste_messages(self):
+        chat_2_reciever_message = self.chat_2.get_incoming_transaction(transaction_value=amount)
-        sign_in = SignInView(self.driver)
+        chat_2_reciever_message.transaction_status.wait_for_element_text(chat_2_reciever_message.confirmed)
-        home = sign_in.create_user()
-        chat = home.add_contact(transaction_senders['N']['public_key'])
 
-        message_text = 'test'
+    @marks.testrail_id(702155)
-        message_input = chat.chat_message_input
+    def test_ens_mention_nickname_1_1_chat(self):
-        message_input.send_keys(message_text)
+        [home.home_button.double_click() for home in (self.home_1, self.home_2)]
 
-        message_input.delete_last_symbols(2)
+        self.home_1.just_fyi('Mention user by ENS in 1-1 chat')
-        current_text = message_input.text
+        message, message_ens_owner = '%s hey!' % self.ens, '%s hey!' % self.reciever['ens']
-        if current_text != message_text[:-2]:
+        self.home_1.get_chat(self.ens).click()
-            self.driver.fail("Message input text '%s' doesn't match expected '%s'" % (current_text, message_text[:-2]))
+        self.chat_1.send_message(message)
 
-        message_input.cut_text()
+        self.home_1.just_fyi('Set nickname and mention user by nickname in 1-1 chat')
+        russian_nickname = 'МОЙ дорогой ДРУх'
+        self.chat_1.chat_options.click()
+        self.chat_1.view_profile_button.click()
+        self.chat_1.set_nickname(russian_nickname)
+        self.chat_1.select_mention_from_suggestion_list(russian_nickname + ' ' + self.ens)
 
-        message_input.paste_text_from_clipboard()
+        self.chat_1.just_fyi('Check that nickname is shown in preview for 1-1 chat')
-        chat.send_message_button.click()
+        updated_message = '%s hey!' % russian_nickname
+        self.chat_1.home_button.double_click()
+        if not self.chat_1.element_by_text(updated_message).is_element_displayed():
+            self.errors.append('"%s" is not show in chat preview on home screen!' % message)
+        self.home_1.get_chat(russian_nickname).click()
 
-        chat.chat_element_by_text(message_text[:-2]).wait_for_visibility_of_element(2)
+        self.chat_1.just_fyi('Check redirect to user profile on mention by nickname tap')
+        self.chat_1.chat_element_by_text(updated_message).click()
+        if not self.chat_1.profile_block_contact.is_element_displayed():
+            self.errors.append(
+                'No redirect to user profile after tapping on message with mention (nickname) in 1-1 chat')
+        else:
+            self.chat_1.profile_send_message.click()
 
-    @marks.testrail_id(6298)
+        self.chat_2.just_fyi("Check message with mention for ENS owner")
-    @marks.medium
+        self.home_2.get_chat(self.sender['username']).click()
-    def test_can_scan_qr_with_chat_key_from_home_start_chat(self):
+        if not self.chat_2.chat_element_by_text(message_ens_owner).is_element_displayed():
-        sign_in = SignInView(self.driver)
+            self.errors.append('Expected %s message is not shown for ENS owner' % message_ens_owner)
-        home = sign_in.recover_access(basic_user['passphrase'])
 
-        url_data = {
+        self.chat_1.just_fyi('Check if after deleting nickname ENS is shown again')
-            'ens_with_stateofus_domain_deep_link': {
+        self.chat_1.chat_options.click()
-                'url': 'https://join.status.im/u/%s.stateofus.eth' % ens_user_ropsten['ens'],
+        self.chat_1.view_profile_button.click()
-                'username': '@%s' % ens_user_ropsten['ens']
+        self.chat_1.profile_nickname_button.click()
-            },
+        self.chat_1.nickname_input_field.clear()
-            'ens_without_stateofus_domain_deep_link': {
+        self.chat_1.element_by_text('Done').click()
-                'url': 'https://join.status.im/u/%s' % ens_user_ropsten['ens'],
+        self.chat_1.close_button.click()
-                'username': '@%s' % ens_user_ropsten['ens']
+        if self.chat_1.user_name_text.text != self.ens:
-            },
+            self.errors.append("Username '%s' is not updated to ENS '%s' after deleting nickname" %
-            'ens_another_domain_deep_link': {
+                               (self.chat_1.user_name_text.text, self.ens))
-                'url': 'status-im://u/%s' % ens_user['ens_another'],
-                'username': '@%s' % ens_user['ens_another']
-            },
-            'own_profile_key_deep_link': {
-                'url': 'https://join.status.im/u/%s' % basic_user['public_key'],
-                'error': "That's you"
-            },
-            'other_user_profile_key_deep_link': {
-                'url': 'https://join.status.im/u/%s' % transaction_senders['M']['public_key'],
-                'username': transaction_senders['M']['username']
-            },
-            'other_user_profile_key_deep_link_invalid': {
-                'url': 'https://join.status.im/u/%sinvalid' % ens_user['public_key'],
-                'error': 'Please enter or scan a valid chat key'
-            },
-            'own_profile_key': {
-                'url': basic_user['public_key'],
-                'error': "That's you"
-            },
-            # 'ens_without_stateofus_domain': {
-            #     'url': ens_user['ens'],
-            #     'username': ens_user['username']
-            # },
-            'other_user_profile_key': {
-                'url': transaction_senders['M']['public_key'],
-                'username': transaction_senders['M']['username']
-            },
-            'other_user_profile_key_invalid': {
-                'url': '%s123' % ens_user['public_key'],
-                'error': 'Please enter or scan a valid chat key'
-            },
-        }
-
-        for key in url_data:
-            home.plus_button.click_until_presence_of_element(home.start_new_chat_button)
-            contacts = home.start_new_chat_button.click()
-            sign_in.just_fyi('Checking scanning qr for "%s" case' % key)
-            contacts.scan_contact_code_button.click()
-            if contacts.allow_button.is_element_displayed():
-                contacts.allow_button.click()
-            contacts.enter_qr_edit_box.scan_qr(url_data[key]['url'])
-            from views.chat_view import ChatView
-            chat = ChatView(self.driver)
-            if url_data[key].get('error'):
-                if not chat.element_by_text_part(url_data[key]['error']).is_element_displayed():
-                    self.errors.append('Expected error %s is not shown' % url_data[key]['error'])
-                chat.ok_button.click()
-            if url_data[key].get('username'):
-                if not chat.chat_message_input.is_element_displayed():
-                    self.errors.append(
-                        'In "%s" case chat input is not found after scanning, so no redirect to 1-1' % key)
-                if not chat.element_by_text(url_data[key]['username']).is_element_displayed():
-                    self.errors.append('In "%s" case "%s" not found after scanning' % (key, url_data[key]['username']))
-                chat.get_back_to_home_view()
-        self.errors.verify_no_errors()
-
-    @marks.testrail_id(6322)
-    @marks.medium
-    def test_can_scan_different_links_with_universal_qr_scanner(self):
-        user = transaction_senders['ETH_STT_3']
-        home = SignInView(self.driver).recover_access(user['passphrase'])
-        wallet = home.wallet_button.click()
-        wallet.home_button.click()
-        send_transaction = SendTransactionView(self.driver)
-
-        url_data = {
-            'ens_without_stateofus_domain_deep_link': {
-                'url': 'https://join.status.im/u/%s' % ens_user_ropsten['ens'],
-                'username': '@%s' % ens_user_ropsten['ens']
-            },
-
-            'other_user_profile_key_deep_link': {
-                'url': 'status-im://u/%s' % basic_user['public_key'],
-                'username': basic_user['username']
-            },
-            'other_user_profile_key_deep_link_invalid': {
-                'url': 'https://join.status.im/u/%sinvalid' % ens_user['public_key'],
-                'error': 'Unable to read this code'
-            },
-            'own_profile_key': {
-                'url': user['public_key'],
-            },
-            'other_user_profile_key': {
-                'url': transaction_senders['A']['public_key'],
-                'username': transaction_senders['A']['username']
-            },
-            'wallet_validation_wrong_address_transaction': {
-                'url': 'ethereum:0x744d70fdbe2ba4cf95131626614a1763df805b9e@3/transfer?address=blablabla&uint256=1e10',
-                'error': 'Invalid address',
-            },
-            'wallet_eip_ens_for_receiver': {
-                'url': 'ethereum:0xc55cf4b03948d7ebc8b9e8bad92643703811d162@3/transfer?address=nastya.stateofus.eth&uint256=1e-1',
-                'data': {
-                    'asset': 'STT',
-                    'amount': '0.1',
-                    'address': '0x58d8…F2ff',
-                },
-            },
-            'wallet_eip_payment_link': {
-                'url': 'ethereum:pay-0xc55cf4b03948d7ebc8b9e8bad92643703811d162@3/transfer?address=0x3d597789ea16054a084ac84ce87f50df9198f415&uint256=1e1',
-                'data': {
-                    'amount': '10',
-                    'asset': 'STT',
-                    'address': '0x3D59…F415',
-                },
-            },
-            'dapp_deep_link': {
-                'url': 'https://join.status.im/b/simpledapp.eth',
-            },
-            'dapp_deep_link_https': {
-                'url': 'https://join.status.im/b/https://simpledapp.eth',
-            },
-            'public_chat_deep_link': {
-                'url': 'https://join.status.im/baga-ma-2020',
-                'chat_name': 'baga-ma-2020'
-            },
-        }
-
-        for key in url_data:
-            home.plus_button.click_until_presence_of_element(home.start_new_chat_button)
-            home.just_fyi('Checking %s case' % key)
-            if home.universal_qr_scanner_button.is_element_displayed():
-                home.universal_qr_scanner_button.click()
-            if home.allow_button.is_element_displayed():
-                home.allow_button.click()
-            home.enter_qr_edit_box.scan_qr(url_data[key]['url'])
-            from views.chat_view import ChatView
-            chat = ChatView(self.driver)
-            if key == 'own_profile_key':
-                from views.profile_view import ProfileView
-                profile = ProfileView(self.driver)
-                if not profile.default_username_text.is_element_displayed():
-                    self.errors.append('In %s case was not redirected to own profile' % key)
-                home.home_button.double_click()
-            if url_data[key].get('error'):
-                if not chat.element_by_text_part(url_data[key]['error']).is_element_displayed():
-                    self.errors.append('Expected error %s is not shown' % url_data[key]['error'])
-                chat.ok_button.click()
-            if url_data[key].get('username'):
-                if not chat.element_by_text(url_data[key]['username']).is_element_displayed():
-                    self.errors.append('In %s case username not shown' % key)
-            if 'wallet' in key:
-                if url_data[key].get('data'):
-                    actual_data = send_transaction.get_values_from_send_transaction_bottom_sheet()
-                    difference_in_data = url_data[key]['data'].items() - actual_data.items()
-                    if difference_in_data:
-                        self.errors.append(
-                            'In %s case returned value does not match expected in %s' % (key, repr(difference_in_data)))
-                    wallet.close_send_transaction_view_button.click()
-                wallet.home_button.click()
-            if 'dapp' in key:
-                home.open_in_status_button.click()
-                if not (chat.allow_button.is_element_displayed() or chat.element_by_text(
-                        "Can't find web3 library").is_element_displayed()):
-                    self.errors.append('No allow button is shown in case of navigating to Status dapp!')
-                chat.dapp_tab_button.click()
-                chat.home_button.click()
-            if 'public' in key:
-                if not chat.chat_message_input.is_element_displayed():
-                    self.errors.append('No message input is shown in case of navigating to public chat via deep link!')
-                if not chat.element_by_text_part(url_data[key]['chat_name']).is_element_displayed():
-                    self.errors.append('Chat name is not shown in case of navigating to public chat via deep link!')
-            chat.get_back_to_home_view()
 
         self.errors.verify_no_errors()
+
+    @marks.testrail_id(702156)
+    def test_ens_mention_push_highlighted_public_chat(self):
+        [home.home_button.double_click() for home in (self.home_1, self.home_2)]
+        self.home_2.put_app_to_background()
+        self.home_2.open_notification_bar()
+
+        self.home_1.just_fyi('check that can mention user with ENS name')
+        self.home_1.get_chat(self.ens).click()
+        self.chat_1.select_mention_from_suggestion_list(self.reciever['ens'])
+        if self.chat_1.chat_message_input.text != self.ens + ' ':
+            self.errors.append(
+                'ENS username is not resolved in chat input after selecting it in mention suggestions list!')
+        self.chat_1.send_message_button.click()
+
+        self.home_2.just_fyi('check that PN is received and after tap you are redirected to chat, mention is highligted')
+        # TODO: issue #11003
+        pn = self.home_2.get_pn(self.reciever['username'])
+        if pn:
+            pn.click()
+        else:
+            self.home_2.click_system_back_button(2)
+        if self.home_2.element_starts_with_text(self.reciever['ens']).is_element_differs_from_template('mentioned.png', 2):
+            self.errors.append('Mention is not highlighted!')
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702157)
+    def test_sticker_1_1_public_chat(self):
+        self.home_2.status_in_background_button.click_if_shown()
+        [home.home_button.double_click() for home in (self.home_1, self.home_2)]
+        (profile_1, profile_2) = (home.profile_button.click() for home in (self.home_1, self.home_2))
+        [profile.switch_network() for profile in (profile_1, profile_2)]
+        # TODO: no check there is no stickers on ropsten due to transfer stickers to status-go
+
+        self.home_2.just_fyi('Check that can use purchased stickerpack')
+        self.home_2.get_chat('#%s' % self.pub_chat_name).click()
+        self.chat_2.install_sticker_pack_by_name('Tozemoon')
+        self.chat_2.sticker_icon.click()
+        if not self.chat_2.chat_item.is_element_displayed():
+            self.errors.append('Cannot use purchased stickers')
+
+        self.home_1.just_fyi('Install free sticker pack and use it in 1-1 chat')
+        self.home_1.get_chat(self.ens).click()
+        self.chat_1.install_sticker_pack_by_name('Status Cat')
+        self.chat_1.sticker_icon.click()
+        if not self.chat_1.sticker_message.is_element_displayed():
+            self.errors.append('Sticker was not sent')
+        self.chat_1.swipe_right()
+        if not self.chat_1.sticker_icon.is_element_displayed():
+            self.errors.append('Sticker is not shown in recently used list')
+        self.chat_1.get_back_to_home_view()
+
+        self.home_1.just_fyi('Send stickers in public chat from Recent')
+        self.home_1.join_public_chat(self.home_1.get_random_chat_name())
+        self.chat_1.show_stickers_button.click()
+        self.chat_1.sticker_icon.click()
+        if not self.chat_1.chat_item.is_element_displayed():
+            self.errors.append('Sticker was not sent from Recent')
+
+        self.home_2.just_fyi('Check that can install stickers by tapping on sticker message')
+        self.home_2.home_button.double_click()
+        self.home_2.get_chat(self.sender['username']).click()
+        self.chat_2.chat_item.click()
+        if not self.chat_2.element_by_text_part('Status Cat').is_element_displayed():
+            self.errors.append('Stickerpack is not available for installation after tapping on sticker message')
+        self.chat_2.element_by_text_part('Free').click()
+        if self.chat_2.element_by_text_part('Free').is_element_displayed():
+            self.errors.append('Stickerpack was not installed')
+
+        self.chat_2.just_fyi('Check that can navigate to another user profile via long tap on sticker message')
+        self.chat_2.close_sticker_view_icon.click()
+        self.chat_2.chat_item.long_press_element()
+        self.chat_2.element_by_text('View Details').click()
+        self.chat_2.profile_send_message.wait_and_click()
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702158)
+    def test_start_new_chat_public_key_validation(self):
+        [home.get_back_to_home_view() for home in (self.home_1, self.home_2)]
+        self.home_2.driver.quit()
+        public_key = basic_user['public_key']
+        self.home_1.plus_button.click()
+        chat = self.home_1.start_new_chat_button.click()
+
+        self.home_1.just_fyi("Validation: invalid public key and invalid ENS")
+        for invalid_chat_key in (basic_user['public_key'][:-1], ens_user_ropsten['ens'][:-2]):
+            chat.public_key_edit_box.clear()
+            chat.public_key_edit_box.set_value(invalid_chat_key)
+            chat.confirm()
+            if not self.home_1.element_by_translation_id("profile-not-found").is_element_displayed():
+                self.errors.append('Error is not shown for invalid public key')
+
+        self.home_1.just_fyi("Check that valid ENS is resolved")
+        chat.public_key_edit_box.clear()
+        chat.public_key_edit_box.set_value(ens_user_ropsten['ens'])
+        resolved_ens = '%s.stateofus.eth' % ens_user_ropsten['ens']
+        if not chat.element_by_text(resolved_ens).is_element_displayed(10):
+            self.errors.append('ENS name is not resolved after pasting chat key')
+        self.home_1.close_button.click()
+
+        self.home_1.just_fyi("Check that can paste public key from keyboard and start chat")
+        self.home_1.get_chat('#%s' % self.pub_chat_name).click()
+        chat.send_message(public_key)
+        chat.copy_message_text(public_key)
+        chat.back_button.click()
+        self.home_1.plus_button.click()
+        self.home_1.start_new_chat_button.click()
+        chat.public_key_edit_box.paste_text_from_clipboard()
+        if chat.public_key_edit_box.text != public_key:
+            self.errors.append('Public key is not pasted from clipboard')
+        if not chat.element_by_text(basic_user['username']).is_element_displayed():
+            self.errors.append('3 random-name is not resolved after pasting chat key')
+
+        self.home_1.just_fyi('My_profile button at Start new chat view opens own QR code with public key pop-up')
+        self.home_1.my_profile_on_start_new_chat_button.click()
+        account = self.home_1.get_profile_view()
+        if not (account.public_key_text.is_element_displayed() and account.share_button.is_element_displayed()
+                and account.qr_code_image.is_element_displayed()):
+            self.errors.append('No self profile pop-up data displayed after My_profile button tap')
+        self.errors.verify_no_errors()

test/appium/tests/critical/chats/test_group_chat.py

@@ -0,0 +1,206 @@
+import pytest
+from tests import marks
+from tests.base_test_case import MultipleSharedDeviceTestCase, create_shared_drivers
+from views.sign_in_view import SignInView
+from views.chat_view import ChatView
+
+
+@pytest.mark.xdist_group(name="group_chat_3")
+@marks.critical
+class TestGroupChatMultipleDeviceMerged(MultipleSharedDeviceTestCase):
+
+    @classmethod
+    def setup_class(cls):
+        cls.drivers, cls.loop = create_shared_drivers(3)
+        cls.message_before_adding = 'message before adding new user'
+        cls.message_to_admin = 'Hey, admin!'
+
+        cls.homes, cls.public_keys, cls.usernames, cls.chats = {}, {}, {}, {}
+        for key in cls.drivers:
+            sign_in = SignInView(cls.drivers[key])
+            cls.homes[key] = sign_in.create_user(enable_notifications=True)
+            cls.public_keys[key], cls.usernames[key] = sign_in.get_public_key_and_username(True)
+            sign_in.home_button.click()
+        cls.chat_name = cls.homes[0].get_random_chat_name()
+
+        cls.homes[0].just_fyi('Admin adds future members to contacts')
+        for i in range(1, 3):
+            cls.homes[0].add_contact(cls.public_keys[i])
+            cls.homes[0].home_button.double_click()
+
+        cls.homes[0].just_fyi('Member adds admin to contacts to see PNs and put app in background')
+        cls.homes[1].add_contact(cls.public_keys[0])
+        cls.homes[1].home_button.double_click()
+
+        cls.homes[0].just_fyi('Admin creates group chat')
+        cls.chats[0] = cls.homes[0].create_group_chat([cls.usernames[1]], cls.chat_name)
+        for i in range(1, 3):
+            cls.chats[i] = ChatView(cls.drivers[i])
+
+        cls.chats[0].send_message(cls.message_before_adding)
+
+    @marks.testrail_id(3994)
+    def test_group_chat_push_system_messages_when_invited(self):
+        self.homes[1].just_fyi("Check system messages in PNs")
+        self.homes[1].put_app_to_background()
+        self.homes[1].open_notification_bar()
+        pns = [self.chats[0].pn_invited_to_group_chat(self.usernames[0], self.chat_name),
+               self.chats[0].pn_wants_you_to_join_to_group_chat(self.usernames[0], self.chat_name)]
+        for pn in pns:
+            if not self.homes[1].get_pn(pn):
+                self.errors.append('%s is not shown after invite to group chat' % pn)
+        if self.homes[1].get_pn(pns[0]):
+            group_invite_pn = self.homes[1].get_pn(pns[0])
+            group_invite_pn.click()
+        else:
+            self.homes[1].click_system_back_button(2)
+            self.homes[1].get_chat(self.chat_name).click()
+
+        self.homes[1].just_fyi("Check system messages in group chat for admin and member")
+        create_system_message = self.chats[0].create_system_message(self.usernames[0], self.chat_name)
+        invite_system_message = self.chats[0].invite_system_message(self.usernames[0], self.usernames[1])
+
+        invited_to_join = self.chats[0].invited_to_join_system_message(self.usernames[0], self.chat_name)
+        create_for_admin_system_message = self.chats[0].create_for_admin_system_message(self.chat_name)
+        for message in [create_for_admin_system_message, create_system_message, invite_system_message]:
+            if not self.chats[0].chat_element_by_text(message):
+                self.errors.append('%s system message is not shown' % message)
+        for message in [invited_to_join, create_system_message, invite_system_message]:
+            if not self.chats[1].chat_element_by_text(message):
+                self.errors.append('%s system message is not shown' % message)
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(700731)
+    def test_group_chat_join_send_text_messages_push(self):
+        message_to_admin = self.message_to_admin
+        [self.homes[i].home_button.double_click() for i in range(3)]
+        self.homes[1].get_chat(self.chat_name).click()
+
+        self.chats[1].just_fyi('Join to group chat')
+        join_system_message = self.chats[1].join_system_message(self.usernames[1])
+        self.chats[1].join_chat_button.click()
+        if not self.chats[1].chat_element_by_text(join_system_message).is_element_displayed(30):
+            self.drivers[1].fail('System message after joining group chat is not shown')
+        self.chats[1].send_message(message_to_admin)
+
+        self.chats[0].just_fyi('check that PN is received and after tap you are redirected to group chat')
+        self.chats[0].open_notification_bar()
+        pn = self.homes[0].get_pn(message_to_admin)
+        if pn:
+            pn.click()
+        else:
+            self.homes[0].click_system_back_button()
+            self.homes[0].get_chat(self.chat_name).click()
+
+        self.chats[1].just_fyi('Check message status and message delivery')
+        message_status = self.chats[1].chat_element_by_text(message_to_admin).status
+        if message_status != 'delivered':
+            self.errors.append('Message status is not delivered, it is %s!' % message_status)
+        for message in (join_system_message, message_to_admin):
+            if not self.chats[0].chat_element_by_text(message).is_element_displayed(30):
+                self.drivers[0].fail('Message %s was not received by admin' % message)
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(700732)
+    def test_group_chat_add_new_member_activity_centre(self):
+        [self.homes[i].home_button.double_click() for i in range(3)]
+        self.homes[0].get_chat(self.chat_name).click()
+        self.chats[0].add_members_to_group_chat([self.usernames[2]])
+
+        self.chats[2].just_fyi("Check there will be no PN but unread in AC if got invite from non-contact")
+        if not self.homes[2].notifications_unread_badge.is_element_displayed(60):
+            self.drivers[2].fail("Group chat is not appeared in AC!")
+        self.homes[2].open_notification_bar()
+        if self.homes[2].element_by_text_part(self.usernames[0]).is_element_displayed():
+            self.errors.append("PN about group chat invite is shown when invited by non-contact")
+        self.homes[2].click_system_back_button()
+        self.homes[2].get_chat(self.chat_name).click()
+        self.chats[2].join_chat_button.click()
+        for message in (self.message_to_admin, self.message_before_adding):
+            if self.chats[2].chat_element_by_text(message).is_element_displayed():
+                self.errors.append('%s is shown for new user' % message)
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(3998)
+    def test_group_chat_offline_pn(self):
+        [self.homes[i].home_button.double_click() for i in range(3)]
+        chat_name = 'for_offline_pn'
+        self.homes[0].create_group_chat([self.usernames[1], self.usernames[2]], chat_name)
+        self.homes[0].home_button.double_click()
+        for i in range(1, 3):
+            self.homes[i].get_chat(chat_name).click()
+            self.chats[i].join_chat_button.click()
+        message_1, message_2 = 'message from old member', 'message from new member'
+
+        self.homes[0].just_fyi("Put admin device to offline and send messages from members")
+        self.homes[0].toggle_airplane_mode()
+        self.chats[1].send_message(message_1)
+        self.chats[2].send_message(message_2)
+
+        self.homes[0].just_fyi("Put admin device to online and check that messages and PNs will be fetched")
+        self.homes[0].toggle_airplane_mode()
+        self.homes[0].connection_offline_icon.wait_for_invisibility_of_element(60)
+        self.homes[0].open_notification_bar()
+        for message in (message_1, message_2):
+            if not self.homes[0].get_pn(message):
+                self.errors.append('%s PN was not fetched from offline' % message)
+        self.homes[0].click_system_back_button()
+        unread_group = self.homes[0].get_chat(chat_name)
+        if not unread_group.new_messages_counter.text == '2':
+            self.errors.append('%s does not match unread messages' % unread_group.new_messages_counter.text)
+        unread_group.click()
+
+        self.homes[0].just_fyi("check that messages are shown for every member")
+        for i in range(3):
+            for message in (message_1, message_2):
+                if not self.chats[i].chat_element_by_text(message).is_element_displayed():
+                    self.errors.append('%s if not shown for device %s' % (message, str(i)))
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(5756)
+    def test_group_chat_decline_invite_chat_highligted(self):
+        chat_name = 'for_invited'
+        left_system_message = self.chats[0].leave_system_message(self.usernames[1])
+        [self.homes[i].home_button.double_click() for i in range(3)]
+        self.homes[0].create_group_chat([self.usernames[1]], chat_name)
+
+        self.homes[1].just_fyi("Check that new group chat from contact is highlited")
+        chat_2_element = self.homes[1].get_chat(chat_name)
+        if chat_2_element.no_message_preview.is_element_differs_from_template('highligted_preview_group.png', 0):
+            self.errors.append("Preview message is not hightligted or text is not shown! ")
+        chat_2 = self.homes[1].get_chat(chat_name).click()
+        chat_2.home_button.click()
+        if not chat_2_element.no_message_preview.is_element_differs_from_template('highligted_preview_group.png', 0):
+            self.errors.append("Preview message is still hightligted after opening! ")
+        self.homes[1].get_chat(chat_name).click()
+        chat_2.decline_invitation_button.click()
+        if self.chats[0].chat_element_by_text(left_system_message).is_element_displayed():
+            self.errors.append('System message when user declined invite is shown')
+        if self.homes[1].element_by_text(chat_name).is_element_displayed():
+            self.errors.append("Group chat '%s' is shown, but user declined invite" % chat_name)
+
+        self.homes[0].just_fyi('Send message after invite is declined and check that it is not reappeared')
+        message = 'sent after leaving'
+        self.chats[0].send_message(message)
+        if self.homes[1].element_by_text(chat_name).is_element_displayed():
+            self.errors.append("Group chat '%s' reappeared when new message is sent" % chat_name)
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(3997)
+    def test_group_chat_leave_relogin(self):
+        self.drivers[2].quit()
+        [self.homes[i].home_button.double_click() for i in range(2)]
+        self.homes[0].home_button.double_click()
+        self.homes[1].get_chat(self.chat_name).click()
+        join_button = self.chats[1].join_chat_button
+        if join_button.is_element_displayed():
+            join_button.click()
+
+        self.homes[0].just_fyi("Admin deleted chat via long press")
+        self.homes[0].leave_chat_long_press(self.chat_name)
+
+        self.homes[0].just_fyi("Member sends some message, admin relogins and check chat does not reappear")
+        self.chats[1].send_message(self.message_to_admin)
+        self.homes[0].relogin()
+        if self.homes[0].get_chat_from_home_view(self.chat_name).is_element_displayed():
+            self.drivers[0].fail('Deleted %s is present after relaunch app' % self.chat_name)

test/appium/tests/critical/onboarding/test_onboarding_flows.py

@@ -2,10 +2,10 @@ import random
 import pytest
 
 from support.utilities import fill_string_with_char
-from tests import marks, common_password, unique_password
+from tests import marks, common_password
-from tests.base_test_case import SingleDeviceTestCase, MultipleSharedDeviceTestCase, create_shared_drivers
+from tests.base_test_case import MultipleSharedDeviceTestCase, create_shared_drivers
 from views.sign_in_view import SignInView
-from tests.users import basic_user, transaction_senders, recovery_users
+from tests.users import basic_user, transaction_senders
 
 
 @pytest.mark.xdist_group(name="onboarding_1")
@@ -213,8 +213,8 @@ class TestOnboardingOneDeviceMerged(MultipleSharedDeviceTestCase):
         [element.wait_and_click(10) for element in (self.sign_in.maybe_later_button, self.sign_in.lets_go_button)]
         self.home.cross_icon_inside_welcome_screen_button.wait_and_click(10)
         if not self.home.element_by_translation_id("welcome-blank-message").is_element_displayed():
-            self.errors.append("'%s' text is not shown after welcome view was closed" % self.home.get_translation_by_key(
+            self.errors.append("'%s' text is not shown after welcome view was closed" %
-                "welcome-blank-message"))
+                               self.home.get_translation_by_key("welcome-blank-message"))
         self.home.profile_button.click()
         shown_username = self.profile.default_username_text.text
         if shown_username != username:
@@ -302,7 +302,7 @@ class TestRestoreOneDeviceMerged(MultipleSharedDeviceTestCase):
         self.errors.verify_no_errors()
 
     @marks.testrail_id(700750)
-    def test_restore_validation_seed_phrase_field(self):
+    def test_restore_seed_phrase_field_validation(self):
         validations = [
             {
                 'case': 'empty value',
@@ -340,8 +340,7 @@ class TestRestoreOneDeviceMerged(MultipleSharedDeviceTestCase):
             self.errors.append("Possible to create account with empty seed phrase")
         for validation in validations:
             self.sign_in.just_fyi("Checking %s" % validation.get('case'))
-            phrase, msg, words_count, popup = validation.get('phrase'), \
+            phrase, msg, words_count, popup = validation.get('phrase'), validation.get('validation message'), \
-                                              validation.get('validation message'), \
                                               validation.get('words count'), \
                                               validation.get('popup')
             if self.sign_in.access_key_button.is_element_displayed():
@@ -377,8 +376,7 @@ class TestRestoreOneDeviceMerged(MultipleSharedDeviceTestCase):
         self.errors.verify_no_errors()
 
     @marks.testrail_id(702189)
-    @marks.transaction
+    def test_restore_account_migrate_multiaccount_to_keycard_no_db_saved_add_wallet_send_tx(self):
-    def test_restore_account_migrate_multiaccount_to_keycard_no_db_saved_add_wallet_sign_tx(self):
         self.sign_in.driver.close_app()
         self.sign_in.driver.launch_app()
         self.sign_in.sign_in(password=self.password)
@@ -479,24 +477,3 @@ class TestRestoreOneDeviceMerged(MultipleSharedDeviceTestCase):
         wallet.send_transaction(amount=transaction_amount_added, recipient=transaction_senders['ETH_8']['address'],
                                 keycard=True, sign_transaction=True)
         self.errors.verify_no_errors()
-
-
-class TestCreateAccount(SingleDeviceTestCase):
-
-    @marks.testrail_id(5455)
-    @marks.medium
-    def test_recover_accounts_with_certain_seedphrase(self):
-        sign_in = SignInView(self.driver)
-        for phrase, account in recovery_users.items():
-            home_view = sign_in.recover_access(passphrase=phrase, password=unique_password)
-            wallet_view = home_view.wallet_button.click()
-            address = wallet_view.get_wallet_address()
-            if address != account:
-                self.errors.append('Restored wallet address "%s" does not match expected "%s"' % (address, account))
-            profile = home_view.profile_button.click()
-            profile.privacy_and_security_button.click()
-            profile.delete_my_profile_button.scroll_and_click()
-            profile.delete_my_profile_password_input.set_value(unique_password)
-            profile.delete_profile_button.click()
-            profile.ok_button.click()
-        self.errors.verify_no_errors()

test/appium/tests/critical/test_pairing_devices_sync.py

@@ -0,0 +1,253 @@
+import pytest
+from tests import marks
+from tests.base_test_case import MultipleSharedDeviceTestCase, create_shared_drivers
+from tests.users import transaction_senders, basic_user, ens_user, ens_user_ropsten
+from views.sign_in_view import SignInView
+
+
+# TODO: suspended according to #13257
+@pytest.mark.xdist_group(name="pairing_2")
+@marks.critical
+@marks.skip
+class TestPairingMultipleDevicesMerged(MultipleSharedDeviceTestCase):
+
+    @classmethod
+    def setup_class(cls):
+        from views.dbs.main_pairing.data import seed_phrase, password
+        cls.drivers, cls.loop = create_shared_drivers(2)
+        cls.device_1, cls.device_2 = SignInView(cls.drivers[0]), SignInView(cls.drivers[1])
+        cls.home_1 = cls.device_1.import_db(seed_phrase=seed_phrase, import_db_folder_name='main_pairing',
+                                            password=password)
+        cls.home_2 = cls.device_2.recover_access(seed_phrase)
+
+        cls.home_1.just_fyi('Pair main and secondary devices')
+        [cls.profile_1, cls.profile_2] = [home.profile_button.click() for home in (cls.home_1, cls.home_2)]
+        name_1, name_2 = 'device_1', 'a_%s_2' % cls.device_2.get_unique_amount()
+        cls.profile_2.discover_and_advertise_device(name_2)
+        cls.profile_1.sync_settings_button.scroll_and_click()
+        cls.profile_1.devices_button.scroll_to_element()
+        cls.profile_1.devices_button.click()
+        cls.home_1.element_by_text_part(name_2).scroll_and_click()
+        cls.profile_1.sync_all_button.click()
+        cls.profile_1.sync_all_button.wait_for_visibility_of_element(20)
+        [profile.get_back_to_home_view() for profile in [cls.profile_1, cls.profile_2]]
+        [home.home_button.click() for home in [cls.home_1, cls.home_2]]
+
+    def test_pairing_initial_sync_chats(self):
+        self.profile_2.just_fyi("Check chats and previews")
+        from views.dbs.main_pairing.data import chats
+        for chat in chats.keys():
+            if chats[chat]['initial_sync']:
+                if 'preview' in chats.keys():
+                    actual_chat_preview = self.home_2.get_chat(chat).chat_preview.text
+                    expected_chat_preview = chats[chat]['preview']
+                    if actual_chat_preview != expected_chat_preview:
+                        self.errors.append('Expected preview for %s is "%s", in fact "%s" after initial sync' %
+                                           (chat, expected_chat_preview, actual_chat_preview))
+
+        # TODO: blocked due to 13176
+        # self.profile_2.just_fyi("Check unread indicator")
+        # if self.home_2.home_button.counter.text != '2':
+        #     self.errors.append('New messages counter is not shown on Home button')
+        # for chat in chats.keys():
+        #     if 'unread' in chats.keys():
+        #         if self.home_2.get_chat(chat).new_messages_counter.text != chats[chat]['unread']:
+        #             self.errors.append('No unread for %s after initial sync' % chat)
+        self.errors.verify_no_errors()
+
+    @marks.skip
+    # TODO: blocked due to 13176
+    def test_pairing_initial_sync_activity_centre(self):
+        from views.dbs.main_pairing.data import activity_centre
+        if self.home_2.notifications_unread_badge.is_element_displayed():
+            self.home_2.notifications_unread_badge.click()
+            for chat in activity_centre.keys():
+                from views.home_view import ActivityCenterChatElement
+                chat_in_ac = ActivityCenterChatElement(self.driver, chat_name=chat)
+                if not chat_in_ac.is_element_displayed():
+                    self.errors.append('No chat "%s" in activity centre' % chat)
+                else:
+                    if not chat_in_ac.chat_message_preview != activity_centre[chat]:
+                        self.errors.append('No chat preview  for "%s" in activity centre, "%s" instead' %
+                                           chat, chat_in_ac.chat_message_preview)
+        else:
+            self.home_2.driver.fail("No unread messages in Activity centre!")
+        self.errors.verify_no_errors()
+
+    def test_pairing_initial_sync_contacts_blocked_nickname(self):
+        from views.dbs.main_pairing.data import contacts, blocked
+        self.profile_2 = self.home_2.profile_button.click()
+        self.profile_2.contacts_button.click()
+        for contact in contacts:
+            if not self.profile_2.element_by_text(contact).is_element_displayed():
+                self.errors.append("%s contact is not synced after initial sync" % contact)
+        self.profile_2.blocked_users_button.click()
+        for blocked_user in blocked.keys():
+            if not self.profile_2.element_by_text(blocked_user).is_element_displayed():
+                self.errors.append("%s blocked user is not synced after initial sync" % blocked_user)
+        self.profile_2.get_back_to_home_view()
+
+
+@pytest.mark.xdist_group(name="sync_2")
+@marks.critical
+class TestPairingSyncMultipleDevicesMerged(MultipleSharedDeviceTestCase):
+
+    @classmethod
+    def setup_class(cls):
+        cls.drivers, cls.loop = create_shared_drivers(2)
+        cls.no_contact_nickname = 'no_contact_nickname'
+        cls.device_1, cls.device_2 = SignInView(cls.drivers[0]), SignInView(cls.drivers[1])
+        cls.home_1 = cls.device_1.create_user()
+
+        cls.name_1, cls.name_2 = 'device_%s' % cls.drivers[0].number, 'device_%s' % cls.drivers[1].number
+        cls.message_before_sync, cls.message_after_sync = 'sent before sync', 'sent after sync'
+        cls.contact_before_sync = basic_user
+        cls.public_chat_before_sync, cls.public_chat_after_sync = cls.home_1.get_random_chat_name(), 'after-pairing'
+
+        cls.home_1.just_fyi("(main device): get recovery phrase")
+        cls.profile_1 = cls.home_1.profile_button.click()
+        cls.profile_1.privacy_and_security_button.click()
+        cls.profile_1.backup_recovery_phrase_button.click()
+        cls.profile_1.ok_continue_button.click()
+        cls.recovery_phrase = cls.profile_1.get_recovery_phrase()
+        cls.profile_1.close_button.click()
+        cls.profile_1.home_button.click()
+        cls.profile_1.get_recovery_phrase()
+
+        cls.home_1.just_fyi('Add contact, 1-1 chat (main device): 3-random, contact with ENS, start 1-1')
+        cls.chat_1 = cls.home_1.add_contact(cls.contact_before_sync['public_key'])
+        cls.chat_1.send_message(cls.message_before_sync)
+        cls.chat_1.home_button.click()
+        cls.home_1.add_contact(ens_user['ens'])
+        cls.chat_1.home_button.click()
+
+        cls.home_1.just_fyi('Chats, contacts (main device): join public chat, block user, set nickname')
+        public_chat_1 = cls.home_1.join_public_chat(cls.public_chat_before_sync)
+        public_chat_1.home_button.click()
+        cls.home_1.add_contact(transaction_senders['A']['public_key'], add_in_contacts=False,
+                               nickname=cls.no_contact_nickname)
+        cls.chat_1.open_user_profile_from_1_1_chat()
+        cls.chat_1.block_contact()
+
+        cls.device_2.just_fyi("(secondary device): restore same multiaccount on another device")
+        cls.home_2 = cls.device_2.recover_access(passphrase=' '.join(cls.recovery_phrase.values()))
+        cls.profile_1, cls.profile_2 = cls.home_1.profile_button.click(), cls.home_2.profile_button.click()
+
+        cls.device_2.just_fyi('Nicknames (main device): set nickname for contact')
+        cls.profile_1.open_contact_from_profile(cls.contact_before_sync['username'])
+        cls.nickname = 'my_basic_user'
+        cls.chat_1.set_nickname(cls.nickname)
+        cls.device_1.back_button.click()
+
+        cls.device_2.just_fyi('Pair main and secondary devices')
+        cls.profile_2.discover_and_advertise_device(cls.name_2)
+        cls.profile_1.discover_and_advertise_device(cls.name_1)
+        cls.profile_1.get_toggle_device_by_name(cls.name_2).wait_and_click()
+        cls.profile_1.sync_all_button.click()
+        cls.profile_1.sync_all_button.wait_for_visibility_of_element(20)
+        [device.profile_button.double_click() for device in (cls.profile_1, cls.profile_2)]
+
+    @marks.testrail_id(702194)
+    def test_pairing_sync_initial_contacts_blocked_users(self):
+        self.profile_2.contacts_button.scroll_to_element(9, 'up')
+        self.profile_2.contacts_button.click()
+        if not self.profile_2.blocked_users_button.is_element_displayed(30):
+            self.errors.append('Blocked users are not synced after initial sync')
+        for name in (basic_user['username'], self.nickname, '@%s' % ens_user['ens']):
+            if not self.profile_2.element_by_text(name).is_element_displayed():
+                self.errors.append('"%s" is not found in Contacts on initial sync' % name)
+        self.profile_2.blocked_users_button.click()
+        if not self.profile_2.element_by_text(self.no_contact_nickname).is_element_displayed():
+            self.errors.append(
+                "'%s' nickname without adding to contacts is not synced on initial sync" % self.no_contact_nickname)
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702195)
+    def test_pairing_sync_initial_public_chats(self):
+        [device.home_button.double_click() for device in (self.profile_1, self.profile_2)]
+        if not self.home_2.element_by_text_part(self.public_chat_before_sync).is_element_displayed():
+            self.errors.append(
+                "'%s' public chat is not appeared on secondary device on initial sync" % self.public_chat_before_sync)
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702196)
+    def test_pairing_sync_contacts_block_unblock(self):
+        [device.profile_button.double_click() for device in (self.profile_1, self.profile_2)]
+        new_user_for_block = transaction_senders['C']
+
+        self.profile_1.just_fyi("Contacts(main device): block and unblock user")
+        self.profile_1.profile_button.click()
+        self.profile_1.contacts_button.scroll_to_element(direction='up')
+        self.profile_1.contacts_button.click()
+        self.profile_1.blocked_users_button.click()
+        self.profile_1.element_by_text(self.no_contact_nickname).click()
+        self.chat_1.unblock_contact_button.click()
+        self.profile_1.close_button.click()
+        self.home_1.home_button.click()
+        self.home_1.add_contact(new_user_for_block['public_key'], add_in_contacts=False)
+        self.chat_1.open_user_profile_from_1_1_chat()
+        self.chat_1.block_contact()
+
+        self.device_2.just_fyi('Contacts (secondary device): check unblocked and blocked user')
+        self.profile_2.contacts_button.click()
+        self.profile_2.blocked_users_button.click()
+        if self.profile_2.element_by_text(self.no_contact_nickname).is_element_displayed():
+            self.errors.append("'%s' unblocked user is not synced!" % self.no_contact_nickname)
+        if not self.profile_2.element_by_text(new_user_for_block['username']).is_element_displayed():
+            self.errors.append("'%s' blocked user is not synced!" % new_user_for_block['username'])
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702197)
+    def test_pairing_sync_contacts_add_remove_set_nickname_ens(self):
+        [device.home_button.double_click() for device in (self.profile_1, self.profile_2)]
+        new_contact, new_nickname = transaction_senders['F'], "completely_new_nick"
+        self.home_1.add_contact(ens_user_ropsten['ens'])
+        self.home_1.home_button.click()
+        self.home_1.add_contact(new_contact['public_key'])
+
+        self.device_2.just_fyi('Contacts (secondary device):check new contact')
+        self.profile_2.profile_button.double_click()
+        self.profile_2.contacts_button.scroll_to_element(direction='up')
+        self.profile_2.contacts_button.click()
+        for contact in (new_contact['username'], '@%s' % ens_user_ropsten['ens']):
+            if not self.profile_2.element_by_text(contact).is_element_displayed():
+                self.errors.append("'%s' new contact is not synced!" % contact)
+
+        self.device_1.just_fyi('(Main device): set nickname, (secondary device): check nickname')
+        self.chat_1.open_user_profile_from_1_1_chat()
+        self.chat_1.set_nickname(new_nickname)
+        if not self.profile_2.element_by_text(new_nickname).is_element_displayed():
+            self.errors.append("'%s' new nickname is not synced!" % new_nickname)
+
+        self.device_1.just_fyi('(Main device): remove contact, (secondary device): check removed contact')
+        self.chat_1.open_user_profile_from_1_1_chat()
+        self.chat_1.remove_from_contacts.click()
+        self.chat_1.close_button.click()
+        self.profile_2.element_by_text(new_nickname).is_element_disappeared(40)
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702198)
+    def test_pairing_sync_1_1_chat_message(self):
+        [device.home_button.double_click() for device in (self.profile_1, self.profile_2)]
+        self.home_1.get_chat(self.nickname).click()
+        self.chat_1.send_message(self.message_after_sync)
+
+        self.home_2.just_fyi("Chats (secondary device): check messages in 1-1")
+        chat = self.home_2.get_chat(self.nickname).click()
+        if chat.chat_element_by_text(self.message_before_sync).is_element_displayed():
+            self.errors.append('"%s" message sent before pairing is synced' % self.message_before_sync)
+        if not chat.chat_element_by_text(self.message_after_sync).is_element_displayed(60):
+            self.errors.append('"%s" message in 1-1 is not synced' % self.message_after_sync)
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702199)
+    def test_pairing_sync_public_chat_add_remove(self):
+        [device.home_button.double_click() for device in (self.profile_1, self.profile_2)]
+        self.home_1.join_public_chat(self.public_chat_after_sync)
+        if not self.home_2.element_by_text("#%s" % self.public_chat_after_sync).is_element_displayed(10):
+            self.errors.append('Public chat "%s" is not synced' % self.public_chat_after_sync)
+        self.home_1.home_button.click()
+        self.home_1.delete_chat_long_press('#%s' % self.public_chat_after_sync)
+        if not self.home_2.element_by_text('#%s' % self.public_chat_after_sync).is_element_disappeared(60):
+            self.errors.append('Remove of "%s" public chat is not synced!' % self.public_chat_after_sync)
+        self.errors.verify_no_errors()

test/appium/tests/critical/test_public_chat_browsing.py

@@ -0,0 +1,509 @@
+import random
+from datetime import timedelta
+
+import emoji
+import pytest
+from dateutil import parser
+
+from tests import marks, test_dapp_name, test_dapp_url
+from tests.base_test_case import create_shared_drivers, MultipleSharedDeviceTestCase
+from views.sign_in_view import SignInView
+from selenium.common.exceptions import NoSuchElementException
+
+
+@pytest.mark.xdist_group(name="public_chat_2")
+@marks.critical
+class TestPublicChatMultipleDeviceMerged(MultipleSharedDeviceTestCase):
+
+    @classmethod
+    def setup_class(cls):
+        cls.drivers, cls.loop = create_shared_drivers(2)
+        device_1, device_2 = SignInView(cls.drivers[0]), SignInView(cls.drivers[1])
+        cls.home_1, cls.home_2 = device_1.create_user(), device_2.create_user()
+        profile_1 = cls.home_1.profile_button.click()
+        cls.username_1 = profile_1.default_username_text.text
+        profile_1.home_button.click()
+        cls.pub_chat_delete_long_press = 'pub-chat'
+        cls.text_message = 'hello'
+        cls.home_1.join_public_chat(cls.pub_chat_delete_long_press)
+        [home.home_button.click() for home in (cls.home_1, cls.home_2)]
+        cls.public_chat_name = cls.home_1.get_random_chat_name()
+        cls.chat_1 = cls.home_1.join_public_chat(cls.public_chat_name)
+        cls.chat_2 = cls.home_2.join_public_chat(cls.public_chat_name)
+        cls.chat_1.send_message(cls.text_message)
+
+    @marks.testrail_id(5313)
+    def test_public_chat_message_send_check_timestamps_while_on_different_tab(self):
+        message = self.text_message
+        self.chat_2.dapp_tab_button.click()
+        sent_time_variants = self.chat_1.convert_device_time_to_chat_timestamp()
+        timestamp = self.chat_1.chat_element_by_text(message).timestamp_on_tap
+        if timestamp not in sent_time_variants:
+            self.errors.append("Timestamp is not shown, expected: '%s', in fact: '%s'" %
+                               (sent_time_variants.join(','), timestamp))
+        self.chat_2.home_button.click(desired_view='chat')
+        for chat in self.chat_1, self.chat_2:
+            chat.verify_message_is_under_today_text(message, self.errors)
+        if self.chat_2.chat_element_by_text(message).username.text != self.username_1:
+            self.errors.append("Default username '%s' is not shown next to the received message" % self.username_1)
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(700734)
+    def test_public_chat_message_edit(self):
+        message_before_edit, message_after_edit = self.text_message, "Message AFTER edit 2"
+        self.chat_1.edit_message_in_chat(message_before_edit, message_after_edit)
+        for chat in (self.chat_1, self.chat_2):
+            if not chat.element_by_text_part("⌫ Edited").is_element_displayed(60):
+                self.errors.append('No mark in message bubble about this message was edited')
+        if not self.chat_2.element_by_text_part(message_after_edit).is_element_displayed(60):
+            self.errors.append('Message is not edited')
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(700735)
+    def test_public_chat_message_delete(self):
+        message_to_delete = 'delete me, please'
+        self.chat_1.send_message(message_to_delete)
+        self.chat_1.delete_message_in_chat(message_to_delete)
+        for chat in (self.chat_1, self.chat_2):
+            if not chat.chat_element_by_text(message_to_delete).is_element_disappeared(30):
+                self.errors.append("Deleted message is shown in chat view for public chat")
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(700719)
+    def test_public_chat_emoji_send_copy_paste_reply(self):
+        emoji_name = random.choice(list(emoji.EMOJI_UNICODE))
+        emoji_unicode = emoji.EMOJI_UNICODE[emoji_name]
+        emoji_message = emoji.emojize(emoji_name)
+        self.chat_1.send_message(emoji_message)
+        for chat in self.chat_1, self.chat_2:
+            if not chat.chat_element_by_text(emoji_unicode).is_element_displayed(30):
+                self.errors.append('Message with emoji was not sent or received in public chat')
+
+        self.chat_1.just_fyi("Can copy and paste emojis")
+        self.chat_1.element_by_text_part(emoji_unicode).long_press_element()
+        self.chat_1.element_by_text('Copy').click()
+        self.chat_1.chat_message_input.paste_text_from_clipboard()
+        if self.chat_1.chat_message_input.text != emoji_unicode:
+            self.errors.append('Emoji message was not copied')
+
+        self.chat_1.just_fyi("Can reply to emojis")
+        self.chat_2.quote_message(emoji_unicode)
+        message_text = 'test message'
+        self.chat_2.chat_message_input.send_keys(message_text)
+        self.chat_2.send_message_button.click()
+        chat_element_1 = self.chat_1.chat_element_by_text(message_text)
+        if not chat_element_1.is_element_displayed(sec=10) or chat_element_1.replied_message_text != emoji_unicode:
+            self.errors.append('Reply message was not received by the sender')
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(5360)
+    def test_public_chat_unread_messages_counter(self):
+        self.chat_1.send_message('пиу')
+        home_1 = self.chat_1.home_button.click()
+        message = 'test message'
+        self.chat_2.send_message(message)
+        if not self.chat_1.home_button.public_unread_messages.is_element_displayed():
+            self.errors.append('New messages public chat badge is not shown on Home button')
+        chat_element = home_1.get_chat('#' + self.public_chat_name)
+        if not chat_element.new_messages_public_chat.is_element_displayed():
+            self.errors.append('New messages counter is not shown in public chat')
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(700718)
+    def test_public_chat_unread_messages_counter_for_mention_relogin(self):
+        message = 'test message2'
+        [chat.get_back_to_home_view() for chat in (self.chat_1, self.chat_2)]
+        chat_element = self.home_1.get_chat('#' + self.public_chat_name)
+        self.home_2.get_chat('#' + self.public_chat_name).click()
+        self.chat_2.select_mention_from_suggestion_list(self.username_1, self.username_1[:2])
+        self.chat_2.send_message_button.click()
+        chat_element.new_messages_counter.wait_for_element(30)
+        chat_element.new_messages_counter.wait_for_element_text("1", 60)
+        chat_element.click()
+        self.home_1.home_button.double_click()
+        if self.home_1.home_button.public_unread_messages.is_element_displayed():
+            self.errors.append('New messages public chat badge is shown on Home button')
+        if chat_element.new_messages_public_chat.is_element_displayed():
+            self.errors.append('Unread messages badge is shown in public chat while there are no unread messages')
+        [home.get_chat('#' + self.public_chat_name).click() for home in (self.home_1, self.home_2)]
+        self.chat_1.send_message(message)
+        self.chat_2.chat_element_by_text(message).wait_for_element(20)
+        self.home_2.reopen_app()
+        chat_element = self.home_2.get_chat('#' + self.public_chat_name)
+        if chat_element.new_messages_public_chat.is_element_displayed():
+            self.drivers[0].fail('New messages counter is shown after relogin')
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(5319)
+    def test_public_chat_delete_chat_long_press(self):
+        [chat.get_back_to_home_view() for chat in (self.chat_1, self.chat_2)]
+        self.home_1.delete_chat_long_press('#%s' % self.pub_chat_delete_long_press)
+        self.home_2.just_fyi("Send message to deleted chat")
+        self.deleted_chat_2 = self.home_2.join_public_chat(self.pub_chat_delete_long_press)
+        self.deleted_chat_2.send_message()
+        if self.home_1.get_chat_from_home_view('#%s' % self.pub_chat_delete_long_press).is_element_displayed():
+            self.drivers[0].fail('Deleted public chat reappears after sending message to it')
+        self.home_1.reopen_app()
+        if self.home_1.get_chat_from_home_view('#%s' % self.pub_chat_delete_long_press).is_element_displayed():
+            self.drivers[0].fail('Deleted public chat reappears after relogin')
+
+    @marks.testrail_id(700736)
+    def test_public_chat_link_send_open(self):
+        [chat.get_back_to_home_view() for chat in (self.chat_1, self.chat_2)]
+        [home.get_chat('#' + self.public_chat_name).click() for home in (self.home_1, self.home_2)]
+        url_message = 'http://status.im'
+        self.chat_2.send_message(url_message)
+        self.chat_1.element_starts_with_text(url_message, 'button').click()
+        web_view = self.chat_1.open_in_status_button.click()
+        if not web_view.element_by_text('Private, Secure Communication').is_element_displayed(60):
+            self.drivers[0].fail('URL was not opened from public chat')
+
+    @marks.testrail_id(700737)
+    def test_public_chat_links_with_previews_github_youtube_twitter_gif_send_enable(self):
+        [chat.home_button.double_click() for chat in (self.chat_1, self.chat_2)]
+        [home.get_chat('#' + self.public_chat_name).click() for home in (self.home_1, self.home_2)]
+        giphy_url = 'https://giphy.com/gifs/this-is-fine-QMHoU66sBXqqLqYvGO'
+        preview_urls = {'github_pr': {'url': 'https://github.com/status-im/status-react/pull/11707',
+                                      'txt': 'Update translations by jinhojang6 · Pull Request #11707 · status-im/status-react',
+                                      'subtitle': 'GitHub'},
+                        'yotube': {
+                            'url': 'https://www.youtube.com/watch?v=XN-SVmuJH2g&list=PLbrz7IuP1hrgNtYe9g6YHwHO6F3OqNMao',
+                            'txt': 'Status & Keycard – Hardware-Enforced Security',
+                            'subtitle': 'YouTube'},
+                        'twitter': {
+                            'url': 'https://twitter.com/ethdotorg/status/1445161651771162627?s=20',
+                            'txt': "We've rethought how we translate content, allowing us to translate",
+                            'subtitle': 'Twitter'
+                        }}
+
+        self.home_1.just_fyi("Check enabling and sending first gif")
+        self.chat_2.send_message(giphy_url)
+        self.chat_2.element_by_translation_id("dont-ask").click()
+        self.chat_1.element_by_translation_id("enable").wait_and_click()
+        self.chat_1.element_by_translation_id("enable-all").wait_and_click()
+        self.chat_1.close_modal_view_from_chat_button.click()
+        if not self.chat_1.get_preview_message_by_text(giphy_url).preview_image:
+            self.errors.append("No preview is shown for %s" % giphy_url)
+        for key in preview_urls:
+            self.home_2.just_fyi("Checking %s preview case" % key)
+            data = preview_urls[key]
+            self.chat_2.send_message(data['url'])
+            message = self.chat_1.get_preview_message_by_text(data['url'])
+            if data['txt'] not in message.preview_title.text:
+                self.errors.append("Title '%s' does not match expected" % message.preview_title.text)
+            if message.preview_subtitle.text != data['subtitle']:
+                self.errors.append("Subtitle '%s' does not match expected" % message.preview_subtitle.text)
+
+        self.home_2.just_fyi("Check if after do not ask again previews are not shown and no enable button appear")
+        if self.chat_2.element_by_translation_id("enable").is_element_displayed():
+            self.errors.append("Enable button is still shown after clicking on 'Den't ask again'")
+        if self.chat_2.get_preview_message_by_text(giphy_url).preview_image:
+            self.errors.append("Preview is shown for sender without permission")
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(6270)
+    def test_public_chat_mark_all_messages_as_read(self):
+        [chat.get_back_to_home_view() for chat in (self.chat_1, self.chat_2)]
+        self.home_2.get_chat('#' + self.public_chat_name).click()
+        self.chat_2.send_message(self.text_message)
+        if not self.home_1.home_button.public_unread_messages.is_element_displayed():
+            self.errors.append('New messages public chat badge is not shown on Home button')
+        chat_element = self.home_1.get_chat('#' + self.public_chat_name)
+        if not chat_element.new_messages_public_chat.is_element_displayed():
+            self.errors.append('New messages counter is not shown in public chat')
+        chat_element.long_press_element()
+        self.home_1.mark_all_messages_as_read_button.click()
+        self.home_1.home_button.double_click()
+        if self.home_1.home_button.public_unread_messages.is_element_displayed():
+            self.errors.append('New messages public chat badge is shown on Home button after marking messages as read')
+        if chat_element.new_messages_public_chat.is_element_displayed():
+            self.errors.append('Unread messages badge is shown in public chat while while there are no unread messages')
+
+        self.errors.verify_no_errors()
+
+
+@pytest.mark.xdist_group(name="public_chat_browser_1")
+@marks.critical
+class TestPublicChatBrowserOneDeviceMerged(MultipleSharedDeviceTestCase):
+
+    @classmethod
+    def setup_class(cls):
+        cls.drivers, cls.loop = create_shared_drivers(1)
+        cls.sign_in = SignInView(cls.drivers[0])
+
+        cls.home = cls.sign_in.create_user()
+        cls.public_chat_name = cls.home.get_random_chat_name()
+        cls.chat = cls.home.join_public_chat(cls.public_chat_name)
+
+    @marks.testrail_id(5675)
+    def test_public_chat_fetch_more_history(self):
+        self.home.just_fyi("Check that can fetch previous history for several days")
+        device_time = parser.parse(self.drivers[0].device_time)
+        yesterday = (device_time - timedelta(days=1)).strftime("%b %-d, %Y")
+        before_yesterday = (device_time - timedelta(days=2)).strftime("%b %-d, %Y")
+        quiet_time_yesterday, quiet_time_before_yesterday = '24 hours', '2 days'
+        fetch_more = self.home.get_translation_by_key("load-more-messages")
+        for message in (yesterday, quiet_time_yesterday):
+            if not self.chat.element_by_text_part(message).is_element_displayed(120):
+                self.drivers[0].fail('"%s" is not shown' % message)
+        self.chat.element_by_text_part(fetch_more).wait_and_click(120)
+        self.chat.element_by_text_part(fetch_more).wait_for_visibility_of_element(180)
+        for message in (before_yesterday, quiet_time_before_yesterday):
+            if not self.chat.element_by_text_part(message).is_element_displayed():
+                self.drivers[0].fail('"%s" is not shown' % message)
+        self.home.just_fyi("Check that can fetch previous history for month")
+        times = {
+            "three-days": '5 days',
+            "one-week": '12 days',
+            "one-month": ['43 days', '42 days', '41 days', '40 days'],
+        }
+        profile = self.home.profile_button.click()
+        profile.sync_settings_button.click()
+        profile.sync_history_for_button.click()
+        for period in times:
+            profile.just_fyi("Checking %s period" % period)
+            profile.element_by_translation_id(period).click()
+            profile.home_button.click(desired_view='chat')
+            self.chat.element_by_text_part(fetch_more).wait_and_click(120)
+            if period != "one-month":
+                if not profile.element_by_text_part(times[period]).is_element_displayed(30):
+                    self.errors.append("'Quiet here for %s' is not shown after fetching more history" % times[period])
+            else:
+                variants = times[period]
+                self.chat.element_by_text_part(fetch_more).wait_for_invisibility_of_element(120)
+                res = any(profile.element_by_text_part(variant).is_element_displayed(30) for variant in variants)
+                if not res:
+                    self.errors.append("History is not fetched for one month!")
+            self.home.profile_button.click(desired_element_text=profile.get_translation_by_key("default-sync-period"))
+            self.errors.verify_no_errors()
+
+    @marks.testrail_id(5396)
+    def test_public_chat_navigate_to_chat_when_relaunch(self):
+        text_message = 'some_text'
+        self.home.home_button.double_click()
+        self.home.get_chat('#%s' % self.public_chat_name).click()
+        self.chat.send_message(text_message)
+        self.chat.reopen_app()
+        if not self.chat.chat_element_by_text(text_message).is_element_displayed(30):
+            self.drivers[0].fail("Not navigated to chat view after reopening app")
+
+    @marks.testrail_id(5317)
+    def test_public_chat_copy_and_paste_message_in_chat_input(self):
+        message_text = {'text_message': 'mmmeowesage_text'}
+        formatted_message = {'message_with_link': 'https://status.im',
+                             # TODO: blocked with 11161 (rechecked 23.11.21, valid)
+                             # 'message_with_tag': '#successishere'
+                             }
+        message_input = self.chat.chat_message_input
+        if not message_input.is_element_displayed():
+            self.home.get_chat('#%s' % self.public_chat_name).click()
+        message_input.send_keys(message_text['text_message'])
+        self.chat.send_message_button.click()
+
+        self.chat.copy_message_text(message_text['text_message'])
+
+        message_input.paste_text_from_clipboard()
+        if message_input.text != message_text['text_message']:
+            self.errors.append('Message %s text was not copied in a public chat' % message_text['text_message'])
+        message_input.clear()
+
+        for message in formatted_message:
+            message_input.send_keys(formatted_message[message])
+            self.chat.send_message_button.click()
+
+            message_bubble = self.chat.chat_element_by_text(formatted_message[message])
+            message_bubble.sent_status_checkmark.long_press_element()
+            self.chat.element_by_text('Copy').click()
+
+            message_input.paste_text_from_clipboard()
+            if message_input.text != formatted_message[message]:
+                self.errors.append('Message %s text was not copied in a public chat' % formatted_message[message])
+            message_input.clear()
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(700738)
+    def test_public_chat_tag_message(self):
+        tag_message = '#wuuut'
+        self.home.home_button.double_click()
+        self.home.get_chat('#%s' % self.public_chat_name).click()
+        self.home.just_fyi("Check that will be redirected to chat view on tap on tag message")
+        self.chat.send_message(tag_message)
+        self.chat.element_starts_with_text(tag_message).click()
+        self.chat.element_by_text_part(self.public_chat_name).wait_for_invisibility_of_element()
+        if not self.chat.user_name_text.text == tag_message:
+            self.errors.append('Could not redirect a user to a public chat tapping the tag message.')
+        self.home.just_fyi("Check that chat is added to home view")
+        self.chat.home_button.double_click()
+        if not self.home.element_by_text(tag_message).is_element_displayed():
+            self.errors.append('Could not find the public chat in user chat list.')
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(700739)
+    def test_public_chat_open_using_deep_link(self):
+        self.drivers[0].close_app()
+        chat_name = self.home.get_random_chat_name()
+        deep_link = 'status-im://%s' % chat_name
+        self.sign_in.open_weblink_and_login(deep_link)
+        try:
+            assert self.chat.user_name_text.text == '#' + chat_name
+        except (AssertionError, NoSuchElementException):
+            self.drivers[0].fail("Public chat '%s' is not opened" % chat_name)
+
+    @marks.testrail_id(702072)
+    def test_browser_blocked_url(self):
+        dapp = self.home.dapp_tab_button.click()
+        for url in ('metamask.site', 'cryptokitties.domainname'):
+            dapp.just_fyi('Checking blocked website %s' % url)
+            dapp_detail = dapp.open_url(url)
+            dapp_detail.element_by_translation_id('browsing-site-blocked-title')
+            if dapp_detail.browser_refresh_page_button.is_element_displayed():
+                self.errors.append("Refresh button is present in blocked site")
+            dapp_detail.go_back_button.click()
+            dapp_detail.open_tabs_button.click()
+            dapp.element_by_text_part(url[:8]).click()
+            dapp_detail.continue_anyway_button.click()
+            if dapp_detail.element_by_text('This site is blocked').is_element_displayed():
+                self.errors.append("Failed to open Dapp after 'Continue anyway' tapped for %s" % url)
+            dapp_detail.open_tabs_button.click()
+            dapp_detail.empty_tab_button.click()
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702073)
+    def test_browser_connection_is_secure_not_secure_warning(self):
+        dapp = self.home.dapp_tab_button.click()
+        web_page = dapp.open_url('http://www.dvwa.co.uk')
+        web_page.url_edit_box_lock_icon.click_until_presence_of_element(
+            web_page.element_by_translation_id("browser-not-secure"))
+        web_page.open_tabs_button.click()
+        web_page.empty_tab_button.click()
+        dapp.just_fyi('Checking connection is secure for Airswap')
+        web_page = dapp.open_url('https://instant.airswap.io')
+        web_page.wait_for_d_aap_to_load()
+        web_page.url_edit_box_lock_icon.click_until_presence_of_element(
+            web_page.element_by_translation_id("browser-secure"))
+        web_page.open_tabs_button.click()
+        web_page.empty_tab_button.click()
+
+    @marks.testrail_id(702074)
+    def test_browser_invalid_url(self):
+        dapp = self.home.dapp_tab_button.click()
+        browsing_view = dapp.open_url('invalid.takoe')
+        browsing_view.element_by_translation_id("web-view-error").wait_for_element(20)
+
+    @marks.testrail_id(702075)
+    def test_browser_offline(self):
+        dapp = self.home.dapp_tab_button.click()
+        self.home.toggle_airplane_mode()
+        browsing_view = dapp.open_url('status.im')
+        offline_texts = ['Unable to load page', 'ERR_INTERNET_DISCONNECTED']
+        for text in offline_texts:
+            browsing_view.element_by_text_part(text).wait_for_element(15)
+        self.home.toggle_airplane_mode()
+        browsing_view.browser_refresh_page_button.click_until_presence_of_element(
+            browsing_view.element_by_text_part('An Open Source Community'))
+
+    @marks.testrail_id(702076)
+    def test_browser_delete_close_tabs(self):
+        dapp = self.home.dapp_tab_button.click()
+        urls = {
+            'google.com': 'Google',
+            'status.im': 'Status - Private',
+            'bbc.com': 'bbc.com'
+        }
+        for url in urls:
+            web_page = dapp.open_url(url)
+            web_page.open_tabs_button.click()
+            web_page.empty_tab_button.click()
+
+        self.home.just_fyi('Delete one tab')
+        web_page.remove_tab(name=urls['bbc.com'])
+        if web_page.element_by_text_part(urls['bbc.com']).is_element_displayed():
+            self.errors.append('Closed tab is present after deletion')
+
+        self.home.just_fyi('Close all tabs via "Close all", relogin and check that it is not reappearing')
+        web_page.close_all_button.click()
+        self.home.reopen_app()
+        web_page.dapp_tab_button.click()
+        web_page.open_tabs_button.click()
+        if web_page.element_by_text_part(urls['status.im']).is_element_displayed():
+            self.errors.append('Tabs are not closed or reappeared after re-login!')
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702077)
+    def test_browser_bookmarks_create_edit_remove(self):
+        dapp = self.home.dapp_tab_button.click()
+
+        self.home.just_fyi('Add some url to bookmarks with default name')
+        web_page = dapp.open_url('status.im')
+        default_bookmark_name = web_page.add_to_bookmarks()
+        web_page.browser_previous_page_button.click()
+        if not web_page.element_by_text(default_bookmark_name).is_element_displayed():
+            self.errors.append("Bookmark with default name is not added!")
+
+        self.home.just_fyi('Add some url to bookmarks with custom name')
+        custom_name = 'Custom BBC'
+        dapp.open_url('bbc.com')
+        web_page.add_to_bookmarks(custom_name)
+        web_page.open_tabs_button.click()
+        web_page.empty_tab_button.click()
+        if not web_page.element_by_text(custom_name).is_element_displayed():
+            self.driver.fail("Bookmark with custom name is not added!")
+
+        self.home.just_fyi('Checking "Open in new tab"')
+        dapp.browser_entry_long_press(custom_name)
+        dapp.open_in_new_tab_button.click()
+        web_page.options_button.click()
+        if not web_page.element_by_translation_id('remove-favourite').is_element_displayed():
+            self.errors.append("Remove favourite is not shown on added bookmark!")
+        dapp.click_system_back_button()
+
+        self.home.just_fyi('Check deleting bookmark')
+        web_page.open_tabs_button.click()
+        web_page.empty_tab_button.click()
+        dapp.browser_entry_long_press(custom_name)
+        dapp.delete_bookmark_button.click()
+        if web_page.element_by_text(custom_name).is_element_displayed():
+            self.errors.append("Bookmark with custom name is not deleted!")
+
+        self.home.just_fyi('Check "Edit bookmark" and "Open in new tab"')
+        edited_name = 'My Fav Status'
+        dapp.browser_entry_long_press(default_bookmark_name)
+        dapp.edit_bookmark_button.click()
+        web_page.edit_bookmark_name(edited_name)
+        if not web_page.element_by_text(edited_name).is_element_displayed():
+            self.driver.fail("Edited bookmark name is not shown!")
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702078)
+    def test_browser_web3_permissions_testdapp(self):
+        self.home.home_button.double_click()
+
+        self.home.just_fyi('open Status Test Dapp, allow all and check permissions in Profile')
+        web_view = self.home.open_status_test_dapp()
+        dapp = self.home.dapp_tab_button.click()
+        profile = self.home.profile_button.click()
+        profile.privacy_and_security_button.click()
+        profile.dapp_permissions_button.click()
+        profile.element_by_text(test_dapp_name).click()
+        if not profile.element_by_text(self.home.status_account_name).is_element_displayed():
+            self.errors.append('Wallet permission was not granted')
+        if not profile.element_by_translation_id("chat-key").is_element_displayed():
+            self.errors.append('Contact code permission was not granted')
+
+        profile.just_fyi('revoke access and check that they are asked second time')
+        profile.revoke_access_button.click()
+        profile.back_button.click()
+        profile.dapp_tab_button.click()
+        web_view.open_tabs_button.click()
+        web_view.empty_tab_button.click()
+        dapp.open_url(test_dapp_url)
+        if not dapp.element_by_text_part(self.home.status_account_name).is_element_displayed():
+            self.errors.append('Wallet permission is not asked')
+        if dapp.allow_button.is_element_displayed():
+            dapp.allow_button.click(times_to_click=1)
+        if not dapp.element_by_translation_id("your-contact-code").is_element_displayed():
+            self.errors.append('Profile permission is not asked')
+        self.errors.verify_no_errors()

test/appium/tests/critical/wallet_and_tx/test_send_tx_dapp_keycard.py

@@ -0,0 +1,478 @@
+import random
+
+import pytest
+from support.utilities import get_merged_txs_list
+
+from tests import marks, common_password, pin, puk, pair_code
+from tests.base_test_case import MultipleSharedDeviceTestCase, create_shared_drivers
+from tests.users import transaction_senders, basic_user, wallet_users, ens_user_ropsten, ens_user
+from views.sign_in_view import SignInView
+
+
+@pytest.mark.xdist_group(name="send_tx_1")
+@marks.critical
+class TestSendTxDeviceMerged(MultipleSharedDeviceTestCase):
+    @classmethod
+    def setup_class(cls):
+        cls.user = transaction_senders['ETH_ADI_STT_3']
+        cls.recipient_address = '0x%s' % transaction_senders['ETH_7']['address']
+        cls.drivers, cls.loop = create_shared_drivers(1)
+        [cls.amount_adi, cls.amount_eth, cls.amount_stt] = ['0.000%s' % str(random.randint(100, 999)) + '1' for _ in range(3)]
+        cls.sign_in = SignInView(cls.drivers[0])
+        cls.home = cls.sign_in.recover_access(cls.user['passphrase'])
+        cls.wallet = cls.home.wallet_button.click()
+        cls.assets = ('ETH', 'ADI', 'STT')
+        [cls.wallet.wait_balance_is_changed(asset) for asset in cls.assets]
+        cls.initial_balances = dict()
+        for asset in cls.assets:
+            cls.initial_balances[asset] = cls.wallet.get_asset_amount_by_name(asset)
+        cls.wallet.send_transaction(amount=cls.amount_eth, recipient=cls.recipient_address)
+        cls.wallet.send_transaction(amount=cls.amount_adi, recipient=cls.recipient_address, asset_name='ADI')
+
+    @marks.testrail_id(700763)
+    def test_send_tx_eth_check_logcat(self):
+        self.wallet.just_fyi('Check that transaction is appeared in tx history')
+        self.wallet.find_transaction_in_history(amount=self.amount_eth)
+        self.wallet.wallet_button.double_click()
+        self.network_api.wait_for_confirmation_of_transaction(self.user['address'], self.amount_eth)
+        self.wallet.wait_balance_is_changed('ETH', initial_balance=self.initial_balances['ETH'])
+
+        self.wallet.just_fyi('Check logcat for sensitive data')
+        values_in_logcat = self.wallet.find_values_in_logcat(password=common_password)
+        if values_in_logcat:
+            self.wallet.driver.fail(values_in_logcat)
+
+    @marks.testrail_id(700764)
+    def test_send_tx_token_7_decimals(self):
+        asset = 'ADI'
+        self.wallet.just_fyi("Checking tx with 7 decimals")
+        transaction_adi = self.wallet.find_transaction_in_history(amount=self.amount_adi, asset=asset, return_hash=True)
+        self.wallet.wallet_button.double_click()
+        self.network_api.find_transaction_by_hash(transaction_adi)
+        self.wallet.wait_balance_is_changed(asset, initial_balance=self.initial_balances[asset])
+
+    @marks.testrail_id(5342)
+    def test_send_tx_sign_message_2tx_in_batch_tx_filters_request_stt_testdapp(self):
+        self.wallet.home_button.click()
+        status_test_dapp = self.home.open_status_test_dapp()
+        status_test_dapp.wait_for_d_aap_to_load()
+
+        self.wallet.just_fyi("Checking request STT")
+        status_test_dapp.assets_button.click()
+        status_test_dapp.request_stt_button.wait_for_element(60)
+        send_transaction = status_test_dapp.request_stt_button.click()
+        send_transaction.sign_transaction()
+
+        self.wallet.just_fyi("Checking signing message")
+        status_test_dapp.transactions_button.click()
+        send_transaction = status_test_dapp.sign_message_button.click()
+        send_transaction.enter_password_input.set_value(common_password)
+        send_transaction.sign_button.click()
+        if not status_test_dapp.element_by_text_part('Signed message').is_element_displayed():
+            self.errors.append('Message was not signed')
+
+        send_transaction.just_fyi('Check logcat for sensitive data')
+        values_in_logcat = send_transaction.find_values_in_logcat(password=common_password)
+        if values_in_logcat:
+            self.errors.append("When signing message from dapp: %s" % values_in_logcat)
+
+        self.wallet.just_fyi("Checking send 2 txs in batch")
+        status_test_dapp.send_two_tx_in_batch_button.scroll_to_element()
+        send_transaction = status_test_dapp.send_two_tx_in_batch_button.click()
+        send_transaction.sign_transaction()
+        if not send_transaction.sign_with_password.is_element_displayed(10):
+            self.errors.append('Second send transaction screen did not appear!')
+        send_transaction.sign_transaction()
+
+        self.wallet.just_fyi("Checking send 2 txs one after another")
+        status_test_dapp.send_two_tx_one_by_one_button.scroll_to_element()
+        send_transaction = status_test_dapp.send_two_tx_one_by_one_button.click()
+        send_transaction.sign_transaction()
+        if not send_transaction.sign_with_password.is_element_displayed(20):
+            self.errors.append('Second send transaction screen did not appear!')
+        send_transaction.sign_transaction()
+
+        self.wallet.just_fyi("Checking test filters")
+        status_test_dapp.test_filters_button.scroll_and_click()
+        for element in status_test_dapp.element_by_text('eth_uninstallFilter'), status_test_dapp.ok_button:
+            if element.is_element_displayed(10):
+                self.errors.append("'Test filters' button produced an error")
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(700765)
+    def test_send_tx_custom_token_18_decimals_invalid_password(self):
+        contract_address, name, symbol, decimals = '0x101848D5C5bBca18E6b4431eEdF6B95E9ADF82FA', 'Weenus 💪', 'WEENUS', '18'
+        self.home.wallet_button.double_click()
+
+        self.wallet.just_fyi("Check that can add custom token")
+        self.wallet.multiaccount_more_options.click()
+        self.wallet.manage_assets_button.click()
+        token_view = self.wallet.add_custom_token_button.click()
+        token_view.contract_address_input.send_keys(contract_address)
+        if token_view.name_input.text != name:
+            self.errors.append('Name for custom token was not set')
+        if token_view.symbol_input.text != symbol:
+            self.errors.append('Symbol for custom token was not set')
+        if token_view.decimals_input.text != decimals:
+            self.errors.append('Decimals for custom token was not set')
+        token_view.add_button.click()
+        token_view.close_button.click()
+        self.wallet.asset_by_name(symbol).scroll_to_element()
+        if not self.wallet.asset_by_name(symbol).is_element_displayed():
+            self.errors.append('Custom token is not shown on Wallet view')
+        send_tx = self.wallet.send_transaction_from_main_screen.click()
+        send_tx.select_asset_button.click()
+        asset_button = send_tx.asset_by_name(symbol)
+        send_tx.select_asset_button.click_until_presence_of_element(
+            send_tx.eth_asset_in_select_asset_bottom_sheet_button)
+        asset_button.click()
+        send_tx.amount_edit_box.click()
+        send_tx.amount_edit_box.set_value(self.amount_eth)
+        send_tx.set_recipient_address(self.recipient_address)
+        send_tx.sign_transaction_button.click()
+        if self.wallet.sign_in_phrase.is_element_displayed():
+            self.wallet.set_up_wallet_when_sending_tx()
+
+        send_tx.just_fyi('Check that can not sign tx with invalid password')
+        self.wallet.next_button.click_if_shown()
+        self.wallet.ok_got_it_button.click_if_shown()
+        send_tx.sign_with_password.click_until_presence_of_element(send_tx.enter_password_input)
+        send_tx.enter_password_input.click()
+        send_tx.enter_password_input.send_keys('wrong_password')
+        send_tx.sign_button.click()
+        if send_tx.element_by_text_part('Transaction sent').is_element_displayed():
+            self.errors.append('Transaction was sent with a wrong password')
+
+        self.wallet.just_fyi("Check that can send tx with custom token")
+        send_tx.enter_password_input.click()
+        send_tx.enter_password_input.clear()
+        send_tx.enter_password_input.send_keys(common_password)
+        send_tx.sign_button.click_until_absense_of_element(send_tx.sign_button)
+        send_tx.ok_button.wait_for_element(120)
+        if not self.wallet.element_by_translation_id("transaction-sent").is_element_displayed():
+            self.errors.append("Tx is not sent!")
+        send_tx.ok_button.click()
+
+        # TODO: disabled due to 10838 (rechecked 23.11.21, valid)
+        # transactions_view = wallet.transaction_history_button.click()
+        # transactions_view.transactions_table.find_transaction(amount=amount, asset=symbol)
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(700757)
+    def test_send_tx_set_recipient_options(self):
+        nickname = 'my_some_nickname'
+        account_name = 'my_acc_name'
+        account_address = '0x8c2E3Cd844848E79cFd4671cE45C12F210b630d7'
+        recent_add_to_fav_name = 'my_Recent_STT'
+        recent_add_to_fav_address = '0x58d8c3d70ce4fa4b9fb10a665c8712238746f2ff'
+        ens_status, ens_other = ens_user_ropsten, ens_user
+
+        basic_add_to_fav_name = 'my_basic_address'
+        self.drivers[0].reset()
+        self.home = self.sign_in.recover_access(wallet_users['D']['passphrase'])
+
+        self.home.just_fyi('Add new account and new ENS contact for recipient')
+        chat = self.home.add_contact(ens_status['ens'])
+        chat.chat_options.click()
+        chat.view_profile_button.click_until_presence_of_element(chat.remove_from_contacts)
+        chat.set_nickname(nickname)
+        wallet = self.home.wallet_button.click()
+        wallet.add_account(account_name=account_name)
+        wallet.accounts_status_account.click()
+        send_tr = wallet.send_transaction_button.click()
+
+        wallet.just_fyi("Check that can't send to invalid address")
+        send_tr.amount_edit_box.click()
+        send_tr.amount_edit_box.set_value(send_tr.get_unique_amount())
+        send_tr.chose_recipient_button.click()
+        for address in (basic_user['public_key'], '0xDE709F2102306220921060314715629080E2fB77'):
+            send_tr.enter_recipient_address_input.set_value(address)
+            send_tr.enter_recipient_address_input.click()
+            send_tr.done_button.click()
+            if send_tr.set_max_button.is_element_displayed():
+                self.errors.append('Can proceed with wrong address %s in recipient' % address)
+
+        send_tr.just_fyi('Set one of my accounts')
+        send_tr.chose_recipient_button.click_if_shown()
+        send_tr.element_by_translation_id("my-accounts").click()
+        send_tr.element_by_text(account_name).click()
+        if send_tr.enter_recipient_address_text.text != send_tr.get_formatted_recipient_address(account_address):
+            self.errors.append('Added account is not resolved as recipient')
+
+        send_tr.just_fyi('Set contract address from recent and check smart contract error')
+        send_tr.chose_recipient_button.click()
+        send_tr.element_by_translation_id("recent").click()
+        send_tr.element_by_text('↓ 1000 MDS').click()
+        if not send_tr.element_by_translation_id("warning-sending-to-contract-descr").is_element_displayed():
+            self.driver.fail('No warning is shown at attempt to set as recipient smart contract')
+        send_tr.ok_button.click()
+        send_tr.element_by_text('↑ 0.001 ETHro').scroll_and_click()
+        send_tr.add_to_favorites(recent_add_to_fav_name)
+        wallet.element_by_translation_id("recent").click()
+
+        send_tr.just_fyi('Scan invalid QR')
+        send_tr.scan_qr_code_button.click()
+        send_tr.allow_button.click(1)
+        wallet.enter_qr_edit_box.scan_qr('something%s' % basic_user['address'])
+        if not send_tr.element_by_text_part('Invalid address').is_element_displayed(10):
+            self.driver.fail('No error is shown at attempt to scan invalid address')
+        wallet.ok_button.click()
+
+        send_tr.just_fyi('Scan code, add it to favorites and recheck that it is preserved')
+        send_tr.scan_qr_code_button.click()
+        wallet.enter_qr_edit_box.scan_qr(basic_user['address'])
+        send_tr.add_to_favorites(basic_add_to_fav_name)
+        send_tr.element_by_translation_id("favourites").scroll_and_click()
+        for name in (recent_add_to_fav_name, basic_add_to_fav_name):
+            wallet.element_by_text(name).scroll_to_element()
+
+        send_tr.element_by_text(recent_add_to_fav_name).scroll_and_click()
+        if str(send_tr.enter_recipient_address_text.text).lower() != send_tr.get_formatted_recipient_address(
+                recent_add_to_fav_address):
+            self.errors.append('Recent address that was added to favourites was not resolved correctly')
+
+        send_tr.just_fyi('Set contact')
+        send_tr.chose_recipient_button.click()
+        send_tr.element_by_translation_id("contacts").scroll_and_click()
+        send_tr.element_by_text(nickname).scroll_and_click()
+        send_tr.recipient_done.click()
+        if send_tr.enter_recipient_address_text.text != send_tr.get_formatted_recipient_address(ens_status['address']):
+            self.errors.append('ENS from contact is not resolved as recipient')
+
+        send_tr.just_fyi('Set different ENS options')
+        send_tr.set_recipient_address(ens_other['ens_another'])
+        if send_tr.enter_recipient_address_text.text != send_tr.get_formatted_recipient_address(ens_other['address']):
+            self.errors.append('ENS address on another domain is not resolved as recipient')
+        send_tr.set_recipient_address('%s.stateofus.eth' % ens_status['ens'])
+        if send_tr.enter_recipient_address_text.text != send_tr.get_formatted_recipient_address(ens_status['address']):
+            self.errors.append('ENS address on stateofus.eth is not resolved as recipient')
+
+        send_tr.just_fyi('Check search and set address from search')
+        send_tr.chose_recipient_button.click()
+        send_tr.search_by_keyword(ens_status['ens'][:2])
+        if not send_tr.element_by_text('@' + ens_status['ens']).is_element_displayed():
+            self.errors.append('ENS address from contacts is not shown in search')
+        send_tr.cancel_button.click()
+        send_tr.search_by_keyword('my')
+        for name in (nickname, account_name, recent_add_to_fav_name, basic_add_to_fav_name):
+            if not send_tr.element_by_text(name).is_element_displayed():
+                self.errors.append('%s is not shown in search when searching by namepart' % name)
+        send_tr.element_by_text(basic_add_to_fav_name).click()
+        if send_tr.enter_recipient_address_text.text != send_tr.get_formatted_recipient_address(
+                '0x' + basic_user['address']):
+            self.errors.append('QR scanned address that was added to favourites was not resolved correctly')
+        self.errors.verify_no_errors()
+
+
+@pytest.mark.xdist_group(name="keycard_tx_1")
+@marks.critical
+class TestKeycardTxOneDeviceMerged(MultipleSharedDeviceTestCase):
+    @classmethod
+    def setup_class(cls):
+        cls.user = transaction_senders['ETH_STT_ADI_1']
+        cls.address = '0x%s' % transaction_senders['ETH_7']['address']
+        cls.drivers, cls.loop = create_shared_drivers(1)
+        cls.sign_in = SignInView(cls.drivers[0])
+
+        cls.home = cls.sign_in.recover_access(passphrase=cls.user['passphrase'], keycard=True)
+        cls.wallet = cls.home.wallet_button.click()
+        cls.assets = ('ETH', 'ADI', 'STT')
+        [cls.wallet.wait_balance_is_changed(asset) for asset in cls.assets]
+        cls.initial_balances = dict()
+        for asset in cls.assets:
+            cls.initial_balances[asset] = cls.wallet.get_asset_amount_by_name(asset)
+
+    @marks.testrail_id(700767)
+    def test_keycard_send_tx_eth(self):
+        wallet = self.home.wallet_button.click()
+        transaction_amount = wallet.get_unique_amount()
+        wallet.send_transaction(amount=transaction_amount, sign_transaction=True, keycard=True,
+                                recipient=self.address)
+
+        wallet.just_fyi('Check that transaction is appeared in transaction history')
+        transaction = wallet.find_transaction_in_history(amount=transaction_amount, return_hash=True)
+        self.wallet.wallet_button.double_click()
+        self.network_api.find_transaction_by_hash(transaction)
+        self.network_api.wait_for_confirmation_of_transaction(self.user['address'], transaction_amount)
+        self.wallet.wait_balance_is_changed('ETH', initial_balance=self.initial_balances['ETH'])
+
+    @marks.testrail_id(700768)
+    def test_keycard_relogin_after_restore(self):
+        self.sign_in.just_fyi('Check that username and public key match expected')
+        public_key, default_username = self.sign_in.get_public_key_and_username(return_username=True)
+        profile = self.sign_in.get_profile_view()
+        if public_key != self.user['public_key']:
+            self.errors.append('Public key %s does not match expected' % public_key)
+        if default_username != self.user['username']:
+            self.errors.append('Default username %s does not match expected' % default_username)
+        profile.logout()
+
+        self.sign_in.just_fyi('Check that can login with restored from mnemonic keycard account')
+        self.sign_in.sign_in(keycard=True)
+        if not self.sign_in.home_button.is_element_displayed(10):
+            self.sign_in.driver.fail('Keycard user is not logged in')
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(700769)
+    def test_keycard_send_tx_sign_message_request_stt_testdapp(self):
+        self.home.home_button.double_click()
+        status_test_dapp = self.home.open_status_test_dapp()
+        status_test_dapp.wait_for_d_aap_to_load()
+
+        self.wallet.just_fyi("Requesting STT in dapp")
+        status_test_dapp.assets_button.click()
+        send_tx = status_test_dapp.request_stt_button.click()
+        send_tx.sign_transaction(keycard=True)
+
+        self.wallet.just_fyi("Checking signing message")
+        status_test_dapp.transactions_button.click()
+        status_test_dapp.sign_message_button.click()
+        if not send_tx.element_by_text("Test message").is_element_displayed():
+            self.errors.append("No message shown when signing!")
+        keycard = send_tx.sign_with_keycard_button.click()
+        keycard.enter_default_pin()
+        if not keycard.element_by_text_part('Signed message').is_element_displayed():
+            self.errors.append('Message was not signed')
+
+        keycard.just_fyi('Check logcat for sensitive data')
+        values_in_logcat = send_tx.find_values_in_logcat(pin=pin, puk=puk, password=pair_code)
+        if values_in_logcat:
+            self.sign_in.driver.fail("After signing message: %s" % values_in_logcat)
+
+        self.wallet.just_fyi("Check send 2 txs in batch")
+        status_test_dapp.send_two_tx_in_batch_button.scroll_to_element()
+        send_tx = status_test_dapp.send_two_tx_in_batch_button.click()
+        send_tx.sign_transaction(keycard=True)
+        if not send_tx.sign_with_keycard_button.is_element_displayed(10):
+            self.sign_in.driver.fail('Second send transaction screen did not appear!')
+        send_tx.sign_transaction(keycard=True)
+
+        self.wallet.just_fyi("Checking send 2 txs one after another")
+        status_test_dapp.send_two_tx_one_by_one_button.scroll_to_element()
+        send_tx = status_test_dapp.send_two_tx_one_by_one_button.click()
+        send_tx.sign_transaction(keycard=True)
+        if not send_tx.sign_with_keycard_button.is_element_displayed(20):
+            self.sign_in.driver.fail('Second send transaction screen did not appear!')
+        send_tx.sign_transaction(keycard=True)
+
+        self.wallet.just_fyi('Verify that wallet balance is updated after receiving money from faucet')
+        self.home.wallet_button.click()
+        self.wallet.wait_balance_is_changed('STT', initial_balance=self.initial_balances['STT'])
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(700770)
+    def test_keycard_wallet_recover_pairing_check_balance_after_offline_tx_history(self):
+        user = transaction_senders['A']
+        self.sign_in.toggle_airplane_mode()
+        self.sign_in.driver.reset()
+
+        self.sign_in.just_fyi('Keycard: recover multiaccount with pairing code ')
+        self.sign_in.accept_tos_checkbox.enable()
+        self.sign_in.get_started_button.click_until_presence_of_element(self.sign_in.access_key_button)
+        self.sign_in.access_key_button.click()
+        self.sign_in.recover_with_keycard_button.click()
+        keycard = self.sign_in.begin_recovery_button.click()
+        keycard.connect_pairing_card_button.click()
+        keycard.pair_code_input.set_value(pair_code)
+        self.sign_in.pair_to_this_device_button.click()
+        keycard.enter_default_pin()
+        self.sign_in.maybe_later_button.click_until_presence_of_element(self.sign_in.lets_go_button)
+        self.sign_in.lets_go_button.click_until_absense_of_element(self.sign_in.lets_go_button)
+        self.sign_in.home_button.wait_for_visibility_of_element(30)
+
+        self.sign_in.just_fyi("Check balance will be restored after going back online")
+        self.sign_in.toggle_airplane_mode()
+        wallet = self.home.wallet_button.click()
+        [wallet.wait_balance_is_changed(asset) for asset in ("ETH", "LXS")]
+
+        self.wallet.just_fyi("Checking whole tx history after backing from offline")
+        self.wallet.accounts_status_account.click()
+        address = user['address']
+        ropsten_txs = self.network_api.get_transactions(address)
+        ropsten_tokens = self.network_api.get_token_transactions(address)
+        expected_txs_list = get_merged_txs_list(ropsten_txs, ropsten_tokens)
+        transactions = self.wallet.transaction_history_button.click()
+        if self.wallet.element_by_translation_id("transactions-history-empty").is_element_displayed():
+            self.wallet.pull_to_refresh()
+        status_tx_number = transactions.transactions_table.get_transactions_number()
+        if status_tx_number < 1:
+            self.errors.append('No transactions found')
+        for n in range(status_tx_number):
+            transactions_details = transactions.transactions_table.transaction_by_index(n).click()
+            tx_hash = transactions_details.get_transaction_hash()
+            tx_from = transactions_details.get_sender_address()
+            tx_to = transactions_details.get_recipient_address()
+            if tx_from != expected_txs_list[tx_hash]['from']:
+                self.errors.append('Transactions senders do not match!')
+            if tx_to != expected_txs_list[tx_hash]['to']:
+                self.errors.append('Transactions recipients do not match!')
+            transactions_details.close_button.click()
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(5689)
+    def test_keycard_create_account_unlock_same_seed(self):
+        self.sign_in.driver.reset()
+        self.sign_in.just_fyi("Create keycard account and save seed phrase")
+        self.sign_in.accept_tos_checkbox.enable()
+        self.sign_in.get_started_button.click()
+        self.sign_in.generate_key_button.click_until_presence_of_element(self.sign_in.next_button)
+        self.sign_in.next_button.click_until_absense_of_element(self.sign_in.element_by_translation_id("intro-wizard-title2"))
+        keycard_flow = self.sign_in.keycard_storage_button.click()
+        keycard_flow.confirm_pin_and_proceed()
+        seed_phrase = keycard_flow.backup_seed_phrase()
+        self.sign_in.maybe_later_button.wait_for_visibility_of_element(30)
+        self.sign_in.maybe_later_button.click_until_presence_of_element(self.sign_in.lets_go_button)
+        self.sign_in.lets_go_button.click_until_absense_of_element(self.sign_in.lets_go_button)
+        self.sign_in.profile_button.wait_for_visibility_of_element(30)
+
+        self.sign_in.just_fyi('Check that after creating keycard account balance is 0, not ...')
+        wallet_1 = self.sign_in.wallet_button.click()
+        wallet_address = wallet_1.get_wallet_address()
+        wallet_1.wallet_button.double_click()
+        if wallet_1.status_account_total_usd_value.text != '0':
+            self.errors.append("Account USD value is not 0, it is %s" % wallet_1.status_account_total_usd_value.text)
+        public_key, default_username = self.sign_in.get_public_key_and_username(return_username=True)
+        profile_1 = self.sign_in.get_profile_view()
+        profile_1.logout()
+
+        profile_1.just_fyi('Check that can re-login with keycard account after account creation')
+        self.sign_in.multi_account_on_login_button.wait_for_visibility_of_element(5)
+        self.sign_in.multi_account_on_login_button.click()
+        if not keycard_flow.element_by_text_part(default_username).is_element_displayed():
+            self.errors.append("%s is not found on keycard login screen!" % default_username)
+        keycard_flow.enter_default_pin()
+        if not self.sign_in.home_button.is_element_displayed(10):
+            self.errors.append('Keycard user is not logged in')
+
+        self.sign_in.just_fyi('Unlock keycard multiaccount at attempt to restore same multiaccount from seed')
+        self.sign_in.profile_button.click()
+        profile_1.logout()
+        self.sign_in.access_key_button.click()
+        self.sign_in.enter_seed_phrase_button.click()
+        self.sign_in.seedphrase_input.click()
+        self.sign_in.seedphrase_input.set_value(seed_phrase)
+        self.sign_in.next_button.click()
+        self.sign_in.element_by_translation_id("unlock", uppercase=True).click()
+        keycard_flow.enter_default_pin()
+        device_1_home = self.sign_in.home_button.click()
+        device_1_home.plus_button.click()
+        if not device_1_home.start_new_chat_button.is_element_displayed():
+            self.errors.append("Can't proceed using account after it's re-recover twice.")
+
+        self.sign_in.just_fyi("Restore same multiaccount from backed up seed phrase on another device")
+        self.sign_in.driver.reset()
+        self.sign_in.recover_access(seed_phrase)
+
+        self.sign_in.just_fyi("Check username and wallet address on restored account")
+        wallet_2 = self.sign_in.wallet_button.click()
+        wallet_address_2 = wallet_2.get_wallet_address()
+        wallet_2.wallet_button.double_click()
+        if wallet_address != wallet_address_2:
+            self.errors.append('Wallet address on restored multiaccount is not equal to created keycard multiaccount')
+        public_key_2, default_username_2 = self.sign_in.get_public_key_and_username(return_username=True)
+        if public_key != public_key_2:
+            self.errors.append('Public key on restored multiaccount is not equal to created keycard multiaccount')
+        if default_username_2 != default_username:
+            self.errors.append('Username on restored multiaccount is not equal to created keycard multiaccount')
+        self.errors.verify_no_errors()

test/appium/tests/critical/wallet_and_tx/test_wallet.py

@@ -3,8 +3,8 @@ import string
 import pytest
 
 from tests import marks, common_password
-from tests.base_test_case import SingleDeviceTestCase, MultipleSharedDeviceTestCase, create_shared_drivers
+from tests.base_test_case import MultipleSharedDeviceTestCase, create_shared_drivers
-from tests.users import wallet_users, transaction_senders, basic_user, ens_user, ens_user_ropsten
+from tests.users import wallet_users, basic_user
 from views.sign_in_view import SignInView
 from support.utilities import get_merged_txs_list
 
@@ -28,7 +28,7 @@ class TestWalletManagementDeviceMerged(MultipleSharedDeviceTestCase):
                                 'STT': cls.wallet.get_asset_amount_by_name('STT')}
 
     @marks.testrail_id(700756)
-    def test_wallet_tx_history_copy_tx_hash_on_lte(self):
+    def test_wallet_tx_history_copy_tx_hash_on_cellular(self):
         self.wallet.accounts_status_account.click()
         address = wallet_users['D']['address']
         ropsten_txs = self.network_api.get_transactions(address)
@@ -389,58 +389,4 @@ class TestWalletManagementDeviceMerged(MultipleSharedDeviceTestCase):
             self.errors.append(
                 "'Insufficient funds' error is not shown when sending %s STT from wallet with balance %s" % (
                     round(stt_value + 1), stt_value))
-        self.errors.verify_no_errors()
+        self.errors.verify_no_errors()
-
-
-class TestWalletManagement(SingleDeviceTestCase):
-
-    @marks.testrail_id(6269)
-    @marks.medium
-    def test_search_asset_and_currency(self):
-        sign_in = SignInView(self.driver)
-        home = sign_in.create_user()
-        profile = home.profile_button.click()
-        profile.switch_network()
-        search_list_assets = {
-            'ad': ['AdEx', 'Open Trading Network', 'TrueCAD'],
-            'zs': ['ZSC']
-        }
-        wallet = home.wallet_button.click()
-
-        home.just_fyi('Searching for asset by name and symbol')
-        wallet.multiaccount_more_options.click()
-        wallet.manage_assets_button.click()
-        for keyword in search_list_assets:
-            home.search_by_keyword(keyword)
-            if keyword == 'ad':
-                search_elements = wallet.all_assets_full_names.find_elements()
-            else:
-                search_elements = wallet.all_assets_symbols.find_elements()
-            if not search_elements:
-                self.errors.append('No search results after searching by %s keyword' % keyword)
-            search_results = [element.text for element in search_elements]
-            if search_results != search_list_assets[keyword]:
-                self.errors.append("'%s' is shown on the home screen after searching by '%s' keyword" %
-                                   (', '.join(search_results), keyword))
-            home.cancel_button.click()
-        wallet.close_button.click()
-
-        home.just_fyi('Searching for currency')
-        search_list_currencies = {
-            'aF': ['Afghanistan Afghani (AFN)', 'South Africa Rand (ZAR)'],
-            'bolívi': ['Bolivia Bolíviano (BOB)']
-        }
-        wallet.multiaccount_more_options.click_until_presence_of_element(wallet.set_currency_button)
-        wallet.set_currency_button.click()
-        for keyword in search_list_currencies:
-            home.search_by_keyword(keyword)
-            search_elements = wallet.currency_item_text.find_elements()
-            if not search_elements:
-                self.errors.append('No search results after searching by %s keyword' % keyword)
-            search_results = [element.text for element in search_elements]
-            if search_results != search_list_currencies[keyword]:
-                self.errors.append("'%s' is shown on the home screen after searching by '%s' keyword" %
-                                   (', '.join(search_results), keyword))
-            home.cancel_button.click()
-
-        self.errors.verify_no_errors()

test/appium/tests/marks.py

@@ -3,11 +3,8 @@ import pytest
 testrail_case_id = pytest.mark.testrail_case_id
 testrail_id = pytest.mark.testrail_id  # atomic tests
 critical = pytest.mark.critical
-high = pytest.mark.high
 medium = pytest.mark.medium
-low = pytest.mark.low
 
 flaky = pytest.mark.flaky
-transaction = pytest.mark.transaction
 upgrade = pytest.mark.upgrade
 skip = pytest.mark.skip

test/appium/tests/medium/chats/test_chats.py

@@ -0,0 +1,436 @@
+import random
+from time import sleep
+import emoji
+import pytest
+
+from tests import marks
+from tests.base_test_case import create_shared_drivers, MultipleSharedDeviceTestCase
+from views.sign_in_view import SignInView
+
+
+@pytest.mark.xdist_group(name="public_chat_medium_2")
+@marks.medium
+class TestPublicChatMultipleDeviceMergedMedium(MultipleSharedDeviceTestCase):
+    @classmethod
+    def setup_class(cls):
+        cls.drivers, cls.loop = create_shared_drivers(2)
+        device_1, device_2 = SignInView(cls.drivers[0]), SignInView(cls.drivers[1])
+        cls.home_1, cls.home_2 = device_1.create_user(), device_2.create_user()
+        profile_1 = cls.home_1.profile_button.click()
+        cls.public_key_1, cls.username_1 = profile_1.get_public_key_and_username(return_username=True)
+        profile_1.home_button.click()
+        cls.text_message = 'hello'
+        [home.home_button.click() for home in (cls.home_1, cls.home_2)]
+        cls.public_chat_name = cls.home_1.get_random_chat_name()
+        cls.chat_1, cls.chat_2 = cls.home_1.join_public_chat(cls.public_chat_name), cls.home_2.join_public_chat(
+            cls.public_chat_name)
+        cls.chat_1.send_message(cls.text_message)
+
+    @marks.testrail_id(6342)
+    def test_public_chat_timeline_different_statuses_reaction(self):
+        emoji_message = random.choice(list(emoji.EMOJI_UNICODE))
+        emoji_unicode = emoji.EMOJI_UNICODE[emoji_message]
+
+        self.home_1.just_fyi('Set status in profile')
+        statuses = {
+            '*formatted text*': 'formatted text',
+            'https://www.youtube.com/watch?v=JjPWmEh2KhA': 'Status Town Hall',
+            emoji.emojize(emoji_message): emoji_unicode,
+
+        }
+        timeline_1 = self.home_1.status_button.click()
+        for status in statuses.keys():
+            timeline_1.set_new_status(status)
+            sleep(60)
+
+        timeline_1.element_by_translation_id("enable").wait_and_click()
+        timeline_1.element_by_translation_id("enable-all").wait_and_click()
+        timeline_1.close_modal_view_from_chat_button.click()
+        for status in statuses:
+            expected_value = statuses[status]
+            if not timeline_1.element_by_text_part(expected_value).is_element_displayed():
+                self.errors.append("Expected value %s is not shown" % expected_value)
+        text_status = 'some text'
+        timeline_1.set_new_status(status=text_status, image=True)
+        for timestamp in ('Now', '1M', '2M'):
+            if not timeline_1.element_by_text(timestamp).is_element_displayed():
+                self.errors.append("Expected timestamp %s is not shown in timeline_1" % timestamp)
+        if not timeline_1.image_message_in_chat.is_element_displayed():
+            self.errors.append("Timeline image is not shown in timeline_1")
+
+        self.home_2.just_fyi('Check that can see user status without adding him as contact')
+        self.home_2.home_button.click()
+        chat_2 = self.home_2.add_contact(self.public_key_1, add_in_contacts=False)
+        chat_2.chat_options.click()
+        timeline_2 = chat_2.view_profile_button.click()
+        if not timeline_2.image_message_in_chat.is_element_displayed(40):
+            self.errors.append(
+                'Timeline image of another user is not shown when open another user profile before adding to contacts')
+        chat_2.chat_element_by_text(text_status).wait_for_element(30)
+        chat_2.element_by_translation_id("enable").scroll_and_click()
+        chat_2.element_by_translation_id("enable-all").wait_and_click()
+        chat_2.close_modal_view_from_chat_button.click()
+        for status in statuses:
+            chat_2.element_by_text_part(statuses['*formatted text*']).scroll_to_element()
+            expected_value = statuses[status]
+            if not chat_2.element_by_text_part(expected_value).is_element_displayed():
+                self.errors.append(
+                    "Expected value %s is not shown in other user profile without adding to contacts" % expected_value)
+
+        self.home_2.just_fyi('Add device1 to contacts and check that status will be shown in timeline_1')
+        chat_2.close_button.scroll_and_click(direction='up')
+        chat_2.add_to_contacts.click()
+        timeline_2 = chat_2.status_button.click()
+        for status in statuses:
+            expected_value = statuses[status]
+            if not timeline_2.element_by_text_part(expected_value).is_element_displayed():
+                self.errors.append(
+                    "Expected value %s is not shown in timeline_1 after adding user to contacts" % expected_value)
+        if not timeline_2.image_message_in_chat.is_element_displayed(40):
+            self.errors.append(
+                'Timeline image of another user is not shown when open another user profile after adding to contacts')
+
+        self.home_2.just_fyi('Checking message tag and reactions on statuses')
+        tag_status = '#public-chat-to-redirect-long-name'
+        timeline_1.set_new_status(tag_status)
+        public_chat_2 = self.home_2.get_chat_view()
+
+        public_chat_2.element_by_text(tag_status).wait_and_click()
+        public_chat_2.user_name_text.wait_for_element(30)
+        if not public_chat_2.user_name_text.text == tag_status:
+            self.errors.append('Could not redirect a user to a public chat tapping the tag message from timeline_1')
+        public_chat_2.back_button.click()
+
+        timeline_1.set_reaction(text_status)
+        status_with_reaction_1 = timeline_1.chat_element_by_text(text_status)
+        if status_with_reaction_1.emojis_below_message() != 1:
+            self.errors.append("Counter of reaction is not updated on your own status in timeline_1!")
+        self.home_2.home_button.double_click()
+        self.home_2.get_chat(self.username_1).click()
+        chat_2.chat_options.click()
+        chat_2.view_profile_button.click()
+        status_with_reaction_2 = chat_2.chat_element_by_text(text_status)
+        if status_with_reaction_2.emojis_below_message(own=False) != 1:
+            self.errors.append("Counter of reaction is not updated on status of another user in profile!")
+        self.home_1.just_fyi("Remove reaction and check it is updated for both users")
+        timeline_1.set_reaction(text_status)
+        status_with_reaction_1 = timeline_1.chat_element_by_text(text_status)
+        if status_with_reaction_1.emojis_below_message() != 0:
+            self.errors.append(
+                "Counter of reaction is not updated after removing reaction on your own status in timeline_1!")
+        status_with_reaction_2 = chat_2.chat_element_by_text(text_status)
+        if status_with_reaction_2.emojis_below_message(own=False) != 0:
+            self.errors.append(
+                "Counter of reaction is not updated after removing on status of another user in profile!")
+
+        self.home_1.just_fyi("Remove user from contacts and check there is no his status in timeline_1 anymore")
+        chat_2.remove_from_contacts.click()
+        chat_2.close_button.click()
+        chat_2.status_button.click()
+        if public_chat_2.chat_element_by_text(text_status).is_element_displayed(10):
+            self.errors.append("Statuses of removed user are still shown in profile")
+
+        self.errors.verify_no_errors()
+
+
+@pytest.mark.xdist_group(name="chat_medium_2")
+@marks.medium
+class TestChatMultipleDevice(MultipleSharedDeviceTestCase):
+
+    @classmethod
+    def setup_class(cls):
+        cls.drivers, cls.loop = create_shared_drivers(2)
+        cls.device_1, cls.device_2 = SignInView(cls.drivers[0]), SignInView(cls.drivers[1])
+        cls.home_1, cls.home_2 = cls.device_1.create_user(enable_notifications=True), cls.device_2.create_user()
+        cls.public_key_1, cls.default_username_1 = cls.home_1.get_public_key_and_username(return_username=True)
+        cls.public_key_2, cls.default_username_2 = cls.home_2.get_public_key_and_username(return_username=True)
+        profile_2 = cls.home_2.profile_button.click()
+        profile_2.switch_network()
+        [home.home_button.click() for home in (cls.home_1, cls.home_2)]
+
+        cls.home_1.just_fyi("Creating 1-1 chats")
+        cls.chat_1 = cls.home_1.add_contact(cls.public_key_2)
+        cls.chat_2 = cls.home_2.add_contact(cls.public_key_1)
+        cls.home_2.just_fyi('Install free sticker pack and use it in 1-1 chat')
+        cls.chat_2.install_sticker_pack_by_name()
+        [home.home_button.click() for home in (cls.home_1, cls.home_2)]
+
+        cls.home_1.just_fyi("Creating group chats")
+        cls.initial_group_chat_name = "GroupChat before rename"
+        cls.new_group_chat_name = "GroupChat after rename"
+        cls.group_chat_1 = cls.home_1.create_group_chat(user_names_to_add=[cls.default_username_2], group_chat_name=cls.initial_group_chat_name)
+        cls.group_chat_2 = cls.home_2.get_chat(cls.initial_group_chat_name).click()
+        cls.group_chat_2.join_chat_button.click()
+        [home.home_button.click() for home in (cls.home_1, cls.home_2)]
+
+        cls.home_1.just_fyi("Creating public chats")
+        cls.public_chat_name = cls.home_1.get_random_chat_name()
+        cls.public_chat_1, cls.public_chat_2 = cls.home_1.join_public_chat(cls.public_chat_name), cls.home_2.join_public_chat(cls.public_chat_name)
+        [home.home_button.click() for home in (cls.home_1, cls.home_2)]
+
+        cls.home_1.get_chat(cls.default_username_2).click()
+        cls.home_2.get_chat(cls.default_username_1).click()
+
+        cls.message_1, cls.message_2, cls.message_3, cls.message_4 = "Message1", "Message2", "Message3", "Message4"
+
+    @marks.testrail_id(702066)
+    def test_chat_1_1_push_and_reaction_for_messages_sticker_audio_image(self):
+
+        # methods with steps to use later in loop
+        def navigate_to_start_state_of_both_devices():
+            self.chat_1.put_app_to_background()
+            self.device_1.open_notification_bar()
+            self.chat_2.get_back_to_home_view(2)
+            self.home_2.get_chat_from_home_view(self.default_username_1).click()
+
+        def device_2_sends_sticker():
+            self.chat_2.just_fyi("Sending Sticker in chat")
+            self.chat_2.show_stickers_button.click()
+            self.chat_2.sticker_icon.click()
+
+        def device_2_sends_image():
+            self.chat_2.just_fyi("Sending Image in chat")
+            self.chat_2.show_images_button.click()
+            self.chat_2.allow_button.click()
+            self.chat_2.first_image_from_gallery.click()
+            self.chat_2.send_message_button.click()
+
+        def device_2_sends_audio():
+            self.chat_2.just_fyi("Sending Audio in chat")
+            self.chat_2.record_audio_message(message_length_in_seconds=3)
+            self.chat_2.send_message_button.click()
+
+        sending_list = {
+            "sticker": device_2_sends_sticker,
+            "image": device_2_sends_image,
+            "audio": device_2_sends_audio,
+        }
+
+        for key, value in sending_list.items():
+            navigate_to_start_state_of_both_devices()
+            sending_list[key]()
+            if not self.device_1.element_by_text_part(key.capitalize()).is_element_displayed(10):
+                self.errors.append("%s not appeared in Push Notification" % key.capitalize())
+                self.device_1.click_system_back_button()
+                self.device_1.get_app_from_background()
+            else:
+                self.device_1.element_by_text_part(key.capitalize()).click()
+            message = self.chat_2.chat_element_by_text(key)
+            self.chat_1.set_reaction(key)
+            if message.emojis_below_message(own=False) != 1:
+                self.errors.append("Counter of reaction is not set on %s for message receiver!" % key)
+            self.chat_1.set_reaction(key)
+            if message.emojis_below_message(own=False) == 1:
+                self.errors.append("Counter of reaction is not re-set on %s for message receiver!" % key)
+
+        self.chat_2.just_fyi("Sending Emoji/Tag/Links in chat")
+        # TODO: add link and tag messages after #11168 is fixed(rechecked 23.11.21, valid)
+        navigate_to_start_state_of_both_devices()
+
+        emoji_name = random.choice(list(emoji.EMOJI_UNICODE))
+        emoji_unicode = emoji.EMOJI_UNICODE[emoji_name]
+
+        self.chat_2.just_fyi("Sending Emoji in chat")
+        self.chat_2.chat_message_input.send_keys(emoji.emojize(emoji_name))
+        self.chat_2.send_message_button.click()
+
+        if not self.device_1.element_by_text_part(emoji_unicode).is_element_displayed(10):
+            self.errors.append("Emoji not appeared in Push Notification")
+            self.device_1.click_system_back_button()
+            self.device_1.get_app_from_background()
+        else:
+            self.device_1.element_by_text_part(emoji_unicode).click()
+
+        emoji_message = self.chat_2.chat_element_by_text(emoji_unicode)
+        self.chat_1.set_reaction(emoji_unicode, emoji_message=True)
+        if emoji_message.emojis_below_message(own=False) != 1:
+            self.errors.append("Counter of reaction is not set on Emoji for message receiver!")
+        self.chat_1.set_reaction(emoji_unicode, emoji_message=True)
+        if emoji_message.emojis_below_message(own=False) == 1:
+            self.errors.append("Counter of reaction is not re-set on Emoji for message receiver!")
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702069)
+    def test_chat_1_1_pin_messages(self):
+        self.home_1.just_fyi("Check that Device1 can pin own message in 1-1 chat")
+        self.chat_1.send_message(self.message_1)
+        self.chat_1.send_message(self.message_2)
+        self.chat_1.pin_message(self.message_1)
+        if not self.chat_1.chat_element_by_text(self.message_1).pinned_by_label.is_element_present():
+            self.drivers[0].fail("Message is not pinned!")
+
+        self.home_1.just_fyi("Check that Device2 can pin Device1 message in 1-1 chat and two pinned "
+                             "messages are in Device1 profile")
+        self.chat_2.pin_message(self.message_2)
+        self.chat_2.chat_options.click()
+        self.chat_2.view_profile_button.click()
+        if not self.chat_2.pinned_messages_button.count == "2":
+            self.drivers[0].fail("Pinned message count is not 2 as expected!")
+
+        self.home_1.just_fyi("Check pinned message are visible in Pinned panel for both users")
+        self.chat_1.chat_options.click()
+        self.chat_1.view_profile_button.click()
+        self.chat_1.pinned_messages_button.click()
+        if not (self.chat_1.chat_element_by_text(self.message_1).pinned_by_label.is_element_present() and
+                self.chat_1.chat_element_by_text(self.message_2).pinned_by_label.is_element_present() and
+                self.chat_1.chat_element_by_text(self.message_1).is_element_present() and
+                self.chat_1.chat_element_by_text(self.message_2).is_element_present()):
+            self.drivers[0].fail("Something missed on Pinned messaged on Device 1!")
+        self.chat_2.pinned_messages_button.click()
+        if not (self.chat_1.chat_element_by_text(self.message_1).pinned_by_label.is_element_present() and
+                self.chat_2.chat_element_by_text(self.message_2).pinned_by_label.is_element_present() and
+                self.chat_2.chat_element_by_text(self.message_1).is_element_present() and
+                self.chat_2.chat_element_by_text(self.message_2).is_element_present()):
+            self.drivers[0].fail("Something missed on Pinned messaged on Device 2!")
+        self.chat_1.close_button.click()
+
+        self.home_1.just_fyi("Check that Device1 can not pin more than 3 messages and 'Unpin' dialog appears"
+                             "messages are in Device1 profile")
+        self.chat_1.send_message(self.message_3)
+        self.chat_1.send_message(self.message_4)
+        self.chat_1.pin_message(self.message_3)
+        self.chat_1.pin_message(self.message_4)
+        if not self.chat_1.unpin_message_popup.is_element_present():
+            self.drivers[0].fail("No 'Unpin' dialog appears when pining 4th message")
+
+        self.home_1.just_fyi("Unpin one message so that another could be pinned")
+        self.chat_1.unpin_message_popup.message_text(self.message_1).click()
+        self.chat_1.unpin_message_popup.click_unpin_message_button()
+
+        if self.chat_1.unpin_message_popup.is_element_present():
+            self.drivers[0].fail("Unpin message pop up keep staying after Unpin button pressed")
+        if self.chat_1.chat_element_by_text(self.message_1).pinned_by_label.is_element_present():
+            self.drivers[0].fail("Message is not unpinned!")
+        if not self.chat_1.chat_element_by_text(self.message_4).pinned_by_label.is_element_present():
+            self.drivers[0].fail("Message is not pinned!")
+
+        self.home_1.just_fyi("Unpin another message and check it's unpinned for another user")
+        self.chat_2.close_button.click()
+        self.chat_2.pin_message(self.message_4, action="unpin")
+        self.chat_1.chat_element_by_text(self.message_4).pinned_by_label.wait_for_invisibility_of_element()
+        if self.chat_1.chat_element_by_text(self.message_4).pinned_by_label.is_element_present():
+            self.drivers[0].fail("Message_4 is not unpinned!")
+
+    @marks.testrail_id(702065)
+    def test_chat_public_markdown_support(self):
+        markdown = {
+            'bold text in asterics': '**',
+            'bold text in underscores': '__',
+            'italic text in asteric': '*',
+            'italic text in underscore': '_',
+            'inline code': '`',
+            'code blocks': '```',
+            'quote reply (one row)': '>',
+        }
+
+        for message, symbol in markdown.items():
+            self.home_1.just_fyi('checking that "%s" is applied (%s) in 1-1 chat' % (message, symbol))
+            message_to_send = symbol + message + symbol if 'quote' not in message else symbol + message
+            self.chat_2.send_message(message_to_send)
+            if not self.chat_2.chat_element_by_text(message).is_element_displayed():
+                self.errors.append('%s is not displayed with markdown in 1-1 chat for the sender \n' % message)
+
+            if not self.chat_1.chat_element_by_text(message).is_element_displayed():
+                self.errors.append('%s is not displayed with markdown in 1-1 chat for the recipient \n' % message)
+
+        [chat.home_button.double_click() for chat in (self.chat_1, self.chat_2)]
+        [home.get_chat('#' + self.public_chat_name).click() for home in (self.home_1, self.home_2)]
+
+        for message, symbol in markdown.items():
+            self.home_1.just_fyi('checking that "%s" is applied (%s) in public chat' % (message, symbol))
+            message_to_send = symbol + message + symbol if 'quote' not in message else symbol + message
+            self.public_chat_1.send_message(message_to_send)
+            if not self.public_chat_2.chat_element_by_text(message).is_element_displayed(30):
+                self.errors.append('%s is not displayed with markdown in public chat for the sender \n' % message)
+
+            if not self.public_chat_1.chat_element_by_text(message).is_element_displayed(30):
+                self.errors.append('%s is not displayed with markdown in public chat for the recipient \n' % message)
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702098)
+    def test_chat_group_chat_rename(self):
+
+        [chat.home_button.double_click() for chat in [self.chat_1, self.chat_2]]
+
+        self.home_2.just_fyi('Rename chat and check system messages')
+        [home.get_chat(self.initial_group_chat_name).click() for home in (self.home_1, self.home_2)]
+        self.group_chat_1.rename_chat_via_group_info(self.new_group_chat_name)
+        for chat in (self.group_chat_1, self.group_chat_2):
+            if not chat.element_by_text(
+                    chat.create_system_message(self.default_username_1, self.initial_group_chat_name)).is_element_displayed():
+                self.errors.append('Initial system message about creating chat was changed!')
+            if not chat.element_by_text(
+                    chat.changed_group_name_system_message(self.default_username_1,
+                                                           self.new_group_chat_name)).is_element_displayed():
+                self.errors.append('Message about changing chat name is not shown')
+
+        self.home_2.just_fyi('Check that you can see renamed chat')
+        self.group_chat_2.back_button.click()
+        self.home_2.get_chat(self.new_group_chat_name).wait_for_visibility_of_element(60)
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702097)
+    def test_chat_block_and_unblock_user_from_group_chat_via_group_info(self):
+
+        [chat.home_button.double_click() for chat in [self.chat_1, self.chat_2]]
+
+        self.home_2.just_fyi('Send message and block user via Group Info')
+        [home.get_chat(self.new_group_chat_name).click() for home in (self.home_1, self.home_2)]
+        message_before_block = 'message from device2'
+        self.group_chat_2.send_message(message_before_block)
+        options_2 = self.group_chat_1.get_user_options(self.default_username_2)
+        options_2.view_profile_button.click()
+        options_2.block_contact()
+        self.home_1.close_button.click()
+        if self.group_chat_1.chat_element_by_text(message_before_block).is_element_displayed(10):
+            self.errors.append('User was blocked, but past message are shown')
+        message_after_block = 'message from device2 after block'
+        self.group_chat_2.send_message(message_after_block)
+        if self.group_chat_1.chat_element_by_text(message_after_block).is_element_displayed(10):
+            self.errors.append('User was blocked, but new messages still received')
+
+        self.home_1.just_fyi('Unblock user via group info and check that new messages will arrive')
+        options_2 = self.group_chat_1.get_user_options(self.default_username_2)
+        options_2.view_profile_button.click()
+        options_2.unblock_contact_button.click()
+        [options_2.close_button.click() for _ in range(2)]
+        message_after_unblock = 'message from device2 after unblock'
+        self.group_chat_2.send_message(message_after_unblock)
+        if not self.group_chat_1.chat_element_by_text(message_after_unblock).is_element_displayed(20):
+            self.errors.append('User was unblocked, but new messages are not received')
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702070)
+    def test_chat_pin_messages_in_group_chat(self):
+
+        [chat.home_button.double_click() for chat in [self.chat_1, self.chat_2]]
+
+        self.home_1.just_fyi("Enter group chat and pin message there. It's pinned for both members.")
+        [home.get_chat(self.new_group_chat_name).click() for home in (self.home_1, self.home_2)]
+        self.group_chat_1.send_message(self.message_1)
+        self.group_chat_1.pin_message(self.message_1)
+        if not (self.group_chat_1.chat_element_by_text(self.message_1).pinned_by_label.is_element_present(30) and
+                self.group_chat_2.chat_element_by_text(self.message_1).pinned_by_label.is_element_present(30)):
+            self.errors.append("Message is not pinned in group chat!")
+
+        self.home_1.just_fyi("Check that non admin user can not unpin messages")
+        self.group_chat_2.chat_element_by_text(self.message_1).long_press_element()
+        if self.group_chat_2.element_by_translation_id("unpin").is_element_present():
+            self.errors.append("Unpin option is available for non-admin user")
+
+        self.home_1.just_fyi("Grant another user with admin rights and check he can unpin message now")
+        self.group_chat_1.chat_options.click()
+        group_info = self.group_chat_1.group_info.click()
+        options = group_info.get_username_options(self.default_username_2).click()
+        options.make_admin_button.click()
+        self.group_chat_2.click_system_back_button()
+        self.group_chat_2.pin_message(self.message_1, action="unpin")
+        if (self.group_chat_1.chat_element_by_text(self.message_1).pinned_by_label.is_element_present() and
+                self.group_chat_2.chat_element_by_text(self.message_1).pinned_by_label.is_element_present()):
+            self.errors.append("Message failed be unpinned by user who granted admin permissions!")
+
+        self.errors.verify_no_errors()

test/appium/tests/medium/test_browser_profile.py

@@ -0,0 +1,465 @@
+import pytest
+
+from tests import marks, common_password, used_fleet
+from tests.base_test_case import create_shared_drivers, MultipleSharedDeviceTestCase
+from views.sign_in_view import SignInView
+from tests.users import basic_user, ens_user, ens_user_ropsten, transaction_senders, chat_users
+
+
+@pytest.mark.xdist_group(name="browser_profile_medium_1")
+@marks.medium
+class TestBrowserProfileOneDevice(MultipleSharedDeviceTestCase):
+
+    @classmethod
+    def setup_class(cls):
+        cls.drivers, cls.loop = create_shared_drivers(1)
+        cls.sign_in = SignInView(cls.drivers[0])
+        cls.home = cls.sign_in.create_user()
+        cls.wiki_texts = ['Español', '日本語', 'Français', '中文', 'Português']
+
+    @marks.testrail_id(702149)
+    def test_browser_can_access_images_by_link(self):
+        urls = {
+            'https://cdn.dribbble.com/users/45534/screenshots/3142450/logo_dribbble.png':
+                'url1.png',
+            'https://steemitimages.com/DQmYEjeBuAKVRa3b3ZqwLicSHaPUm7WFtQqohGaZdA9ghjx/images%20(4).jpeg':
+                'url3.png'
+        }
+        dapp = self.home.dapp_tab_button.click()
+        from views.web_views.base_web_view import BaseWebView
+        base_web = BaseWebView(self.drivers[0])
+        for url in urls:
+            dapp.open_url(url)
+            if dapp.web_page.is_element_differs_from_template(urls[url], 5):
+                self.errors.append('Web page does not match expected template %s' % urls[url])
+            base_web.browser_previous_page_button.click_until_presence_of_element(dapp.element_by_text_part('Discover'))
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702150)
+    def test_browser_back_forward_navigation_history_kept_after_relogin(self):
+
+        dapp = self.home.dapp_tab_button.click()
+        ua_url = 'https://uk.m.wikipedia.org/'
+        browsing = dapp.open_url(ua_url)
+        browsing.element_by_text_part('Ласкаво просимо').wait_for_element(20)
+
+        browsing.just_fyi("Check next page")
+        browsing.just_fyi('Navigate to next page and back')
+        browsing.element_by_text_part('може редагувати кожен').click()
+        browsing.element_by_text_part('написана спільно її читачами').wait_for_element(30)
+        browsing.browser_previous_page_button.click()
+        browsing.wait_for_element_starts_with_text('може редагувати кожен')
+
+        browsing.just_fyi('Relogin and check that tap on "Next" navigates to next page')
+        browsing.reopen_app()
+        self.home.dapp_tab_button.click()
+        browsing.open_tabs_button.click()
+        dapp.element_by_text_part(ua_url).click()
+        browsing.wait_for_element_starts_with_text('може редагувати кожен')
+        browsing.browser_next_page_button.click()
+        browsing.element_by_text_part('написана спільно її читачами').wait_for_element(30)
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702179)
+    def test_browser_refresh_page(self):
+
+        dapp = self.home.dapp_tab_button.click()
+        url = 'app.uniswap.org'
+
+        dapp.just_fyi("Check refresh button")
+        web_page = dapp.open_url(url)
+        dapp.allow_button.click()
+        element_on_start_page = dapp.element_by_text('Select a token')
+        dapp.allow_button.click()
+        element_on_start_page.scroll_and_click()
+
+        # when bottom sheet is opened, elements by text couldn't be found
+        element_on_start_page.wait_for_invisibility_of_element(20)
+        web_page.browser_refresh_page_button.click()
+
+        if not element_on_start_page.is_element_displayed(30):
+            self.errors.append("Page failed to be refreshed")
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702201)
+    def test_browser_resolve_ipns_name(self):
+        ipns_url = 'uniswap.eth'
+
+        self.home.just_fyi('Switching to Mainnet')
+        profile = self.home.profile_button.click()
+        profile.switch_network()
+
+        self.home.just_fyi('Opening url containing ipns name')
+        dapp = self.home.dapp_tab_button.click()
+        web_page = dapp.open_url(ipns_url)
+        if not dapp.allow_button.is_element_displayed(30):
+            self.driver.fail('No permission is asked for dapp, so IPNS name is not resolved')
+        dapp.allow_button.click()
+
+        # Switching back to ropsten
+        web_page.profile_button.click()
+        profile.switch_network('Ropsten with upstream RPC')
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702151)
+    def test_browser_open_url_with_non_english_text(self):
+        dapp = self.home.dapp_tab_button.click()
+
+        dapp.just_fyi('Check non english text is shown in open url')
+        browsing = dapp.open_url('www.wikipedia.org')
+        for wiki_text in self.wiki_texts:
+            if not browsing.element_by_text_part(wiki_text).is_element_displayed(15):
+                self.errors.append("%s is not shown" % wiki_text)
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702180)
+    def test_browser_connect_revoke_wallet(self):
+
+        dapp = self.home.dapp_tab_button.click()
+        browsing = dapp.open_url('www.wikipedia.org')
+
+        dapp.just_fyi("Check that can connect wallet and revoke access")
+        browsing.options_button.click()
+        browsing.connect_account_button.click()
+        browsing.allow_button.click()
+        browsing.options_button.click()
+        if not browsing.connected_account_button.is_element_displayed():
+            self.driver.fail("Account is not connected")
+        browsing.click_system_back_button()
+        profile = browsing.profile_button.click()
+        profile.privacy_and_security_button.click()
+        profile.dapp_permissions_button.click()
+        if not profile.element_by_text('wikipedia.org').is_element_displayed():
+            self.errors.append("Permissions are not granted")
+        profile.dapp_tab_button.click(desired_element_text=self.wiki_texts[0])
+        browsing.options_button.click()
+        browsing.connected_account_button.click()
+        browsing.element_by_translation_id("revoke-access").click()
+        browsing.options_button.click()
+        if not browsing.connect_account_button.is_element_displayed():
+            self.errors.append("Permission for account is not removed if using 'Revoke access' from dapp view")
+        browsing.click_system_back_button()
+        browsing.profile_button.click(desired_element_text='DApp permissions')
+        if profile.element_by_text('wikipedia.org').is_element_displayed():
+            self.errors.append("Permissions are not revoked")
+        profile.get_back_to_home_view()
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702181)
+    def test_browser_open_chat_options(self):
+        dapp = self.home.dapp_tab_button.click()
+        browsing = dapp.open_url('www.wikipedia.org')
+
+        dapp.just_fyi("Check that can open chat view and send some message")
+        browsing.options_button.click()
+        browsing.open_chat_from_dapp_button.click()
+        public_chat = browsing.get_chat_view()
+        if not public_chat.element_by_text('#wikipedia-org').is_element_displayed():
+            self.driver.fail("No redirect to public chat")
+        message = public_chat.get_random_message()
+        public_chat.send_message(message)
+        public_chat.dapp_tab_button.click(desired_element_text=self.wiki_texts[0])
+        browsing.options_button.click()
+        browsing.open_chat_from_dapp_button.click()
+        if not public_chat.chat_element_by_text(message).is_element_displayed():
+            self.errors.append("Messages are not shown if open dapp chat from view")
+        public_chat.get_back_to_home_view()
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702182)
+    def test_browser_new_tab_open(self):
+        dapp = self.home.dapp_tab_button.click()
+        browsing = dapp.open_url('www.wikipedia.org')
+
+        dapp.just_fyi("Check that can open new tab using 'New tab' from bottom sheet")
+        browsing.options_button.click()
+        browsing.new_tab_button.click()
+        if not browsing.element_by_translation_id("open-dapp-store").is_element_displayed():
+            self.errors.append("Was not redirected to home dapp store view using New tab")
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702159)
+    def test_profile_invite_friends(self):
+        self.home.home_button.click()
+
+        self.home.just_fyi("Check it via 'Invite friends' on home view")
+        self.home.invite_friends_button.click()
+        self.home.share_via_messenger()
+        self.home.element_by_text_part("Hey join me on Status: https://join.status.im/u/0x")
+        self.home.click_system_back_button()
+
+        self.home.just_fyi("Check it via bottom sheet menu")
+        self.home.plus_button.click()
+        self.home.chats_menu_invite_friends_button.click()
+        self.home.share_via_messenger()
+        self.home.element_by_text_part("Hey join me on Status: https://join.status.im/u/0x")
+        self.home.click_system_back_button()
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702160)
+    def test_profile_add_remove_contact_via_contacts_view(self):
+
+        self.home.just_fyi('Check empty contacts view')
+        profile = self.home.profile_button.click()
+        profile.contacts_button.click()
+        if not profile.add_new_contact_button.is_element_displayed():
+            self.driver.fail('No expected element on contacts view')
+
+        users = {
+            'scanning_ens_with_stateofus_domain_deep_link': {
+                'contact_code': 'https://join.status.im/u/%s.stateofus.eth' % ens_user_ropsten['ens'],
+                'username': ens_user_ropsten['username']
+            },
+            'scanning_public_key': {
+                'contact_code': transaction_senders['A']['public_key'],
+                'username': transaction_senders['A']['username'],
+            },
+            'pasting_public_key': {
+                'contact_code': basic_user['public_key'],
+                'username': basic_user['username'],
+            },
+            'pasting_ens_another_domain': {
+                'contact_code': ens_user['ens_another'],
+                'username': '@%s' % ens_user['ens_another'],
+                'nickname': 'my_dear_friend'
+            },
+
+        }
+
+        self.home.just_fyi('Add contact  and check that they appear in Contacts view')
+        chat = self.home.get_chat_view()
+        for key in users:
+            profile.add_new_contact_button.click()
+            self.home.just_fyi('Checking %s case' % key)
+            if 'scanning' in key:
+                chat.scan_contact_code_button.click()
+                if chat.allow_button.is_element_displayed():
+                    chat.allow_button.click()
+                chat.enter_qr_edit_box.scan_qr(users[key]['contact_code'])
+            else:
+                chat.public_key_edit_box.click()
+                chat.public_key_edit_box.send_keys(users[key]['contact_code'])
+                if 'nickname' in users[key]:
+                    chat.nickname_input_field.set_value(users[key]['nickname'])
+                chat.confirm_until_presence_of_element(profile.add_new_contact_button)
+            if not profile.element_by_text(users[key]['username']).is_element_displayed():
+                self.errors.append('In %s case username not found in contact view after scanning' % key)
+            if 'nickname' in users[key]:
+                if not profile.element_by_text(users[key]['nickname']).is_element_displayed():
+                    self.errors.append('In %s case nickname %s not found in contact view after scanning' %
+                                       (key, users[key]['nickname']))
+
+        self.home.just_fyi('Remove contact and check that it disappeared')
+        user_to_remove = '@%s' % ens_user['ens_another']
+        profile.element_by_text(user_to_remove).click()
+        chat.remove_from_contacts.click()
+        chat.close_button.click()
+        if profile.element_by_text(user_to_remove).is_element_displayed():
+            self.errors.append('Removed user is still shown in contact view')
+
+        self.home.just_fyi(
+            'Relogin and open profile view of the contact removed from Contact list to ensure there is no crash')
+        profile.profile_button.click()
+        profile.relogin()
+        one_to_one_chat = self.home.add_contact(public_key=ens_user['ens_another'], add_in_contacts=False)
+        one_to_one_chat.chat_options.click()
+        profile = one_to_one_chat.view_profile_button.click()
+        if profile.remove_from_contacts.is_element_displayed():
+            self.errors.append('User still added in contact after relogin')
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702166)
+    def test_profile_add_custom_network(self):
+        self.home.get_back_to_home_view()
+
+        profile = self.home.profile_button.click()
+        profile.add_custom_network()
+        self.sign_in.sign_in()
+        self.home.profile_button.click()
+        profile.advanced_button.click()
+        profile.network_settings_button.scroll_to_element(10, 'up')
+        if not profile.element_by_text_part('custom_ropsten').is_element_displayed():
+            self.driver.fail("Network custom_ropsten was not added!")
+        profile.get_back_to_home_view()
+        # Switching back to Ropsten for the next cases
+        profile.switch_network('Ropsten with upstream RPC')
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702164)
+    def test_profile_backup_of_contacts(self):
+
+        self.home.just_fyi('Add user to contacts')
+        chat = self.home.add_contact(basic_user['public_key'])
+
+        self.home.just_fyi('Add nickname to contact')
+        nickname = 'test user'
+        chat.chat_options.click()
+        chat.view_profile_button.click()
+        chat.set_nickname(nickname)
+        self.home.back_button.click()
+
+        self.home.just_fyi('Add ENS-user to contacts')
+        user_ens = 'pavlotest.eth'
+        self.home.add_contact(user_ens)
+        self.home.back_button.click()
+
+        self.home.just_fyi('Block user')
+        self.home.add_contact(chat_users['A']['public_key'], add_in_contacts=False)
+        chat.chat_options.click()
+        chat.view_profile_button.click()
+        chat.block_contact()
+
+        self.home.just_fyi('Add nickname to non-contact user')
+        nickname1 = 'non-contact user'
+        self.home.add_contact(chat_users['B']['public_key'], add_in_contacts=False)
+        chat.chat_options.click()
+        chat.view_profile_button.click()
+        chat.set_nickname(nickname1)
+
+        self.home.just_fyi('Perform backup')
+        profile = self.home.profile_button.click()
+        profile.sync_settings_button.click()
+        profile.backup_settings_button.click()
+        profile.perform_backup_button.click()
+
+        profile.just_fyi('Backup seed phrase')
+        profile.back_button.click(2)
+        profile.privacy_and_security_button.click()
+        profile.backup_recovery_phrase_button.click()
+        profile.ok_continue_button.click()
+        recovery_phrase = profile.get_recovery_phrase()
+        self.drivers[0].reset()
+
+        profile.just_fyi('Recover account from seed phrase')
+        self.sign_in.recover_access(' '.join(recovery_phrase.values()))
+
+        self.sign_in.just_fyi('Check backup of contact with nickname')
+        profile.profile_button.click()
+        profile.contacts_button.click()
+        profile.wait_for_element_starts_with_text('Blocked users')
+        if not profile.element_by_text(nickname).is_element_displayed():
+            self.errors.append('Nickname of contact was not backed up')
+
+        self.sign_in.just_fyi('Check backup of ENS contact')
+        if not profile.element_by_text('@%s' % user_ens).is_element_displayed():
+            self.errors.append('ENS contact was not backed up')
+
+        self.sign_in.just_fyi('Check backup of blocked user')
+        profile.blocked_users_button.click()
+        if not profile.element_by_text(chat_users['A']['username']).is_element_displayed():
+            self.errors.append('Blocked user was not backed up')
+        profile.get_back_to_home_view()
+
+        self.sign_in.just_fyi('Check backup of nickname for non-contact user')
+        self.home.home_button.double_click()
+        self.home.add_contact(chat_users['B']['public_key'], add_in_contacts=False)
+        if not chat.element_by_text(nickname1).is_element_displayed():
+            self.errors.append("Nickname of non-contact user was not backed up")
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702165)
+    def test_profile_change_log_level(self):
+        self.home.get_back_to_home_view()
+
+        profile = self.home.profile_button.click()
+        profile.advanced_button.click()
+        default_log_level = 'INFO'
+        if not profile.element_by_text(default_log_level).is_element_displayed():
+            self.errors.append('%s is not selected by default' % default_log_level)
+        if self.home.find_values_in_geth('lvl=trce', 'lvl=dbug'):
+            self.errors.append('"%s" is set, but found another entries!' % default_log_level)
+        if not self.home.find_values_in_geth('lvl=info'):
+            self.errors.append('"%s" is set, but no entries are found!' % default_log_level)
+
+        self.home.just_fyi('Set another loglevel and check that changes are applied')
+        profile.log_level_setting_button.click()
+        changed_log_level = 'TRACE'
+        profile.element_by_text(changed_log_level).click_until_presence_of_element(profile.confirm_button)
+        profile.confirm_button.click()
+        self.sign_in.sign_in()
+        self.home.profile_button.click()
+        profile.advanced_button.click()
+        if not profile.element_by_text(changed_log_level).is_element_displayed():
+            self.errors.append('"%s" is not selected after change' % changed_log_level)
+        if not self.home.find_values_in_geth('lvl=trc'):
+            self.errors.append('"%s" is set, but no entries are found!' % changed_log_level)
+
+        profile.get_back_to_home_view()
+
+        self.errors.verify_no_errors()
+
+    @marks.testrail_id(702178)
+    def test_profile_change_fleet(self):
+
+        profile = self.home.profile_button.click()
+        profile.advanced_button.click()
+
+        if not profile.element_by_text(used_fleet).is_element_displayed():
+            self.errors.append('%s is not selected by default' % used_fleet)
+
+        self.home.just_fyi('Set another fleet and check that changes are applied')
+        profile.fleet_setting_button.click()
+        changed_fleet = 'wakuv2.prod'
+        profile.element_by_text(changed_fleet).click_until_presence_of_element(profile.confirm_button)
+        profile.confirm_button.click()
+        self.sign_in.sign_in()
+        self.home.profile_button.click()
+        profile.advanced_button.click()
+        if not profile.element_by_text(changed_fleet).is_element_displayed():
+            self.errors.append('"%s" fleet is not selected after change' % changed_fleet)
+        if not self.home.find_values_in_geth(changed_fleet):
+            self.errors.append('"%s" is set, but no entry is found!' % changed_fleet)
+
+        profile.get_back_to_home_view()
+
+        self.errors.verify_no_errors()
+
+    # This case should always be the last in group as it changes common password
+    @marks.testrail_id(702161)
+    def test_profile_can_reset_password(self):
+        self.home.get_back_to_home_view()
+
+        new_password = basic_user['special_chars_password']
+        profile = self.home.profile_button.click()
+        profile.privacy_and_security_button.click()
+
+        profile.just_fyi("Check that can not reset password when entering wrong current password")
+        profile.reset_password_button.click()
+        profile.current_password_edit_box.send_keys(common_password + '1')
+        profile.new_password_edit_box.set_value(new_password)
+        profile.confirm_new_password_edit_box.set_value(new_password)
+        profile.next_button.click()
+        if not profile.current_password_wrong_text.is_element_displayed():
+            self.errors.append("Validation error for wrong current password is not shown")
+
+        profile.just_fyi("Check that can not procced if did not confirm new password")
+        profile.current_password_edit_box.clear()
+        profile.current_password_edit_box.set_value(common_password)
+        profile.new_password_edit_box.set_value(new_password)
+        profile.confirm_new_password_edit_box.set_value(new_password + '1')
+        profile.next_button.click()
+
+        profile.just_fyi("Delete last symbol and check that can reset password")
+        profile.confirm_new_password_edit_box.delete_last_symbols(1)
+        profile.next_button.click()
+        profile.element_by_translation_id("password-reset-success").wait_for_element(30)
+        profile.element_by_translation_id("okay").click()
+
+        profile.just_fyi("Login with new password")
+        self.sign_in.sign_in(password=new_password)
+        if not self.sign_in.home_button.is_element_displayed():
+            self.errors.append("Could not sign in with new password after reset")
+
+        self.errors.verify_no_errors()