status-im/status-mobile
2
0
Fork 0
mirror of https://github.com/status-im/status-mobile.git synced 2025-01-27 00:49:39 +00:00
Code Issues Projects Releases Wiki Activity

e2e: 1-1 chat groups

Browse Source
This commit is contained in:
Churikova Tetiana 2022-03-31 17:34:34 +02:00
parent 7a964fde29
commit 092b0ed427
No known key found for this signature in database
GPG Key ID: 0D4EA7B33B47E6D8
10 changed files with 670 additions and 798 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
test/appium/support/api/network_api.py
View File

@ -7,10 +7,12 @@ import time
from json import JSONDecodeError from json import JSONDecodeError
from decimal import Decimal from decimal import Decimal
from os import environ from os import environ
from web3.exceptions import TransactionNotFound
import tests import tests
import support.api.web3_api as w3 import support.api.web3_api as w3
class NetworkApi(object): class NetworkApi(object):
def __init__(self): def __init__(self):
@ -79,7 +81,7 @@ class NetworkApi(object):
counter = 0 counter = 0
while True: while True:
if counter >= wait_time: if counter >= wait_time:
for entry in range(0,5): for entry in range(0, 5):
self.log('Transaction #%s, amount is %s' %(entry+1, float(int(transactions[entry]['value']) / 10 ** decimals))) self.log('Transaction #%s, amount is %s' %(entry+1, float(int(transactions[entry]['value']) / 10 ** decimals)))
self.log(str(transactions[entry])) self.log(str(transactions[entry]))
pytest.fail( pytest.fail(
@ -100,6 +102,13 @@ class NetworkApi(object):
try: try:
for transaction in transactions: for transaction in transactions:
if float(int(transaction['value']) / 10 ** decimals) == float(amount): if float(int(transaction['value']) / 10 ** decimals) == float(amount):
self.log("Tx is found: %s (etherscan API)" % transaction['hash'])
try:
w3.transaction_status(transaction['hash'])
self.log("Tx is found (web3 API)")
except TransactionNotFound:
self.log("Tx is not found (web3 API)")
continue
return transaction return transaction
except TypeError as e: except TypeError as e:
self.log("Failed iterate transactions(Etherscan unexpected error): " + str(e)) self.log("Failed iterate transactions(Etherscan unexpected error): " + str(e))

1
test/appium/support/testrail_report.py
View File

@ -110,6 +110,7 @@ class TestrailReport(BaseTestReport):
test_cases['pr']['wallet'] = 50661 test_cases['pr']['wallet'] = 50661
test_cases['pr']['send_tx'] = 50662 test_cases['pr']['send_tx'] = 50662
test_cases['pr']['keycard_tx'] = 50663 test_cases['pr']['keycard_tx'] = 50663
test_cases['pr']['1_1_chat_commands'] = 50825
## Nightly e2e ## Nightly e2e
test_cases['nightly']['medium'] = 736 test_cases['nightly']['medium'] = 736
test_cases['nightly']['chat'] = 50811 test_cases['nightly']['chat'] = 50811

120
test/appium/tests/atomic/chats/test_chats_management.py
View File

@ -11,50 +11,6 @@ from views.chat_view import ChatView
class TestChatManagement(SingleDeviceTestCase): class TestChatManagement(SingleDeviceTestCase):
@marks.testrail_id(5387)
@marks.high
def test_delete_chats_via_delete_button_rejoin(self):
sign_in = SignInView(self.driver)
home = sign_in.create_user()
messages = [home.get_random_message() for _ in range(3)]
home.just_fyi("Creating 3 types of chats")
chat = home.add_contact(basic_user['public_key'])
one_to_one, public, group = basic_user['username'], '#public-delete-long-press', 'group'
chat.get_back_to_home_view()
home.create_group_chat([basic_user['username']], group)
chat.get_back_to_home_view()
home.join_public_chat(public[1:])
chat.get_back_to_home_view()
home.join_public_chat(public[1:])
chat.get_back_to_home_view()
home.just_fyi("Deleting 3 chats via delete button and check they will not reappear after relaunching app")
i = 0
for chat_name in one_to_one, public, group:
message = messages[i]
chat = home.get_chat(chat_name).click()
chat.send_message(message)
chat.leave_chat() if chat_name == group else chat.delete_chat()
i += 1
chat.get_back_to_home_view()
for chat_name in one_to_one, public, group:
if home.get_chat_from_home_view(chat_name).is_element_displayed():
self.errors.append('Deleted %s chat is shown, but the chat has been deleted' % chat_name)
self.driver.close_app()
self.driver.launch_app()
sign_in.sign_in()
for chat_name in one_to_one, public, group:
if home.get_chat_from_home_view(chat_name).is_element_displayed():
self.errors.append('Deleted %s is shown after re-login, but the chat has been deleted' % chat_name)
sign_in.just_fyi('Rejoin public chat and check that messages are fetched again')
public_chat = home.join_public_chat(public[1:])
if not public_chat.chat_element_by_text(messages[1]).is_element_displayed(20):
self.errors.append('Messages are not fetched when rejoining public chat after deleting')
self.errors.verify_no_errors()
@marks.testrail_id(5304) @marks.testrail_id(5304)
@marks.high @marks.high
def test_open_chat_by_pasting_chat_key_check_invalid_chat_key_cases(self): def test_open_chat_by_pasting_chat_key_check_invalid_chat_key_cases(self):
@ -792,82 +748,6 @@ class TestChatManagementMultipleDevice(MultipleDeviceTestCase):
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(6315)
@marks.critical
def test_reactions_to_message_in_chats(self):
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
message_from_sender = "Message sender"
home_1, home_2 = device_1.create_user(), device_2.create_user()
device_1.just_fyi('Both devices join to 1-1 chat')
device_2_public_key = home_2.get_public_key_and_username()
device_1_profile = home_1.profile_button.click()
device_1_username = device_1_profile.default_username_text.text
home_1.home_button.click()
device_1.just_fyi("Sender start 1-1 chat, set emoji and check counter")
device_1_chat = home_1.add_contact(device_2_public_key)
device_1_chat.send_message(message_from_sender)
device_1_chat.set_reaction(message_from_sender)
message_sender = device_1_chat.chat_element_by_text(message_from_sender)
if message_sender.emojis_below_message() != 1:
self.errors.append("Counter of reaction is not updated on your own message!")
device_2.just_fyi("Receiver set own emoji and verifies counter on received message in 1-1 chat")
home_2.home_button.click()
device_2_chat_item = home_2.get_chat(device_1_username)
device_2_chat_item.wait_for_visibility_of_element(20)
device_2_chat = device_2_chat_item.click()
message_receiver = device_2_chat.chat_element_by_text(message_from_sender)
if message_receiver.emojis_below_message(own=False) != 1:
self.errors.append("Counter of reaction is not updated on received message!")
device_2_chat.set_reaction(message_from_sender)
for counter in message_sender.emojis_below_message(), message_receiver.emojis_below_message():
if counter != 2:
self.errors.append('Counter is not updated after setting emoji from receiver!')
device_2.just_fyi("Receiver pick the same emoji and verify that counter will decrease for both users")
device_2_chat.set_reaction(message_from_sender)
for counter in message_sender.emojis_below_message(), message_receiver.emojis_below_message(own=False):
if counter != 1:
self.errors.append('Counter is not decreased after re-tapping emoji from receiver!')
[chat.get_back_to_home_view() for chat in (device_2_chat, device_1_chat)]
device_1.just_fyi('Both devices joining the same public chat, send messages and check counters')
chat_name = device_1.get_random_chat_name()
[home.join_public_chat(chat_name) for home in (home_1, home_2)]
chat_public_1, chat_public_2 = home_1.get_chat_view(), home_2.get_chat_view()
chat_public_1.send_message(message_from_sender)
device_1_chat.just_fyi('Set several emojis as sender and receiver and check counters in public chat')
message_sender = chat_public_1.chat_element_by_text(message_from_sender)
emojis_from_sender = ['thumbs-down', 'love', 'laugh']
[chat_public_1.set_reaction(message_from_sender, reaction) for reaction in emojis_from_sender]
emojis_from_receiver = ['angry', 'sad']
[chat_public_2.set_reaction(message_from_sender, reaction) for reaction in emojis_from_receiver]
message_receiver = chat_public_2.chat_element_by_text(message_from_sender)
for reaction in emojis_from_sender:
if message_sender.emojis_below_message(reaction) != 1:
self.errors.append(
'Counter is not updated on own message after tapping %s for sender in pub chat' % reaction)
if message_receiver.emojis_below_message(reaction, own=False) != 1:
self.errors.append(
'Counter is not updated on received message after tapping %s for receiver in pub chat' % reaction)
for reaction in emojis_from_receiver:
if message_sender.emojis_below_message(reaction, own=False) != 1:
self.errors.append(
'Counter is not updated on own message after tapping %s for receiver in pub chat' % emoji)
if message_receiver.emojis_below_message(reaction) != 1:
self.errors.append(
'Counter is not updated on received message after tapping %s for sender in pub chat' % emoji)
device_1_chat.just_fyi('Unset emoji and check that it is not shown anymore')
chat_public_1.set_reaction(message_from_sender, 'love')
if message_sender.emojis_below_message('love') != 0:
self.errors.append('Emoji is still shown on message after re-tapping last reaction')
self.errors.verify_no_errors()
@marks.testrail_id(6326) @marks.testrail_id(6326)
@marks.medium @marks.medium

278
test/appium/tests/atomic/chats/test_commands.py
View File

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

760
test/appium/tests/atomic/chats/test_one_to_one.py
View File

@ -1,165 +1,183 @@
import emoji import emoji
import random import random
import string import pytest
from tests import marks from tests import marks
from tests.base_test_case import MultipleDeviceTestCase, SingleDeviceTestCase from tests.base_test_case import MultipleDeviceTestCase, SingleDeviceTestCase, MultipleSharedDeviceTestCase, create_shared_drivers
from tests.users import transaction_senders, basic_user, ens_user, ens_user_ropsten from tests.users import transaction_senders, basic_user, ens_user, ens_user_ropsten
from views.sign_in_view import SignInView from views.sign_in_view import SignInView
from views.send_transaction_view import SendTransactionView from views.send_transaction_view import SendTransactionView
class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase): @pytest.mark.xdist_group(name="1_1_chat_2")
@marks.critical
class TestOneToOneChatMultipleSharedDevices(MultipleSharedDeviceTestCase):
@marks.testrail_id(6283) @classmethod
@marks.high def setup_class(cls):
def test_push_notification_1_1_chat_no_pn_activity_center(self): cls.drivers, cls.loop = create_shared_drivers(2)
self.create_drivers(2) cls.device_1, cls.device_2 = SignInView(cls.drivers[0]), SignInView(cls.drivers[1])
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1]) cls.home_1 = cls.device_1.create_user(enable_notifications=True)
home_1, home_2 = device_1.create_user(), device_2.create_user(enable_notifications=True) cls.home_2 = cls.device_2.create_user(enable_notifications=True)
device_2.just_fyi("Device_1 = Enables Notifications from Profile; Device_2 - from onboarding") cls.profile_1 = cls.home_1.profile_button.click()
cls.default_username_1 = cls.profile_1.default_username_text.text
cls.profile_1.home_button.click()
cls.public_key_2, cls.default_username_2 = cls.home_2.get_public_key_and_username(return_username=True)
cls.chat_1 = cls.home_1.add_contact(cls.public_key_2)
cls.chat_1.send_message('hey')
cls.home_2.home_button.double_click()
cls.chat_2 = cls.home_2.get_chat(cls.default_username_1).click()
profile_1 = home_1.profile_button.click() @marks.testrail_id(6315)
default_username_1 = profile_1.default_username_text.text def test_1_1_chat_message_reaction(self):
profile_1.profile_notifications_button.scroll_and_click() message_from_sender = "Message sender"
profile_1.profile_notifications_toggle_button.click() self.device_1.just_fyi("Sender start 1-1 chat, set emoji and check counter")
home_1 = profile_1.home_button.click() self.chat_1.send_message(message_from_sender)
public_key_2 = home_2.get_public_key_and_username() self.chat_1.set_reaction(message_from_sender)
message_no_pn, message = 'No PN', 'Text push notification' message_sender = self.chat_1.chat_element_by_text(message_from_sender)
if message_sender.emojis_below_message() != 1:
self.errors.append("Counter of reaction is not updated on your own message!")
device_2.just_fyi("Device 2 check there is no PN when receiving new message to activity centre") self.device_2.just_fyi("Receiver set own emoji and verifies counter on received message in 1-1 chat")
device_2.put_app_to_background() message_receiver = self.chat_2.chat_element_by_text(message_from_sender)
chat_1 = home_1.add_contact(public_key_2) if message_receiver.emojis_below_message(own=False) != 1:
chat_1.send_message(message_no_pn) self.errors.append("Counter of reaction is not updated on received message!")
device_2.open_notification_bar() self.chat_2.set_reaction(message_from_sender)
if home_2.element_by_text(message_no_pn).is_element_displayed(): for counter in message_sender.emojis_below_message(), message_receiver.emojis_below_message():
self.errors.append("Push notification with text was received for new message in activity centre") if counter != 2:
device_2.get_app_from_background() self.errors.append('Counter is not updated after setting emoji from receiver!')
device_2.home_button.click()
home_2.get_chat(default_username_1).click()
home_2.profile_button.click()
device_2.just_fyi("Device 2 puts app on background being on Profile view to receive PN with text") self.device_2.just_fyi("Receiver pick the same emoji and verify that counter will decrease for both users")
device_2.click_system_home_button() self.chat_2.set_reaction(message_from_sender)
chat_1.send_message(message) for counter in message_sender.emojis_below_message(), message_receiver.emojis_below_message(own=False):
if counter != 1:
device_1.just_fyi("Device 1 puts app on background to receive emoji push notification") self.errors.append('Counter is not decreased after re-tapping emoji from receiver!')
device_1.profile_button.click()
device_1.click_system_home_button()
device_2.just_fyi("Check text push notification and tap it")
device_2.open_notification_bar()
pn = home_2.get_pn(message)
if not pn.icon.is_element_displayed():
device_2.driver.fail("Push notification with text was not received")
chat_2 = device_2.click_upon_push_notification_by_text(message)
device_2.just_fyi("Send emoji message to Device 1 while it's on backround")
emoji_message = random.choice(list(emoji.EMOJI_UNICODE))
emoji_unicode = emoji.EMOJI_UNICODE[emoji_message]
chat_2.send_message(emoji.emojize(emoji_message))
device_1.just_fyi("Device 1 checks PN with emoji")
device_1.open_notification_bar()
if not device_1.element_by_text_part(emoji_unicode).is_element_displayed(10):
device_1.driver.fail("Push notification with emoji was not received")
chat_1 = device_1.click_upon_push_notification_by_text(emoji_unicode)
device_1.just_fyi("Check Device 1 is actually on chat")
if not (chat_1.element_by_text_part(message).is_element_displayed()
and chat_1.element_by_text_part(emoji_unicode).is_element_displayed()):
device_1.driver.fail("Failed to open chat view after tap on PN")
device_1.just_fyi("Checks there are no PN after message was seen")
[device.click_system_home_button() for device in (device_1, device_2)]
[device.open_notification_bar() for device in (device_1, device_2)]
if (device_2.element_by_text_part(message).is_element_displayed()
or device_1.element_by_text_part(emoji_unicode).is_element_displayed()):
self.errors.append("PN are keep staying after message was seen by user")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(5310) @marks.testrail_id(6316)
@marks.critical def test_1_1_chat_text_message_with_push(self):
def test_offline_is_shown_messaging_1_1_chat_sent_delivered(self): self.home_2.just_fyi("Put app on background (to check Push notification received for audio message)")
self.create_drivers(2) self.home_2.click_system_home_button()
home_1, home_2 = SignInView(self.drivers[0]).create_user(), SignInView(self.drivers[1]).create_user()
public_key_1 = home_1.get_public_key_and_username()
home_1.home_button.click()
home_1.just_fyi('turn on airplane mode and check that offline status is shown on home view') self.home_2.just_fyi("Sending audio message to device who is on background")
home_1.toggle_airplane_mode() self.chat_1.record_audio_message(message_length_in_seconds=125)
home_1.connection_offline_icon.wait_and_click(20) if not self.chat_1.element_by_text("Maximum recording time reached").is_element_displayed():
for element in home_1.not_connected_to_node_text, home_1.not_connected_to_peers_text: self.drivers[0].fail("Exceeded 2 mins limit of recording time.")
if not element.is_element_displayed():
self.errors.append(
'Element "%s" is not shown in Connection status screen if device is offline' % element.locator)
home_1.click_system_back_button()
profile_2 = home_2.profile_button.click() self.chat_1.ok_button.click()
username_2 = profile_2.default_username_text.text if self.chat_1.audio_message_recorded_time.text != "1:59":
profile_2.home_button.click() self.errors.append("Timer exceed 2 minutes")
chat_2 = home_2.add_contact(public_key_1) self.chat_1.send_message_button.click()
message_1 = 'test message'
home_2.just_fyi("check sent status") self.device_2.open_notification_bar()
chat_2.send_message(message_1) chat_2 = self.home_2.click_upon_push_notification_by_text("Audio")
if chat_2.chat_element_by_text(message_1).status != 'sent':
self.errors.append('Message status is not sent, it is %s!' % chat_2.chat_element_by_text(message_1).status)
chat_2.toggle_airplane_mode()
home_1.just_fyi('go back online and check that 1-1 chat will be fetched') listen_time = 5
home_1.toggle_airplane_mode()
chat_element = home_1.get_chat(username_2, wait_time=120) self.device_2.home_button.click()
chat_1 = chat_element.click() self.home_2.get_chat(self.default_username_1).click()
chat_1.chat_element_by_text(message_1).wait_for_visibility_of_element(2) chat_2.play_audio_message(listen_time)
if chat_2.audio_message_in_chat_timer.text not in ("00:05", "00:06", "00:07", "00:08"):
self.errors.append("Listened 5 seconds but timer shows different listened time in audio message")
self.errors.verify_no_errors()
@marks.testrail_id(5373)
def test_1_1_chat_emoji_and_link_send_and_open(self):
self.home_1.just_fyi("Check that can send emoji in 1-1 chat")
emoji_name = random.choice(list(emoji.EMOJI_UNICODE))
emoji_unicode = emoji.EMOJI_UNICODE[emoji_name]
self.chat_1.send_message(emoji.emojize(emoji_name))
for chat in self.chat_1, self.chat_2:
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.home_1.just_fyi("Check that link can be opened from 1-1 chat")
url_message = 'http://status.im'
self.chat_1.send_message(url_message)
self.chat_2.element_starts_with_text(url_message, 'button').click()
web_view = self.chat_2.open_in_status_button.click()
if not web_view.element_by_text('Private, Secure Communication').is_element_displayed(60):
self.errors.append('URL was not opened from 1-1 chat')
self.errors.verify_no_errors()
@marks.testrail_id(695843)
def test_1_1_chat_text_message_edit_delete_push_disappear(self):
self.device_2.just_fyi(
"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"
self.chat_1.home_button.click()
self.chat_2.home_button.click()
self.home_2.get_chat(self.default_username_1).click()
self.chat_2.send_message(message_before_edit_1_1)
self.chat_2.edit_message_in_chat(message_before_edit_1_1, message_after_edit_1_1)
if not self.home_1.element_by_text_part(message_after_edit_1_1).is_element_present():
self.errors.append('UNedited message version displayed on preview')
self.home_1.get_chat(self.default_username_2).click()
chat_element = self.chat_1.chat_element_by_text(message_after_edit_1_1)
if not chat_element.is_element_present(30):
self.errors.append('No edited message in 1-1 chat displayed')
if not self.chat_1.element_by_text_part("⌫ Edited").is_element_present(30):
self.errors.append('No mark in message bubble about this message was edited on receiver side')
self.device_2.just_fyi("Verify Device1 can not edit and delete received message from Device2")
chat_element.long_press_element()
for action in ("edit", "delete"):
if self.chat_1.element_by_translation_id(action).is_element_present():
self.errors.append('Option to %s someone else message available!' % action)
self.home_1.click_system_back_button()
self.device_2.just_fyi("Delete message and check it is not shown in chat preview on home")
self.chat_2.delete_message_in_chat(message_after_edit_1_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):
self.errors.append("Deleted message is shown in chat view for 1-1 chat")
self.chat_1.home_button.double_click()
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.device_2.just_fyi("Send one more message and check that PN will be deleted with message deletion")
message_to_delete = 'DELETE ME'
self.home_1.put_app_to_background()
self.chat_2.send_message(message_to_delete)
self.home_1.open_notification_bar()
if not self.home_1.get_pn(message_to_delete):
self.errors.append("Push notification doesn't appear")
self.chat_2.delete_message_in_chat(message_to_delete)
pn_to_disappear = self.home_1.get_pn(message_to_delete)
if pn_to_disappear:
if not pn_to_disappear.is_element_disappeared(30):
self.errors.append("Push notification was not removed after initial message deletion")
home_1.just_fyi('checking offline fetching for another message, check delivered status for first message')
chat_2.toggle_airplane_mode()
if chat_2.chat_element_by_text(message_1).status != 'delivered':
self.errors.append(
'Message status is not delivered, it is %s!' % chat_2.chat_element_by_text(message_1).status)
home_1.toggle_airplane_mode()
message_2 = 'one more message'
chat_2.send_message(message_2)
home_1.toggle_airplane_mode()
chat_1 = chat_element.click()
chat_1.chat_element_by_text(message_2).wait_for_visibility_of_element(180)
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(5315) @marks.testrail_id(5315)
@marks.high def test_1_1_chat_non_latin_message_to_newly_added_contact_with_profile_picture_on_different_networks(self):
def test_send_non_english_message_to_newly_added_contact_on_different_networks(self): self.home_1.get_app_from_background()
self.create_drivers(2) self.home_2.get_app_from_background()
device_1_home, device_2_home = SignInView(self.drivers[0]).create_user(), SignInView( self.home_1.profile_button.click()
self.drivers[1]).create_user() self.profile_1.edit_profile_picture('sauce_logo.png')
profile_1 = device_1_home.profile_button.click() self.profile_1.switch_network()
profile_1.switch_network() self.profile_1.home_button.click()
self.home_1.get_chat(self.default_username_2).click()
profile_1.just_fyi("Getting public keys and usernames for both users") self.profile_1.just_fyi("Send messages on different languages")
device_1_home.profile_button.click()
default_username_1 = profile_1.default_username_text.text
profile_1.home_button.double_click()
profile_1 = device_1_home.profile_button.click()
profile_1.edit_profile_picture('sauce_logo.png')
profile_1.home_button.click()
device_2_public_key, default_username_2 = device_2_home.get_public_key_and_username(return_username=True)
device_2_home.home_button.click()
profile_1.just_fyi("Add user to contacts and send messages on different language")
device_1_chat = device_1_home.add_contact(device_2_public_key + ' ')
messages = ['hello', '¿Cómo estás tu año?', 'ё, доброго вечерочка', '® æ ç ♥'] messages = ['hello', '¿Cómo estás tu año?', 'ё, доброго вечерочка', '® æ ç ♥']
timestamp_message = messages[3] timestamp_message = messages[3]
for message in messages: for message in messages:
device_1_chat.send_message(message) self.chat_1.send_message(message)
device_2_chat = device_2_home.get_chat(default_username_1).click() if not self.chat_2.chat_message_input.is_element_displayed():
sent_time_variants = device_1_chat.convert_device_time_to_chat_timestamp() self.chat_2.home_button.click()
self.home_2.get_chat(self.default_username_1).click()
sent_time_variants = self.chat_1.convert_device_time_to_chat_timestamp()
for message in messages: for message in messages:
if not device_2_chat.chat_element_by_text(message).is_element_displayed(): if not self.chat_2.chat_element_by_text(message).is_element_displayed():
self.errors.append("Message with test '%s' was not received" % message) self.errors.append("Message with test '%s' was not received" % message)
if not device_2_chat.add_to_contacts.is_element_displayed(): if not self.chat_2.add_to_contacts.is_element_displayed():
self.errors.append('Add to contacts button is not shown') self.errors.append('Add to contacts button is not shown')
if device_2_chat.user_name_text.text != default_username_1: if self.chat_2.user_name_text.text != self.default_username_1:
self.errors.append("Default username '%s' is not shown in one-to-one chat" % default_username_1) self.errors.append("Default username '%s' is not shown in one-to-one chat" % self.default_username_1)
# TODO: disabled until https://github.com/status-im/status-react/issues/12936 fix # TODO: disabled until https://github.com/status-im/status-react/issues/12936 fix
# profile_1.just_fyi("Check timestamps for sender and receiver") # profile_1.just_fyi("Check timestamps for sender and receiver")
@ -170,85 +188,220 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
# self.errors.append( # self.errors.append(
# "Timestamp is not shown, expected '%s', in fact '%s'" % (sent_time_variants.join(","), timestamp)) # "Timestamp is not shown, expected '%s', in fact '%s'" % (sent_time_variants.join(","), timestamp))
device_2_home.just_fyi("Add user to contact and verify his default username") self.chat_2.just_fyi("Add user to contact and verify his default username")
device_2_chat.add_to_contacts.click() self.chat_2.add_to_contacts.click()
device_2_chat.chat_options.click() self.chat_2.chat_options.click()
device_2_chat.view_profile_button.click() self.chat_2.view_profile_button.click()
if not device_2_chat.remove_from_contacts.is_element_displayed(): if not self.chat_2.remove_from_contacts.is_element_displayed():
self.errors.append("Remove from contacts in not shown after adding contact from 1-1 chat bar") self.errors.append("Remove from contacts in not shown after adding contact from 1-1 chat bar")
device_2_chat.close_button.click() self.chat_2.close_button.click()
device_2_chat.home_button.double_click() self.chat_2.home_button.double_click()
device_2_home.plus_button.click() self.home_2.plus_button.click()
device_2_contacts = device_2_home.start_new_chat_button.click() device_2_contacts = self.home_2.start_new_chat_button.click()
if not device_2_contacts.element_by_text(default_username_1).is_element_displayed(): if not device_2_contacts.element_by_text(self.default_username_1).is_element_displayed():
self.errors.append('%s is not added to contacts' % default_username_1) self.errors.append('%s is not added to contacts' % self.default_username_1)
if device_1_chat.user_name_text.text != default_username_2: if self.chat_1.user_name_text.text != self.default_username_2:
self.errors.append("Default username '%s' is not shown in one-to-one chat" % default_username_2) self.errors.append("Default username '%s' is not shown in one-to-one chat" % self.default_username_2)
device_1_chat.chat_options.click()
device_1_chat.view_profile_button.click()
if not device_2_chat.contact_profile_picture.is_element_image_equals_template('sauce_logo_profile_2.png'): if not self.chat_2.contact_profile_picture.is_element_image_equals_template('sauce_logo_profile_2.png'):
self.errors.append("Updated profile picture is not shown in one-to-one chat") self.errors.append("Updated profile picture is not shown in one-to-one chat")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(695843) @marks.testrail_id(6283)
@marks.high def test_1_1_chat_push_emoji(self):
def test_edit_delete_message_in_one_to_one_(self): message_no_pn, message = 'No PN', 'Text push notification'
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_1, home_2 = device_1.create_user(enable_notifications=True), device_2.create_user()
device_2.just_fyi("Create public chat on Device1, send message and edit it then") # TODO: Should be moved to group or test where no contact is added in prerequisites
public_key_1, username_1 = home_1.get_public_key_and_username(return_username=True) # self.device_2.just_fyi("Device 2: check there is no PN when receiving new message to activity centre")
public_key_2, username_2 = home_2.get_public_key_and_username(return_username=True) # self.device_2.put_app_to_background()
[home.home_button.click() for home in (home_1, home_2)] # if not self.chat_1.chat_message_input.is_element_displayed():
# self.home_1.get_chat(username=self.default_username_2).click()
# self.chat_1.send_message(message_no_pn)
# self.device_2.open_notification_bar()
# if self.home_2.element_by_text(message_no_pn).is_element_displayed():
# self.errors.append("Push notification with text was received for new message in activity centre")
# self.device_2.get_app_from_background()
self.device_2.home_button.click()
self.home_2.get_chat(self.default_username_1).click()
self.home_2.profile_button.click()
device_2.just_fyi( self.device_2.just_fyi("Device 2 puts app on background being on Profile view to receive PN with text")
"Device 1 sends text message and edits it in 1-1 chat. Device2 checks edited message is shown") self.device_2.click_system_home_button()
chat_private_2 = home_2.add_contact(public_key_1) self.chat_1.send_message(message)
message_before_edit_1_1, message_after_edit_1_1 = "Message before edit 1-1", "AFTER"
chat_private_2.send_message(message_before_edit_1_1)
home_1.home_button.click()
device_1_one_to_one_chat_element = home_1.get_chat(username_2) self.device_1.just_fyi("Device 1 puts app on background to receive emoji push notification")
chat_private_2.edit_message_in_chat(message_before_edit_1_1, message_after_edit_1_1) self.device_1.profile_button.click()
if not home_1.element_by_text_part(message_after_edit_1_1).is_element_displayed(30): self.device_1.click_system_home_button()
self.errors.append('UNedited message version displayed on preview')
chat_private_1 = device_1_one_to_one_chat_element.click()
if not home_1.element_by_text_part(message_after_edit_1_1).is_element_present():
self.errors.append('No edited message in 1-1 chat displayed')
if not home_1.element_by_text_part("⌫ Edited").is_element_present(30):
self.errors.append('No mark in message bubble about this message was edited on receiver side')
device_2.just_fyi("Verify Device1 can not edit and delete received message from Device2") self.device_2.just_fyi("Check text push notification and tap it")
home_1.element_by_text_part(message_after_edit_1_1).long_press_element() self.device_2.open_notification_bar()
for action in ("edit", "delete"): if not self.home_2.get_pn(message):
if home_1.element_by_translation_id(action).is_element_present(): self.device_2.driver.fail("Push notification with text was not received")
self.errors.append('Option to %s someone else message available!' % action) chat_2 = self.device_2.click_upon_push_notification_by_text(message)
home_1.click_system_back_button()
device_2.just_fyi("Delete message and check it is not shown in chat preview on home") self.device_2.just_fyi("Send emoji message to Device 1 while it's on background")
chat_private_2.delete_message_in_chat(message_after_edit_1_1) emoji_message = random.choice(list(emoji.EMOJI_UNICODE))
for chat in (chat_private_2, chat_private_1): emoji_unicode = emoji.EMOJI_UNICODE[emoji_message]
if chat.chat_element_by_text(message_after_edit_1_1).is_element_displayed(30): chat_2.send_message(emoji.emojize(emoji_message))
self.errors.append("Deleted message is shown in chat view for 1-1 chat")
chat_private_1.home_button.double_click()
if 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")
device_2.just_fyi("Send one more message and check that PN will be deleted with message deletion") self.device_1.just_fyi("Device 1 checks PN with emoji")
message_to_delete = 'DELETE ME' self.device_1.open_notification_bar()
home_1.put_app_to_background() if not self.device_1.element_by_text_part(emoji_unicode).is_element_displayed(10):
chat_private_2.send_message(message_to_delete) self.device_1.driver.fail("Push notification with emoji was not received")
home_1.open_notification_bar() chat_1 = self.device_1.click_upon_push_notification_by_text(emoji_unicode)
home_1.get_pn(message_to_delete).wait_for_element(30)
chat_private_2.delete_message_in_chat(message_to_delete) self.device_1.just_fyi("Check Device 1 is actually on chat")
if not home_1.get_pn(message_to_delete).is_element_disappeared(30): if not (chat_1.element_by_text_part(message).is_element_displayed()
self.errors.append("Push notification was not removed after initial message deletion") and chat_1.element_by_text_part(emoji_unicode).is_element_displayed()):
home_1.click_system_back_button(2) self.device_1.driver.fail("Failed to open chat view after tap on PN")
self.device_1.just_fyi("Checks there are no PN after message was seen")
[device.click_system_home_button() for device in (self.device_1, self.device_2)]
[device.open_notification_bar() for device in (self.device_1, self.device_2)]
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("PN are keep staying after message was seen by user")
self.errors.verify_no_errors()
@marks.testrail_id(6305)
def test_1_1_chat_image_send_save_reply(self):
self.home_1.get_app_from_background()
self.home_2.get_app_from_background()
self.home_1.home_button.click()
self.home_1.get_chat(username=self.default_username_2).click()
self.home_1.just_fyi('send image in 1-1 chat from Gallery, check options for sender')
image_description = 'description'
self.chat_1.show_images_button.click()
self.chat_1.allow_button.click_if_shown()
self.chat_1.first_image_from_gallery.click()
if not self.chat_1.cancel_send_image_button.is_element_displayed():
self.errors.append("Can't cancel sending images, expected image preview is not shown!")
self.chat_1.chat_message_input.set_value(image_description)
self.chat_1.send_message_button.click()
self.chat_1.chat_message_input.click()
for message in self.chat_1.image_message_in_chat, self.chat_1.chat_element_by_text(image_description):
if not message.is_element_displayed():
self.errors.append('Image or description is not shown in chat after sending for sender')
self.chat_1.image_message_in_chat.long_press_element()
for element in self.chat_1.reply_message_button, self.chat_1.save_image_button:
if not element.is_element_displayed():
self.errors.append('Save and reply are not available on long-press on own image messages')
if self.chat_1.view_profile_button.is_element_displayed():
self.errors.append('"View profile" is shown on long-press on own message')
self.home_2.just_fyi('check image, description and options for receiver')
self.home_2.get_chat(self.default_username_1).click()
for message in self.chat_2.image_message_in_chat, self.chat_2.chat_element_by_text(image_description):
if not message.is_element_displayed():
self.errors.append('Image or description is not shown in chat after sending for receiver')
self.home_2.just_fyi('check options on long-press image for receiver')
self.chat_2.image_message_in_chat.long_press_element()
for element in (self.chat_2.reply_message_button, self.chat_2.save_image_button):
if not element.is_element_displayed():
self.errors.append('Save and reply are not available on long-press on received image messages')
self.home_1.just_fyi('save image')
self.chat_1.save_image_button.click_until_presence_of_element(self.chat_1.show_images_button)
self.chat_1.show_images_button.click_until_presence_of_element(self.chat_1.image_from_gallery_button)
self.chat_1.image_from_gallery_button.click_until_presence_of_element(self.chat_1.recent_image_in_gallery)
if not self.chat_1.recent_image_in_gallery.is_element_displayed():
self.errors.append('Saved image is not shown in Recent')
self.home_1.click_system_back_button(2)
self.home_2.just_fyi('reply to image message')
self.chat_2.reply_message_button.click()
if self.chat_2.quote_username_in_message_input.text != "↪ Replying to %s" % self.default_username_1:
self.errors.append("Username is not displayed in reply quote snippet replying to image message")
reply_to_message_from_receiver = "image reply"
self.chat_2.send_message(reply_to_message_from_receiver)
reply_message = self.chat_2.chat_element_by_text(reply_to_message_from_receiver)
if not reply_message.image_in_reply.is_element_displayed():
self.errors.append("Image is not displayed in reply")
self.home_2.just_fyi('check share and save options on opened image')
self.chat_2.image_message_in_chat.scroll_to_element(direction='up')
self.chat_2.image_message_in_chat.click()
self.chat_2.share_image_icon_button.click()
self.chat_2.share_via_messenger()
if not self.chat_2.image_in_android_messenger.is_element_present():
self.errors.append("Can't share image")
self.chat_2.click_system_back_button()
self.chat_2.save_image_icon_button.click()
self.chat_2.show_images_button.click()
self.chat_2.allow_button.wait_and_click()
if not self.chat_2.first_image_from_gallery.is_element_image_similar_to_template('saved.png'):
self.errors.append("New picture was not saved!")
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(5310)
def test_1_1_chat_is_shown_message_sent_delivered_from_offline(self):
self.home_1.home_button.click()
self.home_2.home_button.click()
self.home_1.just_fyi('turn on airplane mode and check that offline status is shown on home view')
self.home_1.toggle_airplane_mode()
self.home_1.connection_offline_icon.wait_and_click(20)
for element in self.home_1.not_connected_to_node_text, self.home_1.not_connected_to_peers_text:
if not element.is_element_displayed():
self.errors.append(
'Element "%s" is not shown in Connection status screen if device is offline' % element.locator)
self.home_1.click_system_back_button()
message_1 = 'test message'
self.home_2.just_fyi("check sent status")
self.home_2.get_chat(username=self.default_username_1).click()
self.chat_2.send_message(message_1)
chat_element = self.chat_2.chat_element_by_text(message_1)
if chat_element.status != 'sent':
self.errors.append('Message status is not sent, it is %s!' % chat_element.status)
self.chat_2.toggle_airplane_mode()
self.home_1.just_fyi('go back online and check that 1-1 chat will be fetched')
self.home_1.toggle_airplane_mode()
chat_element = self.home_1.get_chat(self.default_username_2, wait_time=60)
chat_element.click()
self.chat_1.chat_element_by_text(message_1).wait_for_visibility_of_element(20)
self.home_1.just_fyi('checking offline fetching for another message, check delivered status for first message')
self.chat_2.toggle_airplane_mode()
if self.chat_2.chat_element_by_text(message_1).status != 'delivered':
self.errors.append(
'Message status is not delivered, it is %s!' % self.chat_2.chat_element_by_text(message_1).status)
self.home_1.toggle_airplane_mode()
message_2 = 'one more message'
self.chat_2.send_message(message_2)
self.home_1.toggle_airplane_mode()
chat_1 = chat_element.click()
chat_1.chat_element_by_text(message_2).wait_for_visibility_of_element(180)
self.errors.verify_no_errors()
@marks.testrail_id(5387)
def test_1_1_chat_delete_via_delete_button_relogin(self):
self.home_1.driver.quit()
self.home_2.home_button.click()
self.home_2.get_chat(username=self.default_username_1).click()
self.home_2.just_fyi("Deleting chat via delete button and check it will not reappear after relaunching app")
self.chat_2.delete_chat()
self.chat_2.get_back_to_home_view()
if self.home_2.get_chat_from_home_view(self.default_username_1).is_element_displayed():
self.errors.append('Deleted %s chat is shown, but the chat has been deleted' % self.default_username_1)
self.home_2.reopen_app()
if self.home_2.get_chat_from_home_view(self.default_username_1).is_element_displayed():
self.errors.append(
'Deleted chat %s is shown after re-login, but the chat has been deleted' % self.default_username_1)
self.errors.verify_no_errors()
class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
@marks.testrail_id(5782) @marks.testrail_id(5782)
@marks.critical @marks.critical
def test_install_pack_and_send_sticker(self): def test_install_pack_and_send_sticker(self):
@ -306,180 +459,6 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(6305)
@marks.critical
def test_image_in_one_to_one_send_save_reply_timeline(self):
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_1, home_2 = device_1.create_user(), device_2.create_user()
profile_1, profile_2 = home_1.profile_button.click(), home_2.profile_button.click()
device_2_public_key = profile_2.get_public_key_and_username()
home_1.just_fyi('set status in profile')
status_1 = 'Hey hey hey'
timeline = device_1.status_button.click()
timeline.set_new_status(status_1, image=True)
for element in timeline.element_by_text(status_1), timeline.image_message_in_chat:
if not element.is_element_displayed():
self.drivers[0].fail('Status is not set')
public_key_1, username_1 = profile_1.get_public_key_and_username(return_username=True)
[home.click() for home in [profile_1.home_button, profile_2.home_button]]
home_1.just_fyi('start 1-1 chat')
private_chat_1 = home_1.add_contact(device_2_public_key)
home_1.just_fyi('send image in 1-1 chat from Gallery, check options for sender')
image_description = 'description'
private_chat_1.show_images_button.click()
private_chat_1.first_image_from_gallery.click()
if not private_chat_1.cancel_send_image_button.is_element_displayed():
self.errors.append("Can't cancel sending images, expected image preview is not shown!")
private_chat_1.chat_message_input.set_value(image_description)
private_chat_1.send_message_button.click()
private_chat_1.chat_message_input.click()
for message in private_chat_1.image_message_in_chat, private_chat_1.chat_element_by_text(image_description):
if not message.is_element_displayed():
self.errors.append('Image or description is not shown in chat after sending for sender')
private_chat_1.show_images_button.click()
private_chat_1.image_from_gallery_button.click()
private_chat_1.click_system_back_button()
private_chat_1.image_message_in_chat.long_press_element()
for element in private_chat_1.reply_message_button, private_chat_1.save_image_button:
if not element.is_element_displayed():
self.errors.append('Save and reply are not available on long-press on own image messages')
if private_chat_1.view_profile_button.is_element_displayed():
self.errors.append('"View profile" is shown on long-press on own message')
home_2.just_fyi('check image, description and options for receiver')
private_chat_2 = home_2.get_chat(username_1).click()
for message in private_chat_2.image_message_in_chat, private_chat_2.chat_element_by_text(image_description):
if not message.is_element_displayed():
self.errors.append('Image or description is not shown in chat after sending for receiver')
home_2.just_fyi('View user profile and check status')
private_chat_2.chat_options.click()
timeline_device_1 = private_chat_2.view_profile_button.click()
for element in timeline_device_1.element_by_text(status_1), timeline_device_1.image_message_in_chat:
if not element.is_element_displayed(40):
self.errors.append('Status of another user not shown when open another user profile')
private_chat_2.close_button.click()
home_2.just_fyi('check options on long-press image for receiver')
private_chat_2.image_message_in_chat.long_press_element()
for element in (private_chat_2.reply_message_button, private_chat_2.save_image_button):
if not element.is_element_displayed():
self.errors.append('Save and reply are not available on long-press on received image messages')
home_1.just_fyi('save image')
private_chat_1.save_image_button.click()
private_chat_1.show_images_button.click_until_presence_of_element(private_chat_1.image_from_gallery_button)
private_chat_1.image_from_gallery_button.click()
private_chat_1.wait_for_element_starts_with_text('Recent')
if not private_chat_1.recent_image_in_gallery.is_element_displayed():
self.errors.append('Saved image is not shown in Recent')
home_2.just_fyi('reply to image message')
private_chat_2.reply_message_button.click()
if private_chat_2.quote_username_in_message_input.text != "↪ Replying to %s" % username_1:
self.errors.append("Username is not displayed in reply quote snippet replying to image message")
reply_to_message_from_receiver = "image reply"
private_chat_2.send_message(reply_to_message_from_receiver)
reply_message = private_chat_2.chat_element_by_text(reply_to_message_from_receiver)
if not reply_message.image_in_reply.is_element_displayed():
self.errors.append("Image is not displayed in reply")
home_2.just_fyi('check share and save options on opened image')
private_chat_2.image_message_in_chat.scroll_to_element(direction='up')
private_chat_2.image_message_in_chat.click()
private_chat_2.share_image_icon_button.click()
private_chat_2.share_via_messenger()
if not private_chat_2.image_in_android_messenger.is_element_present():
self.errors.append("Can't share image")
private_chat_2.click_system_back_button()
private_chat_2.save_image_icon_button.click()
private_chat_2.show_images_button.click()
private_chat_2.allow_button.wait_and_click()
if not private_chat_2.first_image_from_gallery.is_element_image_similar_to_template('saved.png'):
self.errors.append("New picture was not saved!")
self.errors.verify_no_errors()
@marks.testrail_id(6316)
@marks.critical
def test_send_audio_message_with_push_notification_check(self):
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_1, home_2 = device_1.create_user(), device_2.create_user(enable_notifications=True)
profile_1 = home_1.profile_button.click()
default_username_1 = profile_1.default_username_text.text
home_1 = profile_1.home_button.click()
public_key_2 = home_2.get_public_key_and_username()
chat_1 = home_1.add_contact(public_key_2)
chat_1.send_message('hey')
home_2.home_button.double_click()
home_2.get_chat(default_username_1).click()
home_2.just_fyi("Put app on background (to check Push notification received for audio message)")
home_2.click_system_home_button()
home_2.just_fyi("Sending audio message to device who is on background")
chat_1.record_audio_message(message_length_in_seconds=125)
if not chat_1.element_by_text("Maximum recording time reached").is_element_displayed():
self.drivers[0].fail("Exceeded 2 mins limit of recording time.")
else:
chat_1.ok_button.click()
if chat_1.audio_message_recorded_time.text != "1:59":
self.errors.append("Timer exceed 2 minutes")
chat_1.send_message_button.click()
device_2.open_notification_bar()
chat_2 = home_2.click_upon_push_notification_by_text("Audio")
listen_time = 5
device_2.home_button.click()
home_2.get_chat(default_username_1).click()
chat_2.play_audio_message(listen_time)
if chat_2.audio_message_in_chat_timer.text not in ("00:05", "00:06", "00:07", "00:08"):
self.errors.append("Listened 5 seconds but timer shows different listened time in audio message")
self.errors.verify_no_errors()
@marks.testrail_id(5373)
@marks.high
def test_send_and_open_emoji_link_in_one_to_one(self):
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_1, home_2 = device_1.create_user(), device_2.create_user()
profile_1 = home_1.profile_button.click()
default_username_1 = profile_1.default_username_text.text
home_1 = profile_1.home_button.click()
public_key_2 = home_2.get_public_key_and_username()
home_2.home_button.click()
chat_1 = home_1.add_contact(public_key_2)
home_1.just_fyi("Check that can send emoji in 1-1 chat")
emoji_name = random.choice(list(emoji.EMOJI_UNICODE))
emoji_unicode = emoji.EMOJI_UNICODE[emoji_name]
chat_1.send_message(emoji.emojize(emoji_name))
chat_2 = home_2.get_chat(default_username_1).click()
for chat in chat_1, chat_2:
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')
home_1.just_fyi("Check that link can be opened from 1-1 chat")
url_message = 'http://status.im'
chat_1.send_message(url_message)
chat_1.home_button.double_click()
chat_2.element_starts_with_text(url_message, 'button').click()
web_view = chat_2.open_in_status_button.click()
if not web_view.element_by_text('Private, Secure Communication').is_element_displayed(60):
self.errors.append('URL was not opened from 1-1 chat')
self.errors.verify_no_errors()
@marks.testrail_id(5362) @marks.testrail_id(5362)
@marks.medium @marks.medium
def test_unread_messages_counter_preview_highlited_1_1_chat(self): def test_unread_messages_counter_preview_highlited_1_1_chat(self):
@ -529,45 +508,6 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
class TestMessagesOneToOneChatSingle(SingleDeviceTestCase): class TestMessagesOneToOneChatSingle(SingleDeviceTestCase):
@marks.testrail_id(5317)
@marks.critical
def test_copy_and_paste_messages(self):
sign_in = SignInView(self.driver)
home = sign_in.create_user()
home.join_public_chat(''.join(random.choice(string.ascii_lowercase) for _ in range(7)))
chat = sign_in.get_chat_view()
message_text = {'text_message': 'mmmeowesage_text'}
formatted_message = {'message_with_link': 'https://status.im',
# TODO: blocked with 11161 (rechecked 23.11.21, valid)
# 'message_with_tag': '#successishere'
}
message_input = chat.chat_message_input
message_input.send_keys(message_text['text_message'])
chat.send_message_button.click()
chat.copy_message_text(message_text['text_message'])
message_input.paste_text_from_clipboard()
if message_input.text != message_text['text_message']:
self.errors.append('Message %s text was not copied in a public chat' % message_text['text_message'])
message_input.clear()
for message in formatted_message:
message_input.send_keys(formatted_message[message])
chat.send_message_button.click()
message_bubble = chat.chat_element_by_text(formatted_message[message])
message_bubble.sent_status_checkmark.long_press_element()
chat.element_by_text('Copy').click()
message_input.paste_text_from_clipboard()
if message_input.text != formatted_message[message]:
self.errors.append('Message %s text was not copied in a public chat' % formatted_message[message])
message_input.clear()
self.errors.verify_no_errors()
@marks.testrail_id(5322) @marks.testrail_id(5322)
@marks.medium @marks.medium
def test_delete_cut_and_paste_messages(self): def test_delete_cut_and_paste_messages(self):

272
test/appium/tests/atomic/test_public_chat_browsing.py
View File

@ -287,6 +287,41 @@ class TestPublicChatBrowserOneDeviceMerged(MultipleSharedDeviceTestCase):
if not self.chat.chat_element_by_text(text_message).is_element_displayed(30): if not self.chat.chat_element_by_text(text_message).is_element_displayed(30):
self.drivers[0].fail("Not navigated to chat view after reopening app") self.drivers[0].fail("Not navigated to chat view after reopening app")
@marks.testrail_id(5317)
def test_public_chat_copy_and_paste_message_in_chat_input(self):
message_text = {'text_message': 'mmmeowesage_text'}
formatted_message = {'message_with_link': 'https://status.im',
# TODO: blocked with 11161 (rechecked 23.11.21, valid)
# 'message_with_tag': '#successishere'
}
message_input = self.chat.chat_message_input
if not message_input.is_element_displayed():
self.home.get_chat('#%s' % self.public_chat_name).click()
message_input.send_keys(message_text['text_message'])
self.chat.send_message_button.click()
self.chat.copy_message_text(message_text['text_message'])
message_input.paste_text_from_clipboard()
if message_input.text != message_text['text_message']:
self.errors.append('Message %s text was not copied in a public chat' % message_text['text_message'])
message_input.clear()
for message in formatted_message:
message_input.send_keys(formatted_message[message])
self.chat.send_message_button.click()
message_bubble = self.chat.chat_element_by_text(formatted_message[message])
message_bubble.sent_status_checkmark.long_press_element()
self.chat.element_by_text('Copy').click()
message_input.paste_text_from_clipboard()
if message_input.text != formatted_message[message]:
self.errors.append('Message %s text was not copied in a public chat' % formatted_message[message])
message_input.clear()
self.errors.verify_no_errors()
@marks.testrail_id(700738) @marks.testrail_id(700738)
def test_public_chat_tag_message(self): def test_public_chat_tag_message(self):
tag_message = '#wuuut' tag_message = '#wuuut'
@ -313,7 +348,7 @@ class TestPublicChatBrowserOneDeviceMerged(MultipleSharedDeviceTestCase):
try: try:
assert self.chat.user_name_text.text == '#' + chat_name assert self.chat.user_name_text.text == '#' + chat_name
except (AssertionError, NoSuchElementException): except (AssertionError, NoSuchElementException):
self.driver.fail("Public chat '%s' is not opened" % chat_name) self.drivers[0].fail("Public chat '%s' is not opened" % chat_name)
@marks.testrail_id(702072) @marks.testrail_id(702072)
def test_browser_blocked_url(self): def test_browser_blocked_url(self):
@ -474,6 +509,131 @@ class TestPublicChatBrowserOneDeviceMerged(MultipleSharedDeviceTestCase):
self.errors.verify_no_errors() self.errors.verify_no_errors()
@pytest.mark.xdist_group(name="public_chat_medium_2")
@marks.medium
class TestPublicChatMultipleDeviceMergedMedium(MultipleSharedDeviceTestCase):
@classmethod
def setup_class(cls):
cls.drivers, cls.loop = create_shared_drivers(2)
device_1, device_2 = SignInView(cls.drivers[0]), SignInView(cls.drivers[1])
cls.home_1, cls.home_2 = device_1.create_user(), device_2.create_user()
profile_1 = cls.home_1.profile_button.click()
cls.public_key_1, cls.username_1 = profile_1.get_public_key_and_username(return_username=True)
profile_1.home_button.click()
cls.text_message = 'hello'
[home.home_button.click() for home in (cls.home_1, cls.home_2)]
cls.public_chat_name = cls.home_1.get_random_chat_name()
cls.chat_1, cls.chat_2 = cls.home_1.join_public_chat(cls.public_chat_name), cls.home_2.join_public_chat(
cls.public_chat_name)
cls.chat_1.send_message(cls.text_message)
@marks.testrail_id(6342)
def test_public_chat_timeline_different_statuses_reaction(self):
emoji_message = random.choice(list(emoji.EMOJI_UNICODE))
emoji_unicode = emoji.EMOJI_UNICODE[emoji_message]
self.home_1.just_fyi('Set status in profile')
statuses = {
'*formatted text*': 'formatted text',
'https://www.youtube.com/watch?v=JjPWmEh2KhA': 'Status Town Hall',
emoji.emojize(emoji_message): emoji_unicode,
}
timeline_1 = self.home_1.status_button.click()
for status in statuses.keys():
timeline_1.set_new_status(status)
sleep(60)
timeline_1.element_by_translation_id("enable").wait_and_click()
timeline_1.element_by_translation_id("enable-all").wait_and_click()
timeline_1.close_modal_view_from_chat_button.click()
for status in statuses:
expected_value = statuses[status]
if not timeline_1.element_by_text_part(expected_value).is_element_displayed():
self.errors.append("Expected value %s is not shown" % expected_value)
text_status = 'some text'
timeline_1.set_new_status(status=text_status, image=True)
for timestamp in ('Now', '1M', '2M'):
if not timeline_1.element_by_text(timestamp).is_element_displayed():
self.errors.append("Expected timestamp %s is not shown in timeline_1" % timestamp)
if not timeline_1.image_message_in_chat.is_element_displayed():
self.errors.append("Timeline image is not shown in timeline_1")
self.home_2.just_fyi('Check that can see user status without adding him as contact')
self.home_2.home_button.click()
chat_2 = self.home_2.add_contact(self.public_key_1, add_in_contacts=False)
chat_2.chat_options.click()
timeline_2 = chat_2.view_profile_button.click()
if not timeline_2.image_message_in_chat.is_element_displayed(40):
self.errors.append(
'Timeline image of another user is not shown when open another user profile before adding to contacts')
chat_2.chat_element_by_text(text_status).wait_for_element(30)
chat_2.element_by_translation_id("enable").scroll_and_click()
chat_2.element_by_translation_id("enable-all").wait_and_click()
chat_2.close_modal_view_from_chat_button.click()
for status in statuses:
chat_2.element_by_text_part(statuses['*formatted text*']).scroll_to_element()
expected_value = statuses[status]
if not chat_2.element_by_text_part(expected_value).is_element_displayed():
self.errors.append(
"Expected value %s is not shown in other user profile without adding to contacts" % expected_value)
self.home_2.just_fyi('Add device1 to contacts and check that status will be shown in timeline_1')
chat_2.close_button.scroll_and_click(direction='up')
chat_2.add_to_contacts.click()
timeline_2 = chat_2.status_button.click()
for status in statuses:
expected_value = statuses[status]
if not timeline_2.element_by_text_part(expected_value).is_element_displayed():
self.errors.append(
"Expected value %s is not shown in timeline_1 after adding user to contacts" % expected_value)
if not timeline_2.image_message_in_chat.is_element_displayed(40):
self.errors.append(
'Timeline image of another user is not shown when open another user profile after adding to contacts')
self.home_2.just_fyi('Checking message tag and reactions on statuses')
tag_status = '#public-chat-to-redirect-long-name'
timeline_1.set_new_status(tag_status)
public_chat_2 = self.home_2.get_chat_view()
public_chat_2.element_by_text(tag_status).wait_and_click()
public_chat_2.user_name_text.wait_for_element(30)
if not public_chat_2.user_name_text.text == tag_status:
self.errors.append('Could not redirect a user to a public chat tapping the tag message from timeline_1')
public_chat_2.back_button.click()
timeline_1.set_reaction(text_status)
status_with_reaction_1 = timeline_1.chat_element_by_text(text_status)
if status_with_reaction_1.emojis_below_message() != 1:
self.errors.append("Counter of reaction is not updated on your own status in timeline_1!")
self.home_2.home_button.double_click()
self.home_2.get_chat(self.username_1).click()
chat_2.chat_options.click()
chat_2.view_profile_button.click()
status_with_reaction_2 = chat_2.chat_element_by_text(text_status)
if status_with_reaction_2.emojis_below_message(own=False) != 1:
self.errors.append("Counter of reaction is not updated on status of another user in profile!")
self.home_1.just_fyi("Remove reaction and check it is updated for both users")
timeline_1.set_reaction(text_status)
status_with_reaction_1 = timeline_1.chat_element_by_text(text_status)
if status_with_reaction_1.emojis_below_message() != 0:
self.errors.append(
"Counter of reaction is not updated after removing reaction on your own status in timeline_1!")
status_with_reaction_2 = chat_2.chat_element_by_text(text_status)
if status_with_reaction_2.emojis_below_message(own=False) != 0:
self.errors.append(
"Counter of reaction is not updated after removing on status of another user in profile!")
self.home_1.just_fyi("Remove user from contacts and check there is no his status in timeline_1 anymore")
chat_2.remove_from_contacts.click()
chat_2.close_button.click()
chat_2.status_button.click()
if public_chat_2.chat_element_by_text(text_status).is_element_displayed(10):
self.errors.append("Statuses of removed user are still shown in profile")
self.errors.verify_no_errors()
@pytest.mark.xdist_group(name="chat_medium_2") @pytest.mark.xdist_group(name="chat_medium_2")
@marks.medium @marks.medium
class TestChatMultipleDevice(MultipleSharedDeviceTestCase): class TestChatMultipleDevice(MultipleSharedDeviceTestCase):
@ -515,7 +675,7 @@ class TestChatMultipleDevice(MultipleSharedDeviceTestCase):
cls.message_1, cls.message_2, cls.message_3, cls.message_4 = "Message1", "Message2", "Message3", "Message4" cls.message_1, cls.message_2, cls.message_3, cls.message_4 = "Message1", "Message2", "Message3", "Message4"
@marks.testrail_id(702066) @marks.testrail_id(702066)
def test_chat_push_notifications_reaction_for_messages_sticker_audio_image(self): def test_chat_1_1_push_and_reaction_for_messages_sticker_audio_image(self):
# methods with steps to use later in loop # methods with steps to use later in loop
def navigate_to_start_state_of_both_devices(): def navigate_to_start_state_of_both_devices():
@ -593,7 +753,7 @@ class TestChatMultipleDevice(MultipleSharedDeviceTestCase):
self.errors.verify_no_errors() self.errors.verify_no_errors()
@marks.testrail_id(702069) @marks.testrail_id(702069)
def test_chat_can_pin_messages_in_1_1(self): def test_chat_1_1_pin_messages(self):
self.home_1.just_fyi("Check that Device1 can pin own message in 1-1 chat") self.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)
@ -655,7 +815,7 @@ class TestChatMultipleDevice(MultipleSharedDeviceTestCase):
self.drivers[0].fail("Message_4 is not unpinned!") self.drivers[0].fail("Message_4 is not unpinned!")
@marks.testrail_id(702065) @marks.testrail_id(702065)
def test_chat_markdown_support_in_public(self): def test_chat_public_markdown_support(self):
markdown = { markdown = {
'bold text in asterics': '**', 'bold text in asterics': '**',
'bold text in underscores': '__', 'bold text in underscores': '__',
@ -781,110 +941,6 @@ class TestChatMultipleDevice(MultipleSharedDeviceTestCase):
class TestPublicChatMultipleDevice(MultipleDeviceTestCase): class TestPublicChatMultipleDevice(MultipleDeviceTestCase):
@marks.testrail_id(6342)
@marks.medium
def test_different_status_in_timeline(self):
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_1, home_2 = device_1.create_user(), device_2.create_user()
profile_1, profile_2 = home_1.profile_button.click(), home_2.profile_button.click()
public_key_1, username_1 = profile_1.get_public_key_and_username(return_username=True)
emoji_message = random.choice(list(emoji.EMOJI_UNICODE))
emoji_unicode = emoji.EMOJI_UNICODE[emoji_message]
home_1.just_fyi('Set status in profile')
statuses = {
'*formatted text*': 'formatted text',
'https://www.youtube.com/watch?v=JjPWmEh2KhA': 'Status Town Hall',
emoji.emojize(emoji_message): emoji_unicode,
}
timeline_1 = device_1.status_button.click()
for status in statuses.keys():
timeline_1.set_new_status(status)
sleep(60)
timeline_1.element_by_translation_id("enable").wait_and_click()
timeline_1.element_by_translation_id("enable-all").wait_and_click()
timeline_1.close_modal_view_from_chat_button.click()
for status in statuses:
expected_value = statuses[status]
if not timeline_1.element_by_text_part(expected_value).is_element_displayed():
self.errors.append("Expected value %s is not shown" % expected_value)
text_status = 'some text'
timeline_1.set_new_status(status=text_status)
for timestamp in ('Now', '1M', '2M'):
if not timeline_1.element_by_text(timestamp).is_element_displayed():
self.errors.append("Expected timestamp %s is not shown in timeline_1" % timestamp)
home_2.just_fyi('Check that can see user status without adding him as contact')
profile_2.home_button.click()
chat_2 = home_2.add_contact(public_key_1, add_in_contacts=False)
chat_2.chat_options.click()
chat_2.view_profile_button.click()
chat_2.chat_element_by_text(text_status).wait_for_element(30)
chat_2.element_by_translation_id("enable").scroll_and_click()
chat_2.element_by_translation_id("enable-all").wait_and_click()
chat_2.close_modal_view_from_chat_button.click()
for status in statuses:
chat_2.element_by_text_part(statuses['*formatted text*']).scroll_to_element()
expected_value = statuses[status]
if not chat_2.element_by_text_part(expected_value).is_element_displayed():
self.errors.append(
"Expected value %s is not shown in other user profile without adding to contacts" % expected_value)
home_2.just_fyi('Add device1 to contacts and check that status will be shown in timeline_1')
chat_2.close_button.scroll_and_click(direction='up')
chat_2.add_to_contacts.click()
timeline_2 = chat_2.status_button.click()
for status in statuses:
expected_value = statuses[status]
if not timeline_2.element_by_text_part(expected_value).is_element_displayed():
self.errors.append(
"Expected value %s is not shown in timeline_1 after adding user to contacts" % expected_value)
profile_1.just_fyi('Checking message tag and reactions on statuses')
tag_status = '#public-chat-to-redirect-long-name'
timeline_1.set_new_status(tag_status)
public_chat_2 = home_2.get_chat_view()
public_chat_2.element_by_text(tag_status).wait_and_click()
public_chat_2.user_name_text.wait_for_element(30)
if not public_chat_2.user_name_text.text == tag_status:
self.errors.append('Could not redirect a user to a public chat tapping the tag message from timeline_1')
public_chat_2.back_button.click()
timeline_1.set_reaction(text_status)
status_with_reaction_1 = timeline_1.chat_element_by_text(text_status)
if status_with_reaction_1.emojis_below_message() != 1:
self.errors.append("Counter of reaction is not updated on your own status in timeline_1!")
device_2.home_button.double_click()
home_2.get_chat(username_1).click()
chat_2.chat_options.click()
chat_2.view_profile_button.click()
status_with_reaction_2 = chat_2.chat_element_by_text(text_status)
if status_with_reaction_2.emojis_below_message(own=False) != 1:
self.errors.append("Counter of reaction is not updated on status of another user in profile!")
profile_1.just_fyi("Remove reaction and check it is updated for both users")
timeline_1.set_reaction(text_status)
status_with_reaction_1 = timeline_1.chat_element_by_text(text_status)
if status_with_reaction_1.emojis_below_message() != 0:
self.errors.append(
"Counter of reaction is not updated after removing reaction on your own status in timeline_1!")
status_with_reaction_2 = chat_2.chat_element_by_text(text_status)
if status_with_reaction_2.emojis_below_message(own=False) != 0:
self.errors.append(
"Counter of reaction is not updated after removing on status of another user in profile!")
profile_1.just_fyi("Remove user from contacts and check there is no his status in timeline_1 anymore")
chat_2.remove_from_contacts.click()
chat_2.close_button.click()
chat_2.status_button.click()
if public_chat_2.chat_element_by_text(text_status).is_element_displayed(10):
self.errors.append("Statuses of removed user are still shown in profile")
self.errors.verify_no_errors()
@marks.testrail_id(700727) @marks.testrail_id(700727)
@marks.medium @marks.medium
def test_gap_in_public_chat_and_no_gap_in_1_1_and_group_chats(self): def test_gap_in_public_chat_and_no_gap_in_1_1_and_group_chats(self):

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

@ -98,7 +98,7 @@ class BaseElement(object):
while not desired_element.is_element_present(1) and counter <= attempts: while not desired_element.is_element_present(1) and counter <= attempts:
try: try:
self.find_element().click() self.find_element().click()
desired_element.wait_for_element(5) desired_element.is_element_present(5)
return self.navigate() return self.navigate()
except (NoSuchElementException, TimeoutException): except (NoSuchElementException, TimeoutException):
counter += 1 counter += 1
@ -115,7 +115,7 @@ class BaseElement(object):
.until(expected_conditions.presence_of_element_located((self.by, self.locator))) .until(expected_conditions.presence_of_element_located((self.by, self.locator)))
except TimeoutException: except TimeoutException:
raise TimeoutException( raise TimeoutException(
"Device `%s`: `%s` by` %s`: `%s` is not found on the screen" % ( "Device `%s`: `%s` by` %s`: `%s` is not found on the screen after wait_for_element" % (
self.driver.number, self.name, self.by, self.locator)) from None self.driver.number, self.name, self.by, self.locator)) from None
def wait_for_elements(self, seconds=10): def wait_for_elements(self, seconds=10):
@ -124,7 +124,7 @@ class BaseElement(object):
.until(expected_conditions.presence_of_all_elements_located((self.by, self.locator))) .until(expected_conditions.presence_of_all_elements_located((self.by, self.locator)))
except TimeoutException: except TimeoutException:
raise TimeoutException( raise TimeoutException(
"Device %s: %s by %s:`%s` is not found on the screen" % ( "Device %s: %s by %s:`%s` is not found on the screen after wait_for_elements" % (
self.driver.number, self.name, self.by, self.locator)) from None self.driver.number, self.name, self.by, self.locator)) from None
def wait_for_visibility_of_element(self, seconds=10, ignored_exceptions=None): def wait_for_visibility_of_element(self, seconds=10, ignored_exceptions=None):
@ -133,7 +133,7 @@ class BaseElement(object):
.until(expected_conditions.visibility_of_element_located((self.by, self.locator))) .until(expected_conditions.visibility_of_element_located((self.by, self.locator)))
except TimeoutException: except TimeoutException:
raise TimeoutException( raise TimeoutException(
"Device %s: %s by %s:`%s` is not found on the screen" % ( "Device %s: %s by %s:`%s` is not found on the screen after wait_for_visibility_of_element" % (
self.driver.number, self.name, self.by, self.locator)) from None self.driver.number, self.name, self.by, self.locator)) from None
def wait_for_invisibility_of_element(self, seconds=10): def wait_for_invisibility_of_element(self, seconds=10):
@ -141,7 +141,7 @@ class BaseElement(object):
return WebDriverWait(self.driver, seconds) \ return WebDriverWait(self.driver, seconds) \
.until(expected_conditions.invisibility_of_element_located((self.by, self.locator))) .until(expected_conditions.invisibility_of_element_located((self.by, self.locator)))
except TimeoutException: except TimeoutException:
raise TimeoutException("Device %s: %s by %s:* `%s` is still visible on the screen after %s seconds" % ( raise TimeoutException("Device %s: %s by %s: `%s` is still visible on the screen after %s seconds after wait_for_invisibility_of_element" % (
self.driver.number, self.name, self.by, self.locator, seconds)) from None self.driver.number, self.name, self.by, self.locator, seconds)) from None
def wait_for_element_text(self, text, wait_time=30): def wait_for_element_text(self, text, wait_time=30):

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

@ -565,8 +565,7 @@ class BaseView(object):
def share_via_messenger(self): def share_via_messenger(self):
self.driver.info("Sharing via messenger", device=False) self.driver.info("Sharing via messenger", device=False)
self.element_by_text_part("Direct share").wait_for_element() self.element_by_text('Messages').wait_and_click(40)
self.element_by_text('Messages').wait_and_click()
self.element_by_text('New message').wait_and_click() self.element_by_text('New message').wait_and_click()
self.send_as_keyevent('+0100100101') self.send_as_keyevent('+0100100101')
self.confirm() self.confirm()

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

@ -3,7 +3,7 @@ import dateutil.parser
import time import time
import re import re
from selenium.common.exceptions import NoSuchElementException from selenium.common.exceptions import NoSuchElementException, TimeoutException
from tests import emojis from tests import emojis
from time import sleep from time import sleep
@ -156,11 +156,10 @@ class ChatElementByText(Text):
timestamp_element = Text(self.driver, xpath="//*[@content-desc='message-timestamp']") timestamp_element = Text(self.driver, xpath="//*[@content-desc='message-timestamp']")
try: try:
self.sent_status_checkmark.wait_for_element(30) self.sent_status_checkmark.wait_for_element(30)
except NoSuchElementException: self.sent_status_checkmark.click_until_presence_of_element(timestamp_element)
return '' return timestamp_element.text
self.sent_status_checkmark.click_until_presence_of_element(timestamp_element) except (NoSuchElementException, TimeoutException):
return timestamp_element.text return None
@property @property
def member_photo(self): def member_photo(self):

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

@ -275,7 +275,7 @@ class WalletView(BaseView):
self.manage_assets_button.click() self.manage_assets_button.click()
for asset in args: for asset in args:
self.element_by_text(asset).scroll_to_element() self.element_by_text(asset).scroll_to_element()
self.element_by_text(asset).click() self.element_by_text(asset).scroll_and_click()
self.cross_icon.click() self.cross_icon.click()
def scan_tokens(self, *args): def scan_tokens(self, *args):