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

refactor group e2e + send_stt_in_1_1 + deleted obsolate e2e 

Signed-off-by: Churikova Tetiana <churikova.tm@gmail.com>
This commit is contained in:
Churikova Tetiana 2020-04-10 12:25:46 +02:00
parent 461b6cdb74
commit 966b6e5a33
No known key found for this signature in database
GPG Key ID: 0D4EA7B33B47E6D8
17 changed files with 428 additions and 617 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
test/appium/tests/atomic/account_management/test_create_account.py
View File

@ -15,7 +15,7 @@ class TestCreateAccount(SingleDeviceTestCase):
def test_switch_users_and_add_new_account(self):
sign_in = SignInView(self.driver)
sign_in.create_user()
public_key = sign_in.get_public_key()
public_key = sign_in.get_public_key_and_username()
profile = sign_in.get_profile_view()
profile.logout()
if sign_in.ok_button.is_element_displayed():
@ -31,7 +31,7 @@ class TestCreateAccount(SingleDeviceTestCase):
sign_in.next_button.click()
sign_in.lets_go_button.click()
if sign_in.get_public_key() == public_key:
if sign_in.get_public_key_and_username() == public_key:
self.driver.fail('New account was not created')
@marks.testrail_id(5379)

2
test/appium/tests/atomic/account_management/test_keycard.py
View File

@ -18,7 +18,7 @@ class TestCreateAccount(SingleDeviceTestCase):
wallet_view.set_up_wallet()
if wallet_view.status_account_total_usd_value.text != '0':
self.errors.append("Account USD value is not 0, it is %s" % wallet_view.status_account_total_usd_value.text)
public_key = sign_in.get_public_key()
public_key = sign_in.get_public_key_and_username()
profile = sign_in.get_profile_view()
default_username = profile.default_username_text.text
profile.logout()

24
test/appium/tests/atomic/account_management/test_profile.py
View File

@ -49,7 +49,7 @@ class TestProfileSingleDevice(SingleDeviceTestCase):
"syncing' selected!")
sign_in_view.just_fyi("Check that can join public chat and send message")
chat_name = sign_in_view.get_public_chat_name()
chat_name = sign_in_view.get_random_chat_name()
home = profile_view.get_back_to_home_view()
chat = home.join_public_chat(chat_name)
message = 'test message'
@ -289,7 +289,7 @@ class TestProfileSingleDevice(SingleDeviceTestCase):
recovery_phrase = " ".join(profile_view.get_recovery_phrase().values())
profile_view.back_button.click()
profile_view.back_button.click()
public_key = profile_view.get_public_key()
public_key = profile_view.get_public_key_and_username()
wallet_view = profile_view.wallet_button.click()
wallet_view.set_up_wallet()
address = wallet_view.get_wallet_address()
@ -303,7 +303,7 @@ class TestProfileSingleDevice(SingleDeviceTestCase):
if wallet_view.get_wallet_address() != address:
self.driver.fail("Seed phrase displayed in new accounts for back up does not recover respective address")
profile_view = wallet_view.profile_button.click()
if profile_view.get_public_key() != public_key:
if profile_view.get_public_key_and_username() != public_key:
self.driver.fail("Seed phrase displayed in new accounts for back up does not recover respective public key")
@marks.testrail_id(5433)
@ -510,8 +510,6 @@ class TestProfileSingleDevice(SingleDeviceTestCase):
@marks.testrail_id(5428)
@marks.low
@marks.skip
# TODO: skipped because of 10265
def test_version_format(self):
sign_in_view = SignInView(self.driver)
home_view = sign_in_view.create_user()
@ -526,7 +524,7 @@ class TestProfileSingleDevice(SingleDeviceTestCase):
profile_view.app_version_text.click()
profile_view.back_button.click()
profile_view.home_button.click()
chat = home_view.join_public_chat(home_view.get_public_chat_name())
chat = home_view.join_public_chat(home_view.get_random_chat_name())
message_input = chat.chat_message_input
message_input.paste_text_from_clipboard()
if message_input.text != app_version:
@ -614,7 +612,7 @@ class TestProfileMultipleDevice(MultipleDeviceTestCase):
self.create_drivers(2)
sign_in_1, sign_in_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_1, home_2 = sign_in_1.create_user(), sign_in_2.create_user()
public_key = home_2.get_public_key()
public_key = home_2.get_public_key_and_username()
profile_1, profile_2 = home_1.profile_button.click(), home_2.profile_button.click()
username_1, username_2 = profile_1.default_username_text.text, profile_2.default_username_text.text
@ -655,7 +653,7 @@ class TestProfileMultipleDevice(MultipleDeviceTestCase):
self.create_drivers(2)
sign_in_1, sign_in_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_1, home_2 = sign_in_1.create_user(), sign_in_2.create_user()
public_key = home_2.get_public_key()
public_key = home_2.get_public_key_and_username()
home_2.get_back_to_home_view()
profile_1 = home_1.profile_button.click()
@ -755,7 +753,7 @@ class TestProfileMultipleDevice(MultipleDeviceTestCase):
# TODO: blocked by 10065
# profile_1.home_button.click()
# home_2.just_fyi('send several messages to public channel')
# public_chat_name = home_2.get_public_chat_name()
# public_chat_name = home_2.get_random_chat_name()
# message = 'test_message'
# public_chat_2 = home_2.join_public_chat(public_chat_name)
# public_chat_2.chat_message_input.send_keys(message)
@ -889,9 +887,9 @@ class TestProfileMultipleDevice(MultipleDeviceTestCase):
device_1_profile.get_back_to_home_view()
device_1_name = 'device_%s' % device_1.driver.number
device_2_name = 'device_%s' % device_2.driver.number
public_chat_before_sync_name = 'b-public-%s' % device_1_home.get_public_chat_name()
public_chat_after_sync_name = 'a-public-%s' % device_1_home.get_public_chat_name()
group_chat_name = 'group-%s' % device_1_home.get_public_chat_name()
public_chat_before_sync_name = 'b-public-%s' % device_1_home.get_random_chat_name()
public_chat_after_sync_name = 'a-public-%s' % device_1_home.get_random_chat_name()
group_chat_name = 'group-%s' % device_1_home.get_random_chat_name()
message_after_sync = 'sent after sync'
device_1.just_fyi('join public chat, create group chat, edit user picture')
@ -981,7 +979,7 @@ class TestProfileMultipleDevice(MultipleDeviceTestCase):
profile_1.home_button.click()
home_2.just_fyi('joining same public chat, set ENS name and check it in chat from device2')
chat_name = home_1.get_public_chat_name()
chat_name = home_1.get_random_chat_name()
chat_2 = home_2.join_public_chat(chat_name)
chat_1 = home_1.join_public_chat(chat_name)
chat_1.get_back_to_home_view()

15
test/appium/tests/atomic/account_management/test_recover.py
View File

@ -73,7 +73,7 @@ class TestRecoverAccessFromSignInScreen(SingleDeviceTestCase):
},
]
# check that seed phrase is required (can't be empty)
recover_access_view.just_fyi("check that seed phrase is required (can't be empty)")
recover_access_view.enter_seed_phrase_button.click()
recover_access_view.next_button.click()
if recover_access_view.reencrypt_your_key_button.is_element_displayed():
@ -93,11 +93,11 @@ class TestRecoverAccessFromSignInScreen(SingleDeviceTestCase):
recover_access_view.send_as_keyevent(phrase)
# TODO: uncomment after 8567 fix
#if msg and not elm.is_element_displayed():
# TODO: still disabled because tooltips are not visible
# if msg and not elm.is_element_displayed():
# self.errors.append('"{}" message is not shown'.format(msg))
# check that words count is shown
recover_access_view.just_fyi('check that words count is shown')
if words_count == 1:
if not signin_view.element_by_text('%s word' % words_count):
self.errors.append('"%s word" is not shown ' % words_count)
@ -105,16 +105,15 @@ class TestRecoverAccessFromSignInScreen(SingleDeviceTestCase):
if not signin_view.element_by_text('%s words' % words_count):
self.errors.append('"%s words" is not shown ' % words_count)
# check that "Next" is disabled unless we use allowed count of words
recover_access_view.just_fyi('check that "Next" is disabled unless we use allowed count of words')
if words_count != 12 or 15 or 18 or 21 or 24:
recover_access_view.next_button.click()
if recover_access_view.reencrypt_your_key_button.is_element_displayed():
self.errors.append("Possible to create account with wrong count (%s) of words" % words_count)
# check behavior for popup "Custom seed phrase"
recover_access_view.just_fyi('check behavior for popup "Custom seed phrase"')
if popup:
text = 'Invalid seed phrase'
common_password = 'qwerty'
if not recover_access_view.find_full_text(text):
self.errors.append('"%s" text is not shown' % text)
recover_access_view.cancel_custom_seed_phrase_button.click()
@ -144,7 +143,7 @@ class TestRecoverAccessFromSignInScreen(SingleDeviceTestCase):
signin_view.recover_access(capitalized_passphrase)
profile_view = signin_view.profile_button.click()
username = profile_view.default_username_text.text
public_key = signin_view.get_public_key()
public_key = signin_view.get_public_key_and_username()
if username != user['username'] or public_key != user['public_key']:
self.driver.fail('Incorrect user was recovered')

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

@ -1,6 +1,6 @@
import time
from tests import marks, camera_access_error_text, get_current_time
from tests import marks, camera_access_error_text
from tests.users import basic_user, dummy_user
from tests.base_test_case import SingleDeviceTestCase, MultipleDeviceTestCase
from views.sign_in_view import SignInView
@ -110,7 +110,7 @@ class TestChatManagement(SingleDeviceTestCase):
chat.send_message_button.click()
chat.get_back_to_home_view()
chat.just_fyi('Deleting %s chat' % chat_name)
home.delete_chat_long_press(chat_name)
home.leave_chat_long_press(chat_name) if chat_name == group else home.delete_chat_long_press(chat_name)
home.relogin()
for chat_name in one_to_one, public, group:
if home.get_chat(chat_name).is_element_displayed():
@ -123,7 +123,7 @@ class TestChatManagement(SingleDeviceTestCase):
home = sign_in.create_user()
public_key = basic_user['public_key']
chat = home.join_public_chat(home.get_public_chat_name())
chat = home.join_public_chat(home.get_random_chat_name())
chat.chat_message_input.send_keys(public_key)
chat.send_message_button.click()
chat.chat_element_by_text(public_key).long_press_element()
@ -161,7 +161,7 @@ class TestChatManagement(SingleDeviceTestCase):
chat.chat_message_input.send_keys('test message')
chat.send_message_button.click()
chat.just_fyi('Deleting %s chat' % chat_name)
chat.delete_chat()
chat.leave_chat() if chat_name == group else chat.delete_chat()
chat.get_back_to_home_view()
for chat_name in one_to_one, public, group:
if home.get_chat(chat_name).is_element_displayed():
@ -211,7 +211,7 @@ class TestChatManagement(SingleDeviceTestCase):
home = sign_in.create_user()
search_list = list()
chat_name = home.get_public_chat_name()
chat_name = home.get_random_chat_name()
search_list.append(chat_name)
public_chat = home.join_public_chat(chat_name)
public_chat.get_back_to_home_view()
@ -281,7 +281,7 @@ class TestChatManagement(SingleDeviceTestCase):
chat_view.get_back_to_home_view(times_to_click_on_back_btn=1)
chat_view.just_fyi("Send and quote message in public chat")
public_chat_name = home.get_public_chat_name()
public_chat_name = home.get_random_chat_name()
home.join_public_chat(public_chat_name)
chat_view.send_message(message_to_quote_public)
chat_view.quote_message(message_to_quote_public)
@ -385,7 +385,7 @@ class TestChatManagementMultipleDevice(MultipleDeviceTestCase):
home_1, home_2 = device_1.create_user(), device_2.create_user()
device_1.just_fyi('both devices joining the same public chat and send messages')
chat_name = device_1.get_public_chat_name()
chat_name = device_1.get_random_chat_name()
for home in home_1, home_2:
home.join_public_chat(chat_name)
chat_public_1, chat_public_2 = home_1.get_chat_view(), home_2.get_chat_view()
@ -430,13 +430,13 @@ class TestChatManagementMultipleDevice(MultipleDeviceTestCase):
message_after_block_2 = "After block from %s" % device_2.driver.number
home_1, home_2 = device_1.create_user(), device_2.create_user()
profile_1 = home_1.profile_button.click()
device_2_public_key = home_2.get_public_key()
device_2_public_key = home_2.get_public_key_and_username()
home_2.get_back_to_home_view()
default_username_1 = profile_1.default_username_text.text
profile_1.get_back_to_home_view()
device_1.just_fyi('both devices joining the same public chat and send messages')
chat_name = device_1.get_public_chat_name()
chat_name = device_1.get_random_chat_name()
for home in home_1, home_2:
home.join_public_chat(chat_name)
chat_public_1, chat_public_2 = home_1.get_chat_view(), home_2.get_chat_view()
@ -527,7 +527,7 @@ class TestChatManagementMultipleDevice(MultipleDeviceTestCase):
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()
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()
@ -553,7 +553,7 @@ class TestChatManagementMultipleDevice(MultipleDeviceTestCase):
device_2_chat.back_button.click()
device_1.just_fyi('both devices joining the same public chat and send messages')
chat_name = device_1.get_public_chat_name()
chat_name = device_1.get_random_chat_name()
for home in home_1, home_2:
home.join_public_chat(chat_name)
chat_public_1, chat_public_2 = home_1.get_chat_view(), home_2.get_chat_view()

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

@ -137,28 +137,35 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
@marks.testrail_id(6263)
@marks.critical
def test_request_and_receive_stt_in_1_1_chat_offline(self):
recipient = transaction_recipients['C']
sender = transaction_senders['C']
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_1 = device_1.recover_access(passphrase=recipient['passphrase'])
home_2 = device_2.recover_access(passphrase=sender['passphrase'])
wallet_1, wallet_2 = home_1.wallet_button.click(), home_2.wallet_button.click()
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.set_up_wallet()
recipient_address = wallet_1.get_wallet_address()
wallet_1.back_button.click()
wallet_1.select_asset('STT')
wallet_1.home_button.click()
home_2 = device_2.recover_access(passphrase=sender['passphrase'])
wallet_2 = home_2.wallet_button.click()
wallet_2.set_up_wallet()
chat_1 = home_1.add_contact(sender['public_key'])
chat_1.send_message("Hey there!")
amount = chat_1.get_unique_amount()
asset_name = 'STT'
wallet_2.home_button.click()
chat_element = home_2.get_chat(recipient['username'])
chat_element.wait_for_visibility_of_element(30)
chat_2 = chat_element.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!")
amount = chat_2.get_unique_amount()
asset_name = 'STT'
profile_2 = wallet_2.profile_button.click()
profile_2.logout()
chat_element = home_1.get_chat(sender['username'])
chat_element.wait_for_visibility_of_element(30)
chat_1 = chat_element.click()
home_1.just_fyi('Request %s STT in 1-1 chat and check it is visible for sender and receiver' % amount)
chat_1.commands_button.click()
@ -171,15 +178,15 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
request_transaction.request_transaction_button.click()
chat_1_request_message = chat_1.chat_element_by_text('↓ Incoming transaction')
if not chat_1_request_message.is_element_displayed():
self.driver.fail('No incoming transaction in 1-1 chat is shown for recipient after requesting STT')
self.driver.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_status.wait_for_invisibility_of_element(30)
home_2.get_chat(recipient['username']).click()
home_2.get_chat(recipient_username).click()
chat_2_sender_message = chat_2.chat_element_by_text('↑ Outgoing transaction')
if not chat_2_sender_message.is_element_displayed():
self.driver.fail('No outgoing transaction in 1-1 chat is shown for sender after requesting STT')
self.driver.fail('No outgoing transaction in 1-1 chat is shown for sender after requesting STT')
if chat_2_sender_message.transaction_status.text != 'Address received':
self.errors.append('Wrong state is shown for outgoing transaction: "Address request accepted" is expected, '
'in fact %s ' % chat_2_sender_message.transaction_status.text)
@ -191,12 +198,12 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
chat_2.toggle_airplane_mode()
self.network_api.wait_for_confirmation_of_transaction(sender['address'], amount, confirmations=15, token=True)
chat_2.toggle_airplane_mode()
home_1.connection_status.wait_for_invisibility_of_element(30)
chat_2.connection_status.wait_for_invisibility_of_element(30)
if chat_2_sender_message.transaction_status.text != 'Confirmed':
self.errors.append('Wrong state is shown for outgoing transaction: "Confirmed" is expected, in fact'
' %s ' % chat_2_sender_message.transaction_status.text)
try:
self.network_api.find_transaction_by_unique_amount(recipient['address'], amount, token=True)
self.network_api.find_transaction_by_unique_amount(recipient_address[2:], amount, token=True)
except Failed as e:
self.errors.append(e.msg)
self.errors.verify_no_errors()
@ -252,7 +259,6 @@ class TestCommandsMultipleDevices(MultipleDeviceTestCase):
self.errors.verify_no_errors()
@marks.chat
@marks.transaction
class TestCommandsSingleDevices(SingleDeviceTestCase):

481
test/appium/tests/atomic/chats/test_group_chat.py
View File

@ -4,58 +4,6 @@ from tests.users import chat_users
from views.sign_in_view import SignInView
def return_left_chat_system_message(username):
return "%s left the group" % username
def return_created_chat_system_message(username, chat_name):
return "%s created the group %s" % (username, chat_name)
def return_joined_chat_system_message(username):
return "%s joined the group" % username
def return_made_admin_system_message(username):
return "%s has been made admin" % username
def create_users(driver_1, driver_2):
device_1_sign_in, device_2_sign_in = SignInView(driver_1), SignInView(driver_2)
return device_1_sign_in.create_user(), device_2_sign_in.create_user()
def get_username(device_home):
device_profile_view = device_home.profile_button.click()
username = device_profile_view.default_username_text.text
device_home.home_button.click()
return username
def create_new_group_chat(device_1_home, device_2_home, chat_name):
device_2_home.just_fyi('get public key and default username')
device_2_public_key = device_2_home.get_public_key()
device_2_default_username = get_username(device_2_home)
device_1_home.just_fyi('add device 2 as contact')
device_1_chat = device_1_home.add_contact(device_2_public_key)
device_1_chat.get_back_to_home_view()
device_1_home.just_fyi('create group chat with some user')
device_1_chat = device_1_home.create_group_chat([device_2_default_username], chat_name)
device_2_home.just_fyi('navigate to group chat')
device_2_chat = device_2_home.get_chat(chat_name).click()
return device_1_chat, device_2_chat
def create_and_join_group_chat(device_1_home, device_2_home, chat_name):
device_1_chat, device_2_chat = create_new_group_chat(device_1_home, device_2_home, chat_name)
device_2_chat.join_chat_button.click()
return device_1_chat, device_2_chat
@marks.chat
class TestGroupChatMultipleDevice(MultipleDeviceTestCase):
@ -63,36 +11,53 @@ class TestGroupChatMultipleDevice(MultipleDeviceTestCase):
@marks.high
def test_create_new_group_chat(self):
self.create_drivers(2)
device_1_home, device_2_home = create_users(self.drivers[0], self.drivers[1])
chat_name = device_1_home.get_public_chat_name()
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
device_1_home, device_2_home = device_1.create_user(), device_2.create_user()
device_1_key, device_1_username = device_1.get_public_key_and_username(True)
device_1.home_button.click()
chat_name = device_1_home.get_random_chat_name()
device_1_home.plus_button.click()
device_1_home.just_fyi('Check default placeholder when trying to create group chat without contacts')
device_1_home.new_group_chat_button.click()
if not device_1_home.element_by_text('Invite friends').is_element_displayed():
self.errors.append("No placeholder is shown when there are no contacts")
self.errors.append("No placeholder is shown when there are no contacts")
device_1_home.get_back_to_home_view()
device_1_chat, device_2_chat = create_and_join_group_chat(device_1_home, device_2_home, chat_name)
device_2.just_fyi('Create group chat with new user, check system messages for sender')
device_2_key, device_2_username = device_2.get_public_key_and_username(True)
device_2.home_button.click()
device_1_home.add_contact(device_2_key)
device_1_home.get_back_to_home_view()
device_1_chat = device_1_home.create_group_chat([device_2_username], chat_name)
create_system_message = device_1_chat.create_system_message(device_1_username, chat_name)
invite_system_message = device_1_chat.invite_system_message(device_1_username, device_2_username)
join_system_message = device_1_chat.join_system_message(device_2_username)
create_for_admin_system_message = device_1_chat.create_for_admin_system_message(chat_name)
for message in [create_for_admin_system_message, create_system_message, invite_system_message]:
if not device_1_chat.chat_element_by_text(message):
self.errors.append('%s system message is not shown' % message)
device_2.just_fyi('Navigate to group chat, check system messages for member')
if not device_2_home.get_chat(chat_name).is_element_displayed():
self.drivers[0].fail('Group chat was not created!')
device_2_chat = device_2_home.get_chat(chat_name).click()
for element in device_2_chat.join_chat_button, device_2_chat.decline_invitation_button:
if not element.is_element_displayed():
self.drivers[0].fail('"Join Chat" or "Decline" is not shown for member of group chat')
for message in ['%s invited you to join the group %s' % (device_1_username, chat_name),
create_system_message, invite_system_message]:
if not device_2_chat.chat_element_by_text(message):
self.errors.append('%s system message is not shown' % message)
device_2.just_fyi('Join to group chat, check system messages and send messages to group chat')
device_2_chat.join_chat_button.click()
for chat in (device_1_chat, device_2_chat):
if chat.user_name_text.text != chat_name:
self.errors.append('Oops! Chat screen does not match the entered chat name %s' % chat_name)
self.errors.verify_no_errors()
@marks.testrail_id(3993)
@marks.critical
def test_send_message_in_group_chat(self):
self.create_drivers(2)
device_1_home, device_2_home = create_users(self.drivers[0], self.drivers[1])
chat_name = device_1_home.get_public_chat_name()
device_1_chat, device_2_chat = create_and_join_group_chat(device_1_home, device_2_home, chat_name)
if not chat.chat_element_by_text(join_system_message).is_element_displayed():
self.errors.append('System message after joining group chat is not shown')
for chat in (device_1_chat, device_2_chat):
chat.send_message("Message from device: %s" % chat.driver.number)
for chat in (device_1_chat, device_2_chat):
for chat_driver in (device_1_chat, device_2_chat):
if not chat.chat_element_by_text(
@ -101,228 +66,248 @@ class TestGroupChatMultipleDevice(MultipleDeviceTestCase):
self.errors.verify_no_errors()
@marks.testrail_id(5674)
@marks.high
def test_group_chat_system_messages(self):
self.create_drivers(2)
device_1_home, device_2_home = create_users(self.drivers[0], self.drivers[1])
chat_name = device_1_home.get_public_chat_name()
device_1_default_username = get_username(device_1_home)
device_2_default_username = get_username(device_2_home)
device_1_chat, device_2_chat = create_and_join_group_chat(device_1_home, device_2_home, chat_name)
# device 2: delete group chat
device_2_chat = device_2_home.get_chat(chat_name).click()
device_2_chat.delete_chat()
# device 1: check system messages in the group chat
system_messages = [
return_created_chat_system_message(device_1_default_username, chat_name),
return_joined_chat_system_message(device_2_default_username),
return_left_chat_system_message(device_2_default_username)
]
for message in system_messages:
if not device_1_chat.chat_element_by_text(message).is_element_displayed():
self.errors.append("Message with test '%s' was not received" % message)
self.errors.verify_no_errors()
@marks.testrail_id(3997)
@marks.high
def test_delete_group_chat_via_delete_button(self):
message_from_device_1 = 'Hello from device 1'
message_from_device_2 = 'Hi there! Sent from device 2'
@marks.medium
def test_leave_group_chat_via_group_info(self):
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
device_1_home, device_2_home = device_1.create_user(), device_2.create_user()
chat_name = device_1_home.get_random_chat_name()
device_1_home, device_2_home = create_users(self.drivers[0], self.drivers[1])
chat_name = device_1_home.get_public_chat_name()
device_1_chat, device_2_chat = create_and_join_group_chat(device_1_home, device_2_home, chat_name)
device_2.just_fyi('Create and join group chat')
device_2_key, device_2_username = device_2.get_public_key_and_username(True)
device_2.home_button.click()
device_1_home.add_contact(device_2_key)
device_1_home.get_back_to_home_view()
device_1_chat = device_1_home.create_group_chat([device_2_username], chat_name)
left_system_message = device_1_chat.leave_system_message(device_2_username)
device_2_chat = device_2_home.get_chat(chat_name).click()
device_2_chat.join_chat_button.click()
# send some messages and delete chat
device_1_chat.send_message(message_from_device_1)
device_2_chat.send_message(message_from_device_2)
device_1_chat.delete_chat()
device_2_chat.send_message(message_from_device_2)
# device_1: check if chat is was deleted
if device_1_home.element_by_text(chat_name).is_element_displayed():
self.errors.append("Group chat '%s' is shown, but the chat has been deleted" % chat_name)
device_2.just_fyi('Send several message and leave chat')
for chat in device_1_chat, device_2_chat:
chat.send_message('sent before leaving')
device_2_chat.leave_chat_via_group_info()
if not device_1_chat.chat_element_by_text(left_system_message).is_element_displayed():
self.errors.append('No system message after user left the group chat')
if device_2_home.element_by_text(chat_name).is_element_displayed():
self.errors.append("Group chat '%s' is shown, but user has left" % chat_name)
device_2.just_fyi('Send message after user is left and check that it is not reappeared')
message = 'sent after leaving'
device_1_chat.send_message(message)
if device_2_home.element_by_text(chat_name).is_element_displayed():
self.errors.append("Group chat '%s' reappeared when new message is sent" % chat_name)
self.errors.verify_no_errors()
@marks.testrail_id(3998)
@marks.high
def test_add_new_group_chat_member(self):
message_for_device_2 = 'This message should be visible for device 2'
def test_offline_add_new_group_chat_member(self):
message_before_adding = 'message before adding new user'
message_after_adding = 'message after adding new user'
chat_member = chat_users['A']
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
device_1_home, device_2_home = device_1.create_user(), device_2.create_user()
device_1_key, device_1_username = device_1.get_public_key_and_username(True)
device_1_home.home_button.click()
chat_name = device_1_home.get_random_chat_name()
# create accounts on each device
device_1_home, device_2_home = create_users(self.drivers[0], self.drivers[1])
chat_name = device_1_home.get_public_chat_name()
# device 2: get public key and default username
device_2_public_key = device_2_home.get_public_key()
device_2_default_username = get_username(device_2_home)
# device 1: add contacts
device_1_home.add_contact(chat_member['public_key'])
device_1_home.get_back_to_home_view()
device_1_chat = device_1_home.add_contact(device_2_public_key)
device_1_chat.get_back_to_home_view()
# device 1: create group chat with some user
device_2.just_fyi('Create group chat with some user')
device_2_key, device_2_username = device_2.get_public_key_and_username(True)
device_2.home_button.click()
for key in chat_member['public_key'], device_2_key:
device_1_home.add_contact(key)
device_1_home.get_back_to_home_view()
device_1_chat = device_1_home.create_group_chat([chat_member['username']], chat_name)
device_1_chat.send_message(message_before_adding)
# device 1: add device 2 as a new member of the group chat
device_1_chat.add_members_to_group_chat([device_2_default_username])
# device 2: open the chat
device_2.just_fyi('Put member device to offline and check that invite will be fetched')
invite_system_message = device_1_chat.invite_system_message(device_1_username,chat_member['username'])
device_2_home.toggle_airplane_mode()
device_1_chat.add_members_to_group_chat([device_2_username])
device_2_home.toggle_airplane_mode()
device_2_home.connection_status.wait_for_invisibility_of_element(60)
if not device_2_home.get_chat(chat_name).is_element_displayed():
self.driver[0].fail('Invite to group chat was not fetched from offline')
device_2_chat = device_2_home.get_chat(chat_name).click()
if not device_2_chat.element_by_text(invite_system_message).is_element_displayed():
self.errors.append('Message about adding first chat member is not shown for new added member')
if device_2_chat.element_by_text(message_before_adding).is_element_displayed():
self.errors.append('Message sent before adding user is shown')
device_2.just_fyi('Put admin device to offline and check that message from new member will be fetched')
device_1_chat.toggle_airplane_mode()
device_2_chat.join_chat_button.click()
device_2_chat.send_message(message_after_adding)
device_1_chat.toggle_airplane_mode()
device_1_chat.connection_status.wait_for_invisibility_of_element(60)
for chat in (device_2_chat, device_1_chat):
if not chat.chat_element_by_text(message_after_adding).is_element_displayed(20):
self.errors.append('Message sent after adding new member is not shown!')
# device 1: send a message that should be visible for device 2
device_1_chat.send_message(message_for_device_2)
if not device_2_chat.chat_element_by_text(message_for_device_2).is_element_displayed(30):
self.errors.append('Message that was sent after device 2 has joined is not visible')
self.errors.verify_no_errors()
@marks.testrail_id(5756)
@marks.high
@marks.medium
def test_decline_invitation_to_group_chat(self):
self.create_drivers(2)
message_for_device_2 = 'This message should not be visible for device 2'
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
device_1_home, device_2_home = device_1.create_user(), device_2.create_user()
chat_name = device_1_home.get_random_chat_name()
device_1_home.plus_button.click()
device_1_home, device_2_home = create_users(self.drivers[0], self.drivers[1])
chat_name = device_1_home.get_public_chat_name()
device_1_chat, device_2_chat = create_new_group_chat(device_1_home, device_2_home, chat_name)
device_2_chat.decline_invitation_button.click()
device_2.just_fyi('Create group chat with new user')
device_2_key, device_2_username = device_2.get_public_key_and_username(True)
device_2.home_button.click()
device_1_home.add_contact(device_2_key)
device_1_home.get_back_to_home_view()
device_1_chat = device_1_home.create_group_chat([device_2_username], chat_name)
device_2_chat = device_2_home.get_chat(chat_name).click()
device_2_chat.decline_invitation_button.click()
left_system_message = device_2_chat.leave_system_message(device_2_username)
if not device_1_chat.chat_element_by_text(left_system_message).is_element_displayed():
self.errors.append('No system message after user left the group chat')
if device_2_home.element_by_text(chat_name).is_element_displayed():
self.errors.append("Group chat '%s' is shown, but user has left" % chat_name)
# device 2: check that chat is deleted
if device_2_home.element_by_text(chat_name).is_element_displayed():
self.errors.append("Group chat '%s' is shown, but the chat has been deleted" % chat_name)
device_2.just_fyi('Send message after invite is declined and check that it is not reappeared')
message = 'sent after leaving'
device_1_chat.send_message(message)
if device_2_home.element_by_text(chat_name).is_element_displayed():
self.errors.append("Group chat '%s' reappeared when new message is sent" % chat_name)
# device 1: check system message about leaving a group chat
device_2_default_username = get_username(device_2_home)
user2_left_chat_system_message = return_left_chat_system_message(device_2_default_username)
if not device_1_chat.chat_element_by_text(user2_left_chat_system_message).is_element_displayed():
self.errors.append("Message with text '%s' was not received" % user2_left_chat_system_message)
# device 1: send some message to group chat
device_1_chat.send_message(message_for_device_2)
# device 2: check that chat doesn't reappear
if device_2_home.element_by_text(chat_name).is_element_displayed():
self.errors.append("Group chat '%s' is shown, but the chat has been deleted" % chat_name)
self.errors.verify_no_errors()
self.errors.verify_no_errors()
@marks.testrail_id(4001)
@marks.high
@marks.skip
# TODO:should be retested after fix 10054
@marks.medium
def test_remove_member_from_group_chat(self):
self.create_drivers(2)
message_for_device_2 = 'This message should not be visible for device 2'
self.create_drivers(3)
devices_home, devices_key, devices_username, devices_chat = {}, {}, {}, {}
for key in self.drivers:
sign_in_view = SignInView(self.drivers[key])
devices_home[key] = sign_in_view.create_user()
devices_key[key], devices_username[key] = sign_in_view.get_public_key_and_username(True)
sign_in_view.home_button.click()
device_1_home, device_2_home = create_users(self.drivers[0], self.drivers[1])
chat_name = device_1_home.get_public_chat_name()
device_1_chat, device_2_chat = create_and_join_group_chat(device_1_home, device_2_home, chat_name)
device_2_default_username = get_username(device_2_home)
user2_left_chat_system_message = return_left_chat_system_message(device_2_default_username)
chat_name = devices_home[0].get_random_chat_name()
for i in range(1,3):
devices_home[0].add_contact(devices_key[i])
devices_home[0].get_back_to_home_view()
devices_chat[0] = devices_home[0].create_group_chat([devices_username[1],
devices_username[2]], chat_name)
# device 1: get options for device 2 in group chat and remove him
options = device_1_chat.get_user_options(device_2_default_username)
devices_chat[0].just_fyi('Member_1, member_2: both users join to group chat')
for i in range(1,3):
devices_chat[i] = devices_home[i].get_chat(chat_name).click()
devices_chat[i].join_chat_button.click()
devices_chat[0].just_fyi("Admin: get options for device 2 in group chat and remove him")
options = devices_chat[0].get_user_options(devices_username[1])
options.remove_user_button.click()
left_message = devices_chat[0].leave_system_message(devices_username[1])
for key in devices_chat:
if not devices_chat[key].chat_element_by_text(left_message).is_element_displayed():
self.errors.append("Message with text '%s' was not received" % left_message)
# device 1, 2: check system messages after removing
for chat in device_1_chat, device_2_chat:
if not chat.chat_element_by_text(user2_left_chat_system_message).is_element_displayed():
self.errors.append(
"Message with text '%s' was not received" % user2_left_chat_system_message)
# device 2: check there is no message input so user can't send new message in group chat
if device_2_chat.chat_message_input.is_element_displayed():
devices_chat[0].just_fyi("Check that input field is not available after removing")
if devices_chat[1].chat_message_input.is_element_displayed():
self.errors.append("Message input is still available for removed user")
# device 1: send some message to group chat
device_1_chat.send_message(message_for_device_2)
# device 2: check that message is not received
if device_2_chat.chat_element_by_text(message_for_device_2).is_element_displayed():
self.errors.append("Message with text '%s' was received" % message_for_device_2)
devices_chat[0].just_fyi("Send message and check that it is available only for remaining users")
message = 'after removing member'
devices_chat[0].send_message(message)
for chat in (devices_chat[0], devices_chat[2]):
if not chat.chat_element_by_text(message).is_element_displayed():
self.errors.append("Message '%s' was not received after removing member" % message)
if devices_chat[1].chat_element_by_text(message).is_element_displayed():
self.errors.append("Message '%s' was received by removed member" % message)
self.errors.verify_no_errors()
@marks.testrail_id(5694)
@marks.high
@marks.medium
def test_make_admin_member_of_group_chat(self):
self.create_drivers(2)
chat_member = chat_users['A']
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
device_1_home, device_2_home = device_1.create_user(), device_2.create_user()
device_1_key, device_1_username = device_1.get_public_key_and_username(True)
device_1.home_button.click()
chat_name = device_1_home.get_random_chat_name()
device_1_home, device_2_home = create_users(self.drivers[0], self.drivers[1])
chat_name = device_1_home.get_public_chat_name()
device_2_default_username = get_username(device_2_home)
device_2.just_fyi('Create and join to group chat')
device_2_key, device_2_username = device_2.get_public_key_and_username(True)
device_2.home_button.click()
device_1_home.add_contact(device_2_key)
device_1_home.get_back_to_home_view()
device_1_chat = device_1_home.create_group_chat([device_2_username], chat_name)
device_2_chat = device_2_home.get_chat(chat_name).click()
device_2_chat.join_chat_button.click()
# device 2: add contacts
device_2_home.add_contact(chat_member['public_key'])
device_2_home.get_back_to_home_view()
device_1.just_fyi('Check group info view and options of users')
device_1_chat.chat_options.click()
group_info_view = device_1_chat.group_info.click()
if not group_info_view.user_admin(device_1_username).is_element_displayed():
self.errors.append("Admin user is not marked as admin")
group_info_view.get_user_from_group_info(device_1_username).click()
if device_1_chat.profile_block_contact.is_element_displayed():
self.errors.append("Admin is redirected to own profile on tapping own username from group info")
group_info_view.get_user_from_group_info(device_2_username).click()
if not device_1_chat.profile_block_contact.is_element_displayed():
self.errors.append("Admin is not redirected to user profile on tapping member username from group info")
device_1_chat.back_button.click()
# create and join group chat
device_1_chat, device_2_chat = create_and_join_group_chat(device_1_home, device_2_home, chat_name)
# device 1: get options for device 2 in group chat and make him admin
options = device_1_chat.get_user_options(device_2_default_username)
device_1.just_fyi('Made admin another user and check system message')
options = group_info_view.get_username_options(device_2_username).click()
options.make_admin_button.click()
# device 2: check presence of system message
# TODO: should be reworked after https://github.com/status-im/status-react/pull/8487: replaced with default username
# user2_made_admin_system_message_for_user_2 = return_made_admin_system_message(device_2_custom_username)
# if not device_2_chat.chat_element_by_text(user2_made_admin_system_message_for_user_2).is_element_displayed():
# self.errors.append("Message with test '%s' was not received" % user2_made_admin_system_message_for_user_2)
# device 2: check that as admin can add new members to group chat
device_2_chat.add_members_to_group_chat([chat_member['username']])
self.errors.verify_no_errors()
@marks.testrail_id(5681)
@marks.high
def test_clear_history_of_group_chat_via_group_view(self):
self.create_drivers(2)
device_1_home, device_2_home = create_users(self.drivers[0], self.drivers[1])
chat_name = device_1_home.get_public_chat_name()
# create and join group chat
device_1_chat, device_2_chat = create_and_join_group_chat(device_1_home, device_2_home, chat_name)
messages = []
# device 1, device 2: send messages and clear history on device 1
admin_system_message = device_1_chat.has_been_made_admin_system_message(device_1_username, device_2_username)
for chat in (device_1_chat, device_2_chat):
message = "Message from device: %s" % chat.driver.number
chat.send_message(message)
messages.append(message)
if not chat.chat_element_by_text(admin_system_message).is_element_displayed():
self.errors.append("Message with test '%s' was not received" % admin_system_message)
device_1_chat.clear_history_via_group_info()
# device 1: check that history is deleted
for message in messages:
if device_1_chat.element_starts_with_text(message).is_element_present():
device_1_chat.driver.fail(
"Message '%s' is shown after re-login, but group chat history has been cleared" % message)
device_1_home.relogin()
device_1_home.element_by_text(chat_name).click()
for message in messages:
if device_1_chat.element_starts_with_text(message).is_element_present():
device_1_chat.driver.fail(
"Message '%s' is shown after re-login, but group chat history has been cleared" % message)
device_2.just_fyi('Check Admin in group info and that "add members" is available')
device_2_chat.chat_options.click()
group_info_view = device_2_chat.group_info.click()
for username in (device_1_username, device_2_username):
if not group_info_view.user_admin(username).is_element_displayed():
self.errors.append("Admin user is not marked as admin")
if not group_info_view.add_members.is_element_displayed():
self.errors.append("Add member button is not available for new admin")
self.errors.verify_no_errors()
@marks.testrail_id(6280)
@marks.medium
def test_rename_group_chat(self):
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
device_1_home, device_2_home = device_1.create_user(), device_2.create_user()
device_1_key, device_1_username = device_1.get_public_key_and_username(True)
device_1.home_button.click()
initial_chat_name = device_1_home.get_random_chat_name()
device_2.just_fyi('Create and join group chat')
device_2_key, device_2_username = device_2.get_public_key_and_username(True)
device_2.home_button.click()
device_1_home.add_contact(device_2_key)
device_1_home.get_back_to_home_view()
device_1_chat = device_1_home.create_group_chat([device_2_username], initial_chat_name)
device_2_chat = device_2_home.get_chat(initial_chat_name).click()
device_2_chat.join_chat_button.click()
device_2.just_fyi('Rename chat and check system messages')
new_chat_name = device_1_chat.get_random_chat_name()
device_1_chat.rename_chat_via_group_info(new_chat_name)
for chat in (device_1_chat, device_2_chat):
if not chat.element_by_text(chat.create_system_message(device_1_username, initial_chat_name)).is_element_displayed():
self.errors.append('Initial system message about creating chta was changed!')
if not chat.element_by_text(chat.changed_group_name_system_message(device_1_username, new_chat_name)).is_element_displayed():
self.errors.append('Message about changing chat name is not shown')
device_2.just_fyi('Check that you can navigate to renamed chat')
device_2_chat.back_button.click()
device_2_home.get_chat(new_chat_name).click()
self.errors.verify_no_errors()

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

@ -23,7 +23,7 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
profile_1 = device_1_home.profile_button.click()
default_username_1 = profile_1.default_username_text.text
device_1_home = profile_1.get_back_to_home_view()
device_2_public_key = device_2_home.get_public_key()
device_2_public_key = device_2_home.get_public_key_and_username()
device_2_home.home_button.click()
device_1_chat = device_1_home.add_contact(device_2_public_key)
@ -41,7 +41,7 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
self.create_drivers(2)
sign_in_1, sign_in_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_1, home_2 = sign_in_1.create_user(), sign_in_2.create_user()
public_key_1 = home_1.get_public_key()
public_key_1 = home_1.get_public_key_and_username()
home_1.home_button.click()
home_1.toggle_airplane_mode() # airplane mode on primary device
@ -86,7 +86,7 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
profile_1 = home_1.profile_button.click()
default_username_1 = profile_1.default_username_text.text
home_1 = profile_1.get_back_to_home_view()
public_key_2 = home_2.get_public_key()
public_key_2 = home_2.get_public_key_and_username()
profile_2 = home_2.get_profile_view()
profile_2.switch_network('Mainnet with upstream RPC')
@ -98,7 +98,7 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
chat_2 = home_2.get_chat(default_username_1).click()
chat_2.chat_element_by_text(message).wait_for_visibility_of_element()
public_chat_name = home_1.get_public_chat_name()
public_chat_name = home_1.get_random_chat_name()
chat_1.get_back_to_home_view()
home_1.join_public_chat(public_chat_name)
chat_2.get_back_to_home_view()
@ -125,7 +125,7 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
# profile_1.edit_profile_picture('sauce_logo.png')
# profile_1.home_button.click()
device_2_public_key = device_2_home.get_public_key()
device_2_public_key = device_2_home.get_public_key_and_username()
device_2_home.home_button.click()
device_1_chat = device_1_home.add_contact(device_2_public_key)
@ -162,7 +162,7 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
default_username_1 = profile_1.default_username_text.text
device_1_home = profile_1.get_back_to_home_view()
device_2_public_key = device_2_home.get_public_key()
device_2_public_key = device_2_home.get_public_key_and_username()
profile_2 = device_2_home.get_profile_view()
# TODO: skip until edit image profile is enabled
# file_name = 'sauce_logo.png'
@ -208,7 +208,7 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
profile_1 = home_1.profile_button.click()
default_username_1 = profile_1.default_username_text.text
home_1 = profile_1.get_back_to_home_view()
public_key_2 = home_2.get_public_key()
public_key_2 = home_2.get_public_key_and_username()
home_2.home_button.click()
chat_1 = home_1.add_contact(public_key_2)
@ -263,7 +263,7 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
profile_2 = device_2_home.profile_button.click()
default_username_2 = profile_2.default_username_text.text
device_2_home = profile_2.get_back_to_home_view()
device_1_public_key = device_1_home.get_public_key()
device_1_public_key = device_1_home.get_public_key_and_username()
device_1_home.home_button.click()
device_2_chat = device_2_home.add_contact(device_1_public_key)
@ -299,7 +299,7 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
profile_2 = device_2_home.profile_button.click()
default_username_2 = profile_2.default_username_text.text
device_2_home = profile_2.get_back_to_home_view()
device_1_public_key = device_1_home.get_public_key()
device_1_public_key = device_1_home.get_public_key_and_username()
device_1_home.home_button.click()
device_2_chat = device_2_home.add_contact(device_1_public_key)
@ -330,7 +330,7 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
device_1_chat.get_back_to_home_view()
device_2_chat.get_back_to_home_view()
chat_name = device_1_home.get_public_chat_name()
chat_name = device_1_home.get_random_chat_name()
device_1_home.join_public_chat(chat_name)
device_2_home.join_public_chat(chat_name)
@ -353,7 +353,7 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
self.create_drivers(2)
sign_in_1, sign_in_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
device_1_home, device_2_home = sign_in_1.create_user(), sign_in_2.create_user()
device_2_public_key = device_2_home.get_public_key()
device_2_public_key = device_2_home.get_public_key_and_username()
device_2_home.home_button.click()
device_1_profile = device_1_home.profile_button.click()
default_username_1 = device_1_profile.default_username_text.text
@ -382,7 +382,7 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
# chat.verify_message_is_under_today_text(message, self.errors)
device_1_chat.just_fyi('check user picture and timestamps in chat for sender and recipient in public chat')
chat_name = device_1_home.get_public_chat_name()
chat_name = device_1_home.get_random_chat_name()
for chat in device_1_chat, device_2_chat:
home_view = chat.get_back_to_home_view()
home_view.join_public_chat(chat_name)
@ -405,74 +405,6 @@ class TestMessagesOneToOneChatMultiple(MultipleDeviceTestCase):
self.errors.verify_no_errors()
@marks.testrail_id(5405)
@marks.high
@marks.skip
# TODO: temporary skipped due to 8601
def test_fiat_value_is_correctly_calculated_on_recipient_side(self):
sender = transaction_senders['Y']
recipient = transaction_recipients['I']
self.create_drivers(2)
signin_view1, signin_view2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_view1, home_view2 = signin_view1.recover_access(sender['passphrase']), signin_view2.recover_access(
recipient['passphrase'])
devices = [
{'home_view': home_view1, 'currency': 'AUD'},
{'home_view': home_view2, 'currency': 'EUR'},
]
# changing currency for both devices
for device in devices:
wallet_view = device['home_view'].wallet_button.click()
wallet_view.set_up_wallet()
wallet_view.set_currency(device['currency'])
wallet_view.get_back_to_home_view()
device1 = devices[0]
device2 = devices[1]
# setting up device1 wallet
# wallet1 = device1['home_view'].wallet_button.click()
# wallet1.get_back_to_home_view()
# sending ETH to device2 in 1*1 chat
device1_chat = device1['home_view'].add_contact(recipient['public_key'])
send_amount = device1_chat.get_unique_amount()
device1_chat.send_transaction_in_1_1_chat('ETHro', send_amount)
sent_message = device1_chat.chat_element_by_text(send_amount)
if not sent_message.is_element_displayed() and not sent_message.contains_text(device1['currency']):
self.errors.append('Wrong currency fiat value while sending ETH in 1*1 chat.')
device2_chat = device2['home_view'].get_chat_with_user(sender['username']).click()
received_message = device2_chat.chat_element_by_text(send_amount)
if not received_message.is_element_displayed() and not received_message.contains_text(device2['currency']):
self.errors.append('Wrong currency fiat value while receiving ETH in 1*1 chat.')
# Currently disabled because sending / requesting funds from wallet is not shown in chat
# device1_chat.get_back_to_home_view()
# wallet1 = device1['home_view'].wallet_button.click()
# send_amount = device1_chat.get_unique_amount()
# Send and request some ETH from wallet and check whether the fiat currency value of
# the new messages is equal to user-selected
# wallet1.send_transaction(asset_name='ETHro', recipient=recipient['username'], amount=send_amount)
# wallet1.get_back_to_home_view()
# device1_chat = device1['home_view'].get_chat(recipient['username']).click()
#
# sent_message = device1_chat.chat_element_by_text(send_amount)
# received_message = device2_chat.chat_element_by_text(send_amount)
#
# if not sent_message.is_element_displayed() and not sent_message.contains_text(device1['currency']):
# self.errors.append('Wrong currency fiat value while sending ETH from wallet.')
#
# if not received_message.is_element_displayed() and not sent_message.contains_text(device2['currency']):
# self.errors.append('Wrong currency fiat value while receiving ETH sent via wallet.')
self.errors.verify_no_errors()
@marks.all
@marks.chat
@ -541,7 +473,7 @@ class TestMessagesOneToOneChatSingle(SingleDeviceTestCase):
sign_in = SignInView(self.driver)
home = sign_in.create_user()
home.join_public_chat(home.get_public_chat_name())
home.join_public_chat(home.get_random_chat_name())
chat = sign_in.get_chat_view()
emoji_name = random.choice(list(emoji.EMOJI_UNICODE))
emoji_unicode = emoji.EMOJI_UNICODE[emoji_name]
@ -560,96 +492,6 @@ class TestMessagesOneToOneChatSingle(SingleDeviceTestCase):
self.errors.append('Message with emoji was not sent in 1-1 chat')
self.errors.verify_no_errors()
@marks.testrail_id(5393)
@marks.high
@marks.skip
# TODO: temporary skipped due to 8601
def test_that_fiat_value_is_correct_for_token_transactions(self):
sender_passphrase = transaction_senders['X']['passphrase']
recipient_public_key = transaction_recipients['H']['public_key']
recipient_user_name = transaction_recipients['H']['username']
default_currency = 'USD'
user_currency = 'EUR'
sigin_view = SignInView(self.driver)
home_view = sigin_view.recover_access(sender_passphrase)
wallet = home_view.wallet_button.click()
wallet.set_up_wallet()
wallet.get_back_to_home_view()
chat = home_view.add_contact(recipient_public_key)
send_amount, request_amount = [chat.get_unique_amount() for _ in range(2)]
# Send and request some tokens in 1x1 chat and check whether the fiat currency value of the messages is equal
# to default
chat.send_transaction_in_1_1_chat('STT', send_amount)
chat.request_transaction_in_1_1_chat('STT', request_amount)
send_message = chat.chat_element_by_text(send_amount)
if not send_message.is_element_displayed() and not send_message.contains_text(default_currency):
self.errors.append('Wrong fiat value while sending assets in 1-1 chat with default currency.')
request_message = chat.chat_element_by_text(request_amount)
if not request_message.is_element_displayed() and not request_message.contains_text(default_currency):
self.errors.append('Wrong fiat value while requesting assets in 1-1 chat with default currency.')
chat.get_back_to_home_view()
# Switch default currency to user-selected
wallet_view = sigin_view.wallet_button.click()
wallet_view.set_currency(user_currency)
wallet_view.get_back_to_home_view()
chat = home_view.get_chat(recipient_user_name).click()
# Check whether the fiat currency value of the messages sent is not changed to user-selected
send_message = chat.chat_element_by_text(send_amount)
if not send_message.is_element_displayed() and not send_message.contains_text(default_currency):
self.errors.append('Wrong fiat value while sending assets in 1-1 chat with default currency.')
request_message = chat.chat_element_by_text(request_amount)
if not request_message.is_element_displayed() and not request_message.contains_text(default_currency):
self.errors.append('Wrong fiat value while requesting assets in 1-1 chat with default currency.')
# Send and request some tokens in 1x1 chat and check whether the fiat currency value of
# the new messages is equal to user-selected
send_amount, request_amount = [chat.get_unique_amount() for _ in range(2)]
chat.send_transaction_in_1_1_chat('STT', send_amount)
chat.request_transaction_in_1_1_chat('STT', request_amount)
send_message = chat.chat_element_by_text(send_amount)
if not send_message.is_element_displayed() and not send_message.contains_text(user_currency):
self.errors.append('Wrong fiat value while sending assets in 1-1 chat with user selected currency.')
request_message = chat.chat_element_by_text(request_amount)
if not request_message.is_element_displayed() and not request_message.contains_text(user_currency):
self.errors.append('Wrong fiat value while requesting assets in 1-1 chat with user selected currency.')
# disabled since after merge https://github.com/status-im/status-react/pull/8425 no messages are shown
# in 1-1 chat after sending from wallet
# chat.get_back_to_home_view()
#
# wallet = home_view.wallet_button.click()
# send_amount, request_amount = [chat.get_unique_amount() for _ in range(2)]
# Send and request some tokens from wallet and check whether the fiat currency value of
# the new messages is equal to user-selected
#
# wallet.send_transaction(asset_name='STT', recipient=recipient_user_name, amount=send_amount)
# wallet.receive_transaction(asset_name='STT', recipient=recipient_user_name, amount=request_amount)
#
# wallet.get_back_to_home_view()
# chat = home_view.get_chat(recipient_user_name).click()
#
# send_message = chat.chat_element_by_text(send_amount)
# if not send_message.is_element_displayed() and not send_message.contains_text(user_currency):
# self.errors.append('Wrong fiat value while sending assets from wallet with user selected currency.')
#
# request_message = chat.chat_element_by_text(request_amount)
# if not request_message.is_element_displayed() and not request_message.contains_text(user_currency):
# self.errors.append('Wrong fiat value while requesting assets from wallet with user selected currency.')
self.errors.verify_no_errors()
@marks.testrail_id(5782)
@marks.critical
@ -658,7 +500,7 @@ class TestMessagesOneToOneChatSingle(SingleDeviceTestCase):
home = sign_in.create_user()
sign_in.just_fyi('join public chat and check that stickers are not available on Ropsten')
chat_name = home.get_public_chat_name()
chat_name = home.get_random_chat_name()
home.join_public_chat(chat_name)
chat = sign_in.get_chat_view()
if chat.show_stickers_button.is_element_displayed():
@ -696,7 +538,7 @@ class TestMessagesOneToOneChatSingle(SingleDeviceTestCase):
profile_view.switch_network('Mainnet with upstream RPC')
sign_in_view.just_fyi('join to public chat, buy and install stickers')
chat = home_view.join_public_chat(home_view.get_public_chat_name())
chat = home_view.join_public_chat(home_view.get_random_chat_name())
chat.show_stickers_button.click()
chat.get_stickers.click()
chat.install_sticker_pack_by_name('Tozemoon')
@ -737,7 +579,7 @@ class TestMessagesOneToOneChatSingle(SingleDeviceTestCase):
if home_view.connection_status.text != 'Offline':
self.errors.append('Offline status is not shown in home screen')
public_chat = home_view.join_public_chat(home_view.get_public_chat_name())
public_chat = home_view.join_public_chat(home_view.get_random_chat_name())
if public_chat.connection_status.text != 'Offline':
self.errors.append('Offline status is not shown in a public chat')
self.errors.verify_no_errors()

14
test/appium/tests/atomic/chats/test_public.py
View File

@ -23,7 +23,7 @@ class TestPublicChatMultipleDevice(MultipleDeviceTestCase):
profile_1 = home_1.profile_button.click()
default_username_1 = profile_1.default_username_text.text
profile_1.home_button.click()
public_key_2 = home_2.get_public_key()
public_key_2 = home_2.get_public_key_and_username()
home_2.home_button.click()
home_1.add_contact(public_key_2)
@ -42,7 +42,7 @@ class TestPublicChatMultipleDevice(MultipleDeviceTestCase):
status_chat.get_back_to_home_view()
public_chat_name = home_1.get_public_chat_name()
public_chat_name = home_1.get_random_chat_name()
chat_1, chat_2 = home_1.join_public_chat(public_chat_name), home_2.join_public_chat(public_chat_name)
message = 'hello'
@ -59,7 +59,7 @@ class TestPublicChatMultipleDevice(MultipleDeviceTestCase):
def test_public_chat_clear_history(self):
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
chat_name = device_1.get_public_chat_name()
chat_name = device_1.get_random_chat_name()
for sign_in in device_1, device_2:
home = sign_in.create_user()
home.join_public_chat(chat_name)
@ -96,7 +96,7 @@ class TestPublicChatMultipleDevice(MultipleDeviceTestCase):
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_1, home_2 = device_1.create_user(), device_2.create_user()
chat_name = home_1.get_public_chat_name()
chat_name = home_1.get_random_chat_name()
chat_1, chat_2 = home_1.join_public_chat(chat_name), home_2.join_public_chat(chat_name)
home_1.get_back_to_home_view()
@ -127,7 +127,7 @@ class TestPublicChatMultipleDevice(MultipleDeviceTestCase):
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()
chat_name = home_1.get_public_chat_name()
chat_name = home_1.get_random_chat_name()
chat_1, chat_2 = home_1.join_public_chat(chat_name), home_2.join_public_chat(chat_name)
home_1.get_back_to_home_view()
message = 'test message'
@ -158,7 +158,7 @@ class TestPublicChatMultipleDevice(MultipleDeviceTestCase):
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_1, home_2 = device_1.create_user(), device_2.create_user()
chat_name = home_1.get_public_chat_name()
chat_name = home_1.get_random_chat_name()
chat_1, chat_2 = home_1.join_public_chat(chat_name), home_2.join_public_chat(chat_name)
emoji_name = random.choice(list(emoji.EMOJI_UNICODE))
emoji_unicode = emoji.EMOJI_UNICODE[emoji_name]
@ -191,7 +191,7 @@ class TestPublicChatMultipleDevice(MultipleDeviceTestCase):
self.create_drivers(2)
device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
home_1, home_2 = device_1.create_user(), device_2.create_user()
public_chat_name = home_1.get_public_chat_name()
public_chat_name = home_1.get_random_chat_name()
chat_1, chat_2 = home_1.join_public_chat(public_chat_name), home_2.join_public_chat(public_chat_name)
browser = device_1.dapp_tab_button.click()

2
test/appium/tests/atomic/dapps_and_browsing/test_dapps.py
View File

@ -111,7 +111,7 @@ class TestDApps(SingleDeviceTestCase):
user = basic_user
sign_in_view = SignInView(self.driver)
home_view = sign_in_view.recover_access(passphrase=user['passphrase'])
chat = home_view.join_public_chat(home_view.get_public_chat_name())
chat = home_view.join_public_chat(home_view.get_random_chat_name())
chat.back_button.click()
status_test_dapp = home_view.open_status_test_dapp()
status_test_dapp.wait_for_d_aap_to_load()

2
test/appium/tests/atomic/dapps_and_browsing/test_deep_links.py
View File

@ -14,7 +14,7 @@ class TestDeepLinks(SingleDeviceTestCase):
sign_in_view = SignInView(self.driver)
sign_in_view.create_user()
self.driver.close_app()
chat_name = sign_in_view.get_public_chat_name()
chat_name = sign_in_view.get_random_chat_name()
deep_link = 'https://join.status.im/%s' % chat_name
sign_in_view.open_weblink_and_login(deep_link)
chat_view = sign_in_view.get_chat_view()

73
test/appium/tests/atomic/transactions/test_wallet.py
View File

@ -11,35 +11,6 @@ from views.sign_in_view import SignInView
@marks.transaction
class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
@marks.testrail_id(5307)
@marks.critical
@marks.skip
# TODO: temporary skipped due to 8601
def test_send_eth_from_wallet_to_contact(self):
recipient = basic_user
sender = transaction_senders['N']
sign_in_view = SignInView(self.driver)
sign_in_view.recover_access(sender['passphrase'])
home_view = sign_in_view.get_home_view()
home_view.add_contact(recipient['public_key'])
home_view.get_back_to_home_view()
wallet_view = home_view.wallet_button.click()
wallet_view.set_up_wallet()
wallet_view.accounts_status_account.click()
send_transaction = wallet_view.send_transaction_button.click()
send_transaction.amount_edit_box.click()
transaction_amount = send_transaction.get_unique_amount()
send_transaction.amount_edit_box.set_value(transaction_amount)
send_transaction.confirm()
send_transaction.chose_recipient_button.click()
send_transaction.recent_recipients_button.click()
recent_recipient = send_transaction.element_by_text(recipient['username'])
send_transaction.recent_recipients_button.click_until_presence_of_element(recent_recipient)
recent_recipient.click()
send_transaction.sign_transaction_button.click()
send_transaction.sign_transaction()
self.network_api.find_transaction_by_unique_amount(sender['address'], transaction_amount)
@marks.testrail_id(5308)
@marks.critical
def test_send_eth_from_wallet_to_address(self):
@ -550,46 +521,4 @@ class TestTransactionWalletSingleDevice(SingleDeviceTestCase):
if not account_button.color_matches('multi_account_color.png'):
self.driver.fail('Account color does not match expected')
self.errors.verify_no_errors()
@marks.transaction
class TestTransactionWalletMultipleDevice(MultipleDeviceTestCase):
@marks.testrail_id(5378)
@marks.skip
@marks.high
# TODO: temporary skipped due to 8601
def test_transaction_message_sending_from_wallet(self):
recipient = transaction_recipients['E']
sender = transaction_senders['V']
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'])
home_2 = device_2.recover_access(passphrase=recipient['passphrase'])
chat_1 = home_1.add_contact(recipient['public_key'])
chat_1.get_back_to_home_view()
wallet_1 = home_1.wallet_button.click()
wallet_1.set_up_wallet()
wallet_1.accounts_status_account.click()
send_transaction = wallet_1.send_transaction_button.click()
send_transaction.amount_edit_box.click()
amount = send_transaction.get_unique_amount()
send_transaction.amount_edit_box.set_value(amount)
send_transaction.confirm()
send_transaction.chose_recipient_button.click()
send_transaction.recent_recipients_button.click()
send_transaction.element_by_text_part(recipient['username']).click()
send_transaction.sign_transaction_button.click()
send_transaction.sign_transaction()
wallet_1.home_button.click()
home_1.get_chat(recipient['username']).click()
if not chat_1.chat_element_by_text(amount).is_element_displayed():
self.errors.append('Transaction message is not shown in 1-1 chat for the sender')
chat_2 = home_2.get_chat(sender['username']).click()
if not chat_2.chat_element_by_text(amount).is_element_displayed():
self.errors.append('Transaction message is not shown in 1-1 chat for the recipient')
self.errors.verify_no_errors()
self.errors.verify_no_errors()

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

@ -586,7 +586,7 @@ class BaseView(object):
return '0.00%s' % datetime.now().strftime('%-d%-H%-M%-S').strip('0')
@staticmethod
def get_public_chat_name():
def get_random_chat_name():
return ''.join(random.choice(string.ascii_lowercase) for _ in range(7))
def get_text_from_qr(self):
@ -626,13 +626,15 @@ class BaseView(object):
def close_share_popup(self):
TouchAction(self.driver).tap(None, 255, 104, 1).perform()
def get_public_key(self):
def get_public_key_and_username(self, return_username=False):
profile_view = self.profile_button.click()
default_username = profile_view.default_username_text.text
profile_view.share_my_profile_button.click()
profile_view.public_key_text.wait_for_visibility_of_element()
public_key = profile_view.public_key_text.text
self.close_share_popup()
return public_key
user_data = (public_key, default_username) if return_username else public_key
return user_data
def share_via_messenger(self):
self.element_by_text('Messages').click()

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

@ -1,4 +1,3 @@
import time
from datetime import datetime
import dateutil.parser
@ -63,13 +62,6 @@ class UserNameText(BaseText):
self.locator = \
self.Locator.accessibility_id('chat-name-text')
class TransactionPopupText(BaseText):
def __init__(self, driver):
super(TransactionPopupText, self).__init__(driver)
self.locator = self.Locator.xpath_selector("//*[@text='Specify amount']")
class SendCommand(BaseButton):
def __init__(self, driver):
super(SendCommand, self).__init__(driver)
@ -100,12 +92,6 @@ class RequestCommand(BaseButton):
return self.navigate()
class AssetCommand(BaseButton):
def __init__(self, driver, asset):
super(AssetCommand, self).__init__(driver)
self.locator = self.Locator.text_selector(asset)
class ChatMenuButton(BaseButton):
def __init__(self, driver):
super(ChatMenuButton, self).__init__(driver)
@ -145,11 +131,15 @@ class GroupInfoButton(BaseButton):
def navigate(self):
return GroupChatInfoView(self.driver)
def click(self):
self.wait_for_element().click()
return self.navigate()
class LeaveChatButton(BaseButton):
def __init__(self, driver):
super(LeaveChatButton, self).__init__(driver)
self.locator = self.Locator.xpath_selector('//*[@text="Leave public chat"]')
self.locator = self.Locator.accessibility_id('leave-chat-button')
class ClearButton(BaseButton):
@ -194,18 +184,6 @@ class RemoveButton(BaseButton):
self.locator = self.Locator.xpath_selector("//android.widget.TextView[@text='Remove']")
class FirstRecipient(BaseButton):
def __init__(self, driver):
super(FirstRecipient, self).__init__(driver)
self.locator = self.Locator.accessibility_id('contact-item')
class MoreUsersButton(BaseButton):
def __init__(self, driver):
super(MoreUsersButton, self).__init__(driver)
self.locator = self.Locator.xpath_selector("//android.widget.TextView[contains(@text, 'MORE')]")
class OpenInStatusButton(BaseButton):
def __init__(self, driver):
super(OpenInStatusButton, self).__init__(driver)
@ -291,13 +269,13 @@ class DeclineChatButton(BaseButton):
class RemoveFromChatButton(BaseButton):
def __init__(self, driver):
super(RemoveFromChatButton, self).__init__(driver)
self.locator = self.Locator.xpath_selector('//*[@text="Remove from chat"]')
self.locator = self.Locator.accessibility_id('remove-from-chat')
class MakeAdminButton(BaseButton):
def __init__(self, driver):
super(MakeAdminButton, self).__init__(driver)
self.locator = self.Locator.xpath_selector('//*[@text="Make admin"]')
self.locator = self.Locator.accessibility_id('make-admin')
class ChatElementByText(BaseText):
@ -433,8 +411,6 @@ class ChatElementByText(BaseText):
return SignAndSend(self.driver, self.locator.value)
@property
def replied_message_text(self):
class RepliedMessageText(BaseText):
@ -481,8 +457,44 @@ class HistoryTimeMarker(BaseText):
class UsernameOptions(BaseButton):
def __init__(self, driver, username):
super(UsernameOptions, self).__init__(driver)
self.locator = self.Locator.xpath_selector("//*[@text='%s']/..//*[@content-desc='options']" % username)
self.locator = self.Locator.xpath_selector("//*[@text='%s']/..//*[@content-desc='menu-option']" % username)
def navigate(self):
return ChatView(self.driver)
def click(self):
self.wait_for_element().click()
return self.navigate()
class UserNameInGroupInfo(BaseButton):
def __init__(self, driver, username):
super(UserNameInGroupInfo, self).__init__(driver)
self.locator = self.Locator.xpath_selector("//*[@text='%s']" % username)
class AdminUser(BaseButton):
def __init__(self, driver, username):
super(AdminUser, self).__init__(driver)
self.locator = self.Locator.xpath_selector("//*[@text='%s']/..//*[@text='Admin']" % username)
class EditGroupChatButton(BaseButton):
def __init__(self, driver):
super(EditGroupChatButton, self).__init__(driver)
self.locator = self.Locator.accessibility_id("edit-button")
class EditGroupChatEditBox(BaseEditBox):
def __init__(self, driver):
super(EditGroupChatEditBox, self).__init__(driver)
self.locator = self.Locator.accessibility_id("new-chat-name")
class DoneButton(BaseButton):
def __init__(self, driver):
super(DoneButton, self).__init__(driver)
self.locator = self.Locator.accessibility_id("done")
class GroupChatInfoView(BaseView):
def __init__(self, driver):
@ -492,6 +504,14 @@ class GroupChatInfoView(BaseView):
def get_username_options(self, username: str):
return UsernameOptions(self.driver, username)
def user_admin(self, username: str):
return AdminUser(self.driver, username)
def get_user_from_group_info(self, username: str):
return UserNameInGroupInfo(self.driver, username)
class ChatView(BaseView):
def __init__(self, driver):
@ -533,15 +553,15 @@ class ChatView(BaseView):
self.decline_invitation_button = DeclineChatButton(self.driver)
self.remove_user_button = RemoveFromChatButton(self.driver)
self.make_admin_button = MakeAdminButton(self.driver)
self.edit_group_chat_name_button = EditGroupChatButton(self.driver)
self.edit_group_chat_name_edit_box = EditGroupChatEditBox(self.driver)
self.done_button = DoneButton(self.driver)
self.chat_settings = ChatSettings(self.driver)
self.view_profile_button = ViewProfileButton(self.driver)
self.more_users_button = MoreUsersButton(self.driver)
self.user_options = UserOptions(self.driver)
self.remove_button = RemoveButton(self.driver)
self.first_recipient_button = FirstRecipient(self.driver)
self.open_in_status_button = OpenInStatusButton(self.driver)
# Contact's profile
@ -552,36 +572,34 @@ class ChatView(BaseView):
self.profile_block_contact = ProfileBlockContactButton(self.driver)
self.profile_add_to_contacts = ProfileAddToContactsButton(self.driver)
def send_funds_to_request(self, amount, sender_password=common_password, wallet_set_up=False):
gas_popup = self.element_by_text_part('Specify amount')
send_request_button = self.chat_element_by_text(amount).send_request_button
send_request_button.click_until_presence_of_element(gas_popup)
send_transaction = self.get_send_transaction_view()
if wallet_set_up:
wallet_view = self.get_wallet_view()
self.send_message_button.click_until_presence_of_element(wallet_view.sign_in_phrase)
wallet_view.done_button.click()
wallet_view.yes_button.click()
else:
self.send_message_button.click_until_presence_of_element(send_transaction.sign_with_password)
send_transaction.sign_transaction(sender_password)
def delete_chat(self):
self.chat_options.click()
self.delete_chat_button.click()
self.delete_button.click()
def leave_chat(self):
self.chat_options.click()
self.leave_chat_button.click()
self.leave_button.click()
def clear_history(self):
self.chat_options.click()
self.clear_history_button.click()
self.clear_button.click()
def clear_history_via_group_info(self):
def leave_chat_via_group_info(self):
self.chat_options.click()
self.group_info.click()
self.clear_history_button.click()
self.clear_button.click()
self.back_button.click()
self.leave_chat_button.click()
self.leave_button.click()
def rename_chat_via_group_info(self, new_chat_name):
self.chat_options.click()
self.group_info.click()
self.edit_group_chat_name_button.click()
self.edit_group_chat_name_edit_box.set_value(new_chat_name)
self.done_button.click()
def send_transaction_in_group_chat(self, amount, password, recipient):
self.commands_button.click()
@ -662,3 +680,32 @@ class ChatView(BaseView):
timestamp = datetime.strptime("%s:%s" % (sent_time_object.hour, sent_time_object.minute), '%H:%M').strftime("%I:%M %p")
timestamp = timestamp[1:] if timestamp[0] == '0' else timestamp
return timestamp
# Group chat system messages
@staticmethod
def leave_system_message(username):
return "%s left the group" % username
@staticmethod
def has_been_made_admin_system_message(admin, new_admin):
return "%s has made %s admin" % (admin, new_admin)
@staticmethod
def create_system_message(admin, chat_name):
return '%s created the group %s' % (admin, chat_name)
@staticmethod
def invite_system_message(admin, invited_user):
return '%s has invited %s' % (admin, invited_user)
@staticmethod
def join_system_message(username):
return '%s joined the group' % username
@staticmethod
def create_for_admin_system_message(chat_name):
return 'You created the group %s' % chat_name
@staticmethod
def changed_group_name_system_message(admin, chat_name):
return "%s changed the group's name to %s" % (admin, chat_name)

1
test/appium/views/dapps_view.py
View File

@ -106,7 +106,6 @@ class DappsView(BaseView):
self.always_allow_radio_button = AlwaysAllowRadioButton(self.driver)
self.close_web3_permissions_window_button = CrossCloseWeb3PermissionButton(self.driver)
def open_url(self, url):
self.enter_url_editbox.click()
self.enter_url_editbox.send_keys(url)

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

@ -258,6 +258,12 @@ class HomeView(BaseView):
self.delete_chat_button.click()
self.delete_button.click()
def leave_chat_long_press(self, username):
self.get_chat(username).long_press_element()
from views.chat_view import LeaveChatButton, LeaveButton
LeaveChatButton(self.driver).click()
LeaveButton(self.driver).click()
def clear_chat_long_press(self, username):
self.get_chat(username).long_press_element()
self.clear_history_button.click()

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

@ -437,7 +437,6 @@ class WalletView(BaseView):
else:
self.driver.info('Current USD balance %s is ok' % usd)
def wait_balance_is_equal_expected_amount(self, asset ='ETHro', expected_balance=0.1, wait_time=300):
counter = 0
while True:
@ -469,8 +468,7 @@ class WalletView(BaseView):
self.driver.info('Waiting %s seconds for %s to display asset' % (counter, asset))
else:
self.driver.info('Balance is updated!')
return
return self
def get_sign_in_phrase(self):
return ' '.join([element.text for element in self.sign_in_phrase.find_elements()])