status-react/test/appium/tests/atomic/chats/test_chats_management.py

import pytest
import time

from tests import marks, camera_access_error_text
from tests.users import basic_user
from tests.base_test_case import SingleDeviceTestCase, MultipleDeviceTestCase
from views.sign_in_view import SignInView


@marks.chat
class TestChatManagement(SingleDeviceTestCase):

    @marks.testrail_id(5426)
    @marks.medium
    def test_clear_history_one_to_one_chat(self):
        sign_in_view = SignInView(self.driver)
        home_view = sign_in_view.create_user()
        chat_view = home_view.add_contact(basic_user['public_key'])
        for _ in range(2):
            chat_view.chat_message_input.send_keys('test message')
            chat_view.send_message_button.click()
        chat_view.clear_history()
        if not chat_view.no_messages_in_chat.is_element_present():
            pytest.fail('Message history is shown')
        home_view.relogin()
        home_view.get_chat_with_user(basic_user['username']).click()
        if not chat_view.no_messages_in_chat.is_element_present():
            pytest.fail('Message history is shown after re-login')

    @marks.testrail_id(5319)
    @marks.critical
    def test_swipe_to_delete_1_1_chat(self):
        sign_in = SignInView(self.driver)
        home = sign_in.create_user()
        chat = home.add_contact(basic_user['public_key'])
        chat.chat_message_input.send_keys('test message')
        chat.send_message_button.click()
        chat.get_back_to_home_view()
        home.get_chat_with_user(basic_user['username']).swipe_and_delete()
        self.driver.close_app()
        self.driver.launch_app()
        sign_in.accept_agreements()
        sign_in.sign_in()
        if home.get_chat_with_user(basic_user['username']).is_element_displayed():
            pytest.fail('Deleted 1-1 chat is present after relaunch app')

    @marks.testrail_id(5343)
    @marks.critical
    def test_swipe_to_delete_public_chat(self):
        sign_in = SignInView(self.driver)
        home = sign_in.create_user()
        chat_name = home.get_public_chat_name()
        chat = home.join_public_chat(chat_name)
        message = 'test message'
        chat.chat_message_input.send_keys(message)
        chat.send_message_button.click()
        chat.get_back_to_home_view()
        home.get_chat_with_user('#' + chat_name).swipe_and_delete()
        profile = home.profile_button.click()
        profile.logout()
        sign_in.sign_in()
        if home.get_chat_with_user('#' + chat_name).is_element_displayed():
            self.errors.append('Deleted public chat is present after relogin')
        home.join_public_chat(chat_name)
        if chat.chat_element_by_text(message).is_element_displayed():
            self.errors.append('Chat history is shown')
        self.verify_no_errors()

    @marks.testrail_id(5304)
    @marks.high
    def test_open_chat_by_pasting_public_key(self):
        sign_in = SignInView(self.driver)
        home = sign_in.create_user()
        public_key = basic_user['public_key']

        chat = home.join_public_chat(home.get_public_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()
        chat.element_by_text('Copy').click()
        chat.get_back_to_home_view()

        home.plus_button.click()
        contacts_view = home.start_new_chat_button.click()
        contacts_view.public_key_edit_box.paste_text_from_clipboard()
        if contacts_view.public_key_edit_box.text != public_key:
            pytest.fail('Public key is not pasted from clipboard')
        contacts_view.confirm()
        contacts_view.get_back_to_home_view()
        if not home.get_chat_with_user(basic_user['username']).is_element_present():
            pytest.fail("No chat open in home view")

    @marks.testrail_id(5387)
    @marks.high
    def test_delete_one_to_one_chat_via_delete_button(self):
        sign_in = SignInView(self.driver)
        home = sign_in.create_user()
        chat_view = home.add_contact(basic_user['public_key'])
        for _ in range(2):
            chat_view.chat_message_input.send_keys('test message')
            chat_view.send_message_button.click()
        chat_view.delete_chat()
        if home.get_chat_with_user(basic_user['username']).is_element_present(10):
            self.errors.append("One-to-one' chat is shown, but the chat has been deleted")
        home.relogin()
        if home.get_chat_with_user(basic_user['username']).is_element_present(10):
            self.errors.append("One-to-one' chat is shown after re-login, but the chat has been deleted")
        self.verify_no_errors()

    @marks.testrail_id(5388)
    @marks.high
    def test_delete_public_chat_via_delete_button(self):
        sign_in = SignInView(self.driver)
        home = sign_in.create_user()
        chat_name = home.get_public_chat_name()
        public_chat = home.join_public_chat(chat_name)
        public_chat.chat_message_input.send_keys('test message')
        public_chat.send_message_button.click()
        public_chat.delete_chat()
        if home.element_by_text(chat_name).is_element_present(5):
            self.errors.append("Public chat '%s' is shown, but the chat has been deleted" % chat_name)
        home.relogin()
        if home.element_by_text(chat_name).is_element_present(5):
            self.errors.append("Public chat '%s' is shown after re-login, but the chat has been deleted" % chat_name)
        self.verify_no_errors()

    @marks.testrail_id(5464)
    @marks.medium
    def test_incorrect_contact_code_start_new_chat(self):
        sign_in = SignInView(self.driver)
        home = sign_in.create_user()
        home.plus_button.click()
        contacts_view = home.start_new_chat_button.click()
        contacts_view.public_key_edit_box.set_value(basic_user['public_key'][:-1])
        contacts_view.confirm()
        warning_text = contacts_view.element_by_text('Please enter or scan a valid contact code or username')
        if not warning_text.is_element_displayed():
            pytest.fail('Error is not shown for invalid public key')

    @marks.testrail_id(5466)
    @marks.medium
    def test_deny_camera_access_scanning_contact_code(self):
        sign_in = SignInView(self.driver)
        home = sign_in.create_user()
        home.plus_button.click()
        contacts_view = home.start_new_chat_button.click()
        contacts_view.scan_contact_code_button.click()
        contacts_view.deny_button.click()
        contacts_view.element_by_text(camera_access_error_text).wait_for_visibility_of_element(3)
        contacts_view.ok_button.click()
        contacts_view.scan_contact_code_button.click()
        contacts_view.deny_button.wait_for_visibility_of_element(2)

    @marks.testrail_id(5757)
    @marks.critical
    def test_search_chat_on_home(self):
        sign_in = SignInView(self.driver)
        home = sign_in.create_user()
        search_list = list()

        chat_name = home.get_public_chat_name()
        search_list.append(chat_name)
        public_chat = home.join_public_chat(chat_name)
        public_chat.get_back_to_home_view()

        chat = home.add_contact(basic_user['public_key'])
        search_list.append(basic_user['username'])
        chat.get_back_to_home_view()

        home.swipe_down()
        for keyword in search_list:
            home.search_chat_input.send_keys(keyword)
            search_results = home.chat_name_text.find_elements()
            if not search_results:
                self.errors.append('No search results after searching by %s keyword' % keyword)
            for element in search_results:
                if keyword not in element.text:
                    self.errors.append("'%s' is shown on the home screen after searching by '%s' keyword" %
                                       (element.text, keyword))
            home.search_chat_input.clear()
        self.verify_no_errors()


@marks.chat
class TestChatManagementMultipleDevice(MultipleDeviceTestCase):

    @marks.testrail_id(5332)
    @marks.critical
    def test_add_contact_from_public_chat(self):
        self.create_drivers(2)
        device_1, device_2 = SignInView(self.drivers[0]), SignInView(self.drivers[1])
        home_1, home_2 = device_1.create_user(), device_2.create_user()
        chat_name = 'testaddcontact'
        chat_1, chat_2 = home_1.join_public_chat(chat_name), home_2.join_public_chat(chat_name)
        message = 'test message' + str(round(time.time()))

        chat_2.chat_message_input.send_keys(message)
        chat_2.send_message_button.click()
        chat_2.driver.quit()

        chat_element = chat_1.chat_element_by_text(message)
        chat_element.find_element()
        username = chat_element.username.text
        chat_element.member_photo.click()
        for element in [chat_1.contact_profile_picture,
                        chat_1.element_by_text(username, 'text'),
                        chat_1.add_to_contacts,
                        chat_1.profile_send_message,
                        chat_1.profile_send_transaction,
                        chat_1.profile_address_text]:
            if not element.scroll_to_element():
                self.errors.append('%s is not visible' % element.name)
        chat_1.add_to_contacts.click()
        if not chat_1.element_by_text('In contacts').is_element_displayed():
            self.errors.append("'Add to contacts' is not changed to 'In contacts'")

        chat_1.get_back_to_home_view()
        home_1.plus_button.click()
        contacts_1 = home_1.start_new_chat_button.click()
        if not contacts_1.element_by_text(username).is_element_displayed():
            self.errors.append("List of contacts doesn't contain added user")

        self.verify_no_errors()