status-im
/
status-react
mirror of https://github.com/status-im/status-react.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

e2e: 1-1 chat, communities

This commit is contained in:
Churikova Tetiana 2023-02-24 20:05:30 +01:00
parent 26d618e305
commit 432f7bcd8c
No known key found for this signature in database
GPG Key ID: EDE559EC439D18A0
9 changed files with 205 additions and 447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -16,12 +16,11 @@ from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import WebDriverException from selenium.common.exceptions import WebDriverException
from selenium.webdriver.support.wait import WebDriverWait from selenium.webdriver.support.wait import WebDriverWait
from tests.conftest import option, sauce_username, sauce_access_key from tests.conftest import option, sauce_username, sauce_access_key, apibase
from support.api.network_api import NetworkApi from support.api.network_api import NetworkApi
from support.github_report import GithubHtmlReport from support.github_report import GithubHtmlReport
from tests import test_suite_data, start_threads, appium_container, pytest_config_global from tests import test_suite_data, start_threads, appium_container, pytest_config_global
from tests import transl from tests import transl
from tests.conftest import apibase
executor_sauce_lab = 'https://%s:%s@ondemand.%s:443/wd/hub' % (sauce_username, sauce_access_key, apibase) executor_sauce_lab = 'https://%s:%s@ondemand.%s:443/wd/hub' % (sauce_username, sauce_access_key, apibase)
@ -394,11 +393,7 @@ class SauceSharedMultipleDeviceTestCase(AbstractTestCase):
driver.quit() driver.quit()
except WebDriverException: except WebDriverException:
pass pass
if option.datacenter == 'eu-central-1': url = 'https://api.%s/rest/v1/%s/jobs/%s/assets/%s' % (apibase, sauce_username, session_id, "log.json")
url = 'https://eu-central-1.saucelabs.com/rest/v1/%s/jobs/%s/assets/%s' % (
sauce_username, session_id, "log.json")
else:
url = sauce.jobs.get_job_asset_url(username=sauce_username, job_id=session_id, filename="log.json")
WebDriverWait(driver, 60, 2).until(lambda _: requests_session.get(url).status_code == 200) WebDriverWait(driver, 60, 2).until(lambda _: requests_session.get(url).status_code == 200)
commands = requests_session.get(url).json() commands = requests_session.get(url).json()
for command in commands: for command in commands:

2
test/appium/tests/conftest.py
View File

@ -172,7 +172,7 @@ def pytest_configure(config):
config.addinivalue_line("markers", "testrail_id(name): empty") config.addinivalue_line("markers", "testrail_id(name): empty")
global apibase global apibase
if config.getoption('datacenter') == 'us-west-1': if config.getoption('datacenter') == 'us-west-1':
apibase = 'saucelabs.com' apibase = 'us-west-1.saucelabs.com'
elif config.getoption('datacenter') == 'eu-central-1': elif config.getoption('datacenter') == 'eu-central-1':
apibase = 'eu-central-1.saucelabs.com' apibase = 'eu-central-1.saucelabs.com'
else: else:

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

@ -3,12 +3,12 @@ import time
import emoji import emoji
import pytest import pytest
from selenium.common.exceptions import TimeoutException
from tests import marks, common_password, run_in_parallel from tests import marks, common_password, run_in_parallel
from tests.base_test_case import MultipleSharedDeviceTestCase, create_shared_drivers from tests.base_test_case import MultipleSharedDeviceTestCase, create_shared_drivers
from tests.users import transaction_senders, basic_user, ens_user, ens_user_message_sender from tests.users import transaction_senders, basic_user, ens_user, ens_user_message_sender
from views.sign_in_view import SignInView from views.sign_in_view import SignInView
from views.base_element import Button
@pytest.mark.xdist_group(name="four_2") @pytest.mark.xdist_group(name="four_2")
@ -1033,7 +1033,8 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
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("'You' is not displayed in reply quote snippet replying to own message, '%s' instead" % actual_text) self.errors.append(
"'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()
@ -1073,6 +1074,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.home_1.just_fyi("Check that Device1 can pin own message in 1-1 chat") self.home_1.just_fyi("Check that Device1 can pin own message in 1-1 chat")
self.chat_1.send_message(self.message_1) self.chat_1.send_message(self.message_1)
self.chat_1.send_message(self.message_2) self.chat_1.send_message(self.message_2)
self.chat_1.chat_element_by_text(self.message_1).wait_for_status_to_be("Delivered")
self.chat_1.pin_message(self.message_1, 'pin-to-chat') self.chat_1.pin_message(self.message_1, 'pin-to-chat')
if not self.chat_1.chat_element_by_text(self.message_1).pinned_by_label.is_element_displayed(): if not self.chat_1.chat_element_by_text(self.message_1).pinned_by_label.is_element_displayed():
self.drivers[0].fail("Message is not pinned!") self.drivers[0].fail("Message is not pinned!")
@ -1084,7 +1086,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
chat.pinned_messages_count.wait_for_element_text("2", chat.pinned_messages_count.wait_for_element_text("2",
message="Pinned messages count is not 2 as expected!") message="Pinned messages count is not 2 as expected!")
self.home_1.just_fyi("Check pinned message are visible in Pinned panel for user %s" % (chat_number + 1)) chat.just_fyi("Check pinned message are visible in Pinned panel for user %s" % (chat_number + 1))
chat.pinned_messages_count.click() chat.pinned_messages_count.click()
for message in self.message_1, self.message_2: for message in self.message_1, self.message_2:
pinned_by = chat.pinned_messages_list.get_message_pinned_by_text(message) pinned_by = chat.pinned_messages_list.get_message_pinned_by_text(message)
@ -1108,10 +1110,17 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
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")
for message in (self.message_3, self.message_4): for message in (self.message_3, self.message_4):
self.chat_1.send_message(message) self.chat_1.send_message(message)
self.chat_1.chat_element_by_text(message).wait_for_status_to_be("Delivered")
self.chat_1.pin_message(message, 'pin-to-chat') self.chat_1.pin_message(message, 'pin-to-chat')
if self.chat_1.pin_limit_popover.is_element_displayed(30): # if self.chat_1.pin_limit_popover.is_element_displayed(30):
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)
self.chat_1.pinned_messages_list.message_element_by_text(self.message_2).click_inside_element_by_coordinate() # temp solution instead of getting pin_limit_popover:
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():
self.errors.append("Can pin more than 3 messages in chat")
else:
self.chat_1.pinned_messages_list.message_element_by_text(
self.message_2).click_inside_element_by_coordinate()
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")
self.chat_1.element_by_translation_id('unpin-from-chat').double_click() self.chat_1.element_by_translation_id('unpin-from-chat').double_click()
self.chat_1.chat_element_by_text(self.message_4).click() self.chat_1.chat_element_by_text(self.message_4).click()
@ -1119,36 +1128,32 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
if not (self.chat_1.chat_element_by_text(self.message_4).pinned_by_label.is_element_displayed(30) and if not (self.chat_1.chat_element_by_text(self.message_4).pinned_by_label.is_element_displayed(30) and
self.chat_2.chat_element_by_text(self.message_4).pinned_by_label.is_element_displayed(30)): self.chat_2.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("Message 4 is not pinned in chat after unpinning previous one")
else:
self.errors.append("Can pin more than 3 messages in chat")
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 not 3 for user %s" % (chat_number + 1)) self.errors.append("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)
# temp solution until finding solution for distinguish system and not-system messages
message_element = Button(self.chat_1.driver, xpath="//*[starts-with(@text,'%s')]/ancestor::android.view.ViewGroup[@content-desc='chat-item']//*[starts-with(@text,'[:')]" % self.message_4) self.chat_1.pin_message(self.message_4, action="unpin-from-chat")
message_element.long_press_element() try:
self.chat_1.element_by_translation_id("unpin-from-chat").click() self.chat_2.chat_element_by_text(self.message_4).pinned_by_label.wait_for_invisibility_of_element()
self.chat_2.chat_element_by_text(self.message_4).pinned_by_label.wait_for_invisibility_of_element() except TimeoutException:
if self.chat_2.chat_element_by_text(self.message_4).pinned_by_label.is_element_displayed():
self.errors.append("Message_4 is not unpinned!") self.errors.append("Message_4 is not unpinned!")
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 != '2': if count != '2':
self.errors.append( self.errors.append(
"Pinned messages count is not 2 after unpinning the last pinned message for user %s" % ( "Pinned messages count is %s but should be 2 after unpinning the last pinned message for user %s" %
chat_number + 1) (count, chat_number + 1)
) )
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702745) @marks.testrail_id(702745)
@marks.xfail(reason="On profile picture failed due to 14718")
def test_1_1_chat_non_latin_messages_stack_update_profile_photo(self): def test_1_1_chat_non_latin_messages_stack_update_profile_photo(self):
self.home_1.click_system_back_button_until_element_is_shown() self.home_1.click_system_back_button_until_element_is_shown()
self.home_1.browser_tab.click() # temp, until profile is on browser tab self.home_1.browser_tab.click() # temp, until profile is on browser tab
@ -1237,6 +1242,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702855) @marks.testrail_id(702855)
@marks.xfail(reason="blocked by 15166")
def test_1_1_chat_edit_message(self): def test_1_1_chat_edit_message(self):
[device.click_system_back_button_until_element_is_shown() for device in [device.click_system_back_button_until_element_is_shown() for device in
(self.device_1, self.device_2)] (self.device_1, self.device_2)]
@ -1249,13 +1255,16 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
"Device 1 sends text message and edits it in 1-1 chat. Device2 checks edited message is shown") "Device 1 sends text message and edits it in 1-1 chat. Device2 checks edited message is shown")
message_before_edit_1_1, message_after_edit_1_1 = "Message before edit 1-1", "AFTER" message_before_edit_1_1, message_after_edit_1_1 = "Message before edit 1-1", "AFTER"
self.chat_2.send_message(message_before_edit_1_1) self.chat_2.send_message(message_before_edit_1_1)
self.chat_2.chat_element_by_text(message_before_edit_1_1).wait_for_status_to_be("Delivered")
self.chat_2.edit_message_in_chat(message_before_edit_1_1, message_after_edit_1_1) self.chat_2.edit_message_in_chat(message_before_edit_1_1, message_after_edit_1_1)
chat_element = self.chat_1.chat_element_by_text(message_after_edit_1_1) chat_element = self.chat_1.chat_element_by_text(message_after_edit_1_1)
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('No edited message in 1-1 chat displayed')
if chat_element.status != 'edited': try:
self.errors.append('"Edited" status can not be seen from receiver perspective') chat_element.wait_for_status_to_be('edited')
except TimeoutException:
self.errors.append('Edited message is shown for receiver with status %s but it should be "Edited"' %
chat_element.status)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702733) @marks.testrail_id(702733)
@ -1271,6 +1280,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
message_after_edit_1_1 = 'smth I should edit' message_after_edit_1_1 = 'smth I should edit'
message_to_delete_for_me = 'message to delete for me' message_to_delete_for_me = 'message to delete for me'
self.chat_2.send_message(message_after_edit_1_1) self.chat_2.send_message(message_after_edit_1_1)
self.chat_2.chat_element_by_text(message_after_edit_1_1).wait_for_status_to_be("Delivered")
chat_1_element = self.chat_1.chat_element_by_text(message_after_edit_1_1) chat_1_element = self.chat_1.chat_element_by_text(message_after_edit_1_1)
chat_1_element.long_press_element() chat_1_element.long_press_element()
for action in ("edit", "delete-for-everyone"): for action in ("edit", "delete-for-everyone"):
@ -1280,6 +1290,7 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
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")
self.chat_2.send_message(message_to_delete_for_me) self.chat_2.send_message(message_to_delete_for_me)
self.chat_2.chat_element_by_text(message_to_delete_for_me).wait_for_status_to_be("Delivered")
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)
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("Deleted for me message is shown in chat for the author of message")
@ -1334,20 +1345,22 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.home_2.just_fyi('Device2 checks "Sending" status when sending message from offline') self.home_2.just_fyi('Device2 checks "Sending" status when sending message from offline')
self.chat_2.send_message(message_1) self.chat_2.send_message(message_1)
chat_element = self.chat_2.chat_element_by_text(message_1) chat_element = self.chat_2.chat_element_by_text(message_1)
if not (chat_element.status == ':sending' or chat_element.status == ':sent'): status = chat_element.status
self.errors.append('Message status is not "Sending", it is "%s"!' % chat_element.status) if not (status == 'Sending' or status == 'Sent'):
self.errors.append('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"')
[home.toggle_airplane_mode() for home in (self.home_1, self.home_2)] for i, home in enumerate([self.home_1, self.home_2]):
i = 1 home.toggle_airplane_mode()
while i < 12: if "im.status.ethereum" not in home.driver.current_activity:
i += 1 home.click_system_back_button_until_element_is_shown()
time.sleep(10) home.chats_tab.click()
if chat_element.status == ':delivered': home.get_chat(self.default_username_2 if i == 0 else self.default_username_1).click()
break try:
else: chat_element.wait_for_status_to_be(expected_status='Delivered', timeout=120)
except TimeoutException:
self.errors.append( self.errors.append(
'Message status was not delivered after back up online, it is "%s"!' % chat_element.status) 'Message status was not delivered after back up online, it is "%s"!' % status)
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(60): if not self.chat_1.chat_element_by_text(message_1).is_element_displayed(60):
@ -1367,5 +1380,5 @@ class TestOneToOneChatMultipleSharedDevicesNewUi(MultipleSharedDeviceTestCase):
self.home_2.reopen_app() self.home_2.reopen_app()
if self.home_2.get_chat_from_home_view(self.default_username_1).is_element_displayed(15): if self.home_2.get_chat_from_home_view(self.default_username_1).is_element_displayed(15):
self.errors.append( self.errors.append(
'Deleted chat %s is shown after re-login, but the chat has been deleted' % self.default_username_1) 'Deleted chat %s is shown after re-login, but the chat has been deleted' % self.default_username_1)
self.errors.verify_no_errors() self.errors.verify_no_errors()

308
test/appium/tests/critical/test_public_chat_browsing.py
View File

@ -15,219 +15,6 @@ from views.chat_view import ChatView
from selenium.common.exceptions import NoSuchElementException from selenium.common.exceptions import NoSuchElementException
@pytest.mark.xdist_group(name="one_2")
@marks.critical
class TestPublicChatMultipleDeviceMerged(MultipleSharedDeviceTestCase):
def prepare_devices(self):
self.drivers, self.loop = create_shared_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
self.home_1, self.home_2 = device_1.create_user(), device_2.create_user()
profile_1 = self.home_1.profile_button.click()
self.username_1 = profile_1.default_username_text.text
profile_1.home_button.click()
self.pub_chat_delete_long_press = 'pub-chat'
self.text_message = 'hello'
self.home_1.join_public_chat(self.pub_chat_delete_long_press)
[home.home_button.click() for home in (self.home_1, self.home_2)]
self.public_chat_name = self.home_1.get_random_chat_name()
self.chat_1 = self.home_1.join_public_chat(self.public_chat_name)
self.chat_2 = self.home_2.join_public_chat(self.public_chat_name)
self.chat_1.send_message(self.text_message)
@marks.testrail_id(5313)
def test_public_chat_message_send_check_timestamps_while_on_different_tab(self):
message = self.text_message
self.chat_2.dapp_tab_button.click()
sent_time_variants = self.chat_1.convert_device_time_to_chat_timestamp()
timestamp = self.chat_1.chat_element_by_text(message).timestamp_on_tap
if sent_time_variants and timestamp:
if timestamp not in sent_time_variants:
self.errors.append("Timestamp is not shown, expected: '%s', in fact: '%s'" %
(sent_time_variants.join(','), timestamp))
self.chat_2.home_button.click(desired_view='chat')
for chat in self.chat_1, self.chat_2:
chat.verify_message_is_under_today_text(message, self.errors)
if self.chat_2.chat_element_by_text(message).username.text != self.username_1:
self.errors.append("Default username '%s' is not shown next to the received message" % self.username_1)
self.errors.verify_no_errors()
@marks.testrail_id(700734)
def test_public_chat_message_edit(self):
if not self.chat_2.chat_message_input.is_element_displayed():
self.chat_2.home_button.click(desired_view='chat')
message_before_edit, message_after_edit = self.text_message, "Message AFTER edit 2"
self.chat_1.edit_message_in_chat(message_before_edit, message_after_edit)
for chat in (self.chat_1, self.chat_2):
if not chat.element_by_text_part("⌫ Edited").is_element_displayed(60):
self.errors.append('No mark in message bubble about this message was edited')
if not self.chat_2.element_by_text_part(message_after_edit).is_element_displayed(60):
self.errors.append('Message is not edited')
self.errors.verify_no_errors()
@marks.testrail_id(700735)
def test_public_chat_message_delete(self):
message_to_delete = 'delete me, please'
self.chat_1.send_message(message_to_delete)
self.chat_1.delete_message_in_chat(message_to_delete)
for chat in (self.chat_1, self.chat_2):
if not chat.chat_element_by_text(message_to_delete).is_element_disappeared(30):
self.errors.append("Deleted message is shown in chat view for public chat")
self.errors.verify_no_errors()
@marks.testrail_id(700719)
def test_public_chat_emoji_send_copy_paste_reply(self):
emoji_name = random.choice(list(emoji.EMOJI_UNICODE))
emoji_unicode = emoji.EMOJI_UNICODE[emoji_name]
emoji_message = emoji.emojize(emoji_name)
self.chat_1.send_message(emoji_message)
for chat in self.chat_1, self.chat_2:
if not chat.chat_element_by_text(emoji_unicode).is_element_displayed(30):
self.errors.append('Message with emoji was not sent or received in public chat')
self.chat_1.just_fyi("Can copy and paste emojis")
self.chat_1.element_by_text_part(emoji_unicode).long_press_element()
self.chat_1.element_by_text('Copy').click()
self.chat_1.chat_message_input.paste_text_from_clipboard()
if self.chat_1.chat_message_input.text != emoji_unicode:
self.errors.append('Emoji message was not copied')
self.chat_1.just_fyi("Can reply to emojis")
self.chat_2.quote_message(emoji_unicode)
message_text = 'test message'
self.chat_2.chat_message_input.send_keys(message_text)
self.chat_2.send_message_button.click()
chat_element_1 = self.chat_1.chat_element_by_text(message_text)
if not chat_element_1.is_element_displayed(sec=10) or chat_element_1.replied_message_text != emoji_unicode:
self.errors.append('Reply message was not received by the sender')
self.errors.verify_no_errors()
@marks.testrail_id(5360)
def test_public_chat_unread_messages_counter(self):
self.chat_1.send_message('пиу')
home_1 = self.chat_1.home_button.click()
message = 'test message'
self.chat_2.send_message(message)
if not self.chat_1.home_button.public_unread_messages.is_element_displayed():
self.errors.append('New messages public chat badge is not shown on Home button')
chat_element = home_1.get_chat('#' + self.public_chat_name)
if not chat_element.new_messages_public_chat.is_element_displayed():
self.errors.append('New messages counter is not shown in public chat')
self.errors.verify_no_errors()
@marks.testrail_id(700718)
def test_public_chat_unread_messages_counter_for_mention_relogin(self):
message = 'test message2'
[chat.get_back_to_home_view() for chat in (self.chat_1, self.chat_2)]
chat_element = self.home_1.get_chat('#' + self.public_chat_name)
self.home_2.get_chat('#' + self.public_chat_name).click()
self.chat_2.select_mention_from_suggestion_list(self.username_1, self.username_1[:2])
self.chat_2.send_message_button.click()
chat_element.new_messages_counter.wait_for_element(30)
chat_element.new_messages_counter.wait_for_element_text("1", 60)
chat_element.click()
self.home_1.home_button.double_click()
if self.home_1.home_button.public_unread_messages.is_element_displayed():
self.errors.append('New messages public chat badge is shown on Home button')
if chat_element.new_messages_public_chat.is_element_displayed():
self.errors.append('Unread messages badge is shown in public chat while there are no unread messages')
[home.get_chat('#' + self.public_chat_name).click() for home in (self.home_1, self.home_2)]
self.chat_1.send_message(message)
self.chat_2.chat_element_by_text(message).wait_for_element(20)
self.home_2.reopen_app()
chat_element = self.home_2.get_chat('#' + self.public_chat_name)
if chat_element.new_messages_public_chat.is_element_displayed():
self.drivers[0].fail('New messages counter is shown after relogin')
self.errors.verify_no_errors()
@marks.testrail_id(5319)
def test_public_chat_delete_chat_long_press(self):
[chat.get_back_to_home_view() for chat in (self.chat_1, self.chat_2)]
self.home_1.delete_chat_long_press('#%s' % self.pub_chat_delete_long_press)
self.home_2.just_fyi("Send message to deleted chat")
self.deleted_chat_2 = self.home_2.join_public_chat(self.pub_chat_delete_long_press)
self.deleted_chat_2.send_message()
if self.home_1.get_chat_from_home_view('#%s' % self.pub_chat_delete_long_press).is_element_displayed():
self.drivers[0].fail('Deleted public chat reappears after sending message to it')
self.home_1.reopen_app()
if self.home_1.get_chat_from_home_view('#%s' % self.pub_chat_delete_long_press).is_element_displayed():
self.drivers[0].fail('Deleted public chat reappears after relogin')
@marks.testrail_id(700736)
def test_public_chat_link_send_open(self):
[chat.get_back_to_home_view() for chat in (self.chat_1, self.chat_2)]
[home.get_chat('#' + self.public_chat_name).click() for home in (self.home_1, self.home_2)]
url_message = 'http://status.im'
self.chat_2.send_message(url_message)
self.chat_1.element_starts_with_text(url_message, 'button').click()
web_view = self.chat_1.open_in_status_button.click()
if not web_view.element_by_text('Private, Secure Communication').is_element_displayed(60):
self.drivers[0].fail('URL was not opened from public chat')
@marks.testrail_id(700737)
def test_public_chat_links_with_previews_github_youtube_twitter_gif_send_enable(self):
[chat.home_button.double_click() for chat in (self.chat_1, self.chat_2)]
[home.get_chat('#' + self.public_chat_name).click() for home in (self.home_1, self.home_2)]
giphy_url = 'https://giphy.com/gifs/this-is-fine-QMHoU66sBXqqLqYvGO'
preview_urls = {'github_pr': {'url': 'https://github.com/status-im/status-mobile/pull/11707',
'txt': 'Update translations by jinhojang6 · Pull Request #11707 · status-im/status-mobile',
'subtitle': 'GitHub'},
'yotube': {
'url': 'https://www.youtube.com/watch?v=XN-SVmuJH2g&list=PLbrz7IuP1hrgNtYe9g6YHwHO6F3OqNMao',
'txt': 'Status & Keycard – Hardware-Enforced Security',
'subtitle': 'YouTube'},
'twitter': {
'url': 'https://twitter.com/ethdotorg/status/1445161651771162627?s=20',
'txt': "We've rethought how we translate content, allowing us to translate",
'subtitle': 'Twitter'
}}
self.home_1.just_fyi("Check enabling and sending first gif")
self.chat_2.send_message(giphy_url)
self.chat_2.element_by_translation_id("dont-ask").click()
self.chat_1.element_by_translation_id("enable").wait_and_click()
self.chat_1.element_by_translation_id("enable-all").wait_and_click()
self.chat_1.close_modal_view_from_chat_button.click()
if not self.chat_1.get_preview_message_by_text(giphy_url).preview_image:
self.errors.append("No preview is shown for %s" % giphy_url)
for key in preview_urls:
self.home_2.just_fyi("Checking %s preview case" % key)
data = preview_urls[key]
self.chat_2.send_message(data['url'])
message = self.chat_1.get_preview_message_by_text(data['url'])
if data['txt'] not in message.preview_title.text:
self.errors.append("Title '%s' does not match expected" % message.preview_title.text)
if message.preview_subtitle.text != data['subtitle']:
self.errors.append("Subtitle '%s' does not match expected" % message.preview_subtitle.text)
self.home_2.just_fyi("Check if after do not ask again previews are not shown and no enable button appear")
if self.chat_2.element_by_translation_id("enable").is_element_displayed():
self.errors.append("Enable button is still shown after clicking on 'Den't ask again'")
if self.chat_2.get_preview_message_by_text(giphy_url).preview_image:
self.errors.append("Preview is shown for sender without permission")
self.errors.verify_no_errors()
@marks.testrail_id(6270)
def test_public_chat_mark_all_messages_as_read(self):
[chat.get_back_to_home_view() for chat in (self.chat_1, self.chat_2)]
self.home_2.get_chat('#' + self.public_chat_name).click()
self.chat_2.send_message(self.text_message)
if not self.home_1.home_button.public_unread_messages.is_element_displayed():
self.errors.append('New messages public chat badge is not shown on Home button')
chat_element = self.home_1.get_chat('#' + self.public_chat_name)
if not chat_element.new_messages_public_chat.is_element_displayed():
self.errors.append('New messages counter is not shown in public chat')
chat_element.long_press_element()
self.home_1.mark_all_messages_as_read_button.click()
self.home_1.home_button.double_click()
if self.home_1.home_button.public_unread_messages.is_element_displayed():
self.errors.append('New messages public chat badge is shown on Home button after marking messages as read')
if chat_element.new_messages_public_chat.is_element_displayed():
self.errors.append('Unread messages badge is shown in public chat while while there are no unread messages')
self.errors.verify_no_errors()
@pytest.mark.xdist_group(name="three_1") @pytest.mark.xdist_group(name="three_1")
@marks.critical @marks.critical
class TestPublicChatBrowserOneDeviceMerged(MultipleSharedDeviceTestCase): class TestPublicChatBrowserOneDeviceMerged(MultipleSharedDeviceTestCase):
@ -591,14 +378,11 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.profile_1.add_contact_via_contacts_list(self.public_key_2) self.profile_1.add_contact_via_contacts_list(self.public_key_2)
self.profile_1.communities_tab.click() self.profile_1.communities_tab.click()
self.home_2.chats_tab.click() self.home_2.chats_tab.click()
self.home_2.handle_contact_request(self.default_username_1) self.home_2.handle_contact_request(self.default_username_1)
self.community_leave = 'community_leave'
self.text_message = 'hello' self.text_message = 'hello'
self.home_1.just_fyi("Open community to message")
self.home_1.communities_tab.click() self.home_1.communities_tab.click()
self.home_1.create_community(name=self.community_leave, description='community to be left', require_approval=False)
self.home_1.back_button.double_click()
self.community_name = self.home_1.get_random_chat_name() self.community_name = self.home_1.get_random_chat_name()
self.channel_name = self.home_1.get_random_chat_name() self.channel_name = self.home_1.get_random_chat_name()
self.home_1.create_community(name=self.community_name, description='community to test', require_approval=False) self.home_1.create_community(name=self.community_name, description='community to test', require_approval=False)
@ -606,13 +390,19 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.community_1.send_invite_to_community(self.default_username_2) self.community_1.send_invite_to_community(self.default_username_2)
self.channel_1 = self.community_1.add_channel(self.channel_name) self.channel_1 = self.community_1.add_channel(self.channel_name)
self.channel_1.send_message(self.text_message) self.channel_1.send_message(self.text_message)
self.chat_2 = self.home_2.get_chat(self.default_username_1).click() self.chat_2 = self.home_2.get_chat(self.default_username_1).click()
self.chat_2.element_by_text_part('View').click() self.chat_2.element_by_text_part('View').click()
self.community_2 = CommunityView(self.drivers[1]) self.community_2 = CommunityView(self.drivers[1])
self.community_2.join_button.click() self.community_2.join_button.click()
self.channel_2 = self.community_2.get_chat(self.channel_name).click()
self.home_1.just_fyi("Reopen community view to use new interface")
for home in (self.home_1, self.home_2):
home.jump_to_communities_home()
home.get_chat(self.community_name, community=True).click()
community_view = home.get_community_view()
community_view.get_channel(self.channel_name).click()
self.channel_2 = self.home_2.get_chat_view()
@marks.testrail_id(702838) @marks.testrail_id(702838)
@marks.xfail(reason="blocked by 14797") @marks.xfail(reason="blocked by 14797")
@ -633,9 +423,6 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
@marks.testrail_id(702843) @marks.testrail_id(702843)
def test_community_message_edit(self): def test_community_message_edit(self):
message_before_edit, message_after_edit = 'Message BEFORE edit', "Message AFTER edit 2" message_before_edit, message_after_edit = 'Message BEFORE edit', "Message AFTER edit 2"
if not self.channel_2.chat_message_input.is_element_displayed():
self.home_2.communities_tab.click()
self.community_2.get_chat(self.channel_name).click()
self.channel_1.send_message(message_before_edit) self.channel_1.send_message(message_before_edit)
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):
@ -653,8 +440,8 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
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("Deleted message is shown in channel")
if not channel.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("System message about deletion for everyone is not displayed")
self.home_2.just_fyi('Deleting message for me. Checking that message is deleted only for the author of the message') self.home_2.just_fyi('Deleting message for me. Checking that message is deleted only for the author of the message')
self.channel_2.send_message(message_to_delete_for_me) self.channel_2.send_message(message_to_delete_for_me)
@ -704,12 +491,11 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
'yotube_short': { 'yotube_short': {
'url': 'https://youtu.be/Je7yErjEVt4', 'url': 'https://youtu.be/Je7yErjEVt4',
'txt': 'Status, your gateway to Ethereum', 'txt': 'Status, your gateway to Ethereum',
'subtitle': 'YouTube'},
'yotube_full': {
'url': 'https://www.youtube.com/watch?v=XN-SVmuJH2g&list=PLbrz7IuP1hrgNtYe9g6YHwHO6F3OqNMao',
'txt': 'Status & Keycard – Hardware-Enforced Security',
'subtitle': 'YouTube'} 'subtitle': 'YouTube'}
# blocked by 14865
# 'yotube_full': {
# 'url': 'https://www.youtube.com/watch?v=XN-SVmuJH2g&list=PLbrz7IuP1hrgNtYe9g6YHwHO6F3OqNMao',
# 'txt': 'Status & Keycard – Hardware-Enforced Security',
# 'subtitle': 'YouTube'}
# twitter link is temporary removed from check as current xpath locator in message.preview_title is not applicable for this type of links # twitter link is temporary removed from check as current xpath locator in message.preview_title is not applicable for this type of links
# 'twitter': { # 'twitter': {
# 'url': 'https://twitter.com/ethdotorg/status/1445161651771162627?s=20', # 'url': 'https://twitter.com/ethdotorg/status/1445161651771162627?s=20',
@ -752,7 +538,6 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
@marks.testrail_id(702841) @marks.testrail_id(702841)
def test_community_unread_messages_badge(self): def test_community_unread_messages_badge(self):
self.channel_1.send_message('пиу')
self.channel_1.jump_to_communities_home() self.channel_1.jump_to_communities_home()
message = 'test message' message = 'test message'
self.channel_2.send_message(message) self.channel_2.send_message(message)
@ -762,43 +547,46 @@ class TestCommunityMultipleDeviceMerged(MultipleSharedDeviceTestCase):
self.errors.append('New message community badge is not shown') self.errors.append('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_chat('# %s' % self.channel_name) channel_1_element = community_1.get_channel(self.channel_name)
# blocked of 14906
# 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')
# if not channel_1_element.new_messages_public_chat.is_element_displayed(): if not community_element_1.new_messages_community.is_element_displayed():
# self.errors.append('New messages channel badge is not shown on channel') self.errors.append('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()
# @marks.testrail_id(702842)
@marks.testrail_id(702842) # Skipped until implemented in NEW UI
@marks.xfail(reason='blocked due to navigation issue 14906') # def test_community_mark_all_messages_as_read(self):
def test_community_mark_all_messages_as_read(self): # self.channel_1.jump_to_communities_home()
self.channel_2.send_message(self.text_message) # self.home_1.get_chat(self.community_name, community=True).click()
chan_1_element = self.community_1.get_chat('# %s' % self.channel_name) # self.channel_2.send_message(self.text_message)
if not chan_1_element.new_messages_public_chat.is_element_displayed(): # #self.home_1.get_chat(self.community_name).click()
self.errors.append('New messages counter is not shown in public chat') # channel_1_element = self.community_1.get_channel(self.channel_name)
chan_1_element.long_press_element() # if not channel_1_element.new_messages_public_chat.is_element_displayed():
self.community_1.mark_all_messages_as_read_button.click() # self.errors.append('New messages counter is not shown in public chat')
if chan_1_element.new_messages_public_chat.is_element_displayed(): # mark_as_read_button = self.community_1.mark_all_messages_as_read_button
self.errors.append('Unread messages badge is shown in community channel while there are no unread messages') # channel_1_element.long_press_until_element_is_shown(mark_as_read_button)
self.community_1.click_system_back_button_until_element_is_shown() # mark_as_read_button.click()
community_1_element = self.home_1.get_chat(self.community_name, community=True) # if channel_1_element.new_messages_public_chat.is_element_displayed():
if community_1_element.new_messages_community.is_element_displayed(): # self.errors.append('Unread messages badge is shown in community channel while there are no unread messages')
self.errors.append('New messages community badge is shown on community after marking messages as read') # self.community_1.click_system_back_button_until_element_is_shown()
self.errors.verify_no_errors() # community_1_element = self.home_1.get_chat(self.community_name, community=True)
# if community_1_element.new_messages_community.is_element_displayed():
# self.errors.append('New messages community badge is shown on community after marking messages as read')
# self.errors.verify_no_errors()
@marks.testrail_id(702845) @marks.testrail_id(702845)
@marks.xfail(reason="blocked by 15187")
def test_community_leave(self): def test_community_leave(self):
if not self.home_1.communities_tab.is_element_displayed(): self.home_2.jump_to_communities_home()
self.channel_1.click_system_back_button_until_element_is_shown() community = self.home_2.element_by_text(self.community_name)
comm_to_leave_element = self.home_1.get_chat(self.community_leave, community=True) community_to_leave = CommunityView(self.drivers[1])
comm_to_leave_element.long_press_element() community.long_press_until_element_is_shown(community_to_leave.leave_community_button)
community_to_leave = CommunityView(self.drivers[0])
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 comm_to_leave_element.is_element_displayed(): if community.is_element_displayed():
self.errors.append('Community is still shown in the list after leave') self.errors.append('Community is still shown in the list after leave')
self.errors.verify_no_errors() self.errors.verify_no_errors()

22
test/appium/tests/medium/test_activity_center.py
View File

@ -203,6 +203,7 @@ class TestActivityCenterMultipleDevicePR(MultipleSharedDeviceTestCase):
self.profile_1.switch_push_notifications() self.profile_1.switch_push_notifications()
@marks.testrail_id(702850) @marks.testrail_id(702850)
@marks.xfail(reason="blocked with 15180")
def test_activity_center_decline_contact_request_no_pn(self): def test_activity_center_decline_contact_request_no_pn(self):
self.device_1.put_app_to_background() self.device_1.put_app_to_background()
self.device_2.just_fyi('Device2 sends a contact request to Device1') self.device_2.just_fyi('Device2 sends a contact request to Device1')
@ -235,13 +236,21 @@ class TestActivityCenterMultipleDevicePR(MultipleSharedDeviceTestCase):
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702851) @marks.testrail_id(702851)
@marks.xfail(reason='blocked by 14798')
def test_activity_center_mentions_in_community_jump_to(self): def test_activity_center_mentions_in_community_jump_to(self):
self.device_2.just_fyi('Device2 sends a contact request to Device1') self.device_2.just_fyi('Device2 re-sends a contact request to Device1')
self.home_2.browser_tab.click() self.home_2.browser_tab.click()
self.profile_2.click_system_back_button_until_element_is_shown(self.profile_2.contacts_button) self.profile_2.click_system_back_button_until_element_is_shown(self.profile_2.contacts_button)
self.profile_2.add_contact_via_contacts_list(self.public_key_1)
self.profile_2.click_system_back_button_until_element_is_shown(self.profile_2.contacts_button) self.profile_2.contacts_button.wait_and_click(30)
self.profile_2.add_new_contact_button.wait_and_click()
chat = self.profile_2.get_chat_view()
chat.public_key_edit_box.click()
chat.public_key_edit_box.send_keys(self.public_key_1)
chat.view_profile_new_contact_button.click_until_presence_of_element(chat.profile_block_contact)
if chat.profile_remove_from_contacts.is_element_displayed(20):
chat.profile_remove_from_contacts.click()
chat.profile_add_to_contacts.click()
self.profile_2.click_system_back_button_until_element_is_shown()
self.device_1.just_fyi('Device1 accepts pending contact request and check contact list') self.device_1.just_fyi('Device1 accepts pending contact request and check contact list')
self.home_1.chats_tab.click() self.home_1.chats_tab.click()
@ -259,8 +268,6 @@ class TestActivityCenterMultipleDevicePR(MultipleSharedDeviceTestCase):
self.home_1.create_community(name=self.community_name, description='community to test', require_approval=False) self.home_1.create_community(name=self.community_name, description='community to test', require_approval=False)
self.community_1 = CommunityView(self.drivers[0]) self.community_1 = CommunityView(self.drivers[0])
self.community_1.send_invite_to_community(self.default_username_2) self.community_1.send_invite_to_community(self.default_username_2)
self.channel_1 = self.community_1.add_channel(self.channel_name)
self.channel_1.send_message(self.text_message)
self.home_2.chats_tab.click() self.home_2.chats_tab.click()
self.home_2.recent_tab.click() self.home_2.recent_tab.click()
@ -268,10 +275,11 @@ class TestActivityCenterMultipleDevicePR(MultipleSharedDeviceTestCase):
self.chat_2.element_by_text_part('View').click() self.chat_2.element_by_text_part('View').click()
self.community_2 = CommunityView(self.drivers[1]) self.community_2 = CommunityView(self.drivers[1])
self.community_2.join_button.click() self.community_2.join_button.click()
self.channel_1 = self.community_1.add_channel(self.channel_name)
self.channel_1.send_message(self.text_message)
self.channel_2 = self.community_2.get_chat(self.channel_name).click() self.channel_2 = self.community_2.get_chat(self.channel_name).click()
self.community_2.just_fyi("Check Jump to screen and redirect on tap") self.community_2.just_fyi("Check Jump to screen and redirect on tap")
self.channel_2.click_system_back_button()
self.community_2.jump_to_button.click() self.community_2.jump_to_button.click()
for card in (self.community_name, self.default_username_1): for card in (self.community_name, self.default_username_1):
if not self.community_2.element_by_text_part(card).is_element_displayed(20): if not self.community_2.element_by_text_part(card).is_element_displayed(20):

9
test/appium/views/base_element.py
View File

@ -280,6 +280,15 @@ class BaseElement(object):
action = TouchAction(self.driver) action = TouchAction(self.driver)
action.long_press(element).release().perform() action.long_press(element).release().perform()
def long_press_until_element_is_shown(self, expected_element):
element = self.find_element()
self.driver.info("Long press on `%s` until expected element is shown" % self.name)
action = TouchAction(self.driver)
for _ in range(3):
action.long_press(element).release().perform()
if expected_element.is_element_displayed():
return
def measure_time_before_element_appears(self, max_wait_time=30): def measure_time_before_element_appears(self, max_wait_time=30):
def wrapper(): def wrapper():
return self.wait_for_visibility_of_element(max_wait_time) return self.wait_for_visibility_of_element(max_wait_time)

4
test/appium/views/base_view.py
View File

@ -530,6 +530,10 @@ class BaseView(object):
from views.chat_view import ChatView from views.chat_view import ChatView
return ChatView(self.driver) return ChatView(self.driver)
def get_community_view(self):
from views.chat_view import CommunityView
return CommunityView(self.driver)
def get_sign_in_view(self): def get_sign_in_view(self):
from views.sign_in_view import SignInView from views.sign_in_view import SignInView
return SignInView(self.driver) return SignInView(self.driver)

99
test/appium/views/chat_view.py
View File

@ -4,7 +4,7 @@ from datetime import datetime, timedelta
from time import sleep from time import sleep
import dateutil.parser import dateutil.parser
from selenium.common.exceptions import NoSuchElementException from selenium.common.exceptions import NoSuchElementException, TimeoutException
from tests import emojis from tests import emojis
from views.base_element import Button, EditBox, Text, BaseElement, SilentButton from views.base_element import Button, EditBox, Text, BaseElement, SilentButton
@ -171,7 +171,8 @@ class ChatElementByText(Text):
def username(self): def username(self):
class Username(Text): class Username(Text):
def __init__(self, driver, parent_locator: str): def __init__(self, driver, parent_locator: str):
super().__init__(driver, prefix=parent_locator, xpath="/android.view.ViewGroup/android.widget.TextView[1]") super().__init__(driver, prefix=parent_locator,
xpath="/android.view.ViewGroup/android.widget.TextView[1]")
return Username(self.driver, self.locator) return Username(self.driver, self.locator)
@ -191,8 +192,33 @@ class ChatElementByText(Text):
@property @property
def status(self) -> str: def status(self) -> str:
result = re.search('\[(.*) DEBUG\]', Text(self.driver, prefix=self.locator, xpath="//*[contains(@text, 'DEBUG')]").text) Text(self.driver, xpath=self.locator).click()
return result.group(1) if result else '' status_element = Text(self.driver, prefix=self.locator,
xpath="//*[@content-desc='message-status']/android.widget.TextView")
status = ''
i = 1
while i < 5:
i += 1
if Text(self.driver, prefix=self.locator,
xpath="//*[@content-desc='message-sending']").is_element_displayed(2):
status = "Sending"
break
else:
Text(self.driver, xpath=self.locator).click()
if status_element.is_element_displayed(2):
status = status_element.text
break
time.sleep(2)
return status
def wait_for_status_to_be(self, expected_status: str, timeout: int = 30):
start_time = time.time()
while time.time() - start_time <= timeout:
if self.status == expected_status:
return
time.sleep(1)
raise TimeoutException("Message status was not changed to %s" % expected_status)
@property @property
def sent_status_checkmark(self) -> object: def sent_status_checkmark(self) -> object:
@ -222,26 +248,6 @@ class ChatElementByText(Text):
except NoSuchElementException: except NoSuchElementException:
return '' return ''
# Old UI
# def emojis_below_message(self, emoji: str = 'thumbs-up', own=True):
# class EmojisNumber(Text):
# def __init__(self, driver, parent_locator: str):
# self.own = own
# self.emoji = emoji
# self.emojis_id = 'emoji-' + str(emojis[self.emoji]) + '-is-own-' + str(self.own).lower()
# super().__init__(driver, prefix=parent_locator, xpath="/../..//*[@content-desc='%s']" % self.emojis_id)
#
# @property
# def text(self):
# try:
# text = self.find_element().text
# self.driver.info("%s is '%s' for '%s' where my reaction is set on message is '%s'" % (self.name, text, self.emoji, str(self.own)))
# return text
# except NoSuchElementException:
# return 0
#
# return int(EmojisNumber(self.driver, self.locator).text)
def emojis_below_message(self, emoji: str = 'thumbs-up'): def emojis_below_message(self, emoji: str = 'thumbs-up'):
class EmojisNumber(Text): class EmojisNumber(Text):
def __init__(self, driver, parent_locator: str): def __init__(self, driver, parent_locator: str):
@ -321,6 +327,7 @@ class CommunityView(HomeView):
def __init__(self, driver): def __init__(self, driver):
super().__init__(driver) super().__init__(driver)
#### OLD UI
# Main community page (list with channels) # Main community page (list with channels)
self.add_channel_button = HomeView(self.driver).plus_button self.add_channel_button = HomeView(self.driver).plus_button
self.community_create_a_channel_button = Button(self.driver, accessibility_id="community-create-channel") self.community_create_a_channel_button = Button(self.driver, accessibility_id="community-create-channel")
@ -349,6 +356,15 @@ class CommunityView(HomeView):
self.join_button = Button(self.driver, translation_id="join") self.join_button = Button(self.driver, translation_id="join")
self.follow_button = Button(self.driver, translation_id="follow") self.follow_button = Button(self.driver, translation_id="follow")
#### NEW UI
# Communities initial page
self.community_description_text = Text(self.driver, accessibility_id="community-description-text")
def get_channel(self, channel_name: str):
self.driver.info("Getting %s channel element in community" % channel_name)
chat_element = self.get_chat(username=channel_name, community_channel=True, wait_time=30)
return chat_element
def add_channel(self, name: str, description="Some new channel"): def add_channel(self, name: str, description="Some new channel"):
self.driver.info("Adding channel in community") self.driver.info("Adding channel in community")
self.plus_button.click() self.plus_button.click()
@ -397,6 +413,7 @@ class CommunityView(HomeView):
self.share_invite_button.click_until_presence_of_element(self.invite_button) self.share_invite_button.click_until_presence_of_element(self.invite_button)
self.back_button.click_until_presence_of_element(self.plus_button) self.back_button.click_until_presence_of_element(self.plus_button)
class PreviewMessage(ChatElementByText): class PreviewMessage(ChatElementByText):
def __init__(self, driver, text: str): def __init__(self, driver, text: str):
super().__init__(driver, text=text) super().__init__(driver, text=text)
@ -421,7 +438,8 @@ class PreviewMessage(ChatElementByText):
def preview_title(self): def preview_title(self):
class PreviewTitle(SilentButton): class PreviewTitle(SilentButton):
def __init__(self, driver, parent_locator: str): def __init__(self, driver, parent_locator: str):
super().__init__(driver, prefix=parent_locator, xpath="//*[@content-desc='member-photo']/preceding-sibling::android.widget.TextView[2]") super().__init__(driver, prefix=parent_locator,
xpath="//*[@content-desc='member-photo']/preceding-sibling::android.widget.TextView[2]")
return PreviewMessage.return_element_or_empty(PreviewTitle(self.driver, self.locator)) return PreviewMessage.return_element_or_empty(PreviewTitle(self.driver, self.locator))
@ -429,7 +447,8 @@ class PreviewMessage(ChatElementByText):
def preview_subtitle(self): def preview_subtitle(self):
class PreviewSubTitle(SilentButton): class PreviewSubTitle(SilentButton):
def __init__(self, driver, parent_locator: str): def __init__(self, driver, parent_locator: str):
super().__init__(driver, prefix=parent_locator, xpath="//*[@content-desc='member-photo']/preceding-sibling::android.widget.TextView[3]") super().__init__(driver, prefix=parent_locator,
xpath="//*[@content-desc='member-photo']/preceding-sibling::android.widget.TextView[3]")
return PreviewMessage.return_element_or_empty(PreviewSubTitle(self.driver, self.locator)) return PreviewMessage.return_element_or_empty(PreviewSubTitle(self.driver, self.locator))
@ -592,13 +611,19 @@ class PinnedMessagesList(BaseElement):
def __init__(self, driver): def __init__(self, driver):
super().__init__(driver, xpath="//*[@content-desc='pinned-messages-list']") super().__init__(driver, xpath="//*[@content-desc='pinned-messages-list']")
def get_pinned_messages_number(self):
self.driver.info("Getting number of pinned messages inside pinned messages list element")
element = BaseElement(self.driver, prefix=self.locator, xpath="//*[@content-desc='message-sent']")
return len(element.find_elements())
def message_element_by_text(self, text): def message_element_by_text(self, text):
message_element = Text(self.driver, prefix=self.locator, xpath="//*[starts-with(@text,'%s')]" % text) message_element = Text(self.driver, prefix=self.locator, xpath="//*[starts-with(@text,'%s')]" % text)
self.driver.info("Looking for a pinned message by text: %s" % message_element.exclude_emoji(text)) self.driver.info("Looking for a pinned message by text: %s" % message_element.exclude_emoji(text))
return message_element return message_element
def get_message_pinned_by_text(self, text): def get_message_pinned_by_text(self, text):
xpath = "//*[starts-with(@text,'%s')]/../../../*[@content-desc='pinned-by']/android.widget.TextView" % text xpath = "//*[starts-with(@text,'%s')]/ancestor::*[@content-desc='message-sent']/" % text + \
"preceding-sibling::*[@content-desc='pinned-by']/android.widget.TextView"
pinned_by_element = Text(self.driver, prefix=self.locator, xpath=xpath) pinned_by_element = Text(self.driver, prefix=self.locator, xpath=xpath)
self.driver.info("Looking for a pinned by message with text: %s" % text) self.driver.info("Looking for a pinned by message with text: %s" % text)
return pinned_by_element return pinned_by_element
@ -716,6 +741,7 @@ class ChatView(BaseView):
self.profile_mute_contact = Button(self.driver, accessibility_id="Mute-item-button") self.profile_mute_contact = Button(self.driver, accessibility_id="Mute-item-button")
self.profile_unmute_contact = Button(self.driver, accessibility_id="Unmute-item-button") self.profile_unmute_contact = Button(self.driver, accessibility_id="Unmute-item-button")
self.profile_add_to_contacts = Button(self.driver, accessibility_id="Add to contacts-item-button") self.profile_add_to_contacts = Button(self.driver, accessibility_id="Add to contacts-item-button")
self.profile_remove_from_contacts = Button(self.driver, accessibility_id="Remove from contacts-item-button")
self.profile_details = Button(self.driver, accessibility_id="share-button") self.profile_details = Button(self.driver, accessibility_id="share-button")
self.profile_nickname = Text(self.driver, self.profile_nickname = Text(self.driver,
xpath="//*[@content-desc='profile-nickname-item']/android.widget.TextView[2]") xpath="//*[@content-desc='profile-nickname-item']/android.widget.TextView[2]")
@ -748,6 +774,7 @@ class ChatView(BaseView):
self.pin_limit_popover = BaseElement(self.driver, translation_id="pin-limit-reached") self.pin_limit_popover = BaseElement(self.driver, translation_id="pin-limit-reached")
self.view_pinned_messages_button = Button(self.driver, accessibility_id="pinned-banner") self.view_pinned_messages_button = Button(self.driver, accessibility_id="pinned-banner")
def get_outgoing_transaction(self, account=None, transaction_value=None) -> object: def get_outgoing_transaction(self, account=None, transaction_value=None) -> object:
if account is None: if account is None:
account = self.status_account_name account = self.status_account_name
@ -871,13 +898,15 @@ class ChatView(BaseView):
def pin_message(self, message, action="pin"): def pin_message(self, message, action="pin"):
self.driver.info("Looking for message '%s' pin" % message) self.driver.info("Looking for message '%s' pin" % message)
self.element_by_text_part(message).long_press_element() element = self.element_by_translation_id(action)
self.element_by_translation_id(action).click() self.chat_element_by_text(message).long_press_until_element_is_shown(element)
element.click_until_absense_of_element(element)
def edit_message_in_chat(self, message_to_edit, message_to_update): def edit_message_in_chat(self, message_to_edit, message_to_update):
self.driver.info("Looking for message '%s' to edit it" % message_to_edit) self.driver.info("Looking for message '%s' to edit it" % message_to_edit)
self.element_by_text_part(message_to_edit).long_press_element() element = self.element_by_translation_id("edit-message")
self.element_by_translation_id("edit-message").click() self.element_by_text_part(message_to_edit).long_press_until_element_is_shown(element)
element.click()
self.chat_message_input.clear() self.chat_message_input.clear()
self.chat_message_input.send_keys(message_to_update) self.chat_message_input.send_keys(message_to_update)
self.send_message_button.click() self.send_message_button.click()
@ -896,7 +925,7 @@ class ChatView(BaseView):
def quote_message(self, message=str): def quote_message(self, message=str):
self.driver.info("Quoting '%s' message" % message) self.driver.info("Quoting '%s' message" % message)
self.element_by_text_part(message).long_press_element() self.element_by_text_part(message).long_press_until_element_is_shown(self.reply_message_button)
self.reply_message_button.click() self.reply_message_button.click()
def set_reaction(self, message: str, emoji: str = 'thumbs-up', emoji_message=False): def set_reaction(self, message: str, emoji: str = 'thumbs-up', emoji_message=False):
@ -904,16 +933,16 @@ class ChatView(BaseView):
key = emojis[emoji] key = emojis[emoji]
# Audio message is obvious should be tapped not on audio-scroll-line # Audio message is obvious should be tapped not on audio-scroll-line
# so we tap on its below element as exception here (not the case for link/tag message!) # so we tap on its below element as exception here (not the case for link/tag message!)
element = Button(self.driver, accessibility_id='emoji-picker-%s' % key)
if message == 'audio': if message == 'audio':
self.audio_message_in_chat_timer.long_press_element() self.audio_message_in_chat_timer.long_press_element()
else: else:
if not emoji_message: if not emoji_message:
self.chat_element_by_text(message).long_press_element() self.chat_element_by_text(message).long_press_until_element_is_shown(element)
else: else:
self.element_by_text_part(message).long_press_element() self.element_by_text_part(message).long_press_until_element_is_shown(element)
# old UI # old UI
# element = Button(self.driver, accessibility_id='pick-emoji-%s' % key) # element = Button(self.driver, accessibility_id='pick-emoji-%s' % key)
element = Button(self.driver, accessibility_id='emoji-picker-%s' % key)
element.click() element.click()
element.wait_for_invisibility_of_element() element.wait_for_invisibility_of_element()

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

@ -17,11 +17,16 @@ class ChatButton(Button):
class ChatElement(SilentButton): class ChatElement(SilentButton):
def __init__(self, driver, username_part, community=False): def __init__(self, driver, username_part, community=False, community_channel=False):
self.username = username_part self.username = username_part
self.community = community self.community = community
super().__init__(driver, self.community_channel = community_channel
xpath="//*[@content-desc='chat-name-text'][starts-with(@text,'%s')]/.." % username_part) if self.community_channel is True:
super().__init__(driver,
xpath="//*[@content-desc='chat-name-text']//*[starts-with(@text,'# %s')]/../.." % username_part)
else:
super().__init__(driver,
xpath="//*[@content-desc='chat-name-text'][starts-with(@text,'%s')]/.." % username_part)
def navigate(self): def navigate(self):
if self.community: if self.community:
@ -34,7 +39,7 @@ class ChatElement(SilentButton):
def click(self): def click(self):
if self.community: if self.community:
from views.chat_view import CommunityView from views.chat_view import CommunityView
desired_element = CommunityView(self.driver).community_options_button desired_element = CommunityView(self.driver).community_description_text
else: else:
from views.chat_view import ChatView from views.chat_view import ChatView
desired_element = ChatView(self.driver).chat_message_input desired_element = ChatView(self.driver).chat_message_input
@ -124,102 +129,6 @@ class ActivityCenterElement(SilentButton):
decline_element.click() decline_element.click()
# Old UI
# def __init__(self, driver, chat_name):
# self.chat_name = chat_name
# super().__init__(driver,
# xpath="//*[@content-desc='chat-name-or-sender-text'][starts-with(@text,'%s')]/../.." % chat_name)
# def navigate(self):
# from views.chat_view import ChatView
# return ChatView(self.driver)
#
# def click(self):
# from views.chat_view import ChatView
# desired_element = ChatView(self.driver).chat_message_input
# self.click_until_presence_of_element(desired_element=desired_element)
#
# return self.navigate()
#
# @property
# def chat_image(self):
# class ChatImage(BaseElement):
# def __init__(self, driver, parent_locator: str):
# super().__init__(driver, xpath="%s//*[@content-desc='current-account-photo']" % parent_locator)
#
# return ChatImage(self.driver, self.locator)
#
# @property
# def chat_message_preview(self):
# class ChatMessagePreview(BaseElement):
# def __init__(self, driver, parent_locator: str):
# super().__init__(driver, xpath="%s//*[@content-desc='chat-message-text']" % parent_locator)
#
# return ChatMessagePreview(self.driver, self.locator).text
#
# @property
# def chat_name_indicator_text(self):
# class ChatNameIndicatorText(BaseElement):
# def __init__(self, driver, parent_locator: str):
# super().__init__(driver,
# xpath="(%s//*[@content-desc='chat-name-container']//android.widget.TextView)[last()]" % parent_locator)
#
# try:
# return ChatNameIndicatorText(self.driver, self.locator).text
# except NoSuchElementException:
# return ''
#
# def accept_contact_request(self):
# try:
# accept_element = Button(self.driver, xpath=self.locator + '/*[@content-desc="accept-cr"]').find_element()
# except NoSuchElementException:
# return ''
# if accept_element:
# accept_element.click()
#
# def decline_contact_request(self):
# try:
# decline_element = Button(self.driver, xpath=self.locator + '/*[@content-desc="decline-cr"]').find_element()
# except NoSuchElementException:
# return ''
# if decline_element:
# decline_element.click()
#
#
# class PushNotificationElement(SilentButton):
# def __init__(self, driver, pn_text):
# self.pn_text = pn_text
# super().__init__(driver, xpath="//*[@text='%s']" % pn_text)
#
# @property
# def icon(self):
# class PnIconElement(BaseElement):
# def __init__(self, driver, parent_locator):
# super().__init__(driver,
# xpath="%s/../../../../*/*[@resource-id='android:id/message_icon']" % parent_locator)
#
# return PnIconElement(self.driver, self.locator)
#
# @property
# def username(self):
# class PnUsername(BaseElement):
# def __init__(self, driver, parent_locator):
# super().__init__(driver,
# xpath="%s/../../*[@resource-id='android:id/message_name']" % parent_locator)
#
# return PnUsername(self.driver, self.locator).text
#
# @property
# def group_chat_icon(self):
# class GroupChatIconElement(BaseElement):
# def __init__(self, driver, parent_locator):
# super().__init__(driver,
# xpath="%s/../../../../*[@resource-id='android:id/right_icon_container']" % parent_locator)
#
# return GroupChatIconElement(self.driver, self.locator)
class PushNotificationElement(SilentButton): class PushNotificationElement(SilentButton):
def __init__(self, driver, pn_text): def __init__(self, driver, pn_text):
self.pn_text = pn_text self.pn_text = pn_text
@ -334,10 +243,13 @@ class HomeView(BaseView):
except TimeoutException: except TimeoutException:
break break
def get_chat(self, username, community=False, wait_time=10): def get_chat(self, username, community=False, community_channel=False, wait_time=10):
self.driver.info("Looking for chat: '%s'" % username) if community:
chat_element = ChatElement(self.driver, username[:25], community=community) self.driver.info("Looking for community: '%s'" % username)
if not chat_element.is_element_displayed(wait_time): else:
self.driver.info("Looking for chat: '%s'" % username)
chat_element = ChatElement(self.driver, username[:25], community=community, community_channel=community_channel)
if not chat_element.is_element_displayed(wait_time) and community is False and community_channel is False:
if self.notifications_unread_badge.is_element_displayed(30): if self.notifications_unread_badge.is_element_displayed(30):
chat_in_ac = ActivityCenterElement(self.driver, username[:25]) chat_in_ac = ActivityCenterElement(self.driver, username[:25])
self.open_activity_center_button.click_until_presence_of_element(chat_in_ac) self.open_activity_center_button.click_until_presence_of_element(chat_in_ac)