status-im/status-react
2
0
Fork 0
mirror of https://github.com/status-im/status-react.git synced 2025-01-28 19:56:10 +00:00
Code Issues Projects Releases Wiki Activity

e2e: additional logging for errors in tests

Browse Source
This commit is contained in:
Yevheniia Berdnyk 2025-01-22 20:53:59 +02:00
parent 85d00e47af
commit 4dfd616583
No known key found for this signature in database
9 changed files with 405 additions and 312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
test/appium/tests/activity_center/test_activity_center.py
View File

@ -40,9 +40,10 @@ class TestActivityCenterContactRequestMultipleDevicePR(MultipleSharedDeviceTestC
if text_name != self.username_1 and text_name != "%s...%s" % ( if text_name != self.username_1 and text_name != "%s...%s" % (
self.public_key_1[:3], self.public_key_1[-6:]): self.public_key_1[:3], self.public_key_1[-6:]):
self.errors.append( self.errors.append(
self.home_2,
"Neither username nor public key is shown on 'Add contact' page after entering valid public key") "Neither username nor public key is shown on 'Add contact' page after entering valid public key")
else: else:
self.errors.append("User is not found on 'Add contact' page after entering valid public key") self.errors.append(self.home_2, "User is not found on 'Add contact' page after entering valid public key")
chat = self.home_2.get_chat_view() chat = self.home_2.get_chat_view()
chat.view_profile_new_contact_button.click_until_presence_of_element(chat.profile_send_contact_request_button) chat.view_profile_new_contact_button.click_until_presence_of_element(chat.profile_send_contact_request_button)
@ -55,7 +56,8 @@ class TestActivityCenterContactRequestMultipleDevicePR(MultipleSharedDeviceTestC
self.device_1.just_fyi("Device 1: check there is no PN when receiving new message to activity centre") self.device_1.just_fyi("Device 1: check there is no PN when receiving new message to activity centre")
self.device_1.open_notification_bar() self.device_1.open_notification_bar()
if self.home_1.element_by_text_part("Please add me to your contacts").is_element_displayed(): if self.home_1.element_by_text_part("Please add me to your contacts").is_element_displayed():
self.errors.append("Push notification with text was received for new message in activity centre") self.errors.append(self.home_1,
"Push notification with text was received for new message in activity centre")
self.device_1.click_system_back_button() self.device_1.click_system_back_button()
self.device_1.driver.activate_app(app_package) self.device_1.driver.activate_app(app_package)
self.device_1.wait_for_application_to_be_running(app_package) self.device_1.wait_for_application_to_be_running(app_package)
@ -65,9 +67,9 @@ class TestActivityCenterContactRequestMultipleDevicePR(MultipleSharedDeviceTestC
for indicator in (self.home_1.notifications_unread_badge, self.home_1.contact_new_badge): for indicator in (self.home_1.notifications_unread_badge, self.home_1.contact_new_badge):
if not indicator.is_element_displayed(): if not indicator.is_element_displayed():
self.errors.append( self.errors.append(
"Unread indicator on contacts tab or on activity center is not shown for incoming CR!") self.home_1, "Unread indicator on contacts tab or on activity center is not shown for incoming CR!")
if self.home_1.pending_contact_request_text.text != '1': if self.home_1.pending_contact_request_text.text != '1':
self.errors.append("The amount of contact requests is not shown for incoming CR!") self.errors.append(self.home_1, "The amount of contact requests is not shown for incoming CR!")
self.device_1.just_fyi('Device1 declines pending contact request') self.device_1.just_fyi('Device1 declines pending contact request')
self.home_1.handle_contact_request(username=self.username_2, action='decline') self.home_1.handle_contact_request(username=self.username_2, action='decline')
@ -75,6 +77,7 @@ class TestActivityCenterContactRequestMultipleDevicePR(MultipleSharedDeviceTestC
self.home_1.pending_contact_request_text): self.home_1.pending_contact_request_text):
if indicator.is_element_displayed(): if indicator.is_element_displayed():
self.errors.append( self.errors.append(
self.home_1,
"Unread indicator on contacts tab or on activity center is shown after declining contact request!") "Unread indicator on contacts tab or on activity center is shown after declining contact request!")
self.device_1.just_fyi("Check that it is still pending contact after declining on sender device") self.device_1.just_fyi("Check that it is still pending contact after declining on sender device")
@ -85,7 +88,7 @@ class TestActivityCenterContactRequestMultipleDevicePR(MultipleSharedDeviceTestC
if element.title.text != 'Contact request' or element.context_tag_text != self.username_1 \ if element.title.text != 'Contact request' or element.context_tag_text != self.username_1 \
or not element.pending_status_tag.is_element_displayed(): or not element.pending_status_tag.is_element_displayed():
self.errors.append( self.errors.append(
"Pending contact request is not shown on unread notification element on Activity center!") self.home_2, "Pending contact request is not shown on unread notification element on Activity center!")
self.home_2.close_activity_centre.click() self.home_2.close_activity_centre.click()
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -123,7 +126,8 @@ class TestActivityCenterContactRequestMultipleDevicePR(MultipleSharedDeviceTestC
self.home_1.more_options_activity_button.click() self.home_1.more_options_activity_button.click()
self.home_1.mark_all_read_activity_button.click() self.home_1.mark_all_read_activity_button.click()
if cr_element.is_element_displayed(): if cr_element.is_element_displayed():
self.errors.append("Contact request is still shown in activity centre after marking all messages as read!") self.errors.append(
self.home_1, "Contact request is still shown in activity centre after marking all messages as read!")
self.home_1.just_fyi("Check that can accept contact request from read notifications") self.home_1.just_fyi("Check that can accept contact request from read notifications")
self.home_1.activity_unread_filter_button.click() self.home_1.activity_unread_filter_button.click()
@ -132,14 +136,16 @@ class TestActivityCenterContactRequestMultipleDevicePR(MultipleSharedDeviceTestC
self.home_1.close_activity_centre.click() self.home_1.close_activity_centre.click()
self.home_1.contacts_tab.click() self.home_1.contacts_tab.click()
if not self.home_1.contact_details_row(username=new_username).is_element_displayed(20): if not self.home_1.contact_details_row(username=new_username).is_element_displayed(20):
self.errors.append("Contact was not added to contact list after accepting contact request (as receiver)") self.errors.append(self.home_1,
"Contact was not added to contact list after accepting contact request (as receiver)")
self.device_2.just_fyi('Device1 check that contact appeared in contact list mutually') self.device_2.just_fyi('Device1 check that contact appeared in contact list mutually')
self.home_2.navigate_back_to_home_view() self.home_2.navigate_back_to_home_view()
self.home_2.chats_tab.click() self.home_2.chats_tab.click()
self.home_2.contacts_tab.click() self.home_2.contacts_tab.click()
if not self.home_2.contact_details_row(username=self.username_1).is_element_displayed(20): if not self.home_2.contact_details_row(username=self.username_1).is_element_displayed(20):
self.errors.append("Contact was not added to contact list after accepting contact request (as sender)") self.errors.append(self.home_2,
"Contact was not added to contact list after accepting contact request (as sender)")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -172,9 +178,10 @@ class TestActivityCenterContactRequestMultipleDevicePR(MultipleSharedDeviceTestC
text_name = self.home_1.user_name_text.text text_name = self.home_1.user_name_text.text
if text_name != self.username_2 and text_name != "%s...%s" % (public_key_2[:3], public_key_2[-6:]): if text_name != self.username_2 and text_name != "%s...%s" % (public_key_2[:3], public_key_2[-6:]):
self.errors.append( self.errors.append(
self.home_1,
"Neither username nor public key is shown on 'Add contact' page after entering valid profile link") "Neither username nor public key is shown on 'Add contact' page after entering valid profile link")
else: else:
self.errors.append("User is not found on 'Add contact' page after entering valid public key") self.errors.append(self.home_1, "User is not found on 'Add contact' page after entering valid public key")
chat_1 = self.home_1.get_chat_view() chat_1 = self.home_1.get_chat_view()
chat_1.view_profile_new_contact_button.click_until_presence_of_element( chat_1.view_profile_new_contact_button.click_until_presence_of_element(
chat_1.profile_send_contact_request_button) chat_1.profile_send_contact_request_button)
@ -197,9 +204,10 @@ class TestActivityCenterContactRequestMultipleDevicePR(MultipleSharedDeviceTestC
text_name = self.home_1.user_name_text.text text_name = self.home_1.user_name_text.text
if text_name != self.username_2 and text_name != "%s...%s" % (public_key_2[:3], public_key_2[-6:]): if text_name != self.username_2 and text_name != "%s...%s" % (public_key_2[:3], public_key_2[-6:]):
self.errors.append( self.errors.append(
self.home_1,
"Neither username nor public key is shown on 'Add contact' page after entering valid public key") "Neither username nor public key is shown on 'Add contact' page after entering valid public key")
else: else:
self.errors.append("User is not found on 'Add contact' page after entering valid public key") self.errors.append(self.home_1, "User is not found on 'Add contact' page after entering valid public key")
self.home_2.just_fyi("Device 2 gets sync code") self.home_2.just_fyi("Device 2 gets sync code")
self.home_2.navigate_back_to_home_view() self.home_2.navigate_back_to_home_view()
@ -217,7 +225,7 @@ class TestActivityCenterContactRequestMultipleDevicePR(MultipleSharedDeviceTestC
try: try:
self.home_1.element_by_translation_id("invalid-ens-or-key").wait_for_visibility_of_element() self.home_1.element_by_translation_id("invalid-ens-or-key").wait_for_visibility_of_element()
except TimeoutException: except TimeoutException:
self.errors.append("Error message is not shown for value \"%s\"" % value) self.errors.append(self.home_1, "Error message is not shown for value \"%s\"" % value)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -266,15 +274,16 @@ class TestActivityMultipleDevicePR(MultipleSharedDeviceTestCase):
self.community_1.click_on_floating_jump_to() self.community_1.click_on_floating_jump_to()
for card in (self.community_name, self.username_2): for card in (self.community_name, self.username_2):
if not self.community_1.element_by_text_part(card).is_element_displayed(20): if not self.community_1.element_by_text_part(card).is_element_displayed(20):
self.errors.append("Card %s is not shown on Jump to screen!" % card) self.errors.append(self.community_1, "Card %s is not shown on Jump to screen!" % card)
self.community_1.element_by_translation_id("community-channel").click() self.community_1.element_by_translation_id("community-channel").click()
if not self.channel_1.chat_element_by_text(self.text_message).is_element_displayed(20): if not self.channel_1.chat_element_by_text(self.text_message).is_element_displayed(20):
self.errors.append("User was not redirected to community channel after tapping on community channel card!") self.errors.append(self.channel_1,
"User was not redirected to community channel after tapping on community channel card!")
self.channel_1.click_system_back_button() self.channel_1.click_system_back_button()
self.community_1.click_on_floating_jump_to() self.community_1.click_on_floating_jump_to()
self.community_1.element_by_text_part(self.username_2).click() self.community_1.element_by_text_part(self.username_2).click()
if not self.chat_1.chat_element_by_text(self.one_to_one_message).is_element_displayed(20): if not self.chat_1.chat_element_by_text(self.one_to_one_message).is_element_displayed(20):
self.errors.append("User was not redirected to 1-1 chat after tapping card!") self.errors.append(self.chat_1, "User was not redirected to 1-1 chat after tapping card!")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -298,29 +307,29 @@ class TestActivityMultipleDevicePR(MultipleSharedDeviceTestCase):
community_element_1 = self.home_1.get_chat(self.community_name, community=True) community_element_1 = self.home_1.get_chat(self.community_name, community=True)
for unread_counter in community_element_1.new_messages_counter, self.home_1.communities_tab.counter: for unread_counter in community_element_1.new_messages_counter, self.home_1.communities_tab.counter:
if not unread_counter.is_element_displayed(60): if not unread_counter.is_element_displayed(60):
self.errors.append('New message counter badge is not shown!') self.errors.append(self.home_1, 'New message counter badge is not shown!')
if int(unread_counter.text) != 1: if int(unread_counter.text) != 1:
self.errors.append('New message counter badge is not 1, it is %s!' % unread_counter.text) self.errors.append(self.home_1, 'New message counter badge is not 1, it is %s!' % unread_counter.text)
self.home_1.just_fyi("Checking reply attributes in activity center") self.home_1.just_fyi("Checking reply attributes in activity center")
self.home_1.open_activity_center_button.click() self.home_1.open_activity_center_button.click()
reply_element = self.home_1.get_element_from_activity_center_view(reply_to_message_from_sender) reply_element = self.home_1.get_element_from_activity_center_view(reply_to_message_from_sender)
if reply_element.title.text != 'Reply': if reply_element.title.text != 'Reply':
self.errors.append("Expected title is not shown, '%s' is instead!" % reply_element.title) self.errors.append(self.home_1, "Expected title is not shown, '%s' is instead!" % reply_element.title)
if not reply_element.unread_indicator.is_element_displayed(): if not reply_element.unread_indicator.is_element_displayed():
self.errors.append("No unread dot is shown on activity center element!") self.errors.append(self.home_1, "No unread dot is shown on activity center element!")
self.home_2.chats_tab.is_element_displayed() # just saving device 2 session from expiration self.home_2.chats_tab.is_element_displayed() # just saving device 2 session from expiration
self.home_1.just_fyi("Swiping to 'Replies' on activity center and check unread there") self.home_1.just_fyi("Swiping to 'Replies' on activity center and check unread there")
self.home_1.mention_activity_tab_button.click() self.home_1.mention_activity_tab_button.click()
if reply_element.is_element_displayed(2): if reply_element.is_element_displayed(2):
self.errors.append("Filter on mentions is not working in Activity centre!") self.errors.append(self.home_1, "Filter on mentions is not working in Activity centre!")
self.home_1.reply_activity_tab_button.click() self.home_1.reply_activity_tab_button.click()
if not self.home_1.reply_activity_tab_button.counter.is_element_displayed(2): if not self.home_1.reply_activity_tab_button.counter.is_element_displayed(2):
self.errors.append("No unread dot is shown on activity center tab element!") self.errors.append(self.home_1, "No unread dot is shown on activity center tab element!")
if not reply_element.is_element_displayed(): if not reply_element.is_element_displayed():
self.errors.append("Filter on replies tab is not working in Activity centre!") self.errors.append(self.home_1, "Filter on replies tab is not working in Activity centre!")
self.home_2.chats_tab.is_element_displayed() # just saving device 2 session from expiration self.home_2.chats_tab.is_element_displayed() # just saving device 2 session from expiration
@ -328,10 +337,10 @@ class TestActivityMultipleDevicePR(MultipleSharedDeviceTestCase):
reply_element.title.swipe_right_on_element(width_percentage=6) reply_element.title.swipe_right_on_element(width_percentage=6)
self.home_1.activity_notification_swipe_button.click() self.home_1.activity_notification_swipe_button.click()
if reply_element.is_element_displayed(2): if reply_element.is_element_displayed(2):
self.errors.append("Message is not marked as read!") self.errors.append(self.home_1, "Message is not marked as read!")
self.home_1.activity_unread_filter_button.click() self.home_1.activity_unread_filter_button.click()
if not reply_element.is_element_displayed(2): if not reply_element.is_element_displayed(2):
self.errors.append("Read filter is not displayed read message!") self.errors.append(self.home_1, "Read filter is not displayed read message!")
self.home_2.chats_tab.is_element_displayed() # just saving device 2 session from expiration self.home_2.chats_tab.is_element_displayed() # just saving device 2 session from expiration
@ -339,16 +348,18 @@ class TestActivityMultipleDevicePR(MultipleSharedDeviceTestCase):
reply_element.title.swipe_right_on_element(width_percentage=6) reply_element.title.swipe_right_on_element(width_percentage=6)
self.home_1.activity_notification_swipe_button.click() self.home_1.activity_notification_swipe_button.click()
if not reply_element.unread_indicator.is_element_displayed(): if not reply_element.unread_indicator.is_element_displayed():
self.errors.append("No unread dot is shown on activity center element after marking it as unread!") self.errors.append(self.home_1,
"No unread dot is shown on activity center element after marking it as unread!")
self.home_1.just_fyi("Tap on it and check it marked as read") self.home_1.just_fyi("Tap on it and check it marked as read")
reply_element.click() reply_element.click()
if not self.channel_1.chat_element_by_text(reply_to_message_from_sender).is_element_displayed(): if not self.channel_1.chat_element_by_text(reply_to_message_from_sender).is_element_displayed():
self.errors.append("Was not redirected to chat after tapping on reply!") self.errors.append(self.home_1, "Was not redirected to chat after tapping on reply!")
self.home_1.navigate_back_to_home_view() self.home_1.navigate_back_to_home_view()
self.home_1.communities_tab.click() self.home_1.communities_tab.click()
if self.home_1.notifications_unread_badge.is_element_displayed(): if self.home_1.notifications_unread_badge.is_element_displayed():
self.errors.append("Notification was not marked as read after opening it in community channel!") self.errors.append(self.home_1,
"Notification was not marked as read after opening it in community channel!")
self.home_2.chats_tab.is_element_displayed() # just saving device 2 session from expiration self.home_2.chats_tab.is_element_displayed() # just saving device 2 session from expiration
@ -357,7 +368,7 @@ class TestActivityMultipleDevicePR(MultipleSharedDeviceTestCase):
reply_element.swipe_left_on_element() reply_element.swipe_left_on_element()
self.home_1.activity_notification_swipe_button.click() self.home_1.activity_notification_swipe_button.click()
if reply_element.is_element_displayed(): if reply_element.is_element_displayed():
self.errors.append("Reply is still shown after removing from activity centre!") self.errors.append(self.home_1, "Reply is still shown after removing from activity centre!")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -414,25 +425,26 @@ class TestActivityMultipleDevicePRTwo(MultipleSharedDeviceTestCase):
community_element_1 = self.home_1.get_chat(self.community_name, community=True) community_element_1 = self.home_1.get_chat(self.community_name, community=True)
for unread_counter in community_element_1.new_messages_counter, self.home_1.communities_tab.counter: for unread_counter in community_element_1.new_messages_counter, self.home_1.communities_tab.counter:
if not unread_counter.is_element_displayed(60): if not unread_counter.is_element_displayed(60):
self.errors.append('New message counter badge is not shown while mentioned!') self.errors.append(self.home_1, 'New message counter badge is not shown while mentioned!')
if int(unread_counter.text) != 1: if int(unread_counter.text) != 1:
self.errors.append('New message counter badge is not 1, it is %s!' % unread_counter.text) self.errors.append(self.home_1, 'New message counter badge is not 1, it is %s!' % unread_counter.text)
self.home_1.just_fyi("Checking mention attributes in activity center") self.home_1.just_fyi("Checking mention attributes in activity center")
self.home_1.open_activity_center_button.click() self.home_1.open_activity_center_button.click()
mention_element = self.home_1.get_element_from_activity_center_view('@%s' % self.username_1) mention_element = self.home_1.get_element_from_activity_center_view('@%s' % self.username_1)
if mention_element.title.text != 'Mention': if mention_element.title.text != 'Mention':
self.errors.append("Expected title is not shown, '%s' is instead!" % mention_element.title) self.errors.append(self.home_1, "Expected title is not shown, '%s' is instead!" % mention_element.title)
if not mention_element.unread_indicator.is_element_displayed(): if not mention_element.unread_indicator.is_element_displayed():
self.errors.append("No unread dot is shown on activity center element (mention)!") self.errors.append(self.home_1, "No unread dot is shown on activity center element (mention)!")
if mention_element.message_body.text != '@%s' % self.username_1: if mention_element.message_body.text != '@%s' % self.username_1:
self.errors.append( self.errors.append(
"Mention body in activity center does not match expected, it is %s!" % mention_element.message_body.text) self.home_1, "Mention body in activity center does not match expected, it is %s!"
% mention_element.message_body.text)
self.home_1.just_fyi("Tap on it and check redirect to channel") self.home_1.just_fyi("Tap on it and check redirect to channel")
mention_element.click() mention_element.click()
if not self.channel_1.chat_element_by_text(self.username_1).is_element_displayed(): if not self.channel_1.chat_element_by_text(self.username_1).is_element_displayed():
self.errors.append("Was not redirected to chat after tapping on mention!") self.errors.append(self.home_1, "Was not redirected to chat after tapping on mention!")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702958) @marks.testrail_id(702958)
@ -465,13 +477,13 @@ class TestActivityMultipleDevicePRTwo(MultipleSharedDeviceTestCase):
try: try:
self.home_1.notifications_unread_badge.wait_for_visibility_of_element(120) self.home_1.notifications_unread_badge.wait_for_visibility_of_element(120)
except TimeoutException: except TimeoutException:
self.errors.append("Unread indicator is not shown in notifications") self.errors.append(self.home_1, "Unread indicator is not shown in notifications")
self.home_1.open_activity_center_button.click() self.home_1.open_activity_center_button.click()
reply_element = self.home_1.get_element_from_activity_center_view(self.username_2) reply_element = self.home_1.get_element_from_activity_center_view(self.username_2)
if reply_element.title.text != 'Join request': if reply_element.title.text != 'Join request':
self.errors.append("Expected title is not shown, '%s' is instead!" % reply_element.title) self.errors.append(self.home_1, "Expected title is not shown, '%s' is instead!" % reply_element.title)
if not reply_element.unread_indicator.is_element_displayed(): if not reply_element.unread_indicator.is_element_displayed():
self.errors.append("No unread dot is shown on activity center element!") self.errors.append(self.home_1, "No unread dot is shown on activity center element!")
reply_element.title.swipe_right_on_element(width_percentage=2.5) reply_element.title.swipe_right_on_element(width_percentage=2.5)
self.home_1.activity_notification_swipe_button.click() self.home_1.activity_notification_swipe_button.click()
self.home_1.close_activity_centre.click() self.home_1.close_activity_centre.click()
@ -479,5 +491,5 @@ class TestActivityMultipleDevicePRTwo(MultipleSharedDeviceTestCase):
self.home_2.just_fyi("Checking that community appeared on the list") self.home_2.just_fyi("Checking that community appeared on the list")
if not self.home_2.element_by_text_part(community_name).is_element_displayed(30): if not self.home_2.element_by_text_part(community_name).is_element_displayed(30):
self.errors.append( self.errors.append(
"Community is not appeared in the list after accepting admin request from activity centre") self.home_2, "Community is not appeared in the list after accepting admin request from activity centre")
self.errors.verify_no_errors() self.errors.verify_no_errors()

9
test/appium/tests/base_test_case.py
View File

@ -18,6 +18,7 @@ from urllib3.exceptions import MaxRetryError, ProtocolError
from support.api.network_api import NetworkApi from support.api.network_api import NetworkApi
from tests import test_suite_data, start_threads, pytest_config_global, transl from tests import test_suite_data, start_threads, pytest_config_global, transl
from tests.conftest import github_report, run_name, lambda_test_username, lambda_test_access_key from tests.conftest import github_report, run_name, lambda_test_username, lambda_test_access_key
from views.base_view import BaseView
executor_lambda_test = 'https://%s:%s@mobile-hub.lambdatest.com/wd/hub' % (lambda_test_username, lambda_test_access_key) executor_lambda_test = 'https://%s:%s@mobile-hub.lambdatest.com/wd/hub' % (lambda_test_username, lambda_test_access_key)
@ -164,12 +165,14 @@ class Driver(webdriver.Remote):
self.execute_script("lambda-hook: %s" % str(data).replace("'", "\"")) self.execute_script("lambda-hook: %s" % str(data).replace("'", "\""))
class Errors(object): class Errors:
def __init__(self): def __init__(self):
self.errors = list() self.errors = list()
def append(self, text=str()): def append(self, view: BaseView, text: str):
self.errors.append(text) error_text = "Device %s: %s" % (view.driver.number, text)
self.errors.append(error_text)
view.driver.log_event("appium", error_text)
def verify_no_errors(self): def verify_no_errors(self):
if self.errors: if self.errors:

148
test/appium/tests/critical/chats/test_1_1_public_chats.py
View File

@ -89,13 +89,13 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
if not self.chat_1.user_list_element_by_name( if not self.chat_1.user_list_element_by_name(
self.username_1).is_element_displayed() or not self.chat_1.user_list_element_by_name( self.username_1).is_element_displayed() or not self.chat_1.user_list_element_by_name(
self.username_2).is_element_displayed(): self.username_2).is_element_displayed():
self.errors.append("Incorrect users are shown for 'love' reaction.") self.errors.append(self.chat_1, "Incorrect users are shown for 'love' reaction.")
self.chat_1.authors_for_reaction(emoji="thumbs-up").double_click() self.chat_1.authors_for_reaction(emoji="thumbs-up").double_click()
if not self.chat_1.user_list_element_by_name( if not self.chat_1.user_list_element_by_name(
self.username_1).is_element_displayed() or self.chat_1.user_list_element_by_name( self.username_1).is_element_displayed() or self.chat_1.user_list_element_by_name(
self.username_2).is_element_displayed(): self.username_2).is_element_displayed():
self.errors.append("Incorrect users are shown for 'thumbs-up' reaction.") self.errors.append(self.chat_1, "Incorrect users are shown for 'thumbs-up' reaction.")
self.chat_1.driver.press_keycode(4) self.chat_1.driver.press_keycode(4)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -111,17 +111,18 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.chat_1.send_message(emoji.emojize(emoji_name)) self.chat_1.send_message(emoji.emojize(emoji_name))
for chat in self.chat_1, self.chat_2: for chat in self.chat_1, self.chat_2:
if not chat.chat_element_by_text(emoji_unicode).is_element_displayed(): if not chat.chat_element_by_text(emoji_unicode).is_element_displayed():
self.errors.append('Message with emoji was not sent or received in 1-1 chat') self.errors.append(chat, 'Message with emoji was not sent or received in 1-1 chat')
self.chat_1.quote_message(emoji_unicode) self.chat_1.quote_message(emoji_unicode)
actual_text = self.chat_1.quote_username_in_message_input.text actual_text = self.chat_1.quote_username_in_message_input.text
if actual_text != "You": if actual_text != "You":
self.errors.append( self.errors.append(
self.chat_1,
"'You' is not displayed in reply quote snippet replying to own message, '%s' instead" % actual_text) "'You' is not displayed in reply quote snippet replying to own message, '%s' instead" % actual_text)
self.chat_1.just_fyi("Clear quote and check there is not snippet anymore") self.chat_1.just_fyi("Clear quote and check there is not snippet anymore")
self.chat_1.cancel_reply_button.click() self.chat_1.cancel_reply_button.click()
if self.chat_1.cancel_reply_button.is_element_displayed(): if self.chat_1.cancel_reply_button.is_element_displayed():
self.errors.append("Message quote kept in public chat input after it was cancelled") self.errors.append(self.chat_1, "Message quote kept in public chat input after it was cancelled")
self.chat_1.just_fyi("Send reply") self.chat_1.just_fyi("Send reply")
self.chat_1.quote_message(emoji_unicode) self.chat_1.quote_message(emoji_unicode)
@ -130,7 +131,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.chat_1.just_fyi("Receiver verifies received reply...") self.chat_1.just_fyi("Receiver verifies received reply...")
if self.chat_2.chat_element_by_text(reply_to_message_from_sender).replied_message_text != emoji_unicode: if self.chat_2.chat_element_by_text(reply_to_message_from_sender).replied_message_text != emoji_unicode:
self.errors.append("No reply received in 1-1 chat") self.errors.append(self.chat_2, "No reply received in 1-1 chat")
else: else:
self.chat_2.just_fyi("Device 2 sets a reaction on the message reply. Device 1 checks the reaction") self.chat_2.just_fyi("Device 2 sets a reaction on the message reply. Device 1 checks the reaction")
self.chat_1.set_reaction(reply_to_message_from_sender) self.chat_1.set_reaction(reply_to_message_from_sender)
@ -138,7 +139,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.chat_1.chat_element_by_text( self.chat_1.chat_element_by_text(
reply_to_message_from_sender).emojis_below_message().wait_for_element_text(1) reply_to_message_from_sender).emojis_below_message().wait_for_element_text(1)
except Failed: except Failed:
self.errors.append("Reply message reaction is not shown for the sender") self.errors.append(self.chat_1, "Reply message reaction is not shown for the sender")
self.home_1.just_fyi("Check that link can be opened and replied from 1-1 chat") self.home_1.just_fyi("Check that link can be opened and replied from 1-1 chat")
reply = 'reply to link' reply = 'reply to link'
@ -149,14 +150,15 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.chat_2.send_message(reply) self.chat_2.send_message(reply)
replied_message = self.chat_1.chat_element_by_text(reply) replied_message = self.chat_1.chat_element_by_text(reply)
if replied_message.replied_message_text != url_message: if replied_message.replied_message_text != url_message:
self.errors.append("Reply for '%s' not present in message received in public chat" % url_message) self.errors.append(self.chat_1,
"Reply for '%s' not present in message received in public chat" % url_message)
self.chat_2.just_fyi("Device 2 sets a reaction on the message with a link. Device 1 checks the reaction") self.chat_2.just_fyi("Device 2 sets a reaction on the message with a link. Device 1 checks the reaction")
self.chat_2.set_reaction(url_message) self.chat_2.set_reaction(url_message)
try: try:
self.chat_1.chat_element_by_text(url_message).emojis_below_message().wait_for_element_text(1) self.chat_1.chat_element_by_text(url_message).emojis_below_message().wait_for_element_text(1)
except (Failed, NoSuchElementException): except (Failed, NoSuchElementException):
self.errors.append("Link message reaction is not shown for the sender") self.errors.append(self.chat_1, "Link message reaction is not shown for the sender")
self.home_2.just_fyi("Check 'Open in Status' option") self.home_2.just_fyi("Check 'Open in Status' option")
# url_to_open = 'http://status.app' # url_to_open = 'http://status.app'
@ -169,15 +171,15 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
try: try:
self.chat_2.wait_for_current_package_to_be('com.android.chrome') self.chat_2.wait_for_current_package_to_be('com.android.chrome')
except TimeoutException: except TimeoutException:
self.errors.append('URL was not opened from 1-1 chat') self.errors.append(self.chat_2, 'URL was not opened from 1-1 chat')
else: else:
self.chat_2.element_by_text("No thanks").click_if_shown() self.chat_2.element_by_text("No thanks").click_if_shown()
text_element = self.chat_2.element_by_text("a free (libre) open source, mobile OS for Ethereum") text_element = self.chat_2.element_by_text("a free (libre) open source, mobile OS for Ethereum")
sign_in_button = Button(self.chat_2.driver, xpath="//android.view.View[@content-desc='Sign in']") sign_in_button = Button(self.chat_2.driver, xpath="//android.view.View[@content-desc='Sign in']")
if not text_element.is_element_displayed() or not sign_in_button.is_element_displayed(): if not text_element.is_element_displayed() or not sign_in_button.is_element_displayed():
self.errors.append('URL was not opened from 1-1 chat') self.errors.append(self.chat_2, 'URL was not opened from 1-1 chat')
else: else:
self.errors.append("Message with URL was not received") self.errors.append(self.chat_2, "Message with URL was not received")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -212,14 +214,15 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
else: else:
expected_text = "You" if message == self.message_2 else self.username_1 expected_text = "You" if message == self.message_2 else self.username_1
if text != expected_text: if text != expected_text:
self.errors.append( self.errors.append(chat,
"Pinned by '%s' doesn't match expected '%s' for user %s" % ( "Pinned by '%s' doesn't match expected '%s' for user %s" % (
text, expected_text, chat_number + 1) text, expected_text, chat_number + 1)
) )
else: else:
self.errors.append( self.errors.append(chat,
"Message '%s' is missed on Pinned messages list for user %s" % (message, chat_number + 1) "Message '%s' is missed on Pinned messages list for user %s" % (
) message, chat_number + 1)
)
chat.click_system_back_button() chat.click_system_back_button()
self.home_1.just_fyi("Check that Device1 can not pin more than 3 messages and 'Unpin' dialog appears") self.home_1.just_fyi("Check that Device1 can not pin more than 3 messages and 'Unpin' dialog appears")
@ -232,22 +235,23 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.chat_1.view_pinned_messages_button.click_until_presence_of_element(self.chat_1.pinned_messages_list) self.chat_1.view_pinned_messages_button.click_until_presence_of_element(self.chat_1.pinned_messages_list)
if self.chat_1.pinned_messages_list.get_pinned_messages_number() > 3 \ if self.chat_1.pinned_messages_list.get_pinned_messages_number() > 3 \
or self.chat_1.pinned_messages_list.message_element_by_text(self.message_4).is_element_displayed(): or self.chat_1.pinned_messages_list.message_element_by_text(self.message_4).is_element_displayed():
self.errors.append("Can pin more than 3 messages in chat") self.errors.append(self.chat_1, "Can pin more than 3 messages in chat")
else: else:
unpin_element = self.chat_1.element_by_translation_id('unpin-from-chat') unpin_element = self.chat_1.element_by_translation_id('unpin-from-chat')
self.chat_1.pinned_messages_list.message_element_by_text(self.message_2).long_press_without_release() self.chat_1.pinned_messages_list.message_element_by_text(self.message_2).long_press_without_release()
self.home_1.just_fyi("Unpin one message so that another could be pinned") self.home_1.just_fyi("Unpin one message so that another could be pinned")
unpin_element.click_until_absense_of_element(desired_element=unpin_element) unpin_element.click_until_absense_of_element(desired_element=unpin_element)
self.chat_1.pin_message(self.message_4, 'pin-to-chat') self.chat_1.pin_message(self.message_4, 'pin-to-chat')
if not (self.chat_1.chat_element_by_text(self.message_4).pinned_by_label.is_element_displayed(30) and for chat in self.chat_1, self.chat_2:
self.chat_2.chat_element_by_text(self.message_4).pinned_by_label.is_element_displayed(30)): if chat.chat_element_by_text(self.message_4).pinned_by_label.is_element_displayed(30):
self.errors.append("Message 4 is not pinned in chat after unpinning previous one") self.errors.append(chat, "Message 4 is not pinned in chat after unpinning previous one")
self.home_1.just_fyi("Check pinned messages are visible in Pinned panel for both users") self.home_1.just_fyi("Check pinned messages are visible in Pinned panel for both users")
for chat_number, chat in enumerate([self.chat_1, self.chat_2]): for chat_number, chat in enumerate([self.chat_1, self.chat_2]):
count = chat.pinned_messages_count.text count = chat.pinned_messages_count.text
if count != '3': if count != '3':
self.errors.append("Pinned messages count is %s but should be 3 for user %s" % (count, chat_number + 1)) self.errors.append(chat,
"Pinned messages count is %s but should be 3 for user %s" % (count, chat_number + 1))
self.home_1.just_fyi("Unpin one message and check it's unpinned for another user") self.home_1.just_fyi("Unpin one message and check it's unpinned for another user")
self.chat_2.tap_by_coordinates(500, 100) self.chat_2.tap_by_coordinates(500, 100)
@ -268,7 +272,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
chat.pinned_messages_count.wait_for_element_text(text='2', wait_time=20) chat.pinned_messages_count.wait_for_element_text(text='2', wait_time=20)
except Failed: except Failed:
self.errors.append( self.errors.append(
"Pinned messages count is not 2 after unpinning the last pinned message for user %s" % ( chat, "Pinned messages count is not 2 after unpinning the last pinned message for user %s" % (
chat_number + 1) chat_number + 1)
) )
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -293,7 +297,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
for message in messages: for message in messages:
self.chat_2.send_message(message) self.chat_2.send_message(message)
if not self.chat_1.chat_element_by_text(message).is_element_displayed(30): if not self.chat_1.chat_element_by_text(message).is_element_displayed(30):
self.errors.append("Message with text '%s' was not received" % message) self.errors.append(self.chat_1, "Message with text '%s' was not received" % message)
self.chat_2.just_fyi("Checking updated member photo, timestamp and username on message") self.chat_2.just_fyi("Checking updated member photo, timestamp and username on message")
self.chat_2.hide_keyboard_if_shown() self.chat_2.hide_keyboard_if_shown()
@ -301,13 +305,15 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
timestamp = self.chat_2.chat_element_by_text(messages[0]).timestamp timestamp = self.chat_2.chat_element_by_text(messages[0]).timestamp
sent_time_variants = self.chat_2.convert_device_time_to_chat_timestamp() sent_time_variants = self.chat_2.convert_device_time_to_chat_timestamp()
if timestamp not in sent_time_variants: if timestamp not in sent_time_variants:
self.errors.append( self.errors.append(self.chat_2,
'Timestamp on message %s does not correspond expected %s' % (timestamp, sent_time_variants)) 'Timestamp on message %s does not correspond expected %s' % (
timestamp, sent_time_variants))
except NoSuchElementException: except NoSuchElementException:
self.errors.append("No timestamp on message %s" % messages[0]) self.errors.append(self.chat_2, "No timestamp on message %s" % messages[0])
for message in [messages[1], messages[2]]: for message in [messages[1], messages[2]]:
if self.chat_2.chat_element_by_text(message).member_photo.is_element_displayed(): if self.chat_2.chat_element_by_text(message).member_photo.is_element_displayed():
self.errors.append('%s is not stack to 1st(they are sent in less than 5 minutes)!' % message) self.errors.append(self.chat_2,
'%s is not stack to 1st(they are sent in less than 5 minutes)!' % message)
self.chat_1.just_fyi("Sending message") self.chat_1.just_fyi("Sending message")
message = 'profile_photo' message = 'profile_photo'
@ -319,7 +325,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.home_2.get_chat(self.username_1).click() self.home_2.get_chat(self.username_1).click()
if self.chat_2.chat_element_by_text(message).member_photo.is_element_differs_from_template( if self.chat_2.chat_element_by_text(message).member_photo.is_element_differs_from_template(
"profile_image_in_1_1_chat.png", diff=7): "profile_image_in_1_1_chat.png", diff=7):
self.errors.append("Image of user in 1-1 chat is too different from template!") self.errors.append(self.chat_2, "Image of user in 1-1 chat is too different from template!")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702813) @marks.testrail_id(702813)
@ -371,9 +377,10 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.device_1.just_fyi("Checks there are no PN after message was seen") self.device_1.just_fyi("Checks there are no PN after message was seen")
[home.open_notification_bar() for home in self.homes] [home.open_notification_bar() for home in self.homes]
if (self.device_2.element_by_text_part(message).is_element_displayed() if self.device_2.element_by_text_part(message).is_element_displayed():
or self.device_1.element_by_text_part(emoji_unicode).is_element_displayed()): self.errors.append(self.chat_2, "PN are keep staying after message '%s' was seen by user" % message)
self.errors.append("PN are keep staying after message was seen by user") if self.device_1.element_by_text_part(emoji_unicode).is_element_displayed():
self.errors.append(self.chat_1, "PN are keep staying after message '%s' was seen by user" % emoji_unicode)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702855) @marks.testrail_id(702855)
@ -393,7 +400,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
message_text_after_edit = message_after_edit_1_1 + ' (Edited)' message_text_after_edit = message_after_edit_1_1 + ' (Edited)'
chat_element = self.chat_1.chat_element_by_text(message_text_after_edit) chat_element = self.chat_1.chat_element_by_text(message_text_after_edit)
if not chat_element.is_element_displayed(30): if not chat_element.is_element_displayed(30):
self.errors.append('No edited message in 1-1 chat displayed') self.errors.append(self.chat_1, 'No edited message in 1-1 chat displayed')
else: else:
self.device_1.just_fyi("Device 1 sets a reaction on the edited message. Device 2 checks the reaction") self.device_1.just_fyi("Device 1 sets a reaction on the edited message. Device 2 checks the reaction")
self.chat_1.set_reaction(message_text_after_edit) self.chat_1.set_reaction(message_text_after_edit)
@ -401,7 +408,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.chat_1.chat_element_by_text( self.chat_1.chat_element_by_text(
message_text_after_edit).emojis_below_message().wait_for_element_text(1) message_text_after_edit).emojis_below_message().wait_for_element_text(1)
except Failed: except Failed:
self.errors.append("Message reaction is not shown for the sender") self.errors.append(self.chat_1, "Message reaction is not shown for the sender")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(703391) @marks.testrail_id(703391)
@ -425,7 +432,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.chat_2.chat_element_by_text(image_description).wait_for_visibility_of_element(30) self.chat_2.chat_element_by_text(image_description).wait_for_visibility_of_element(30)
if not self.chat_2.chat_element_by_text( if not self.chat_2.chat_element_by_text(
image_description).image_in_message.is_element_image_similar_to_template('image_1_chat_view.png'): image_description).image_in_message.is_element_image_similar_to_template('image_1_chat_view.png'):
self.errors.append("Not expected image is shown to the receiver.") self.errors.append(self.chat_2, "Not expected image is shown to the receiver.")
for chat in self.chat_1, self.chat_2: for chat in self.chat_1, self.chat_2:
chat.just_fyi("Open the image and share it") chat.just_fyi("Open the image and share it")
@ -437,8 +444,9 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
try: try:
chat.wait_for_current_package_to_be('com.google.android.apps.docs') chat.wait_for_current_package_to_be('com.google.android.apps.docs')
except TimeoutException: except TimeoutException:
self.errors.append( self.errors.append(chat,
"%s can't share an image via Gmail." % ("Sender" if chat is self.chat_1 else "Receiver")) "%s can't share an image via Gmail." % (
"Sender" if chat is self.chat_1 else "Receiver"))
chat.navigate_back_to_chat_view() chat.navigate_back_to_chat_view()
for chat in self.chat_1, self.chat_2: for chat in self.chat_1, self.chat_2:
@ -452,10 +460,10 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
toast_element_text = toast_element.text toast_element_text = toast_element.text
if toast_element_text != chat.get_translation_by_key("photo-saved"): if toast_element_text != chat.get_translation_by_key("photo-saved"):
self.errors.append( self.errors.append(
"Shown message '%s' doesn't match expected '%s' after saving an image for %s." % ( chat, "Shown message '%s' doesn't match expected '%s' after saving an image for %s." % (
toast_element_text, chat.get_translation_by_key("photo-saved"), device_name)) toast_element_text, chat.get_translation_by_key("photo-saved"), device_name))
else: else:
self.errors.append("Message about saving a photo is not shown for %s." % device_name) self.errors.append(chat, "Message about saving a photo is not shown for %s." % device_name)
chat.navigate_back_to_chat_view() chat.navigate_back_to_chat_view()
for chat in self.chat_1, self.chat_2: for chat in self.chat_1, self.chat_2:
@ -463,8 +471,9 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
chat.show_images_button.click() chat.show_images_button.click()
chat.allow_all_button.click_if_shown() chat.allow_all_button.click_if_shown()
if not chat.get_image_by_index(0).is_element_image_similar_to_template("image_1_gallery_view.png"): if not chat.get_image_by_index(0).is_element_image_similar_to_template("image_1_gallery_view.png"):
self.errors.append( self.errors.append(chat,
"Image is not saved to gallery for %s." % ("sender" if chat is self.chat_1 else "receiver")) "Image is not saved to gallery for %s." % (
"sender" if chat is self.chat_1 else "receiver"))
chat.click_system_back_button() chat.click_system_back_button()
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -490,7 +499,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
chat_1_element.long_press_without_release() chat_1_element.long_press_without_release()
for action in ("edit", "delete-for-everyone"): for action in ("edit", "delete-for-everyone"):
if self.chat_1.element_by_translation_id(action).is_element_displayed(): if self.chat_1.element_by_translation_id(action).is_element_displayed():
self.errors.append('Option to %s someone else message available!' % action) self.errors.append(self.chat_1, 'Option to %s someone else message available!' % action)
self.home_1.tap_by_coordinates(500, 100) self.home_1.tap_by_coordinates(500, 100)
self.device_2.just_fyi("Delete message for me and check it is only deleted for the author") self.device_2.just_fyi("Delete message for me and check it is only deleted for the author")
@ -500,23 +509,23 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.chat_2.chat_element_by_text(message_to_delete_for_me).wait_for_status_to_be("Delivered", timeout) self.chat_2.chat_element_by_text(message_to_delete_for_me).wait_for_status_to_be("Delivered", timeout)
self.chat_2.delete_message_in_chat(message_to_delete_for_me, everyone=False) self.chat_2.delete_message_in_chat(message_to_delete_for_me, everyone=False)
except TimeoutException: except TimeoutException:
self.errors.append("Message status was not changed to 'Delivered' after %s s" % timeout) self.errors.append(self.chat_2, "Message status was not changed to 'Delivered' after %s s" % timeout)
else: else:
if not self.chat_2.chat_element_by_text(message_to_delete_for_me).is_element_disappeared(20): if not self.chat_2.chat_element_by_text(message_to_delete_for_me).is_element_disappeared(20):
self.errors.append("Deleted for me message is shown in chat for the author of message") self.errors.append(self.chat_2, "Deleted for me message is shown in chat for the author of message")
if not self.chat_2.element_by_translation_id('message-deleted-for-you').is_element_displayed(20): if not self.chat_2.element_by_translation_id('message-deleted-for-you').is_element_displayed(20):
self.errors.append("System message about deletion for you is not displayed") self.errors.append(self.chat_2, "System message about deletion for you is not displayed")
if not self.chat_1.chat_element_by_text(message_to_delete_for_me).is_element_displayed(20): if not self.chat_1.chat_element_by_text(message_to_delete_for_me).is_element_displayed(20):
self.errors.append("Deleted for me message is deleted for both users") self.errors.append(self.chat_1, "Deleted for me message is deleted for both users")
self.device_2.just_fyi("Delete message for everyone and check it is not shown in chat preview on home") self.device_2.just_fyi("Delete message for everyone and check it is not shown in chat preview on home")
self.chat_2.delete_message_in_chat(message_after_edit_1_1) self.chat_2.delete_message_in_chat(message_after_edit_1_1)
for chat in (self.chat_2, self.chat_1): for chat in (self.chat_2, self.chat_1):
if chat.chat_element_by_text(message_after_edit_1_1).is_element_displayed(30): if chat.chat_element_by_text(message_after_edit_1_1).is_element_displayed(30):
self.errors.append("Deleted message is shown in chat view for 1-1 chat") self.errors.append(chat, "Deleted message is shown in chat view for 1-1 chat")
self.chat_1.navigate_back_to_home_view() self.chat_1.navigate_back_to_home_view()
if self.home_1.element_by_text(message_after_edit_1_1).is_element_displayed(30): if self.home_1.element_by_text(message_after_edit_1_1).is_element_displayed(30):
self.errors.append("Deleted message is shown on chat element on home screen") self.errors.append(self.home_1, "Deleted message is shown on chat element on home screen")
self.device_2.just_fyi("Send one more message and check that PN will be deleted with message deletion") self.device_2.just_fyi("Send one more message and check that PN will be deleted with message deletion")
message_to_delete = 'DELETE ME' message_to_delete = 'DELETE ME'
@ -527,12 +536,12 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
if not self.home_1.get_pn(message_to_delete): if not self.home_1.get_pn(message_to_delete):
self.home_1.click_system_back_button() self.home_1.click_system_back_button()
self.device_2.driver.activate_app(app_package) self.device_2.driver.activate_app(app_package)
self.errors.append("Push notification doesn't appear") self.errors.append(self.home_1, "Push notification doesn't appear")
self.chat_2.delete_message_in_chat(message_to_delete) self.chat_2.delete_message_in_chat(message_to_delete)
pn_to_disappear = self.home_1.get_pn(message_to_delete) pn_to_disappear = self.home_1.get_pn(message_to_delete)
if pn_to_disappear: if pn_to_disappear:
if not pn_to_disappear.is_element_disappeared(90): if not pn_to_disappear.is_element_disappeared(90):
self.errors.append("Push notification was not removed after initial message deletion") self.errors.append(self.home_1, "Push notification was not removed after initial message deletion")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -580,9 +589,9 @@ class TestOneToOneChatMultipleSharedDevicesNewUiTwo(MultipleSharedDeviceTestCase
chat_element = chat.chat_element_by_text(image_description) chat_element = chat.chat_element_by_text(image_description)
if chat_element.is_element_displayed(30): if chat_element.is_element_displayed(30):
if not chat_element.image_in_message.is_element_image_similar_to_template('saucelabs_camera_image.png'): if not chat_element.image_in_message.is_element_image_similar_to_template('saucelabs_camera_image.png'):
self.errors.append("Not expected image is shown to the %s." % chat_name) self.errors.append(chat, "Not expected image is shown to the %s." % chat_name)
else: else:
self.errors.append("Message with camera image is not shown in chat for %s" % chat_name) self.errors.append(chat, "Message with camera image is not shown in chat for %s" % chat_name)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702783) @marks.testrail_id(702783)
@ -608,7 +617,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUiTwo(MultipleSharedDeviceTestCase
self.chat_2.send_message(message_1) self.chat_2.send_message(message_1)
status = self.chat_2.chat_element_by_text(message_1).status status = self.chat_2.chat_element_by_text(message_1).status
if not (status == 'Sending' or status == 'Sent'): if not (status == 'Sending' or status == 'Sent'):
self.errors.append('Message status is not "Sending", it is "%s"!' % status) self.errors.append(self.chat_2, 'Message status is not "Sending", it is "%s"!' % status)
self.home_2.just_fyi('Device2 goes back online and checks that status of the message is changed to "delivered"') self.home_2.just_fyi('Device2 goes back online and checks that status of the message is changed to "delivered"')
for home in self.homes: for home in self.homes:
@ -616,13 +625,13 @@ class TestOneToOneChatMultipleSharedDevicesNewUiTwo(MultipleSharedDeviceTestCase
self.home_1.just_fyi('Device1 goes back online and checks that 1-1 chat will be fetched') self.home_1.just_fyi('Device1 goes back online and checks that 1-1 chat will be fetched')
if not self.chat_1.chat_element_by_text(message_1).is_element_displayed(120): if not self.chat_1.chat_element_by_text(message_1).is_element_displayed(120):
self.errors.append("Message was not delivered after resending from offline") self.errors.append(self.chat_1, "Message was not delivered after resending from offline")
self.home_2.just_fyi('Device1 goes back online and checks that 1-1 chat will be fetched') self.home_2.just_fyi('Device1 goes back online and checks that 1-1 chat will be fetched')
try: try:
self.chat_2.chat_element_by_text(message_1).wait_for_status_to_be(expected_status='Delivered', timeout=120) self.chat_2.chat_element_by_text(message_1).wait_for_status_to_be(expected_status='Delivered', timeout=120)
except TimeoutException as e: except TimeoutException as e:
self.errors.append('%s after back up online!' % e.msg) self.errors.append(self.chat_2, '%s after back up online!' % e.msg)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(703496) @marks.testrail_id(703496)
@ -636,33 +645,35 @@ class TestOneToOneChatMultipleSharedDevicesNewUiTwo(MultipleSharedDeviceTestCase
self.chat_2.send_message(muted_message) self.chat_2.send_message(muted_message)
chat = self.home_1.get_chat(self.username_2) chat = self.home_1.get_chat(self.username_2)
if chat.new_messages_counter.is_element_displayed(30) or self.home_1.chats_tab.counter.is_element_displayed(10): if chat.new_messages_counter.is_element_displayed(30) or self.home_1.chats_tab.counter.is_element_displayed(10):
self.errors.append("New messages counter is shown after mute") self.errors.append(self.home_1, "New messages counter is shown after mute")
if not chat.chat_preview.text.startswith(muted_message): if not chat.chat_preview.text.startswith(muted_message):
self.errors.append("Message text '%s' is not shown in chat preview after mute" % muted_message) self.errors.append(self.home_1, "Message text '%s' is not shown in chat preview after mute" % muted_message)
chat.click() chat.click()
if not self.chat_1.chat_element_by_text(muted_message).is_element_displayed(30): if not self.chat_1.chat_element_by_text(muted_message).is_element_displayed(30):
self.errors.append("Message '%s' is not shown in chat for receiver after mute" % muted_message) self.errors.append(self.chat_1, "Message '%s' is not shown in chat for receiver after mute" % muted_message)
self.chat_1.just_fyi("Unmute chat") self.chat_1.just_fyi("Unmute chat")
self.chat_1.navigate_back_to_home_view() self.chat_1.navigate_back_to_home_view()
chat.long_press_without_release() chat.long_press_without_release()
if self.home_1.mute_chat_button.text != transl["unmute-chat"]: if self.home_1.mute_chat_button.text != transl["unmute-chat"]:
self.errors.append("Chat is not muted") self.errors.append(self.home_1, "Chat is not muted")
expected_text = "Muted until you turn it back on" expected_text = "Muted until you turn it back on"
if not self.home_1.element_by_text(expected_text).is_element_displayed(): if not self.home_1.element_by_text(expected_text).is_element_displayed():
self.errors.append("Text '%s' is not shown for muted chat" % expected_text) self.errors.append(self.home_1, "Text '%s' is not shown for muted chat" % expected_text)
self.home_1.mute_chat_button.double_click() self.home_1.mute_chat_button.double_click()
unmuted_message = "after unmute" unmuted_message = "after unmute"
self.chat_2.send_message(unmuted_message) self.chat_2.send_message(unmuted_message)
if not chat.new_messages_counter.is_element_displayed( if not chat.new_messages_counter.is_element_displayed(
30) or not self.home_1.chats_tab.counter.is_element_displayed(10): 30) or not self.home_1.chats_tab.counter.is_element_displayed(10):
self.errors.append("New messages counter is not shown after unmute") self.errors.append(self.home_1, "New messages counter is not shown after unmute")
if not chat.chat_preview.text.startswith(unmuted_message): if not chat.chat_preview.text.startswith(unmuted_message):
self.errors.append("Message text '%s' is not shown in chat preview after unmute" % unmuted_message) self.errors.append(self.home_1,
"Message text '%s' is not shown in chat preview after unmute" % unmuted_message)
chat.click() chat.click()
if not self.chat_1.chat_element_by_text(unmuted_message).is_element_displayed(30): if not self.chat_1.chat_element_by_text(unmuted_message).is_element_displayed(30):
self.errors.append("Message '%s' is not shown in chat for receiver after unmute" % unmuted_message) self.errors.append(self.chat_1,
"Message '%s' is not shown in chat for receiver after unmute" % unmuted_message)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -677,7 +688,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUiTwo(MultipleSharedDeviceTestCase
for element in self.chat_2.chat_element_by_text(text='').message_text_content.find_elements(): for element in self.chat_2.chat_element_by_text(text='').message_text_content.find_elements():
chat_history.append(element.text) chat_history.append(element.text)
if not chat_history: if not chat_history:
self.errors.append("No chat history was loaded") self.errors.append(self.chat_2, "No chat history was loaded")
self.home_2.just_fyi("Deleting chat via delete button and check it will not reappear after relaunching app") self.home_2.just_fyi("Deleting chat via delete button and check it will not reappear after relaunching app")
self.home_2.navigate_back_to_home_view() self.home_2.navigate_back_to_home_view()
@ -685,10 +696,12 @@ class TestOneToOneChatMultipleSharedDevicesNewUiTwo(MultipleSharedDeviceTestCase
self.home_2.delete_chat_long_press(username=self.username_1) self.home_2.delete_chat_long_press(username=self.username_1)
chat = self.home_2.get_chat_from_home_view(self.username_1) chat = self.home_2.get_chat_from_home_view(self.username_1)
if chat.is_element_displayed(): if chat.is_element_displayed():
self.errors.append("Deleted '%s' chat is shown, but the chat has been deleted" % self.username_1) self.errors.append(self.chat_2,
"Deleted '%s' chat is shown, but the chat has been deleted" % self.username_1)
self.home_2.reopen_app(user_name=self.username_2) self.home_2.reopen_app(user_name=self.username_2)
if chat.is_element_displayed(15): if chat.is_element_displayed(15):
self.errors.append( self.errors.append(
self.chat_2,
"Deleted chat '%s' is shown after re-login, but the chat has been deleted" % self.username_1) "Deleted chat '%s' is shown after re-login, but the chat has been deleted" % self.username_1)
chat.click() chat.click()
else: else:
@ -701,5 +714,6 @@ class TestOneToOneChatMultipleSharedDevicesNewUiTwo(MultipleSharedDeviceTestCase
if not self.chat_2.chat_element_by_text(message_text).is_element_displayed(): if not self.chat_2.chat_element_by_text(message_text).is_element_displayed():
lost_messages.append(message_text) lost_messages.append(message_text)
if lost_messages: if lost_messages:
self.errors.append("Message(s) missed in 1-1 chat after deleting the chat and relogin: %s" % lost_messages) self.errors.append(self.chat_2,
"Message(s) missed in 1-1 chat after deleting the chat and relogin: %s" % lost_messages)
self.errors.verify_no_errors() self.errors.verify_no_errors()

116
test/appium/tests/critical/chats/test_group_chat.py
View File

@ -95,14 +95,14 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
if pn: if pn:
pn.click() pn.click()
else: else:
self.errors.append("No PN was received on new message for message in group chat") self.errors.append(self.homes[0], "No PN was received on new message for message in group chat")
self.homes[0].click_system_back_button() self.homes[0].click_system_back_button()
self.homes[0].get_chat(self.chat_name).click() self.homes[0].get_chat(self.chat_name).click()
self.chats[1].just_fyi('Check message status and message delivery') self.chats[1].just_fyi('Check message status and message delivery')
self.chats[1].chat_element_by_text(message_to_admin).wait_for_status_to_be('Delivered', timeout=120) self.chats[1].chat_element_by_text(message_to_admin).wait_for_status_to_be('Delivered', timeout=120)
if not self.chats[0].chat_element_by_text(message_to_admin).is_element_displayed(30): if not self.chats[0].chat_element_by_text(message_to_admin).is_element_displayed(30):
self.errors.append('Message %s was not received by admin' % message_to_admin) self.errors.append(self.chats[0], 'Message %s was not received by admin' % message_to_admin)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(703202) @marks.testrail_id(703202)
@ -139,19 +139,19 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
if not self.chats[0].user_list_element_by_name( if not self.chats[0].user_list_element_by_name(
self.usernames[1]).is_element_displayed() or not self.chats[0].user_list_element_by_name( self.usernames[1]).is_element_displayed() or not self.chats[0].user_list_element_by_name(
self.usernames[2]).is_element_displayed(): self.usernames[2]).is_element_displayed():
self.errors.append("Incorrect users are shown for 'thumbs-up' reaction.") self.errors.append(self.chats[0], "Incorrect users are shown for 'thumbs-up' reaction.")
self.chats[0].authors_for_reaction(emoji="love").double_click() self.chats[0].authors_for_reaction(emoji="love").double_click()
if not self.chats[0].user_list_element_by_name( if not self.chats[0].user_list_element_by_name(
self.usernames[1]).is_element_displayed() or self.chats[0].user_list_element_by_name( self.usernames[1]).is_element_displayed() or self.chats[0].user_list_element_by_name(
self.usernames[2]).is_element_displayed(): self.usernames[2]).is_element_displayed():
self.errors.append("Incorrect users are shown for 'love' reaction.") self.errors.append(self.chats[0], "Incorrect users are shown for 'love' reaction.")
self.chats[0].authors_for_reaction(emoji="laugh").click() self.chats[0].authors_for_reaction(emoji="laugh").click()
if self.chats[0].user_list_element_by_name( if self.chats[0].user_list_element_by_name(
self.usernames[1]).is_element_displayed() or not self.chats[0].user_list_element_by_name( self.usernames[1]).is_element_displayed() or not self.chats[0].user_list_element_by_name(
self.usernames[2]).is_element_displayed(): self.usernames[2]).is_element_displayed():
self.errors.append("Incorrect users are shown for 'laugh' reaction.") self.errors.append(self.chats[0], "Incorrect users are shown for 'laugh' reaction.")
self.chats[0].just_fyi("Admin opens member_2 profile") self.chats[0].just_fyi("Admin opens member_2 profile")
self.chats[0].user_list_element_by_name(self.usernames[2]).click() self.chats[0].user_list_element_by_name(self.usernames[2]).click()
@ -159,11 +159,12 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
username_shown = self.chats[0].get_profile_view().contact_name_text.text username_shown = self.chats[0].get_profile_view().contact_name_text.text
if username_shown != self.usernames[2]: if username_shown != self.usernames[2]:
self.errors.append( self.errors.append(
self.chats[0],
"Incorrect profile is opened from the list of reactions, username is %s but expected to be %s" % ( "Incorrect profile is opened from the list of reactions, username is %s but expected to be %s" % (
username_shown, self.usernames[2]) username_shown, self.usernames[2])
) )
except NoSuchElementException: except NoSuchElementException:
self.errors.append("User profile was not opened from the list of reactions") self.errors.append(self.chats[0], "User profile was not opened from the list of reactions")
self.chats[0].navigate_back_to_chat_view() self.chats[0].navigate_back_to_chat_view()
self.chats[1].just_fyi("Member_1 removes 'thumbs-up' reaction and adds 'sad' one") self.chats[1].just_fyi("Member_1 removes 'thumbs-up' reaction and adds 'sad' one")
@ -183,8 +184,9 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
chat_element.emojis_below_message(emoji="love").wait_for_element_text(1) chat_element.emojis_below_message(emoji="love").wait_for_element_text(1)
chat_element.emojis_below_message(emoji="sad").wait_for_element_text(2) chat_element.emojis_below_message(emoji="sad").wait_for_element_text(2)
except (Failed, NoSuchElementException): except (Failed, NoSuchElementException):
self.errors.append( self.errors.append(self.chats[chat_view_index],
"Incorrect reactions count for %s after changing the reactions" % self.usernames[chat_view_index]) "Incorrect reactions count for %s after changing the reactions" % self.usernames[
chat_view_index])
self.loop.run_until_complete(run_in_parallel(( self.loop.run_until_complete(run_in_parallel((
(_check_reactions_count_after_change, {'chat_view_index': 0}), (_check_reactions_count_after_change, {'chat_view_index': 0}),
@ -204,7 +206,7 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
message_element.emojis_below_message(emoji="love").wait_for_element_text(1) message_element.emojis_below_message(emoji="love").wait_for_element_text(1)
message_element.emojis_below_message(emoji="sad").wait_for_element_text(2) message_element.emojis_below_message(emoji="sad").wait_for_element_text(2)
except (Failed, NoSuchElementException): except (Failed, NoSuchElementException):
self.errors.append("Incorrect reactions count after relogin") self.errors.append(self.chats[0], "Incorrect reactions count after relogin")
for chat in self.chats[1], self.chats[2]: for chat in self.chats[1], self.chats[2]:
chat.just_fyi("Just making the session not to quit") chat.just_fyi("Just making the session not to quit")
@ -215,19 +217,19 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
if self.chats[0].user_list_element_by_name( if self.chats[0].user_list_element_by_name(
self.usernames[1]).is_element_displayed() or not self.chats[0].user_list_element_by_name( self.usernames[1]).is_element_displayed() or not self.chats[0].user_list_element_by_name(
self.usernames[2]).is_element_displayed(): self.usernames[2]).is_element_displayed():
self.errors.append("Incorrect users are shown for 'thumbs-up' reaction after relogin.") self.errors.append(self.chats[0], "Incorrect users are shown for 'thumbs-up' reaction after relogin.")
self.chats[0].authors_for_reaction(emoji="love").double_click() self.chats[0].authors_for_reaction(emoji="love").double_click()
if not self.chats[0].user_list_element_by_name( if not self.chats[0].user_list_element_by_name(
self.usernames[1]).is_element_displayed() or self.chats[0].user_list_element_by_name( self.usernames[1]).is_element_displayed() or self.chats[0].user_list_element_by_name(
self.usernames[2]).is_element_displayed(): self.usernames[2]).is_element_displayed():
self.errors.append("Incorrect users are shown for 'love' reaction after relogin.") self.errors.append(self.chats[0], "Incorrect users are shown for 'love' reaction after relogin.")
self.chats[0].authors_for_reaction(emoji="sad").click() self.chats[0].authors_for_reaction(emoji="sad").click()
if not self.chats[0].user_list_element_by_name( if not self.chats[0].user_list_element_by_name(
self.usernames[1]).is_element_displayed() or not self.chats[0].user_list_element_by_name( self.usernames[1]).is_element_displayed() or not self.chats[0].user_list_element_by_name(
self.usernames[2]).is_element_displayed(): self.usernames[2]).is_element_displayed():
self.errors.append("Incorrect users are shown for 'laugh' reaction after relogin.") self.errors.append(self.chats[0], "Incorrect users are shown for 'laugh' reaction after relogin.")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -245,13 +247,13 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
chat_element = self.chats[0].chat_element_by_text(image_description) chat_element = self.chats[0].chat_element_by_text(image_description)
chat_element.wait_for_visibility_of_element(60) chat_element.wait_for_visibility_of_element(60)
if not chat_element.image_in_message.is_element_image_similar_to_template('image_2_chat_view.png'): if not chat_element.image_in_message.is_element_image_similar_to_template('image_2_chat_view.png'):
self.errors.append("Not expected image is shown to the admin.") self.errors.append(self.chats[0], "Not expected image is shown to the admin.")
self.chats[2].just_fyi("Member_2 checks image message") self.chats[2].just_fyi("Member_2 checks image message")
chat_element = self.chats[2].chat_element_by_text(image_description) chat_element = self.chats[2].chat_element_by_text(image_description)
chat_element.wait_for_visibility_of_element(60) chat_element.wait_for_visibility_of_element(60)
if not chat_element.image_in_message.is_element_image_similar_to_template('image_2_chat_view.png'): if not chat_element.image_in_message.is_element_image_similar_to_template('image_2_chat_view.png'):
self.errors.append("Not expected image is shown to the member_2.") self.errors.append(self.chats[2], "Not expected image is shown to the member_2.")
self.chats[0].just_fyi("Admin opens the image and shares it") self.chats[0].just_fyi("Admin opens the image and shares it")
self.chats[0].chat_element_by_text(image_description).image_in_message.click() self.chats[0].chat_element_by_text(image_description).image_in_message.click()
@ -260,7 +262,7 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
try: try:
self.chats[0].wait_for_current_package_to_be('com.google.android.apps.docs') self.chats[0].wait_for_current_package_to_be('com.google.android.apps.docs')
except TimeoutException: except TimeoutException:
self.errors.append("Admin can't share an image via Gmail.") self.errors.append(self.chats[0], "Admin can't share an image via Gmail.")
self.chats[0].navigate_back_to_chat_view() self.chats[0].navigate_back_to_chat_view()
self.chats[1].navigate_back_to_home_view() self.chats[1].navigate_back_to_home_view()
@ -275,10 +277,11 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
toast_element_text = toast_element.wait_for_visibility_of_element().text toast_element_text = toast_element.wait_for_visibility_of_element().text
if toast_element_text != self.chats[2].get_translation_by_key("photo-saved"): if toast_element_text != self.chats[2].get_translation_by_key("photo-saved"):
self.errors.append( self.errors.append(
self.chats[2],
"Shown message '%s' doesn't match expected '%s' after saving an image for member_2." % ( "Shown message '%s' doesn't match expected '%s' after saving an image for member_2." % (
toast_element_text, self.chats[2].get_translation_by_key("photo-saved"))) toast_element_text, self.chats[2].get_translation_by_key("photo-saved")))
except TimeoutException: except TimeoutException:
self.errors.append("Message about saving a photo is not shown for member_2.") self.errors.append(self.chats[2], "Message about saving a photo is not shown for member_2.")
self.chats[2].navigate_back_to_chat_view() self.chats[2].navigate_back_to_chat_view()
# workaround for app closed after navigating back from gallery # workaround for app closed after navigating back from gallery
@ -292,7 +295,7 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
self.chats[2].show_images_button.click() self.chats[2].show_images_button.click()
self.chats[2].allow_all_button.click_if_shown() self.chats[2].allow_all_button.click_if_shown()
if not self.chats[2].get_image_by_index(0).is_element_image_similar_to_template("image_2_gallery_view.png"): if not self.chats[2].get_image_by_index(0).is_element_image_similar_to_template("image_2_gallery_view.png"):
self.errors.append("Image is not saved to gallery for member_2.") self.errors.append(self.chats[2], "Image is not saved to gallery for member_2.")
self.chats[2].navigate_back_to_home_view() self.chats[2].navigate_back_to_home_view()
# workaround for app closed after navigating back from gallery # workaround for app closed after navigating back from gallery
@ -333,7 +336,7 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
if self.homes[0].element_by_text(message).is_element_displayed(30): if self.homes[0].element_by_text(message).is_element_displayed(30):
break break
else: else:
self.errors.append('Messages PN was not fetched from offline') self.errors.append(self.homes[0], 'Messages PN was not fetched from offline')
self.homes[0].click_system_back_button() self.homes[0].click_system_back_button()
# workaround for app closed after opening notifications # workaround for app closed after opening notifications
if not self.homes[0].chats_tab.is_element_displayed(): if not self.homes[0].chats_tab.is_element_displayed():
@ -346,7 +349,7 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
self.chats[index].just_fyi("Check that messages are shown for user %s" % self.usernames[index]) self.chats[index].just_fyi("Check that messages are shown for user %s" % self.usernames[index])
for message_text in (message_1, message_2): for message_text in (message_1, message_2):
if not self.chats[index].chat_element_by_text(message_text).is_element_displayed(30): if not self.chats[index].chat_element_by_text(message_text).is_element_displayed(30):
self.errors.append('%s if not shown for device %s' % (message_text, index)) self.errors.append(self.chats[index], '%s if not shown for device %s' % (message_text, index))
self.loop.run_until_complete(run_in_parallel(( self.loop.run_until_complete(run_in_parallel((
(_check_messages, {'index': 0}), (_check_messages, {'index': 0}),
@ -367,14 +370,14 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
self.chats[0].send_message(self.message_1) self.chats[0].send_message(self.message_1)
self.chats[0].pin_message(self.message_1, "pin-to-chat") self.chats[0].pin_message(self.message_1, "pin-to-chat")
if not (self.chats[0].chat_element_by_text(self.message_1).pinned_by_label.is_element_displayed(30) and for chat in self.chats[0], self.chats[1]:
self.chats[1].chat_element_by_text(self.message_1).pinned_by_label.is_element_displayed(30)): if not chat.chat_element_by_text(self.message_1).pinned_by_label.is_element_displayed(30):
self.errors.append("Message 1 is not pinned in group chat!") self.errors.append(chat, "Message 1 is not pinned in group chat!")
self.chats[0].just_fyi("Check that non admin user can not unpin messages") self.chats[0].just_fyi("Check that non admin user can not unpin messages")
self.chats[1].chat_element_by_text(self.message_1).long_press_without_release() self.chats[1].chat_element_by_text(self.message_1).long_press_without_release()
if self.chats[1].element_by_translation_id("unpin-from-chat").is_element_displayed(): if self.chats[1].element_by_translation_id("unpin-from-chat").is_element_displayed():
self.errors.append("Unpin option is available for non-admin user") self.errors.append(self.chats[1], "Unpin option is available for non-admin user")
self.chats[1].tap_by_coordinates(500, 100) self.chats[1].tap_by_coordinates(500, 100)
self.chats[1].tap_by_coordinates(500, 100) self.chats[1].tap_by_coordinates(500, 100)
@ -396,9 +399,9 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
# here group_chat_1 should be changed to group_chat_2 after enabling the previous block # here group_chat_1 should be changed to group_chat_2 after enabling the previous block
self.chats[0].send_message(message) self.chats[0].send_message(message)
self.chats[0].pin_message(message, 'pin-to-chat') self.chats[0].pin_message(message, 'pin-to-chat')
if not (self.chats[0].chat_element_by_text(message).pinned_by_label.is_element_displayed(30) and for chat in self.chats[0], self.chats[1]:
self.chats[1].chat_element_by_text(message).pinned_by_label.is_element_displayed(30)): if not chat.chat_element_by_text(message).pinned_by_label.is_element_displayed(30):
self.errors.append("%s is not pinned in group chat!" % message) self.errors.append(chat, "%s is not pinned in group chat!" % message)
self.chats[0].just_fyi("Check that a user can not pin more than 3 messages") self.chats[0].just_fyi("Check that a user can not pin more than 3 messages")
self.chats[0].send_message(self.message_4) self.chats[0].send_message(self.message_4)
@ -409,16 +412,17 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
unpin_element.click_until_absense_of_element(desired_element=unpin_element) unpin_element.click_until_absense_of_element(desired_element=unpin_element)
self.chats[0].chat_element_by_text(self.message_4).click() self.chats[0].chat_element_by_text(self.message_4).click()
self.chats[0].pin_message(self.message_4, 'pin-to-chat') self.chats[0].pin_message(self.message_4, 'pin-to-chat')
if not (self.chats[0].chat_element_by_text(self.message_4).pinned_by_label.is_element_displayed(30) and for chat in self.chats[0], self.chats[1]:
self.chats[1].chat_element_by_text(self.message_4).pinned_by_label.is_element_displayed(30)): if not chat.chat_element_by_text(self.message_4).pinned_by_label.is_element_displayed(30):
self.errors.append("Message 4 is not pinned in group chat after unpinning previous one") self.errors.append(chat, "Message 4 is not pinned in group chat after unpinning previous one")
def _check_pinned_messages(index): def _check_pinned_messages(index):
self.chats[index].just_fyi("Check pinned messages count and content for user %s" % self.usernames[index]) self.chats[index].just_fyi("Check pinned messages count and content for user %s" % self.usernames[index])
count = self.chats[index].pinned_messages_count.text count = self.chats[index].pinned_messages_count.text
if count != '3': if count != '3':
self.errors.append( self.errors.append(self.chats[index],
"Pinned messages count %s doesn't match expected 3 for user %s" % (count, self.usernames[index])) "Pinned messages count %s doesn't match expected 3 for user %s" % (
count, self.usernames[index]))
self.chats[index].pinned_messages_count.click() self.chats[index].pinned_messages_count.click()
for message_text in self.message_1, self.message_3, self.message_4: for message_text in self.message_1, self.message_3, self.message_4:
pinned_by = self.chats[index].pinned_messages_list.get_message_pinned_by_text(message_text) pinned_by = self.chats[index].pinned_messages_list.get_message_pinned_by_text(message_text)
@ -426,14 +430,15 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
text = pinned_by.text.strip() text = pinned_by.text.strip()
expected_text = "You" if index == 0 else self.usernames[0] expected_text = "You" if index == 0 else self.usernames[0]
if text != expected_text: if text != expected_text:
self.errors.append( self.errors.append(self.chats[index],
"Pinned by '%s' doesn't match expected '%s' for user %s" % ( "Pinned by '%s' doesn't match expected '%s' for user %s" % (
text, expected_text, self.usernames[index]) text, expected_text, self.usernames[index])
) )
else: else:
self.errors.append( self.errors.append(self.chats[index],
"Message '%s' is missed on Pinned messages list for user %s" % (message, self.usernames[index]) "Message '%s' is missed on Pinned messages list for user %s" % (
) message, self.usernames[index])
)
self.loop.run_until_complete(run_in_parallel(( self.loop.run_until_complete(run_in_parallel((
(_check_pinned_messages, {'index': 0}), (_check_pinned_messages, {'index': 0}),
@ -460,7 +465,7 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
pytest.fail("Chat is not muted") pytest.fail("Chat is not muted")
current_text = self.homes[1].mute_chat_button.unmute_caption_text current_text = self.homes[1].mute_chat_button.unmute_caption_text
if current_text not in expected_texts: if current_text not in expected_texts:
self.errors.append("Text '%s' is not shown for muted chat" % expected_texts[1]) self.errors.append(self.homes[1], "Text '%s' is not shown for muted chat" % expected_texts[1])
self.homes[1].click_system_back_button() self.homes[1].click_system_back_button()
try: try:
initial_counter = int(self.homes[1].chats_tab.counter.text) initial_counter = int(self.homes[1].chats_tab.counter.text)
@ -474,20 +479,23 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
self.homes[1].just_fyi("Member 1 checks that chat is muted and message is received") self.homes[1].just_fyi("Member 1 checks that chat is muted and message is received")
if chat.new_messages_grey_dot.is_element_displayed(30): if chat.new_messages_grey_dot.is_element_displayed(30):
self.errors.append("New messages grey dot near chat name is shown after mute") self.errors.append(self.homes[1], "New messages grey dot near chat name is shown after mute")
try: try:
after_mute_counter = int(self.homes[1].chats_tab.counter.text) after_mute_counter = int(self.homes[1].chats_tab.counter.text)
except NoSuchElementException: except NoSuchElementException:
after_mute_counter = 0 after_mute_counter = 0
if after_mute_counter > initial_counter: if after_mute_counter > initial_counter:
self.errors.append("New messages counter near chats tab button is %s after mute, but should be %s" % ( self.errors.append(self.homes[1],
after_mute_counter, initial_counter)) "New messages counter near chats tab button is %s after mute, but should be %s" % (
after_mute_counter, initial_counter))
if not chat.chat_preview.text.startswith("%s: %s" % (self.usernames[0], muted_message[:25])): if not chat.chat_preview.text.startswith("%s: %s" % (self.usernames[0], muted_message[:25])):
self.errors.append("Message text '%s' is not shown in chat preview after mute" % muted_message) self.errors.append(self.homes[1],
"Message text '%s' is not shown in chat preview after mute" % muted_message)
chat.click() chat.click()
if not self.chats[1].chat_element_by_text(muted_message).is_element_displayed(30): if not self.chats[1].chat_element_by_text(muted_message).is_element_displayed(30):
self.errors.append( self.errors.append(self.chats[1],
"Message '%s' is not shown in chat for %s (Member 1) after mute" % (muted_message, self.usernames[1])) "Message '%s' is not shown in chat for %s (Member 1) after mute" % (
muted_message, self.usernames[1]))
self.chats[1].navigate_back_to_home_view() self.chats[1].navigate_back_to_home_view()
self.chats[1].just_fyi("Member 1 unmutes the chat") self.chats[1].just_fyi("Member 1 unmutes the chat")
@ -495,7 +503,7 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
self.homes[1].mute_chat_button.double_click() self.homes[1].mute_chat_button.double_click()
chat.long_press_without_release() chat.long_press_without_release()
if self.homes[1].element_starts_with_text("Muted until").is_element_displayed(): if self.homes[1].element_starts_with_text("Muted until").is_element_displayed():
self.errors.append("Chat is still muted after being unmuted") self.errors.append(self.homes[1], "Chat is still muted after being unmuted")
self.errors.verify_no_errors() self.errors.verify_no_errors()
if self.homes[1].mute_chat_button.is_element_displayed(): if self.homes[1].mute_chat_button.is_element_displayed():
self.homes[1].click_system_back_button() self.homes[1].click_system_back_button()
@ -510,20 +518,22 @@ class TestGroupChatMultipleDeviceMergedNewUI(MultipleSharedDeviceTestCase):
self.chats[2].send_message(unmuted_message) self.chats[2].send_message(unmuted_message)
self.homes[1].just_fyi("Member 1 checks that chat is unmuted and message is received") self.homes[1].just_fyi("Member 1 checks that chat is unmuted and message is received")
if not chat.new_messages_grey_dot.is_element_displayed(30): if not chat.new_messages_grey_dot.is_element_displayed(30):
self.errors.append("New messages counter near chat name is not shown after unmute") self.errors.append(self.homes[1], "New messages counter near chat name is not shown after unmute")
try: try:
after_mute_counter = int(self.homes[1].chats_tab.counter.text) after_mute_counter = int(self.homes[1].chats_tab.counter.text)
except NoSuchElementException: except NoSuchElementException:
after_mute_counter = 0 after_mute_counter = 0
if after_mute_counter != initial_counter: if after_mute_counter != initial_counter:
self.errors.append("New messages counter near chats tab button is %s after unmute, but should be %s" % ( self.errors.append(self.homes[1],
after_mute_counter, initial_counter + 1)) "New messages counter near chats tab button is %s after unmute, but should be %s" % (
after_mute_counter, initial_counter + 1))
if not chat.chat_preview.text.startswith("%s: %s" % (self.usernames[2], unmuted_message)): if not chat.chat_preview.text.startswith("%s: %s" % (self.usernames[2], unmuted_message)):
self.errors.append("Message text '%s' is not shown in chat preview after unmute" % unmuted_message) self.errors.append(self.homes[1],
"Message text '%s' is not shown in chat preview after unmute" % unmuted_message)
chat.click() chat.click()
if not self.chats[1].chat_element_by_text(unmuted_message).is_element_displayed(30): if not self.chats[1].chat_element_by_text(unmuted_message).is_element_displayed(30):
self.errors.append( self.errors.append(self.chats[1],
"Message '%s' is not shown in chat for %s (Member 1) after unmute" % ( "Message '%s' is not shown in chat for %s (Member 1) after unmute" % (
unmuted_message, self.usernames[1])) unmuted_message, self.usernames[1]))
self.errors.verify_no_errors() self.errors.verify_no_errors()

226
test/appium/tests/critical/chats/test_public_chat_browsing.py
View File

@ -10,7 +10,7 @@ from selenium.common.exceptions import NoSuchElementException, TimeoutException,
from tests import marks, run_in_parallel, pytest_config_global, transl from tests import marks, run_in_parallel, pytest_config_global, transl
from tests.base_test_case import create_shared_drivers, MultipleSharedDeviceTestCase from tests.base_test_case import create_shared_drivers, MultipleSharedDeviceTestCase
from views.chat_view import CommunityView, ChatView from views.chat_view import CommunityView
from views.dbs.waku_backup import user as waku_user from views.dbs.waku_backup import user as waku_user
from views.sign_in_view import SignInView from views.sign_in_view import SignInView
@ -61,6 +61,7 @@ class TestCommunityOneDeviceMerged(MultipleSharedDeviceTestCase):
actual_copied_text = self.channel.driver.get_clipboard_text() actual_copied_text = self.channel.driver.get_clipboard_text()
if actual_copied_text != message: if actual_copied_text != message:
self.errors.append( self.errors.append(
self.channel,
'Message %s text was not copied in community channel, text in clipboard %s' % actual_copied_text) 'Message %s text was not copied in community channel, text in clipboard %s' % actual_copied_text)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -103,9 +104,9 @@ class TestCommunityOneDeviceMerged(MultipleSharedDeviceTestCase):
try: try:
current_text = self.home.unmute_community_button.unmute_caption_text current_text = self.home.unmute_community_button.unmute_caption_text
if current_text not in expected_texts: if current_text not in expected_texts:
self.errors.append("Text '%s' is not shown for muted community" % expected_texts[1]) self.errors.append(self.home, "Text '%s' is not shown for muted community" % expected_texts[1])
except NoSuchElementException: except NoSuchElementException:
self.errors.append("Caption with text 'Muted until...' is not shown for muted community") self.errors.append(self.home, "Caption with text 'Muted until...' is not shown for muted community")
self.home.click_system_back_button() self.home.click_system_back_button()
self.home.get_chat(self.community_name, community=True).click() self.home.get_chat(self.community_name, community=True).click()
@ -114,9 +115,11 @@ class TestCommunityOneDeviceMerged(MultipleSharedDeviceTestCase):
try: try:
current_text = self.home.mute_channel_button.unmute_caption_text current_text = self.home.mute_channel_button.unmute_caption_text
if current_text not in expected_texts: if current_text not in expected_texts:
self.errors.append("Text '%s' is not shown for a channel in muted community" % expected_texts[1]) self.errors.append(self.home,
"Text '%s' is not shown for a channel in muted community" % expected_texts[1])
except NoSuchElementException: except NoSuchElementException:
self.errors.append("Caption with text 'Muted until...' is not shown for a channel in muted community") self.errors.append(self.home,
"Caption with text 'Muted until...' is not shown for a channel in muted community")
self.home.just_fyi("Unmute channel and check that the community is also unmuted") self.home.just_fyi("Unmute channel and check that the community is also unmuted")
self.home.mute_channel_button.click() self.home.mute_channel_button.click()
@ -124,7 +127,7 @@ class TestCommunityOneDeviceMerged(MultipleSharedDeviceTestCase):
self.home.communities_tab.click() self.home.communities_tab.click()
self.home.get_chat(self.community_name, community=True).long_press_element() self.home.get_chat(self.community_name, community=True).long_press_element()
if not self.home.element_by_text("Mute community").is_element_displayed(): if not self.home.element_by_text("Mute community").is_element_displayed():
self.errors.append("Community is not unmuted when channel is unmuted") self.errors.append(self.home, "Community is not unmuted when channel is unmuted")
self.home.click_system_back_button() self.home.click_system_back_button()
self.home.just_fyi("Mute channel and check that community is not muted") self.home.just_fyi("Mute channel and check that community is not muted")
@ -140,16 +143,18 @@ class TestCommunityOneDeviceMerged(MultipleSharedDeviceTestCase):
try: try:
current_text = self.home.mute_channel_button.unmute_caption_text current_text = self.home.mute_channel_button.unmute_caption_text
if current_text not in expected_texts: if current_text not in expected_texts:
self.errors.append("Text '%s' is not shown for a muted community channel" % expected_texts[1]) self.errors.append(self.home,
"Text '%s' is not shown for a muted community channel" % expected_texts[1])
except NoSuchElementException: except NoSuchElementException:
self.errors.append("Caption with text '%s' is not shown for a muted community channel" % expected_texts[1]) self.errors.append(self.home,
"Caption with text '%s' is not shown for a muted community channel" % expected_texts[1])
self.home.click_system_back_button() self.home.click_system_back_button()
self.home.navigate_back_to_home_view() self.home.navigate_back_to_home_view()
self.home.communities_tab.click() self.home.communities_tab.click()
self.home.get_chat(self.community_name, community=True).long_press_element() self.home.get_chat(self.community_name, community=True).long_press_element()
if self.home.element_by_text_part("Muted until").is_element_displayed() or \ if self.home.element_by_text_part("Muted until").is_element_displayed() or \
self.home.mute_community_button.text != transl["mute-community"]: self.home.mute_community_button.text != transl["mute-community"]:
self.errors.append("Community is muted when channel is muted") self.errors.append(self.home, "Community is muted when channel is muted")
self.home.click_system_back_button() self.home.click_system_back_button()
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -172,7 +177,7 @@ class TestCommunityOneDeviceMerged(MultipleSharedDeviceTestCase):
# "Incorrect contacts number restored: %s instead of %s" % (contacts_number, len(waku_user.contacts))) # "Incorrect contacts number restored: %s instead of %s" % (contacts_number, len(waku_user.contacts)))
for contact in waku_user.contacts: for contact in waku_user.contacts:
if not self.home.element_by_text(contact).is_element_displayed(30): if not self.home.element_by_text(contact).is_element_displayed(30):
self.errors.append('%s was not restored as a contact from waku backup!' % contact) self.errors.append(self.home, '%s was not restored as a contact from waku backup!' % contact)
# Disabled for simple check as sometimes from waku-backup users restored with 3-random names # Disabled for simple check as sometimes from waku-backup users restored with 3-random names
# self.home.click_system_back_button_until_element_is_shown() # self.home.click_system_back_button_until_element_is_shown()
# contact_row = self.home.contact_details_row(index=i + 1) # contact_row = self.home.contact_details_row(index=i + 1)
@ -201,7 +206,7 @@ class TestCommunityOneDeviceMerged(MultipleSharedDeviceTestCase):
self.home.communities_tab.click() self.home.communities_tab.click()
for key in ['admin_open', 'member_open', 'admin_closed', 'member_closed']: for key in ['admin_open', 'member_open', 'admin_closed', 'member_closed']:
if not self.home.element_by_text(waku_user.communities[key]).is_element_displayed(30): if not self.home.element_by_text(waku_user.communities[key]).is_element_displayed(30):
self.errors.append("%s was not restored from waku-backup!!" % key) self.errors.append(self.home, "%s was not restored from waku-backup!!" % key)
# TODO: there is a bug when pending community sometimes restored as joined; needs investigation # TODO: there is a bug when pending community sometimes restored as joined; needs investigation
# self.home.opened_communities_tab.click() # self.home.opened_communities_tab.click()
# if not self.home.element_by_text(waku_user.communities['member_pending']).is_element_displayed(30): # if not self.home.element_by_text(waku_user.communities['member_pending']).is_element_displayed(30):
@ -222,7 +227,7 @@ class TestCommunityOneDeviceMerged(MultipleSharedDeviceTestCase):
self.home.navigate_back_to_home_view() self.home.navigate_back_to_home_view()
self.home.communities_tab.click() self.home.communities_tab.click()
if self.home.element_by_text(waku_user.communities['admin_open']).is_element_displayed(30): if self.home.element_by_text(waku_user.communities['admin_open']).is_element_displayed(30):
self.errors.append("Community of previous user is shown!") self.errors.append(self.home, "Community of previous user is shown!")
self.home.just_fyi("Check that can remove user from logged out state") self.home.just_fyi("Check that can remove user from logged out state")
self.home.reopen_app(sign_in=False) self.home.reopen_app(sign_in=False)
@ -230,13 +235,13 @@ class TestCommunityOneDeviceMerged(MultipleSharedDeviceTestCase):
user_card.open_user_options() user_card.open_user_options()
self.sign_in.remove_profile_button.click() self.sign_in.remove_profile_button.click()
if not self.sign_in.element_by_translation_id("remove-profile-confirm-message").is_element_displayed(30): if not self.sign_in.element_by_translation_id("remove-profile-confirm-message").is_element_displayed(30):
self.errors.append("Warning is not shown on removing profile!") self.errors.append(self.home, "Warning is not shown on removing profile!")
self.sign_in.element_by_translation_id("remove").click() self.sign_in.element_by_translation_id("remove").click()
self.home.just_fyi("Check that removed user is not shown in the list anymore") self.home.just_fyi("Check that removed user is not shown in the list anymore")
self.home.reopen_app(sign_in=False) self.home.reopen_app(sign_in=False)
if self.sign_in.element_by_text(recover_user_name).is_element_displayed(): if self.sign_in.element_by_text(recover_user_name).is_element_displayed():
self.errors.append("Removed user is re-appeared after relogin!") self.errors.append(self.home, "Removed user is re-appeared after relogin!")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -279,21 +284,23 @@ class TestCommunityOneDeviceMerged(MultipleSharedDeviceTestCase):
except TimeoutException: except TimeoutException:
missing_tags.append(text) missing_tags.append(text)
if missing_tags: if missing_tags:
self.errors.append("Community '%s' is missing tag(s) %s." % (community_name, ','.join(tags))) self.errors.append(self.home,
"Community '%s' is missing tag(s) %s." % (community_name, ','.join(tags)))
# if community_name == 'Status': # if community_name == 'Status':
self.home.just_fyi("Check Status community screen") self.home.just_fyi("Check Status community screen")
card.click() card.click()
if self.community_view.join_button.is_element_differs_from_template( if self.community_view.join_button.is_element_differs_from_template(
'status_community_join_button.png'): 'status_community_join_button.png'):
self.errors.append("Status community Join button is different from expected template.") self.errors.append(self.home, "Status community Join button is different from expected template.")
if self.community_view.community_logo.is_element_differs_from_template('status_community_logo.png'): if self.community_view.community_logo.is_element_differs_from_template('status_community_logo.png'):
self.errors.append("Status community logo is different from expected template.") self.errors.append(self.home, "Status community logo is different from expected template.")
# self.community_view.close_community_view_button.click() # self.community_view.close_community_view_button.click()
# self.home.swipe_up() # self.home.swipe_up()
except TimeoutException: except TimeoutException:
self.errors.append("Community '%s' is not in the Discover Communities list." % community_name) self.errors.append(self.home,
"Community '%s' is not in the Discover Communities list." % community_name)
self.errors.verify_no_errors() self.errors.verify_no_errors()
# Note: this test should always be the LAST ONE in the group because it turns on mainnet in the app! # Note: this test should always be the LAST ONE in the group because it turns on mainnet in the app!
@ -350,7 +357,7 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
timestamp = self.channel_1.chat_element_by_text(message).timestamp timestamp = self.channel_1.chat_element_by_text(message).timestamp
if sent_time_variants and timestamp: if sent_time_variants and timestamp:
if timestamp not in sent_time_variants: if timestamp not in sent_time_variants:
self.errors.append("Timestamp is not shown, expected: '%s', in fact: '%s'" % self.errors.append(self.channel_1, "Timestamp is not shown, expected: '%s', in fact: '%s'" %
(", ".join(sent_time_variants), timestamp)) (", ".join(sent_time_variants), timestamp))
self.channel_1.verify_message_is_under_today_text(message, self.errors) self.channel_1.verify_message_is_under_today_text(message, self.errors)
self.channel_2.send_message("one more message") self.channel_2.send_message("one more message")
@ -358,7 +365,8 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.channel_1.send_message(new_message) self.channel_1.send_message(new_message)
self.channel_2.verify_message_is_under_today_text(new_message, self.errors, 60) self.channel_2.verify_message_is_under_today_text(new_message, self.errors, 60)
if self.channel_2.chat_element_by_text(new_message).username.text != self.username_1: if self.channel_2.chat_element_by_text(new_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.append(self.channel_2,
"Default username '%s' is not shown next to the received message" % self.username_1)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.smoke @marks.smoke
@ -370,13 +378,13 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.channel_1.edit_message_in_chat(message_before_edit, message_after_edit) self.channel_1.edit_message_in_chat(message_before_edit, message_after_edit)
for channel in (self.channel_1, self.channel_2): for channel in (self.channel_1, self.channel_2):
if not channel.element_by_text_part(message_after_edit).is_element_displayed(60): if not channel.element_by_text_part(message_after_edit).is_element_displayed(60):
self.errors.append('Message is not edited') self.errors.append(channel, 'Message is not edited')
message_text_after_edit = message_after_edit + ' (Edited)' message_text_after_edit = message_after_edit + ' (Edited)'
self.channel_2.set_reaction(message_text_after_edit) self.channel_2.set_reaction(message_text_after_edit)
try: try:
self.channel_1.chat_element_by_text(message_text_after_edit).emojis_below_message().wait_for_element_text(1) self.channel_1.chat_element_by_text(message_text_after_edit).emojis_below_message().wait_for_element_text(1)
except (Failed, NoSuchElementException): except (Failed, NoSuchElementException):
self.errors.append("Message reaction is not shown for the sender") self.errors.append(self.channel_1, "Message reaction is not shown for the sender")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702839) @marks.testrail_id(702839)
@ -389,9 +397,9 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.channel_2.delete_message_in_chat(message_to_delete_everyone) self.channel_2.delete_message_in_chat(message_to_delete_everyone)
for channel in (self.channel_1, self.channel_2): for channel in (self.channel_1, self.channel_2):
if not channel.chat_element_by_text(message_to_delete_everyone).is_element_disappeared(30): if not channel.chat_element_by_text(message_to_delete_everyone).is_element_disappeared(30):
self.errors.append("Deleted message is shown in channel") self.errors.append(channel, "Deleted message is shown in channel")
if not self.channel_2.element_by_translation_id('message-deleted-for-everyone').is_element_displayed(30): if not self.channel_2.element_by_translation_id('message-deleted-for-everyone').is_element_displayed(30):
self.errors.append("System message about deletion for everyone is not displayed") self.errors.append(self.channel_2, "System message about deletion for everyone is not displayed")
self.home_2.just_fyi( self.home_2.just_fyi(
'Deleting message for me. Checking that message is deleted only for the author of the message') 'Deleting message for me. Checking that message is deleted only for the author of the message')
@ -399,11 +407,11 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.channel_1.chat_element_by_text(message_to_delete_for_me).wait_for_element(120) self.channel_1.chat_element_by_text(message_to_delete_for_me).wait_for_element(120)
self.channel_2.delete_message_in_chat(message_to_delete_for_me, everyone=False) self.channel_2.delete_message_in_chat(message_to_delete_for_me, everyone=False)
if not self.channel_2.chat_element_by_text(message_to_delete_for_me).is_element_disappeared(30): if not self.channel_2.chat_element_by_text(message_to_delete_for_me).is_element_disappeared(30):
self.errors.append("Deleted for me message is shown in channel for the author of message") self.errors.append(self.channel_2, "Deleted for me message is shown in channel for the author of message")
if not self.channel_2.element_by_translation_id('message-deleted-for-you').is_element_displayed(30): if not self.channel_2.element_by_translation_id('message-deleted-for-you').is_element_displayed(30):
self.errors.append("System message about deletion for you is not displayed") self.errors.append(self.channel_2, "System message about deletion for you is not displayed")
if not self.channel_1.chat_element_by_text(message_to_delete_for_me).is_element_displayed(30): if not self.channel_1.chat_element_by_text(message_to_delete_for_me).is_element_displayed(30):
self.errors.append("Deleted for me message is deleted all channel members") self.errors.append(self.channel_1, "Deleted for me message is deleted all channel members")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(703194) @marks.testrail_id(703194)
@ -423,22 +431,22 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
image = chat_element.image_container_in_message image = chat_element.image_container_in_message
if (image.is_element_differs_from_template("images_gallery.png", 5) and if (image.is_element_differs_from_template("images_gallery.png", 5) and
image.is_element_differs_from_template("images_gallery_inverted.png", 5)): image.is_element_differs_from_template("images_gallery_inverted.png", 5)):
self.errors.append("Gallery message does not match the template!") self.errors.append(self.channel_2, "Gallery message does not match the template!")
except TimeoutException: except TimeoutException:
self.errors.append("Gallery message was not received") self.errors.append(self.channel_2, "Gallery message was not received")
received = False received = False
if received: if received:
self.channel_2.just_fyi("Checking an ability to save and share an image from gallery") self.channel_2.just_fyi("Checking an ability to save and share an image from gallery")
chat_element.image_container_in_message.image_by_index(1).click() chat_element.image_container_in_message.image_by_index(1).click()
if not self.channel_2.share_image_icon_button.is_element_displayed(): if not self.channel_2.share_image_icon_button.is_element_displayed():
self.errors.append("Can't share an image from gallery.") self.errors.append(self.channel_2, "Can't share an image from gallery.")
if self.channel_2.view_image_options_button.is_element_displayed(): if self.channel_2.view_image_options_button.is_element_displayed():
self.channel_2.view_image_options_button.click() self.channel_2.view_image_options_button.click()
if not self.channel_2.save_image_icon_button.is_element_displayed(): if not self.channel_2.save_image_icon_button.is_element_displayed():
self.errors.append("Can't save an image from gallery.") self.errors.append(self.channel_2, "Can't save an image from gallery.")
else: else:
self.errors.append("Image options button is not shown for an image from gallery.") self.errors.append(self.channel_2, "Image options button is not shown for an image from gallery.")
self.channel_2.navigate_back_to_chat_view() self.channel_2.navigate_back_to_chat_view()
@ -450,7 +458,7 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
chat_element_1 = self.channel_1.chat_element_by_text(message_text) chat_element_1 = self.channel_1.chat_element_by_text(message_text)
if not chat_element_1.is_element_displayed( if not chat_element_1.is_element_displayed(
sec=60) or chat_element_1.replied_message_text != image_description: sec=60) or chat_element_1.replied_message_text != image_description:
self.errors.append('Reply message was not received by the sender') self.errors.append(self.channel_1, 'Reply message was not received by the sender')
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702859) @marks.testrail_id(702859)
@ -465,7 +473,7 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.channel_2.chat_element_by_text(image_description).wait_for_visibility_of_element(10) self.channel_2.chat_element_by_text(image_description).wait_for_visibility_of_element(10)
if not self.channel_2.chat_element_by_text( if not self.channel_2.chat_element_by_text(
image_description).image_in_message.is_element_image_similar_to_template('image_1_chat_view.png'): image_description).image_in_message.is_element_image_similar_to_template('image_1_chat_view.png'):
self.errors.append("Not expected image is shown to the receiver") self.errors.append(self.channel_2, "Not expected image is shown to the receiver")
if not self.channel_1.chat_element_by_text(image_description).is_element_displayed(60): if not self.channel_1.chat_element_by_text(image_description).is_element_displayed(60):
self.channel_1.hide_keyboard_if_shown() self.channel_1.hide_keyboard_if_shown()
@ -477,11 +485,11 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
if toast_element.is_element_displayed(): if toast_element.is_element_displayed():
toast_element_text = toast_element.text toast_element_text = toast_element.text
if toast_element_text != self.channel_1.get_translation_by_key("photo-saved"): if toast_element_text != self.channel_1.get_translation_by_key("photo-saved"):
self.errors.append( self.errors.append(self.channel_1,
"Shown message '%s' doesn't match expected '%s' after saving an image." % ( "Shown message '%s' doesn't match expected '%s' after saving an image." % (
toast_element_text, self.channel_1.get_translation_by_key("photo-saved"))) toast_element_text, self.channel_1.get_translation_by_key("photo-saved")))
else: else:
self.errors.append("Message about saving a photo is not shown.") self.errors.append(self.channel_1, "Message about saving a photo is not shown.")
self.channel_1.navigate_back_to_chat_view() self.channel_1.navigate_back_to_chat_view()
self.channel_1.just_fyi("Check that image is saved in gallery") self.channel_1.just_fyi("Check that image is saved in gallery")
@ -489,7 +497,7 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.channel_1.allow_all_button.click_if_shown() self.channel_1.allow_all_button.click_if_shown()
if not self.channel_1.get_image_by_index(0).is_element_image_similar_to_template( if not self.channel_1.get_image_by_index(0).is_element_image_similar_to_template(
"image_1_gallery_view.png"): "image_1_gallery_view.png"):
self.errors.append('Saved image is not shown in Recent') self.errors.append(self.channel_1, 'Saved image is not shown in Recent')
self.channel_1.click_system_back_button() self.channel_1.click_system_back_button()
self.home_2.just_fyi('Check share option on opened image') self.home_2.just_fyi('Check share option on opened image')
@ -499,7 +507,7 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
try: try:
self.channel_2.wait_for_current_package_to_be('com.google.android.apps.docs') self.channel_2.wait_for_current_package_to_be('com.google.android.apps.docs')
except TimeoutException: except TimeoutException:
self.errors.append("Can't share image") self.errors.append(self.channel_2, "Can't share image")
self.channel_2.navigate_back_to_chat_view() self.channel_2.navigate_back_to_chat_view()
self.channel_2.just_fyi("Can reply to images") self.channel_2.just_fyi("Can reply to images")
@ -511,20 +519,20 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.channel_2.send_message_button.click() self.channel_2.send_message_button.click()
chat_element_1 = self.channel_1.chat_element_by_text(message_text) chat_element_1 = self.channel_1.chat_element_by_text(message_text)
if not chat_element_1.is_element_displayed(sec=60) or chat_element_1.replied_message_text != image_description: if not chat_element_1.is_element_displayed(sec=60) or chat_element_1.replied_message_text != image_description:
self.errors.append('Reply message was not received by the sender') self.errors.append(self.channel_1, 'Reply message was not received by the sender')
self.channel_2.just_fyi("Set a reaction for the image message") self.channel_2.just_fyi("Set a reaction for the image message")
self.channel_2.set_reaction(message=image_description) self.channel_2.set_reaction(message=image_description)
try: try:
self.channel_1.chat_element_by_text(image_description).emojis_below_message().wait_for_element_text(1) self.channel_1.chat_element_by_text(image_description).emojis_below_message().wait_for_element_text(1)
except (Failed, NoSuchElementException): except (Failed, NoSuchElementException):
self.errors.append("Image message reaction is not shown for the sender") self.errors.append(self.channel_1, "Image message reaction is not shown for the sender")
self.channel_1.just_fyi("Set a reaction for the message reply") self.channel_1.just_fyi("Set a reaction for the message reply")
self.channel_2.set_reaction(message=image_description, emoji="love") self.channel_2.set_reaction(message=image_description, emoji="love")
try: try:
self.channel_2.chat_element_by_text(message_text).emojis_below_message( self.channel_2.chat_element_by_text(message_text).emojis_below_message(
emoji="love").wait_for_element_text(1) emoji="love").wait_for_element_text(1)
except (Failed, NoSuchElementException): except (Failed, NoSuchElementException):
self.errors.append("Reply message reaction is not shown for the reply sender") self.errors.append(self.channel_2, "Reply message reaction is not shown for the reply sender")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -537,13 +545,14 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.channel_1.send_message(emoji_message) self.channel_1.send_message(emoji_message)
for channel in self.channel_1, self.channel_2: for channel in self.channel_1, self.channel_2:
if not channel.chat_element_by_text(emoji_unicode).is_element_displayed(30): if not channel.chat_element_by_text(emoji_unicode).is_element_displayed(30):
self.errors.append('Message with emoji was not sent or received in community channel') self.errors.append(channel, 'Message with emoji was not sent or received in community channel')
self.channel_1.just_fyi("Can copy and paste emojis") self.channel_1.just_fyi("Can copy and paste emojis")
self.channel_1.copy_message_text(emoji_unicode) self.channel_1.copy_message_text(emoji_unicode)
actual_copied_text = self.channel_1.driver.get_clipboard_text() actual_copied_text = self.channel_1.driver.get_clipboard_text()
if actual_copied_text != emoji_unicode: if actual_copied_text != emoji_unicode:
self.errors.append('Emoji message was not copied, text in clipboard is %s' % actual_copied_text) self.errors.append(self.channel_1,
'Emoji message was not copied, text in clipboard is %s' % actual_copied_text)
self.channel_1.just_fyi("Can reply to emojis") self.channel_1.just_fyi("Can reply to emojis")
if not self.channel_2.chat_message_input.is_element_displayed(): if not self.channel_2.chat_message_input.is_element_displayed():
@ -557,7 +566,7 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
chat_element_1 = self.channel_1.chat_element_by_text(message_text) chat_element_1 = self.channel_1.chat_element_by_text(message_text)
chat_element_1.wait_for_element(60) chat_element_1.wait_for_element(60)
if chat_element_1.replied_message_text != emoji_unicode: if chat_element_1.replied_message_text != emoji_unicode:
self.errors.append('Reply message is not reply to original message!') self.errors.append(self.channel_1, 'Reply message is not reply to original message!')
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702844) @marks.testrail_id(702844)
@ -613,27 +622,30 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
try: try:
self.channel_2.url_preview_composer.wait_for_element(20) self.channel_2.url_preview_composer.wait_for_element(20)
except TimeoutException: except TimeoutException:
self.errors.append("No preview is loaded for url %s" % url) self.errors.append(self.channel_1, "No preview is loaded for url %s" % url)
self.channel_2.send_message_button.click() self.channel_2.send_message_button.click()
continue continue
shown_title = self.channel_2.url_preview_composer_text.text shown_title = self.channel_2.url_preview_composer_text.text
if shown_title != data['title']: if shown_title != data['title']:
self.errors.append("Preview text is not expected, it is '%s'" % shown_title) self.errors.append(self.channel_2, "Preview text is not expected, it is '%s'" % shown_title)
self.channel_2.send_message_button.click() self.channel_2.send_message_button.click()
message = self.channel_1.get_preview_message_by_text(url) message = self.channel_1.get_preview_message_by_text(url)
message.wait_for_element(60) message.wait_for_element(60)
if not message.preview_image: if not message.preview_image:
self.errors.append("No preview image is shown for %s" % url) self.errors.append(self.channel_1, "No preview image is shown for %s" % url)
shown_title = message.preview_title.text shown_title = message.preview_title.text
if shown_title != data['title']: if shown_title != data['title']:
self.errors.append("Title is not equal expected for '%s', actual is '%s'" % (url, shown_title)) self.errors.append(self.channel_1,
"Title is not equal expected for '%s', actual is '%s'" % (url, shown_title))
shown_description = message.preview_subtitle.text shown_description = message.preview_subtitle.text
if shown_description != data['description']: if shown_description != data['description']:
self.errors.append( self.errors.append(self.channel_1,
"Description is not equal expected for '%s', actual is '%s'" % (url, shown_description)) "Description is not equal expected for '%s', actual is '%s'" % (
url, shown_description))
shown_link = message.preview_link.text shown_link = message.preview_link.text
if shown_link != data['link']: if shown_link != data['link']:
self.errors.append("Link is not equal expected for '%s', actual is '%s'" % (url, shown_link)) self.errors.append(self.channel_1,
"Link is not equal expected for '%s', actual is '%s'" % (url, shown_link))
self.channel_1.just_fyi("Set reaction and check it") self.channel_1.just_fyi("Set reaction and check it")
message_with_reaction = list(preview_urls.values())[-1]['url'] message_with_reaction = list(preview_urls.values())[-1]['url']
@ -645,7 +657,7 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.channel_2.chat_element_by_text(message_with_reaction).emojis_below_message( self.channel_2.chat_element_by_text(message_with_reaction).emojis_below_message(
emoji="laugh").wait_for_element_text(1) emoji="laugh").wait_for_element_text(1)
except (Failed, NoSuchElementException): except (Failed, NoSuchElementException):
self.errors.append("Link message reaction is not shown for the sender") self.errors.append(self.channel_2, "Link message reaction is not shown for the sender")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -662,14 +674,14 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.home_1.just_fyi('Check new messages badge is shown for community') self.home_1.just_fyi('Check new messages badge is shown for community')
community_element_1 = self.home_1.get_chat(self.community_name, community=True) community_element_1 = self.home_1.get_chat(self.community_name, community=True)
if not community_element_1.new_messages_grey_dot.is_element_displayed(sec=30): if not community_element_1.new_messages_grey_dot.is_element_displayed(sec=30):
self.errors.append('New message community badge is not shown') self.errors.append(self.home_1, 'New message community badge is not shown')
community_1 = community_element_1.click() community_1 = community_element_1.click()
channel_1_element = community_1.get_channel(self.channel_name) channel_1_element = community_1.get_channel(self.channel_name)
self.home_1.just_fyi('Check new messages badge is shown for channel') self.home_1.just_fyi('Check new messages badge is shown for channel')
if not channel_1_element.new_messages_grey_dot.is_element_displayed(): if not channel_1_element.new_messages_grey_dot.is_element_displayed():
self.errors.append('New messages channel badge is not shown on channel') self.errors.append(self.channel_1, 'New messages channel badge is not shown on channel')
channel_1_element.click() channel_1_element.click()
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -696,7 +708,7 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.chat_1.just_fyi('Check that messages from blocked user are hidden in public chat and close app') self.chat_1.just_fyi('Check that messages from blocked user are hidden in public chat and close app')
if not self.chat_1.chat_element_by_text(message_to_disappear).is_element_disappeared(30): if not self.chat_1.chat_element_by_text(message_to_disappear).is_element_disappeared(30):
self.errors.append("Messages from blocked user is not cleared in public chat ") self.errors.append(self.chat_1, "Messages from blocked user is not cleared in public chat ")
self.chat_1.navigate_back_to_home_view() self.chat_1.navigate_back_to_home_view()
# ToDo: enable when https://github.com/status-im/status-mobile/issues/19334 is fixed # ToDo: enable when https://github.com/status-im/status-mobile/issues/19334 is fixed
# self.home_1.chats_tab.click() # self.home_1.chats_tab.click()
@ -715,8 +727,8 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.home_1.get_chat(self.channel_name, community_channel=True).click() self.home_1.get_chat(self.channel_name, community_channel=True).click()
for message in message_to_disappear, message_blocked: for message in message_to_disappear, message_blocked:
if self.chat_1.chat_element_by_text(message).is_element_displayed(30): if self.chat_1.chat_element_by_text(message).is_element_displayed(30):
self.errors.append( self.errors.append(self.chat_1,
"'%s' from blocked user is fetched from offline in community channel" % message) "'%s' from blocked user is fetched from offline in community channel" % message)
self.chat_1.just_fyi('Unblock user and check that can see further messages') self.chat_1.just_fyi('Unblock user and check that can see further messages')
# TODO: still no blocked users in new UI # TODO: still no blocked users in new UI
@ -736,7 +748,8 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.home_1.get_chat(self.channel_name, community_channel=True).click() self.home_1.get_chat(self.channel_name, community_channel=True).click()
self.chat_1.hide_keyboard_if_shown() self.chat_1.hide_keyboard_if_shown()
if not self.chat_1.chat_element_by_text(message_unblocked).is_element_displayed(120): if not self.chat_1.chat_element_by_text(message_unblocked).is_element_displayed(120):
self.errors.append("%s was not received in public chat after user unblock!" % message_unblocked) self.errors.append(self.chat_1,
"%s was not received in public chat after user unblock!" % message_unblocked)
self.errors.verify_no_errors() self.errors.verify_no_errors()
self.home_1.just_fyi("Add blocked user to contacts again after removing(removed automatically when blocked)") self.home_1.just_fyi("Add blocked user to contacts again after removing(removed automatically when blocked)")
@ -756,7 +769,7 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
unblocked = True unblocked = True
except TimeoutException: except TimeoutException:
unblocked = False unblocked = False
self.errors.append("Chat with unblocked user was not enabled after 1 minute") self.errors.append(self.chat_1, "Chat with unblocked user was not enabled after 1 minute")
if unblocked: if unblocked:
self.home_2.just_fyi("Check message in 1-1 chat after unblock") self.home_2.just_fyi("Check message in 1-1 chat after unblock")
@ -767,9 +780,9 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.chat_2.chat_element_by_text(message_unblocked).wait_for_status_to_be(expected_status='Delivered', self.chat_2.chat_element_by_text(message_unblocked).wait_for_status_to_be(expected_status='Delivered',
timeout=120) timeout=120)
if not self.chat_1.chat_element_by_text(message_unblocked).is_element_displayed(30): if not self.chat_1.chat_element_by_text(message_unblocked).is_element_displayed(30):
self.errors.append("Message was not received in 1-1 chat after user unblock!") self.errors.append(self.chat_1, "Message was not received in 1-1 chat after user unblock!")
except TimeoutException: except TimeoutException:
self.errors.append('Message was not delivered after back up online.') self.errors.append(self.chat_2, 'Message was not delivered after back up online.')
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -783,22 +796,23 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.channel_2.send_message(self.text_message) self.channel_2.send_message(self.text_message)
community_1_element = self.community_1.get_chat(self.community_name, community=True) community_1_element = self.community_1.get_chat(self.community_name, community=True)
if not community_1_element.new_messages_grey_dot.is_element_displayed(90): if not community_1_element.new_messages_grey_dot.is_element_displayed(90):
self.errors.append('New messages counter is not shown in home > Community element') self.errors.append(self.community_1, 'New messages counter is not shown in home > Community element')
community_1_element.click() community_1_element.click()
channel_1_element = self.community_1.get_chat(self.channel_name, community_channel=True) channel_1_element = self.community_1.get_chat(self.channel_name, community_channel=True)
if not channel_1_element.new_messages_grey_dot.is_element_displayed(): if not channel_1_element.new_messages_grey_dot.is_element_displayed():
self.errors.append("New messages counter is not shown in community channel element") self.errors.append(self.community_1, "New messages counter is not shown in community channel element")
self.community_1.click_system_back_button() self.community_1.click_system_back_button()
mark_as_read_button = self.community_1.mark_all_messages_as_read_button mark_as_read_button = self.community_1.mark_all_messages_as_read_button
self.home_1.community_floating_screen.wait_for_invisibility_of_element() self.home_1.community_floating_screen.wait_for_invisibility_of_element()
community_1_element.long_press_until_element_is_shown(mark_as_read_button) community_1_element.long_press_until_element_is_shown(mark_as_read_button)
mark_as_read_button.click() mark_as_read_button.click()
if community_1_element.new_messages_grey_dot.is_element_displayed(): if community_1_element.new_messages_grey_dot.is_element_displayed():
self.errors.append( self.errors.append(self.community_1,
'Unread messages badge is shown in community element while there are no unread messages') 'Unread messages badge is shown in community element while there are no unread messages')
community_1_element.click() community_1_element.click()
if channel_1_element.new_messages_grey_dot.is_element_displayed(): if channel_1_element.new_messages_grey_dot.is_element_displayed():
self.errors.append( self.errors.append(
self.community_1,
"New messages badge is shown in community channel element while there are no unread messages") "New messages badge is shown in community channel element while there are no unread messages")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -827,9 +841,10 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.channel_1.just_fyi("Receiver is checking if messages were updated and deleted") self.channel_1.just_fyi("Receiver is checking if messages were updated and deleted")
if not self.channel_1.chat_element_by_text(message_after_edit).is_element_displayed(30): if not self.channel_1.chat_element_by_text(message_after_edit).is_element_displayed(30):
self.errors.append("Updated message '%s' is not delivered to the receiver" % message_after_edit) self.errors.append(self.channel_1,
"Updated message '%s' is not delivered to the receiver" % message_after_edit)
if not self.channel_1.chat_element_by_text(message_to_delete).is_element_disappeared(): if not self.channel_1.chat_element_by_text(message_to_delete).is_element_disappeared():
self.errors.append("Message '%s' was not deleted for the receiver" % message_to_delete) self.errors.append(self.channel_1, "Message '%s' was not deleted for the receiver" % message_to_delete)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -890,12 +905,13 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
message_received = True message_received = True
if not self.channel_1.chat_element_by_text(self.username_1).is_element_displayed(): if not self.channel_1.chat_element_by_text(self.username_1).is_element_displayed():
if self.channel_1.chat_message_input.is_element_displayed(): if self.channel_1.chat_message_input.is_element_displayed():
self.errors.append("Message with the mention is not shown in the chat for the admin") self.errors.append(self.channel_1,
"Message with the mention is not shown in the chat for the admin")
else: else:
self.errors.append( self.errors.append(self.channel_1,
"Channel did not open by clicking on a notification with the mention for admin") "Channel did not open by clicking on a notification with the mention for admin")
else: else:
self.errors.append("Push notification with the mention was not received by admin") self.errors.append(self.channel_1, "Push notification with the mention was not received by admin")
if not self.channel_1.chat_message_input.is_element_displayed(): if not self.channel_1.chat_message_input.is_element_displayed():
self.channel_1.navigate_back_to_home_view() self.channel_1.navigate_back_to_home_view()
@ -925,20 +941,20 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
self.channel_2.send_message_button.click() self.channel_2.send_message_button.click()
edit_done = True edit_done = True
if chat_element.message_body_with_mention.text != expected_message: if chat_element.message_body_with_mention.text != expected_message:
self.errors.append("Edited message is not shown correctly for the sender") self.errors.append(self.channel_2, "Edited message is not shown correctly for the sender")
except NoSuchElementException: except NoSuchElementException:
self.errors.append("Can not edit a message with a mention") self.errors.append(self.channel_2, "Can not edit a message with a mention")
if edit_done: if edit_done:
element = self.channel_1.chat_element_by_text(self.username_1).message_body_with_mention element = self.channel_1.chat_element_by_text(self.username_1).message_body_with_mention
if not element.is_element_displayed(10) or element.text != expected_message: if not element.is_element_displayed(10) or element.text != expected_message:
self.errors.append("Edited message is not shown correctly for the (receiver) admin") self.errors.append(self.channel_1, "Edited message is not shown correctly for the (receiver) admin")
self.device_2.just_fyi("Sender checks the reaction for a message with a mention") self.device_2.just_fyi("Sender checks the reaction for a message with a mention")
try: try:
self.channel_2.chat_element_by_text(self.username_1).emojis_below_message( self.channel_2.chat_element_by_text(self.username_1).emojis_below_message(
emoji="sad").wait_for_element_text(1) emoji="sad").wait_for_element_text(1)
except (Failed, NoSuchElementException): except (Failed, NoSuchElementException):
self.errors.append("Message reaction is not shown for the sender") self.errors.append(self.channel_2, "Message reaction is not shown for the sender")
self.home_2.navigate_back_to_home_view() self.home_2.navigate_back_to_home_view()
if not self.channel_1.chat_message_input.is_element_displayed(): if not self.channel_1.chat_message_input.is_element_displayed():
@ -957,12 +973,15 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
push_notification_element.click() push_notification_element.click()
if not self.channel_2.chat_element_by_text(self.username_2).is_element_displayed(): if not self.channel_2.chat_element_by_text(self.username_2).is_element_displayed():
if self.channel_2.chat_message_input.is_element_displayed(): if self.channel_2.chat_message_input.is_element_displayed():
self.errors.append("Message with the mention is not shown in the chat for the invited member") self.errors.append(self.channel_2,
"Message with the mention is not shown in the chat for the invited member")
else: else:
self.errors.append( self.errors.append(
self.channel_2,
"Channel did not open by clicking on a notification with the mention for the invited member") "Channel did not open by clicking on a notification with the mention for the invited member")
else: else:
self.errors.append("Push notification with the mention was not received by the invited member") self.errors.append(self.channel_2,
"Push notification with the mention was not received by the invited member")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702809) @marks.testrail_id(702809)
@ -989,11 +1008,13 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
self.channel_2.send_message(message_to_send) self.channel_2.send_message(message_to_send)
if not self.channel_2.chat_element_by_text(message).is_element_displayed(): if not self.channel_2.chat_element_by_text(message).is_element_displayed():
self.errors.append( self.errors.append(
'%s is not displayed with markdown in community channel for the sender (device 2) \n' % message) self.channel_2,
'%s is not displayed with markdown in community channel for the sender \n' % message)
if not self.channel_1.chat_element_by_text(message).is_element_displayed(): if not self.channel_1.chat_element_by_text(message).is_element_displayed():
self.errors.append( self.errors.append(
'%s is not displayed with markdown in community channel for the recipient (device 1) \n' % message) self.channel_1,
'%s is not displayed with markdown in community channel for the recipient \n' % message)
for home in self.homes: for home in self.homes:
home.navigate_back_to_home_view() home.navigate_back_to_home_view()
@ -1009,10 +1030,11 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
self.chat_1.send_message(message_to_send) self.chat_1.send_message(message_to_send)
if not self.chat_1.chat_element_by_text(message).is_element_displayed(30): if not self.chat_1.chat_element_by_text(message).is_element_displayed(30):
self.errors.append( self.errors.append(
'%s is not displayed with markdown in 1-1 chat for the sender (device 1) \n' % message) self.chat_1, '%s is not displayed with markdown in 1-1 chat for the sender (device 1) \n' % message)
if not self.chat_2.chat_element_by_text(message).is_element_displayed(30): if not self.chat_2.chat_element_by_text(message).is_element_displayed(30):
self.errors.append( self.errors.append(
self.chat_2,
'%s is not displayed with markdown in 1-1 chat for the recipient (device 2) \n' % message) '%s is not displayed with markdown in 1-1 chat for the recipient (device 2) \n' % message)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -1027,7 +1049,7 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
community_to_leave.leave_community_button.click() community_to_leave.leave_community_button.click()
community_to_leave.leave_community_button.click() community_to_leave.leave_community_button.click()
if not community.is_element_disappeared(): if not community.is_element_disappeared():
self.errors.append('Community is still shown in the list after leave') self.errors.append(self.home_2, 'Community is still shown in the list after leave')
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.xfail(reason="Can't navigate to a community channel before joining the community, " @marks.xfail(reason="Can't navigate to a community channel before joining the community, "
@ -1058,12 +1080,13 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
if not self.community_2.get_channel(chan_name).is_element_displayed(): if not self.community_2.get_channel(chan_name).is_element_displayed():
not_shown.append(chan_name) not_shown.append(chan_name)
if not_shown: if not_shown:
self.errors.append("Not all channels are shown in community before joining: %s" % not_shown) self.errors.append(self.community_2,
"Not all channels are shown in community before joining: %s" % not_shown)
chan = self.community_2.get_channel("general") chan = self.community_2.get_channel("general")
if chan.is_element_displayed(): if chan.is_element_displayed():
chan.find_element().click() chan.find_element().click()
if not self.channel_2.chat_element_by_text(control_message_general_chat).is_element_displayed(20): if not self.channel_2.chat_element_by_text(control_message_general_chat).is_element_displayed(20):
self.errors.append("Message in community channel is not visible for user before join") self.errors.append(self.channel_2, "Message in community channel is not visible for user before join")
else: else:
not_shown.append("general") not_shown.append("general")
@ -1078,7 +1101,7 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
try: try:
self.home_1.notifications_unread_badge.wait_for_visibility_of_element(120) self.home_1.notifications_unread_badge.wait_for_visibility_of_element(120)
except TimeoutException: except TimeoutException:
self.errors.append("Unread indicator is not shown in notifications on membership request") self.errors.append(self.home_1, "Unread indicator is not shown in notifications on membership request")
self.home_1.open_activity_center_button.click() self.home_1.open_activity_center_button.click()
reply_element = self.home_1.get_element_from_activity_center_view(self.username_2) reply_element = self.home_1.get_element_from_activity_center_view(self.username_2)
reply_element.title.swipe_right_on_element(width_percentage=2.5) reply_element.title.swipe_right_on_element(width_percentage=2.5)
@ -1104,12 +1127,12 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
self.home_2.get_to_community_channel_from_home(community_name, dogs_channel) self.home_2.get_to_community_channel_from_home(community_name, dogs_channel)
self.channel_2.chat_element_by_text(message_with_hashtag).click_on_link_inside_message_body() self.channel_2.chat_element_by_text(message_with_hashtag).click_on_link_inside_message_body()
if not self.channel_2.chat_element_by_text(cats_message).is_element_displayed(30): if not self.channel_2.chat_element_by_text(cats_message).is_element_displayed(30):
self.errors.append("Receiver was not navigated to the cats channel") self.errors.append(self.channel_2, "Receiver was not navigated to the cats channel")
self.home_1.just_fyi("Device 1 clicks on the message with hashtag in the community channel") self.home_1.just_fyi("Device 1 clicks on the message with hashtag in the community channel")
self.channel_1.chat_element_by_text(message_with_hashtag).click_on_link_inside_message_body() self.channel_1.chat_element_by_text(message_with_hashtag).click_on_link_inside_message_body()
if not self.channel_1.chat_element_by_text(cats_message).is_element_displayed(30): if not self.channel_1.chat_element_by_text(cats_message).is_element_displayed(30):
self.errors.append("Sender was not navigated to the cats channel") self.errors.append(self.channel_1, "Sender was not navigated to the cats channel")
for home in self.homes: for home in self.homes:
home.navigate_back_to_home_view() home.navigate_back_to_home_view()
@ -1123,12 +1146,12 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
self.home_1.get_chat(self.username_2).click() self.home_1.get_chat(self.username_2).click()
self.chat_1.chat_element_by_text(message_with_hashtag).click_on_link_inside_message_body() self.chat_1.chat_element_by_text(message_with_hashtag).click_on_link_inside_message_body()
if self.chat_1.chat_element_by_text(control_message_1_1_chat).is_element_disappeared(): if self.chat_1.chat_element_by_text(control_message_1_1_chat).is_element_disappeared():
self.errors.append("Receiver was navigated out of 1-1 chat") self.errors.append(self.chat_1, "Receiver was navigated out of 1-1 chat")
self.home_2.just_fyi("Device 2 clicks on the message with hashtag in 1-1 chat") self.home_2.just_fyi("Device 2 clicks on the message with hashtag in 1-1 chat")
self.chat_2.chat_element_by_text(message_with_hashtag).click_on_link_inside_message_body() self.chat_2.chat_element_by_text(message_with_hashtag).click_on_link_inside_message_body()
if self.chat_2.chat_element_by_text(control_message_1_1_chat).is_element_disappeared(): if self.chat_2.chat_element_by_text(control_message_1_1_chat).is_element_disappeared():
self.errors.append("Sender was navigated out of 1-1 chat") self.errors.append(self.chat_2, "Sender was navigated out of 1-1 chat")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -1169,21 +1192,23 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
if self.community_2.toast_content_element.is_element_displayed(10): if self.community_2.toast_content_element.is_element_displayed(10):
cur_text = self.community_2.toast_content_element.text cur_text = self.community_2.toast_content_element.text
if cur_text != exp_text: if cur_text != exp_text:
self.errors.append( self.errors.append(self.community_2,
"Text \"%s\" in shown toast element doesn't match expected \"%s\"" % (cur_text, exp_text)) "Text \"%s\" in shown toast element doesn't match expected \"%s\"" % (
cur_text, exp_text))
else: else:
self.errors.append("Toast element with the text \"%s\" doesn't appear" % exp_text) self.errors.append(self.community_2, "Toast element with the text \"%s\" doesn't appear" % exp_text)
if not self.community_2.community_status_pending.is_element_displayed(): if not self.community_2.community_status_pending.is_element_displayed():
self.errors.append("Pending status is not displayed") self.errors.append(self.community_2, "Pending status is not displayed")
general_channel = self.community_2.get_channel("general") general_channel = self.community_2.get_channel("general")
if general_channel.is_element_displayed(): if general_channel.is_element_displayed():
general_channel.find_element().click() general_channel.find_element().click()
if not self.channel_2.chat_element_by_text(control_message_general_chat).is_element_displayed(30): if not self.channel_2.chat_element_by_text(control_message_general_chat).is_element_displayed(30):
self.errors.append( self.errors.append(
self.community_2,
"Message in community channel is not visible for user before join, it was indicated as " \ "Message in community channel is not visible for user before join, it was indicated as " \
"%s sent for the sender before he went offline" % ("" if message_sent else "not")) "%s sent for the sender before he went offline" % ("" if message_sent else "not"))
else: else:
self.errors.append("Community channel is not displayed for user before join") self.errors.append(self.community_2, "Community channel is not displayed for user before join")
self.community_2.toast_content_element.wait_for_invisibility_of_element(30) self.community_2.toast_content_element.wait_for_invisibility_of_element(30)
self.home_2.navigate_back_to_home_view() self.home_2.navigate_back_to_home_view()
self.home_2.communities_tab.click() self.home_2.communities_tab.click()
@ -1191,7 +1216,7 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
if self.home_2.get_chat(community_name, community=True).is_element_displayed(): if self.home_2.get_chat(community_name, community=True).is_element_displayed():
self.home_2.get_chat(community_name, community=True).click() self.home_2.get_chat(community_name, community=True).click()
else: else:
self.errors.append("%s is not listed inside Pending communities tab" % community_name) self.errors.append(self.home_2, "%s is not listed inside Pending communities tab" % community_name)
self.home_1.just_fyi("Device 1 goes back online") self.home_1.just_fyi("Device 1 goes back online")
self.home_1.driver.activate_app(app_package) self.home_1.driver.activate_app(app_package)
@ -1202,13 +1227,14 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
if self.community_2.toast_content_element.is_element_displayed(60): if self.community_2.toast_content_element.is_element_displayed(60):
cur_text = self.community_2.toast_content_element.text cur_text = self.community_2.toast_content_element.text
if cur_text != exp_text: if cur_text != exp_text:
self.errors.append( self.errors.append(self.community_2,
"Text \"%s\" in shown toast element doesn't match expected \"%s\"" % (cur_text, exp_text)) "Text \"%s\" in shown toast element doesn't match expected \"%s\"" % (
cur_text, exp_text))
# else: # else:
# self.errors.append("Toast element with the text \"%s\" doesn't appear" % exp_text) # self.errors.append("Toast element with the text \"%s\" doesn't appear" % exp_text)
# ToDo: add verification when toast is fixed # ToDo: add verification when toast is fixed
if not self.community_2.community_status_joined.is_element_displayed(): if not self.community_2.community_status_joined.is_element_displayed():
self.errors.append("Joined status is not displayed") self.errors.append(self.community_2, "Joined status is not displayed")
self.community_2.close_community_view_button.click_until_absense_of_element( self.community_2.close_community_view_button.click_until_absense_of_element(
self.community_2.close_community_view_button) self.community_2.close_community_view_button)
self.home_2.joined_communities_tab.click() self.home_2.joined_communities_tab.click()
@ -1216,6 +1242,6 @@ class TestCommunityMultipleDeviceMergedTwo(MultipleSharedDeviceTestCase):
if chat_element.is_element_displayed(30): if chat_element.is_element_displayed(30):
chat_element.click() chat_element.click()
else: else:
self.errors.append("%s is not listed inside Joined communities tab" % community_name) self.errors.append(self.home_2, "%s is not listed inside Joined communities tab" % community_name)
self.errors.verify_no_errors() self.errors.verify_no_errors()

18
test/appium/tests/critical/test_deep_and_universal_links.py
View File

@ -42,9 +42,9 @@ class TestDeepLinksOneDevice(MultipleSharedDeviceTestCase):
if self.channel.profile_send_contact_request_button.is_element_displayed(10): if self.channel.profile_send_contact_request_button.is_element_displayed(10):
username_text = self.profile_view.contact_name_text.text username_text = self.profile_view.contact_name_text.text
if not (username_text.endswith(url[-6:]) or username_text == text): if not (username_text.endswith(url[-6:]) or username_text == text):
self.errors.append("Incorrect username is shown for profile url %s" % url) self.errors.append(self.channel, "Incorrect username is shown for profile url %s" % url)
else: else:
self.errors.append("Profile was not opened by the profile url %s" % url) self.errors.append(self.channel, "Profile was not opened by the profile url %s" % url)
self.profile_view.close_button.click() self.profile_view.close_button.click()
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -69,7 +69,7 @@ class TestDeepLinksOneDevice(MultipleSharedDeviceTestCase):
else: else:
name_is_shown = shown_name_text.endswith(link[-6:]) name_is_shown = shown_name_text.endswith(link[-6:])
if not self.channel.profile_send_contact_request_button.is_element_displayed(10) or not name_is_shown: if not self.channel.profile_send_contact_request_button.is_element_displayed(10) or not name_is_shown:
self.errors.append("Profile was not opened by the profile deep link %s" % link) self.errors.append(self.channel, "Profile was not opened by the profile deep link %s" % link)
self.browser_view.click_system_back_button() self.browser_view.click_system_back_button()
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -103,11 +103,13 @@ class TestDeepLinksOneDevice(MultipleSharedDeviceTestCase):
self.browser_view.open_url(link) self.browser_view.open_url(link)
if text == snt_community_name: if text == snt_community_name:
if self.community_view.community_title.text != text: if self.community_view.community_title.text != text:
self.errors.append("Community '%s' was not requested to join by the deep link %s" % (text, link)) self.errors.append(self.community_view,
"Community '%s' was not requested to join by the deep link %s" % (text, link))
else: else:
if not self.community_view.join_button.is_element_displayed( if not self.community_view.join_button.is_element_displayed(
10) or self.community_view.community_title.text != text: 10) or self.community_view.community_title.text != text:
self.errors.append("Community '%s' was not requested to join by the deep link %s" % (text, link)) self.errors.append(self.community_view,
"Community '%s' was not requested to join by the deep link %s" % (text, link))
if text != closed_community_name: # the last one if text != closed_community_name: # the last one
self.home.navigate_back_to_home_view() self.home.navigate_back_to_home_view()
self.home.browser_tab.click() self.home.browser_tab.click()
@ -123,7 +125,8 @@ class TestDeepLinksOneDevice(MultipleSharedDeviceTestCase):
self.home.open_link_from_google_search_app(profile_url, app_package) self.home.open_link_from_google_search_app(profile_url, app_package)
if not self.channel.profile_add_to_contacts_button.is_element_displayed( if not self.channel.profile_add_to_contacts_button.is_element_displayed(
10) or not self.profile_view.default_username_text.text.endswith(profile_url[-6:]): 10) or not self.profile_view.default_username_text.text.endswith(profile_url[-6:]):
self.errors.append("Profile was not opened by the url %s when user is logged in" % profile_url) self.errors.append(self.profile_view,
"Profile was not opened by the url %s when user is logged in" % profile_url)
self.home.just_fyi("Opening a community URL from google search bar when user is logged out") self.home.just_fyi("Opening a community URL from google search bar when user is logged out")
self.driver.terminate_app(app_package) self.driver.terminate_app(app_package)
@ -131,7 +134,8 @@ class TestDeepLinksOneDevice(MultipleSharedDeviceTestCase):
self.home.open_link_from_google_search_app(community_url, app_package) self.home.open_link_from_google_search_app(community_url, app_package)
self.sign_in.sign_in(user_name=self.username) self.sign_in.sign_in(user_name=self.username)
if not self.community_view.join_button.is_element_displayed(10): if not self.community_view.join_button.is_element_displayed(10):
self.errors.append("Closed community was not requested to join by the url %s" % community_url) self.errors.append(self.community_view,
"Closed community was not requested to join by the url %s" % community_url)
# ToDo: enable when https://github.com/status-im/status-mobile/issues/18074 is fixed # ToDo: enable when https://github.com/status-im/status-mobile/issues/18074 is fixed
# self.home.just_fyi("Opening a community channel URL from google search bar with no account created") # self.home.just_fyi("Opening a community channel URL from google search bar with no account created")

80
test/appium/tests/critical/test_fallback.py
View File

@ -72,9 +72,11 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
if device_element.is_element_displayed(): if device_element.is_element_displayed():
if not device_element.get_pair_button.is_element_displayed(): if not device_element.get_pair_button.is_element_displayed():
self.errors.append( self.errors.append(
self.profile_1,
"Pair button is absent for the device 2 inside Paired devices list of profile 1 before pairing") "Pair button is absent for the device 2 inside Paired devices list of profile 1 before pairing")
else: else:
self.errors.append("Device 2 is not shown in Paired devices list for device 1 before pairing") self.errors.append(self.profile_1,
"Device 2 is not shown in Paired devices list for device 1 before pairing")
self.profile_1.click_system_back_button(times=3) self.profile_1.click_system_back_button(times=3)
for home in self.home_1, self.home_2: for home in self.home_1, self.home_2:
@ -84,9 +86,10 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
self.home_1.just_fyi("Checking pairing request on device 1") self.home_1.just_fyi("Checking pairing request on device 1")
a_c_element = self.home_1.get_activity_center_element_by_text(transl['review-pairing-request']) a_c_element = self.home_1.get_activity_center_element_by_text(transl['review-pairing-request'])
if a_c_element.title.text != transl['new-device-detected']: if a_c_element.title.text != transl['new-device-detected']:
self.errors.append( self.errors.append(self.home_1,
"Notification with title '%s' is not shown in the activity center for the device 1" % transl[ "Notification with title '%s' is not shown in the activity center for the device 1" %
'new-device-detected']) transl[
'new-device-detected'])
a_c_element.review_pairing_request_button.click() a_c_element.review_pairing_request_button.click()
device_id_1 = self.home_1.get_new_device_installation_id() device_id_1 = self.home_1.get_new_device_installation_id()
@ -95,14 +98,15 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
self.home_2.just_fyi("Checking sync profile on device 2") self.home_2.just_fyi("Checking sync profile on device 2")
a_c_element = self.home_2.get_activity_center_element_by_text(transl['more-details']) a_c_element = self.home_2.get_activity_center_element_by_text(transl['more-details'])
if a_c_element.title.text != transl['sync-your-profile']: if a_c_element.title.text != transl['sync-your-profile']:
self.errors.append( self.errors.append(self.home_2,
"Notification with title '%s' is not shown in the activity center for the device 2" % transl[ "Notification with title '%s' is not shown in the activity center for the device 2" %
'sync-your-profile']) transl[
'sync-your-profile'])
a_c_element.more_details_button.click() a_c_element.more_details_button.click()
device_id_2 = self.home_2.get_new_device_installation_id() device_id_2 = self.home_2.get_new_device_installation_id()
if device_id_1 != device_id_2: if device_id_1 != device_id_2:
self.errors.append("Device ids don't match on the activity center notifications") self.errors.append(self.home_2, "Device ids don't match on the activity center notifications")
self.home_1.just_fyi("Confirm pairing request on device 1") self.home_1.just_fyi("Confirm pairing request on device 1")
self.home_1.element_by_translation_id('pair-and-sync').click() self.home_1.element_by_translation_id('pair-and-sync').click()
@ -121,9 +125,11 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
if device_element.is_element_displayed(): if device_element.is_element_displayed():
if not device_element.get_unpair_button.is_element_displayed(): if not device_element.get_unpair_button.is_element_displayed():
self.errors.append( self.errors.append(
self.profile_1,
"Unpair button is absent for the device 2 inside Paired devices list of profile 1 after pairing") "Unpair button is absent for the device 2 inside Paired devices list of profile 1 after pairing")
else: else:
self.errors.append("Device 2 is not shown in Paired devices list for device 1 after pairing") self.errors.append(self.profile_1,
"Device 2 is not shown in Paired devices list for device 1 after pairing")
self.home_2.just_fyi("Device 2: Check that the device 1 is shown paired devices list") self.home_2.just_fyi("Device 2: Check that the device 1 is shown paired devices list")
self.home_2.profile_button.click() self.home_2.profile_button.click()
@ -133,9 +139,11 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
if device_element.is_element_displayed(): if device_element.is_element_displayed():
if not device_element.get_unpair_button.is_element_displayed(): if not device_element.get_unpair_button.is_element_displayed():
self.errors.append( self.errors.append(
self.profile_2,
"Unpair button is absent for the device 1 inside Paired devices list of profile 2 after pairing") "Unpair button is absent for the device 1 inside Paired devices list of profile 2 after pairing")
else: else:
self.errors.append("Device 1 is not shown in Paired devices list for device 2 after pairing") self.errors.append(self.profile_2,
"Device 1 is not shown in Paired devices list for device 2 after pairing")
self.home_3.just_fyi("Device 3: send a message to user 1") self.home_3.just_fyi("Device 3: send a message to user 1")
self.home_3.chats_tab.click() self.home_3.chats_tab.click()
@ -153,7 +161,7 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
chat_view = chat_element.click() chat_view = chat_element.click()
chat_view.chat_element_by_text(message).wait_for_visibility_of_element(60) chat_view.chat_element_by_text(message).wait_for_visibility_of_element(60)
except TimeoutException: except TimeoutException:
self.errors.append("Message is not received by the user %s" % index) self.errors.append(home_view, "Message is not received by the user %s" % index)
self.loop.run_until_complete( self.loop.run_until_complete(
run_in_parallel(((_check_message, {'home_view': self.home_1, 'index': 1}), run_in_parallel(((_check_message, {'home_view': self.home_1, 'index': 1}),
@ -178,11 +186,12 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
wallet_1.close_account_button.click_until_presence_of_element(account_element) wallet_1.close_account_button.click_until_presence_of_element(account_element)
if regular_account_address != expected_addresses[1]: if regular_account_address != expected_addresses[1]:
self.errors.append("Newly added regular account address %s doesn't match expected %s" % ( self.errors.append(wallet_1, "Newly added regular account address %s doesn't match expected %s" % (
regular_account_address, expected_addresses[1])) regular_account_address, expected_addresses[1]))
if regular_account_address not in expected_addresses: if regular_account_address not in expected_addresses:
self.errors.append("Newly added regular account address %s is not in the list of expected addresses %s" % ( self.errors.append(wallet_1,
regular_account_address, expected_addresses)) "Newly added regular account address %s is not in the list of expected addresses %s" % (
regular_account_address, expected_addresses))
wallet_1.just_fyi("Device 1: add a new key pair account by importing recovery phrase") wallet_1.just_fyi("Device 1: add a new key pair account by importing recovery phrase")
account_element.swipe_left_on_element() account_element.swipe_left_on_element()
@ -210,7 +219,7 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
] ]
for text in expected_texts_regular: for text in expected_texts_regular:
if not wallet_1.default_key_pair_container.get_child_element_by_text_part(text).is_element_displayed(): if not wallet_1.default_key_pair_container.get_child_element_by_text_part(text).is_element_displayed():
self.errors.append("Newly added regular account is not shown in default key pair list") self.errors.append(wallet_1, "Newly added regular account is not shown in default key pair list")
break break
expected_texts_key_pair = [ expected_texts_key_pair = [
imported_key_pair_account_name, imported_key_pair_name, imported_key_pair_account_name, imported_key_pair_name,
@ -218,7 +227,7 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
] ]
for text in expected_texts_key_pair: for text in expected_texts_key_pair:
if not wallet_1.added_key_pair_container.get_child_element_by_text_part(text).is_element_displayed(): if not wallet_1.added_key_pair_container.get_child_element_by_text_part(text).is_element_displayed():
self.errors.append("Newly added regular account is not shown in default key pair list") self.errors.append(wallet_1, "Newly added regular account is not shown in default key pair list")
break break
wallet_1.just_fyi("Device 1: add a new key pair account by generating a new key pair") wallet_1.just_fyi("Device 1: add a new key pair account by generating a new key pair")
@ -232,27 +241,30 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
expected_addresses = generate_wallet_address(passphrase=generated_passphrase, number=4) expected_addresses = generate_wallet_address(passphrase=generated_passphrase, number=4)
if generated_key_pair_account_address != expected_addresses[0]: if generated_key_pair_account_address != expected_addresses[0]:
self.errors.append("Generated key pair account address %s doesn't match expected %s" % ( self.errors.append(wallet_1, "Generated key pair account address %s doesn't match expected %s" % (
generated_key_pair_account_address, expected_addresses[0])) generated_key_pair_account_address, expected_addresses[0]))
if generated_key_pair_account_address not in expected_addresses: if generated_key_pair_account_address not in expected_addresses:
self.errors.append("Generated key pair account address %s is not in the list of expected addresses %s" % ( self.errors.append(wallet_1,
generated_key_pair_account_address, expected_addresses)) "Generated key pair account address %s is not in the list of expected addresses %s" % (
generated_key_pair_account_address, expected_addresses))
self.home_2.just_fyi("Device 2: check imported accounts are shown before importing key pair") self.home_2.just_fyi("Device 2: check imported accounts are shown before importing key pair")
self.home_2.profile_button.click() self.home_2.profile_button.click()
self.profile_2.profile_wallet_button.click() self.profile_2.profile_wallet_button.click()
self.profile_2.key_pairs_and_accounts_button.click() self.profile_2.key_pairs_and_accounts_button.click()
if not self.profile_2.get_missing_key_pair_by_name(key_pair_name=imported_key_pair_name).is_element_displayed(): if not self.profile_2.get_missing_key_pair_by_name(key_pair_name=imported_key_pair_name).is_element_displayed():
self.errors.append("New imported key pair is not shown in profile as missing before importing") self.errors.append(self.profile_2,
"New imported key pair is not shown in profile as missing before importing")
if not self.profile_2.get_missing_key_pair_by_name( if not self.profile_2.get_missing_key_pair_by_name(
key_pair_name=generated_key_pair_name).is_element_displayed(): key_pair_name=generated_key_pair_name).is_element_displayed():
self.errors.append("Generated key pair is not shown in profile as missing before importing") self.errors.append(self.profile_2, "Generated key pair is not shown in profile as missing before importing")
if not self.profile_2.get_key_pair_account_by_name(account_name=regular_account_name).is_element_displayed(): if not self.profile_2.get_key_pair_account_by_name(account_name=regular_account_name).is_element_displayed():
self.errors.append( self.errors.append(
self.profile_2,
"Newly added regular account is not shown in profile as on device before importing key pair") "Newly added regular account is not shown in profile as on device before importing key pair")
self.profile_2.options_button.click() self.profile_2.options_button.click()
if not self.profile_2.import_by_entering_recovery_phrase_button.is_element_displayed(): if not self.profile_2.import_by_entering_recovery_phrase_button.is_element_displayed():
self.errors.append("Can not import key pair account from profile") self.errors.append(self.profile_2, "Can not import key pair account from profile")
self.profile_2.click_system_back_button(times=4) self.profile_2.click_system_back_button(times=4)
wallet_2.just_fyi("Device 2: import key pair") wallet_2.just_fyi("Device 2: import key pair")
@ -270,9 +282,11 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
address_text = self.profile_2.get_key_pair_account_by_name(account_name=regular_account_name).address.text address_text = self.profile_2.get_key_pair_account_by_name(account_name=regular_account_name).address.text
if address_text != '...'.join((regular_account_address[:5], regular_account_address[-3:])): if address_text != '...'.join((regular_account_address[:5], regular_account_address[-3:])):
self.errors.append( self.errors.append(
self.profile_2,
"Incorrect wallet address if shown for regular account after importing: " + address_text) "Incorrect wallet address if shown for regular account after importing: " + address_text)
else: else:
self.errors.append("Newly added regular account is not shown in profile after importing key pair") self.errors.append(self.profile_2,
"Newly added regular account is not shown in profile after importing key pair")
account_element = self.profile_2.get_key_pair_account_by_name( account_element = self.profile_2.get_key_pair_account_by_name(
account_name=imported_key_pair_account_name) account_name=imported_key_pair_account_name)
@ -281,14 +295,17 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
if address_text != '...'.join( if address_text != '...'.join(
(imported_key_pair_account_address[:5], imported_key_pair_account_address[-3:])): (imported_key_pair_account_address[:5], imported_key_pair_account_address[-3:])):
self.errors.append( self.errors.append(
self.profile_2,
"Incorrect wallet address if shown for imported key pair account after importing: " + address_text) "Incorrect wallet address if shown for imported key pair account after importing: " + address_text)
else: else:
self.errors.append( self.errors.append(
self.profile_2,
"Imported key pair account is not shown in profile as on device after importing key pair") "Imported key pair account is not shown in profile as on device after importing key pair")
if not self.profile_2.get_missing_key_pair_by_name( if not self.profile_2.get_missing_key_pair_by_name(
key_pair_name=generated_key_pair_name).is_element_displayed(): key_pair_name=generated_key_pair_name).is_element_displayed():
self.errors.append( self.errors.append(
self.profile_2,
"Generated key pair account is not shown in profile as missing after importing the first key pair") "Generated key pair account is not shown in profile as missing after importing the first key pair")
self.profile_2.click_system_back_button(times=3) self.profile_2.click_system_back_button(times=3)
@ -306,14 +323,15 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
wallet_2.about_tab.click() wallet_2.about_tab.click()
der_path = wallet_2.account_about_derivation_path_text.text der_path = wallet_2.account_about_derivation_path_text.text
if der_path != regular_derivation_path: if der_path != regular_derivation_path:
self.errors.append("Incorrect derivation path %s is shown for the regular account" % der_path) self.errors.append(wallet_2, "Incorrect derivation path %s is shown for the regular account" % der_path)
wallet_2.close_account_button.click_until_presence_of_element(account_element) wallet_2.close_account_button.click_until_presence_of_element(account_element)
account_element.swipe_left_on_element() account_element.swipe_left_on_element()
wallet_2.get_account_element(account_name=imported_key_pair_account_name).click() wallet_2.get_account_element(account_name=imported_key_pair_account_name).click()
wallet_2.about_tab.click() wallet_2.about_tab.click()
der_path = wallet_2.account_about_derivation_path_text.text der_path = wallet_2.account_about_derivation_path_text.text
if der_path != imported_key_pair_derivation_path: if der_path != imported_key_pair_derivation_path:
self.errors.append("Incorrect derivation path %s is shown for the imported key pair account" % der_path) self.errors.append(wallet_2,
"Incorrect derivation path %s is shown for the imported key pair account" % der_path)
wallet_2.close_account_button.click_until_presence_of_element(account_element) wallet_2.close_account_button.click_until_presence_of_element(account_element)
account_element.swipe_left_on_element() account_element.swipe_left_on_element()
wallet_2.get_account_element(account_name=generated_key_pair_account_name).click() wallet_2.get_account_element(account_name=generated_key_pair_account_name).click()
@ -324,7 +342,8 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
wallet_2.about_tab.click() wallet_2.about_tab.click()
der_path = wallet_2.account_about_derivation_path_text.text der_path = wallet_2.account_about_derivation_path_text.text
if der_path != generated_key_pair_derivation_path: if der_path != generated_key_pair_derivation_path:
self.errors.append("Incorrect derivation path %s is shown for the generated key pair account" % der_path) self.errors.append(wallet_2,
"Incorrect derivation path %s is shown for the generated key pair account" % der_path)
if not wallet_2.element_by_text_part(generated_key_pair_account_address).is_element_displayed(): if not wallet_2.element_by_text_part(generated_key_pair_account_address).is_element_displayed():
self.errors.append( self.errors.append(
"Generated key pair address %s is absent in About tab" % generated_key_pair_account_address) "Generated key pair address %s is absent in About tab" % generated_key_pair_account_address)
@ -345,14 +364,14 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
self.sign_in_2.passphrase_edit_box.send_keys(' '.join(['asset'] * 12)) self.sign_in_2.passphrase_edit_box.send_keys(' '.join(['asset'] * 12))
self.sign_in_2.continue_button.click() self.sign_in_2.continue_button.click()
if not self.sign_in_2.element_by_translation_id('seed-phrase-invalid').is_element_displayed(): if not self.sign_in_2.element_by_translation_id('seed-phrase-invalid').is_element_displayed():
self.errors.append("Error message is not displayed for invalid recovery phrase") self.errors.append(self.sign_in_2, "Error message is not displayed for invalid recovery phrase")
self.sign_in_2.just_fyi("Device 2: try creating an account with another valid passphrase") self.sign_in_2.just_fyi("Device 2: try creating an account with another valid passphrase")
self.sign_in_2.passphrase_edit_box.clear() self.sign_in_2.passphrase_edit_box.clear()
self.sign_in_2.passphrase_edit_box.send_keys(transaction_senders['A']['passphrase']) self.sign_in_2.passphrase_edit_box.send_keys(transaction_senders['A']['passphrase'])
self.sign_in_2.continue_button.click() self.sign_in_2.continue_button.click()
if not self.sign_in_2.password_input.is_element_displayed(): if not self.sign_in_2.password_input.is_element_displayed():
self.errors.append("Can't recover an access with a valid passphrase") self.errors.append(self.sign_in_2, "Can't recover an access with a valid passphrase")
self.sign_in_2.click_system_back_button(times=2) self.sign_in_2.click_system_back_button(times=2)
self.sign_in_2.just_fyi("Device 2: try recovering an account which is already synced") self.sign_in_2.just_fyi("Device 2: try recovering an account which is already synced")
@ -363,9 +382,10 @@ class TestFallbackMultipleDevice(MultipleSharedDeviceTestCase):
self.sign_in_2.native_alert_title.wait_for_element() self.sign_in_2.native_alert_title.wait_for_element()
shown_text = self.sign_in_2.native_alert_title.text shown_text = self.sign_in_2.native_alert_title.text
if shown_text != "Keys for this account already exist": if shown_text != "Keys for this account already exist":
self.errors.append("Incorrect error message '%s' is shown for already synced account" % shown_text) self.errors.append(self.sign_in_2,
"Incorrect error message '%s' is shown for already synced account" % shown_text)
self.sign_in_2.cancel_button.click() self.sign_in_2.cancel_button.click()
except TimeoutException: except TimeoutException:
self.errors.append("Error is not shown for already synced account") self.errors.append(self.sign_in_2, "Error is not shown for already synced account")
self.errors.verify_no_errors() self.errors.verify_no_errors()

32
test/appium/tests/critical/test_wallet.py
View File

@ -3,7 +3,7 @@ import time
import pytest import pytest
from _pytest.outcomes import Failed from _pytest.outcomes import Failed
from selenium.common import TimeoutException, NoSuchElementException from selenium.common import NoSuchElementException
from base_test_case import MultipleSharedDeviceTestCase, create_shared_drivers from base_test_case import MultipleSharedDeviceTestCase, create_shared_drivers
from support.api.network_api import NetworkApi from support.api.network_api import NetworkApi
@ -75,8 +75,9 @@ class TestWalletMultipleDevice(MultipleSharedDeviceTestCase):
return return
if user_name == self.receiver_username and new_eth_amount >= exp_amount: if user_name == self.receiver_username and new_eth_amount >= exp_amount:
return return
self.errors.append( self.errors.append(wallet_view,
"Eth amount in the %s's wallet is %s but should be %s" % (user_name, new_eth_amount, exp_amount)) "Eth amount in the %s's wallet is %s but should be %s" % (
user_name, new_eth_amount, exp_amount))
# ToDo: disable relogin when autoupdate feature is ready # ToDo: disable relogin when autoupdate feature is ready
self.home_1.just_fyi("Relogin for getting an updated balance") self.home_1.just_fyi("Relogin for getting an updated balance")
@ -119,10 +120,12 @@ class TestWalletMultipleDevice(MultipleSharedDeviceTestCase):
activity_element.from_text == sender_address_short, activity_element.from_text == sender_address_short,
activity_element.to_text == receiver_address_short)): activity_element.to_text == receiver_address_short)):
self.errors.append( self.errors.append(
wallet_view,
"The last transaction is not listed in activity for the %s, expected timestamp is %s" % "The last transaction is not listed in activity for the %s, expected timestamp is %s" %
('sender' if sender else 'receiver', expected_time)) ('sender' if sender else 'receiver', expected_time))
except NoSuchElementException: except NoSuchElementException:
self.errors.append("Can't find the last transaction for the %s" % ('sender' if sender else 'receiver')) self.errors.append(wallet_view,
"Can't find the last transaction for the %s" % ('sender' if sender else 'receiver'))
finally: finally:
wallet_view.close_account_button.click_until_presence_of_element(wallet_view.show_qr_code_button) wallet_view.close_account_button.click_until_presence_of_element(wallet_view.show_qr_code_button)
@ -237,7 +240,7 @@ class TestWalletOneDevice(MultipleSharedDeviceTestCase):
for asset in self.total_balance: for asset in self.total_balance:
if real_balance[asset] != self.total_balance[asset]: if real_balance[asset] != self.total_balance[asset]:
self.errors.append("For the %s the wrong value %s is shown, expected %s in total" % self.errors.append(self.wallet_view, "For the %s the wrong value %s is shown, expected %s in total" %
(asset, real_balance[asset], self.total_balance[asset])) (asset, real_balance[asset], self.total_balance[asset]))
expected_balances = { expected_balances = {
'Mainnet': self.mainnet_balance, 'Mainnet': self.mainnet_balance,
@ -253,7 +256,7 @@ class TestWalletOneDevice(MultipleSharedDeviceTestCase):
real_balance[asset] = self.wallet_view.get_asset(asset).get_amount() real_balance[asset] = self.wallet_view.get_asset(asset).get_amount()
for asset in expected_balances[network]: for asset in expected_balances[network]:
if real_balance[asset] != expected_balances[network][asset]: if real_balance[asset] != expected_balances[network][asset]:
self.errors.append("For the %s the wrong value %s is shown, expected %s on %s" % self.errors.append(self.wallet_view, "For the %s the wrong value %s is shown, expected %s on %s" %
(asset, real_balance[asset], expected_balances[network][asset], network)) (asset, real_balance[asset], expected_balances[network][asset], network))
self.wallet_view.set_network_in_wallet(network) self.wallet_view.set_network_in_wallet(network)
@ -274,16 +277,17 @@ class TestWalletOneDevice(MultipleSharedDeviceTestCase):
self.home_view.show_qr_code_button.click() self.home_view.show_qr_code_button.click()
self.home_view.share_wallet_tab_button.click() self.home_view.share_wallet_tab_button.click()
if self.home_view.account_name_text.text != 'Account 1': if self.home_view.account_name_text.text != 'Account 1':
self.errors.append("Incorrect first account is shown on Share QR Code menu") self.errors.append(self.home_view, "Incorrect first account is shown on Share QR Code menu")
self.home_view.qr_code_image_element.swipe_left_on_element() self.home_view.qr_code_image_element.swipe_left_on_element()
try: try:
self.home_view.account_name_text.wait_for_element_text(text=new_account_name, wait_time=3) self.home_view.account_name_text.wait_for_element_text(text=new_account_name, wait_time=3)
except Failed: except Failed:
self.errors.append("Can't swipe between accounts, newly added account is not shown") self.errors.append(self.home_view, "Can't swipe between accounts, newly added account is not shown")
else: else:
shown_address = self.home_view.copy_wallet_address() shown_address = self.home_view.copy_wallet_address()
if set(shown_address.split(':')) != set(new_wallet_address.split(':')): if set(shown_address.split(':')) != set(new_wallet_address.split(':')):
self.errors.append( self.errors.append(
self.home_view,
"Incorrect address '%s' is shown when swiping between accounts, expected one is '%s'" % ( "Incorrect address '%s' is shown when swiping between accounts, expected one is '%s'" % (
shown_address, new_wallet_address)) shown_address, new_wallet_address))
self.home_view.click_system_back_button() self.home_view.click_system_back_button()
@ -292,9 +296,9 @@ class TestWalletOneDevice(MultipleSharedDeviceTestCase):
if self.wallet_view.get_account_element(account_name=new_account_name).is_element_displayed(): if self.wallet_view.get_account_element(account_name=new_account_name).is_element_displayed():
self.wallet_view.remove_account(account_name=new_account_name) self.wallet_view.remove_account(account_name=new_account_name)
if self.wallet_view.get_account_element(account_name=new_account_name).is_element_displayed(): if self.wallet_view.get_account_element(account_name=new_account_name).is_element_displayed():
self.errors.append("Account was not removed from wallet") self.errors.append(self.wallet_view, "Account was not removed from wallet")
else: else:
self.errors.append("Newly added account is not shown in the accounts list") self.errors.append(self.wallet_view, "Newly added account is not shown in the accounts list")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@ -316,12 +320,12 @@ class TestWalletOneDevice(MultipleSharedDeviceTestCase):
self.home_view.show_qr_code_button.click() self.home_view.show_qr_code_button.click()
self.home_view.share_wallet_tab_button.click() self.home_view.share_wallet_tab_button.click()
if self.home_view.account_name_text.text != 'Account 1': if self.home_view.account_name_text.text != 'Account 1':
self.errors.append("Incorrect first account is shown on Share QR Code menu") self.errors.append(self.home_view, "Incorrect first account is shown on Share QR Code menu")
self.home_view.qr_code_image_element.swipe_left_on_element() self.home_view.qr_code_image_element.swipe_left_on_element()
try: try:
self.home_view.account_name_text.wait_for_element_text(text=new_account_name, wait_time=3) self.home_view.account_name_text.wait_for_element_text(text=new_account_name, wait_time=3)
except Failed: except Failed:
self.errors.append("Can't swipe between accounts, account to watch is not shown") self.errors.append(self.home_view, "Can't swipe between accounts, account to watch is not shown")
else: else:
shown_address = self.home_view.copy_wallet_address() shown_address = self.home_view.copy_wallet_address()
if set(shown_address.split(':')) != {'eth', 'arb1', 'oeth', address_to_watch}: if set(shown_address.split(':')) != {'eth', 'arb1', 'oeth', address_to_watch}:
@ -334,8 +338,8 @@ class TestWalletOneDevice(MultipleSharedDeviceTestCase):
if self.wallet_view.get_account_element(account_name=new_account_name).is_element_displayed(): if self.wallet_view.get_account_element(account_name=new_account_name).is_element_displayed():
self.wallet_view.remove_account(account_name=new_account_name, watch_only=True) self.wallet_view.remove_account(account_name=new_account_name, watch_only=True)
if self.wallet_view.get_account_element(account_name=new_account_name).is_element_displayed(): if self.wallet_view.get_account_element(account_name=new_account_name).is_element_displayed():
self.errors.append("Account was not removed from wallet") self.errors.append(self.wallet_view, "Account was not removed from wallet")
else: else:
self.errors.append("Watch only account is not shown in the accounts list") self.errors.append(self.wallet_view, "Watch only account is not shown in the accounts list")
self.errors.verify_no_errors() self.errors.verify_no_errors()

2
test/appium/views/home_view.py
View File

@ -377,7 +377,7 @@ class HomeView(BaseView):
if self.toast_content_element.is_element_displayed(10): if self.toast_content_element.is_element_displayed(10):
self.toast_content_element.wait_for_invisibility_of_element() self.toast_content_element.wait_for_invisibility_of_element()
try: try:
self.notifications_unread_badge.wait_for_visibility_of_element(60) self.notifications_unread_badge.wait_for_visibility_of_element(120)
except TimeoutException: except TimeoutException:
pass pass
self.open_activity_center_button.click_until_presence_of_element(self.close_activity_centre) self.open_activity_center_button.click_until_presence_of_element(self.close_activity_centre)