Python HelpNavigateCheckMethods.progress方法代码示例

# 需要导入模块: from tests.front_office.not_sorted.classes.class_navigate import HelpNavigateCheckMethods [as 别名]
# 或者: from tests.front_office.not_sorted.classes.class_navigate.HelpNavigateCheckMethods import progress [as 别名]
 def test_as_visitor_to_chat(self, number_good=1, test_data=HelpNavigateCheckMethods.CATALOG_TO_GOOD):
     #TODO: обновить
     """
     Title: Я, как Гость, при нажатии на "Связаться с продавцом" увижу страницу Авторизации
     """
     self.driver.delete_all_cookies()
     self.driver.refresh()
     HelpNavigateCheckMethods.progress(self.driver)
     self.go_main(self.driver, flag_auth=False)
     # Выбираем товар и сохраняем его имя
     service_log.put("Выбираем товар и сохраняем его имя")
     good_name = self.get_name(self.get_element_navigate(self.driver, test_data["start_xpath_good"] % number_good))
     # Переход на страницу товара
     service_log.put("Переход на страницу товара")
     self.check_navigate_in_good_page(self.driver, test_data, number_good)
     # Жмем кнопку
     service_log.put("Жмем кнопку Связаться с продавцом")
     btn_to_call = self.get_element_navigate(self.driver, self.click_good.BTN_CALL_SELLER)
     btn_to_call.click()
     obj_send = self.get_element_navigate(self.driver, self.click_good.BTN_SEND)
     self.click_button(obj_send)
     # Проверяем, что перекинуло на авторизацию
     service_log.put("Проверяем, что перекинуло на авторизацию")
     #self.click_to_phone(self.driver)
     self.check_page_authorization(self.driver)

# 需要导入模块: from tests.front_office.not_sorted.classes.class_navigate import HelpNavigateCheckMethods [as 别名]
# 或者: from tests.front_office.not_sorted.classes.class_navigate.HelpNavigateCheckMethods import progress [as 别名]
    def test_smoke_user_settings(self):
        """
        Title: Тест сценарий изменений настроек пользователя.
        Description:
            1) Авторизоваться пользователем
            2) Перейти на страницу "Настройки"
                - Проверить, что отображаемые данные  = тому что в базе (включая аватар)
                - Проверить, что Имя и Аватар отображаемом в виджете "Профиль пользователя" = тому что в базе
            3) Изменить Имя пользователя и пол
                - Проверить что изменения отображаются и в базе и в интерфейсе
            4) Изменить аватар (старый удалить)
                - Проверить, что отображается заглушка фото (в настройках и в профиле продавца)
            5) Изменить аватар (добавить новый)
                - Проверить, что отображается новая фото (в настройках и в профиле продавца)
        """

        # 1) Авторизоваться Пользователем через e-mail и проверить успешность операции.
        self.go_to_main_page(self.driver)
        self.click_reg_and_auth(self.driver)
        self.click_tab_login(self.driver)
        auth_form = self.get_auth_email_form(self.driver)
        auth_form["email_input"].send_keys(self.user['email'])
        auth_form["password_input"].send_keys(self.default_passwd)
        self.click_button(auth_form["login_btn"])

        # Перейти на страницу "Настройки"
        self.get_page(self.driver, self.path_settings.PATH_PROFILE_SETTINGS)
        profile = self.get_user_profile_form(self.driver, self.user)
        gender = self.get_gender_user2(self.driver, self.user["gender"])

        # Изменить Имя пользователя и пол
        self.clear_input_row(self.driver, profile["name_input"])
        new_name = common_utils.random_string()
        profile["name_input"].send_keys(new_name)
        gender_ui = self.set_gender(gender, self.user["gender"])
        self.click_button(profile["save_btn"])

        # Проверяем, что изменения вступили в силу, как в БД, так и в интерфейсе
        criteria = "gender='%s' and display_name='%s' and id=%s" % (gender_ui, new_name, self.user["id"])
        user_updated = databases.db1.accounting.get_user_by_criteria_only(criteria)[0]
        self.driver.refresh()
        Navigate.progress(self.driver)
        self.get_user_profile_form(self.driver, user_updated)
        self.get_gender_user(self.driver, user_updated["gender"])

        # Изменить аватар (старый удалить)
        btn_avatar = self.get_delete_avatar_button(self.driver)  # TODO: У пользователя уже должен быть аватар!
        btn_avatar.click()

        # Изменить аватар (добавить новый)
        img_path = self.IMG_AVATAR[0]
        add_img_btn = self.get_element_navigate(self.driver, self.click_my_goods.ADD_AVATAR)
        add_img_btn.click()
        self.add_photo(img_path)
        self.assertIsNotNone(self.get_delete_avatar_button(self.driver))

# 需要导入模块: from tests.front_office.not_sorted.classes.class_navigate import HelpNavigateCheckMethods [as 别名]
# 或者: from tests.front_office.not_sorted.classes.class_navigate.HelpNavigateCheckMethods import progress [as 别名]
    def go_main(driver, phone=None, email=None, passwd=None, flag_auth=True, flag_api=True):
        """ Универсальный переход на главную страницу.
        :param driver: ссылка на драйвер
        :param phone: номер телефона
        :param email: электронная почта
        :param passwd: пароль
        :param flag_auth: флаг авторизации
        """
        from support.utils.variables import EVariable
        env_base_url = EVariable.front_base.url.strip()

        # авторизоваться через API
        if flag_auth:
            service_log.put("To authorization via API")
            if flag_api:
                if email is None and phone is not None:
                    HelpAuthMethods.set_authorization_by_phone(driver, phone, passwd)
                elif email is not None and phone is None:
                    # TODO
                    pass
                else:
                    msg_error = "Not correct params."
                    service_log.error(msg_error)
                    assert AssertionError(msg_error)
            else:
                if email is None and phone is not None:
                    HelpNavigateCheckMethods.get_page(driver, HelpNavigateCheckMethods.path_auth.PATH_AUTH)
                    obj_phone, obj_password, obj_submit_button = HelpAuthCheckMethods.get_data_authorization(driver)

                    # Вводим данные на авторизацию
                    l = lambda e, p:e if p is None else p
                    HelpAuthCheckMethods.send_phone(phone_object=obj_phone, phone_number=l(email, phone))
                    HelpAuthCheckMethods.send_password(password_object=obj_password, password_number=passwd)
                    # Нажатие на кнопку авторизации
                    HelpNavigateCheckMethods.element_click(driver, obj_submit_button, change_page_url=True)
                    time.sleep(HelpNavigateCheckMethods.time_sleep)
                elif email is not None and phone is None:
                    # TODO
                    pass
                else:
                    msg_error = "Not correct params."
                    service_log.error(msg_error)
                    assert AssertionError(msg_error)
            service_log.put("To authorization via API - success.")

        service_log.put("Get page: %s" % env_base_url)
        do_get_work = time.time()
        driver.get(env_base_url)
        work_get_time = HelpNavigateCheckMethods.work_time(do_get_work)
        service_log.put("Onload event time: [%s]" % work_get_time)
        HelpNavigateCheckMethods.progress(driver)
        work_load_time = HelpNavigateCheckMethods.work_time(do_get_work)
        service_log.put("Page received: %s" % env_base_url)
        service_log.put("Page received time: %s" % work_load_time)
        time.sleep(3)

# 需要导入模块: from tests.front_office.not_sorted.classes.class_navigate import HelpNavigateCheckMethods [as 别名]
# 或者: from tests.front_office.not_sorted.classes.class_navigate.HelpNavigateCheckMethods import progress [as 别名]
 def check_delete_first_user_in_cl(self, driver, user_id, fav_usr, link_db):
     fav_users_list_old = link_db.accounting.get_fav_user_in_cl_user(user_id, fav_usr["id"])
     self.assertNotEqual(len(fav_users_list_old), 0 , "Пользователя нет в БД контактах")
     self.delete_first_user_in_cl(driver, fav_usr)
     fav_users_list_new = link_db.accounting.get_fav_user_in_cl_user(user_id, fav_usr["id"])
     self.assertEqual(len(fav_users_list_new), 0, "Пользователь есть в БД контактах: '%s'" % fav_users_list_new)
     HelpUserContactsCheckMethods.check_user_no_in_cl(self, driver, fav_usr["id"])
     driver.refresh()
     Navigate.progress(driver)
     HelpUserContactsCheckMethods.check_user_no_in_cl(self, driver, fav_usr["id"])
     Navigate.get_page(driver, Navigate.path_buyer.URL_BUYER % fav_usr["id"])
     Navigate.get_element_navigate(driver, Navigate.click_user_contact.IN_CONTACT_USER, sleep=0.1, mode=None)
     driver.back()

# 需要导入模块: from tests.front_office.not_sorted.classes.class_navigate import HelpNavigateCheckMethods [as 别名]
# 或者: from tests.front_office.not_sorted.classes.class_navigate.HelpNavigateCheckMethods import progress [as 别名]
 def go_authorization_page(driver, env_base_url=MainClass.ENV_BASE_URL, sleep=2):
     """ Авторизоваться через главную страницу.
     :param driver: ссылка на драйвер
     :param env_base_url: адрес главной страницы
     :param sleep: ожидание пока страница прогрузиться
     """
     service_log.put("Get page: %s" % env_base_url)
     do_get_work = time.time()
     driver.get(env_base_url)
     work_get_time = HelpNavigateCheckMethods.work_time(do_get_work)
     service_log.put("Onload event time: [%s]" % work_get_time)
     HelpNavigateCheckMethods.progress(driver)
     work_load_time = HelpNavigateCheckMethods.work_time(do_get_work)
     service_log.put("Page received: %s" % env_base_url)
     service_log.put("Page received time: %s" % work_load_time)
     reg_log_btn = HelpNavigateCheckMethods.get_element_navigate(driver, HelpAuthData.click_main.BUTTON_REG_AN_LOGIN)
     HelpAuthCheckMethods.click_button(reg_log_btn)
     login_button = HelpNavigateCheckMethods.get_element_navigate(driver, HelpAuthData.click_main.BUTTON_LOGIN, mode=None)
     login_button.is_displayed()
     login_button.is_enabled()
     HelpNavigateCheckMethods.element_click(driver, login_button)

# 需要导入模块: from tests.front_office.not_sorted.classes.class_navigate import HelpNavigateCheckMethods [as 别名]
# 或者: from tests.front_office.not_sorted.classes.class_navigate.HelpNavigateCheckMethods import progress [as 别名]
 def go_registration_page(driver, type_xpath=1, env_base_url=MainClass.ENV_BASE_URL, sleep=2):
     """ Переход на страницу регистрации.
     :param driver: ссылка на драйвер
     :param type_xpath: тип перехода по xpath
     :param sleep: задержка в миллесекундах
     """
     registration_button = None
     if type_xpath == 1:
         registration_button = HelpNavigateCheckMethods.element_is_present(driver, HelpAuthData.REGISTRATION_PAGE)
         # time.sleep(sleep)
     elif type_xpath == 2:
         service_log.put("Get page: %s" % env_base_url)
         do_get_work = time.time()
         driver.get(env_base_url)
         work_get_time = HelpNavigateCheckMethods.work_time(do_get_work)
         service_log.put("Onload event time: [%s]" % work_get_time)
         HelpNavigateCheckMethods.progress(driver)
         work_load_time = HelpNavigateCheckMethods.work_time(do_get_work)
         service_log.put("Page received: %s" % env_base_url)
         service_log.put("Page received time: %s" % work_load_time)
         registration_button = HelpNavigateCheckMethods.element_is_present(driver, HelpAuthData.click_main.BUTTON_REG_AN_LOGIN)
     registration_button.click()
     time.sleep(sleep)

# 需要导入模块: from tests.front_office.not_sorted.classes.class_navigate import HelpNavigateCheckMethods [as 别名]
# 或者: from tests.front_office.not_sorted.classes.class_navigate.HelpNavigateCheckMethods import progress [as 别名]
    def test_my_goods_switch_good_status(self):
        """
        Title: Перемещение товара [В Активные]. Перемещение товара [В Неактивые]
        """
        service_log.run(self)
        # получаем список id товаров
        list_good_id = self.get_good_id_from_page_source(self.driver, self.path_my_goods.TO_FIND_GOODS)
        str_good = ''
        for good_id in list_good_id:
            str_good += "'" + good_id + "'"
            str_good += ", "
        # Первый товар преводим в статус НЕАКТИВНЫЙ
        checkbox = self.get_element_navigate(self.driver, self.click_my_goods.CHECKBOX % list_good_id[0])
        self.click_button(checkbox)
        good_to_inactive = self.get_element_navigate(self.driver, self.click_my_goods.GOOD_BY_ID_TO_STATUS %
                                                     'В неактивные')
        self.click_button(good_to_inactive)
        name_stock_state = 'HIDDEN'
        stock_state = self.get_StockState(name_stock_state)
        #services.warehouse.root.tframed.makePublication(list_good_id[0], stock_state)
        # Проверяем, что товар перешел в статус HIDDEN
        ware_cassandra = databases.db0.warehouse.get_wares_by_ware_id(list_good_id[0])[0]
        self.assertEqual(ware_cassandra['stock_state'], stock_state, "Статус товара не равен 3 - неактивному товару")
        # Обновляем страницу мои товары
        self.driver.refresh()
        HelpNavigateCheckMethods.progress(self.driver)
        time.sleep(self.time_sleep)
        # Получаем обновленный список товаров на странице мои товары - активные
        list_good_id_new = self.get_good_id_from_page_source(self.driver, self.path_my_goods.TO_FIND_GOODS)
        msg_error = "Неактивный товар присутствует в обновленном списке товаров - активные"
        self.assertEqual(list_good_id_new.count(list_good_id[0]), 0, msg_error)
        # Проверяем товары на странице - активные
        str_good_new = ''
        for good_id_new in list_good_id_new:
            str_good_new += "'" + good_id_new + "'"
            str_good_new += ", "
        wares_cassandra_new = databases.db0.warehouse.get_wares_by_ware_ids(str_good_new[:-2])
        self.assertIsNotNone(wares_cassandra_new, "Из базы не были получены товары")
        for ware_cassandra in wares_cassandra_new:
            self.assertEqual(ware_cassandra['shop_id'], self.user["id"], "Id продавца не совпадает с shop_id")
            self.assertEqual(ware_cassandra['stock_state'], 2, "Статус товара не равен 2 - активному товару")
            msg_error = "Статус товара не равен 1 или 2 - опубликованному или прошедшему модерацию"
            self.assertLessEqual(ware_cassandra['moderation_state'], 2, msg_error)

        # Переходим на страницу - неактивные
        obj_inactive_page = self.get_element_navigate(self.driver, self.click_my_goods.INACTIVE_PAGE)
        self.click_button(obj_inactive_page)
        # получаем список id товаров
        list_good_id_inact = self.get_good_id_from_page_source(self.driver, self.path_my_goods.TO_FIND_GOODS)
        msg_error = "Неактивный товар отсутствует в списке товаров - неактивные"
        self.assertEqual(list_good_id_inact.count(list_good_id[0]), 1, msg_error)
        str_good_inact = ''
        for good_id_inact in list_good_id_inact:
            str_good_inact += "'" + good_id_inact + "'"
            str_good_inact += ", "
        wares_cassandra_inact = databases.db0.warehouse.get_wares_by_ware_ids(str_good_inact[:-2])
        self.assertIsNotNone(wares_cassandra_inact, "Из базы не были получены товары")
        for ware_cassandra in wares_cassandra_inact:
            self.assertEqual(ware_cassandra['shop_id'], self.user["id"], "Id продавца не совпадает с shop_id")
            self.assertEqual(ware_cassandra['stock_state'], 3, "Статус товара не равен 3 - неактивному товару")
            msg_error = "Товар в статусах: Отклоненные модератором и Ожидающие модерации, Одобренные или Забанненые"
            self.assertIn(str(ware_cassandra['moderation_state']), '1,2,3,4', msg_error)

        # Первый товар преводим в статус АКТИВНЫЙ
        checkbox = self.get_element_navigate(self.driver, self.click_my_goods.CHECKBOX % list_good_id[0])
        self.click_button(checkbox)
        good_to_active = self.get_element_navigate(self.driver, self.click_my_goods.GOOD_BY_ID_TO_STATUS % 'В активные')
        self.click_button(good_to_active)
        name_stock_state = 'PUBLISHED'
        stock_state = self.get_StockState(name_stock_state)
        #services.warehouse.root.tframed.makePublication(list_good_id[0], stock_state)
        # Проверяем, что товар перешел в статус PUBLISHED
        ware_cassandra = databases.db0.warehouse.get_wares_by_ware_id(list_good_id[0])[0]
        self.assertEqual(ware_cassandra['stock_state'], stock_state, "Статус товара не равен 2 - активному товару")

        # Обновляем страницу товаров - неактивные
        self.driver.refresh()
        HelpNavigateCheckMethods.progress(self.driver)
        time.sleep(self.time_sleep)

        # получаем список id товаров
        list_good_id_inact_new = self.get_good_id_from_page_source(self.driver, self.path_my_goods.TO_FIND_GOODS)
        msg_error = "Активный товар присутствует в списке товаров - неактивные"
        self.assertEqual(list_good_id_inact_new.count(list_good_id[0]), 0, msg_error)
        # Переходим на страницу - активные
        obj_active_page = self.get_element_navigate(self.driver, self.click_my_goods.ACTIVE_PAGE)
        self.click_button(obj_active_page)
        # получаем список id товаров
        list_good_id_act_new = self.get_good_id_from_page_source(self.driver, self.path_my_goods.TO_FIND_GOODS)
        msg_error = "Активный товар отсутствует в списке товаров - активные"
        self.assertEqual(list_good_id_act_new.count(list_good_id[0]), 1, msg_error)

# 需要导入模块: from tests.front_office.not_sorted.classes.class_navigate import HelpNavigateCheckMethods [as 别名]
# 或者: from tests.front_office.not_sorted.classes.class_navigate.HelpNavigateCheckMethods import progress [as 别名]
    def test_seller_shop_switch_good_status(self):
        """
        Title: Отображаются только АКТИВНЫЕ товары (Активные.В модерации или Активные.Утвержден)
        """
        service_log.run(self)
        # получаем список id товаров
        list_good_id = self.get_good_id_from_page_source(self.driver, self.path_shop.TO_FIND_GOODS)
        str_good = ''
        for good_id in list_good_id:
            str_good += "'" + good_id + "'"
            str_good += ", "
        # Первый товар преводим в статус НЕАКТИВНЫЙ
        name_stock_state = 'HIDDEN'
        stock_state = self.get_StockState(name_stock_state)
        services.warehouse.root.tframed.makePublication(list_good_id[0], stock_state)
        # Проверяем, что товар перешел в статус HIDDEN
        ware_cassandra = databases.db0.warehouse.get_wares_by_ware_id(list_good_id[0])[0]
        self.assertEqual(ware_cassandra['stock_state'], stock_state, "Статус товара не равен 3 - неактивному товару")
        # Обновляем страницу магазина
        self.driver.refresh()
        HelpNavigateCheckMethods.progress(self.driver)
        time.sleep(self.time_sleep)
        # Получаем обновленный список товаров на странице магазина
        list_good_id_new = self.get_good_id_from_page_source(self.driver, self.path_shop.TO_FIND_GOODS)
        msg_error = "Неактивный товар присутствует в обновленном списке товаров на странице магазина."
        self.assertEqual(list_good_id_new.count(list_good_id[0]), 0, msg_error)
        str_good_new = ''
        for good_id_new in list_good_id_new:
            str_good_new += "'" + good_id_new + "'"
            str_good_new += ", "
        wares_cassandra = databases.db0.warehouse.get_wares_by_ware_ids(str_good_new[:-2])
        self.assertIsNotNone(wares_cassandra, "Из базы не были получены товары")
        for ware_cassandra in wares_cassandra:
            self.assertEqual(ware_cassandra['shop_id'], self.user["id"], "Id продавца не совпадает с shop_id")
            self.assertEqual(ware_cassandra['stock_state'], 2, "Статус товара не равен 2 - активному товару")
            msg_error = "Статус товара не равен 1 или 2 - опубликованному или прошедшему модерацию"
            self.assertLessEqual(ware_cassandra['moderation_state'], 2, msg_error)
        # Первый товар преводим в статус АКТИВНЫЙ
        name_stock_state = 'PUBLISHED'
        stock_state = self.get_StockState(name_stock_state)
        services.warehouse.root.tframed.makePublication(list_good_id[0], stock_state)
        # Проверяем, что товар перешел в статус PUBLISHED
        ware_cassandra = databases.db0.warehouse.get_wares_by_ware_id(list_good_id[0])[0]
        self.assertEqual(ware_cassandra['stock_state'], stock_state, "Статус товара не равен 2 - активному товару")

        # Обновляем страницу магазина
        self.driver.refresh()
        HelpNavigateCheckMethods.progress(self.driver)
        time.sleep(self.time_sleep)
        # Получаем обновленный список товаров на странице магазина
        list_good_id_new_2 = self.get_good_id_from_page_source(self.driver, self.path_shop.TO_FIND_GOODS)
        msg_error = "Активный товар отсутствует в обновленном списке товаров на странице магазина"
        self.assertEqual(list_good_id_new_2.count(list_good_id[0]), 1, msg_error)
        str_good_new_2 = ''
        for good_id_new_2 in list_good_id_new_2:
            str_good_new_2 += "'" + good_id_new_2 + "'"
            str_good_new_2 += ", "
        wares_cassandra_2 = databases.db0.warehouse.get_wares_by_ware_ids(str_good_new_2[:-2])
        self.assertIsNotNone(wares_cassandra, "Из базы не были получены товары")
        for ware_cassandra in wares_cassandra_2:
            self.assertEqual(ware_cassandra['shop_id'], self.user["id"], "Id продавца не совпадает с shop_id")
            self.assertEqual(ware_cassandra['stock_state'], 2, "Статус товара не равен 2 - активному товару")
            msg_error = "Статус товара не равен 1 или 2 - опубликованному или прошедшему модерацию"
            self.assertLessEqual(ware_cassandra['moderation_state'], 2, msg_error)

# 需要导入模块: from tests.front_office.not_sorted.classes.class_navigate import HelpNavigateCheckMethods [as 别名]
# 或者: from tests.front_office.not_sorted.classes.class_navigate.HelpNavigateCheckMethods import progress [as 别名]

#.........这里部分代码省略.........
        self.check_menu_no_prod()

        # 2. Кликнуть на карточку любого товара на странице
        # выбираем первый товар в разделе "Одежда"
        num_element = 1
        clothing_ware_1 = MainPage.Path.BLOCK_CLOTHING % num_element
        obj_clothing_ware_1 = self.get_element_navigate(self.driver, clothing_ware_1)
        name_ware_from_main_page = obj_clothing_ware_1.text
        obj_clothing_ware_1.click()

        breadcrumb_list = self.get_breadcrumb_list(self.driver)  # запоминаем хлебные крошки
        # выковыриваем идентификатор товара из url и берем по нему и по продовцу инфу из БД
        name_ware = self.get_element_navigate(self.driver, GoodPage.Check.TITLE_WARE)
        ware_id = name_ware.parent.current_url.split('/')[-1]
        db_ware_data = databases.db1.warehouse.get_wares_by_ware_id(ware_id)
        data_user = databases.db1.accounting.get_data_user_by_id(db_ware_data[0]["shop_id"])
        name = self.driver.find_element_by_xpath(GoodPage.Check.USER_NAME_SELLER)
        button = self.driver.find_element_by_xpath(GoodPage.Click.BTN_CALL_SELLER2)
        # проверка имени продавца, названия товара, наличия
        self.assertEqual(data_user[0]["display_name"], name.text)
        self.assertEqual(len(db_ware_data), 1, u"Find several ware with one id.")
        self.assertEqual(name_ware_from_main_page, name_ware.text)
        self.assertEqual(len(breadcrumb_list), 3, u"Does not match the number of levels of categories.")
        self.assertTrue(button.is_displayed(), u"Button is not active.")

        # 3. Переходим на страницу авторизации
        self.do_login(self.driver)
        #self.click_to_phone(self.driver)
        self.check_page_authorization(self.driver)  # Проверка страница авторизации
        # вводим данные на авторизацию и авторизовываемся
        user_phone = self.data_auths[0]["phone"][1:]
        obj_phone, obj_password, obj_submit_button = self.get_data_authorization(self.driver)
        self.send_password(password_object=obj_password, password_number=self.default_passwd)
        self.send_phone(phone_object=obj_phone, phone_number=user_phone)
        self.submit_button(obj_submit_button, sleep=3)

        # 4. Выполнить поиск товара
        # Получаем инпут поиска, кнопку поиска с главной страницы, вводим данные и жмем кнопку поиска
        input_search = self.get_element_navigate(self.driver, self.input_main.SEARCH)
        btn_search = self.get_element_navigate(self.driver, self.click_main.BTN_SEARCH)
        input_search.send_keys(ware_for_search["name"].decode('utf-8'))
        btn_search.click()
        # Проверяем, что перешли в результаты поиска
        self.get_element_navigate(self.driver, self.check_search.TITLE_SEARCH)
        # Ищем на странице товар, заданный в поиске и переходим на страницу товара, проверяем урл страницы и название
        path_ware = self.click_search.LNK_GOOD_WITH_HREF % (ware_for_search["id"], ware_for_search["name"])
        ware_in_search = self.get_element_navigate(self.driver, path_ware)
        ware_in_search.click()
        self.check_url_ware(ware_for_search["id"], self.driver.current_url)
        obj_ware_title = self.get_element_navigate(self.driver, self.check_good.TITLE_GOOD)
        self.assertEqual(self.get_name(obj_ware_title), ware_for_search["name"])

        # 5. Связаться с продавцом
        data_good, good_str = HelpChatMethods.get_good_data(self.driver)
        button_call = self.driver.find_element_by_xpath(GoodPage.Click.BTN_CALL_SELLER2)
        button_call.click()
        dialog_window = self.driver.find_element_by_xpath(GoodPage.Check.POPUP_MESSAGE_TO_SELLER)
        button_answer = self.driver.find_element_by_xpath(GoodPage.Click.BTN_ANSWER_TO_SELLER)

        self.assertIsNotNone(dialog_window, "Not found dialog window for answer seller!")
        self.assertTrue(button_answer.is_displayed(), "Button is not active.")
        text = common_utils.random_string(length=50)
        link_popup = self.check_good.POPUP_MSG_FROM_GOOD % HelpChatMethods.TEXT_MSG_TO_GOOD
        popup_text = self.get_element_navigate(self.driver, link_popup)

        HelpProfileSettingsMethods.clear_input_row(self.driver, popup_text) # очищаем сообщение
        popup_text.send_keys(text)
        button_answer.click()
        time.sleep(3)
        button_go_to_chat = self.driver.find_element_by_xpath(GoodPage.Click.BTN_GO_TO_CHAT)
        button_go_to_good_page = self.driver.find_element_by_xpath(GoodPage.Click.BTN_GO_TO_GOOD_PAGE)
        self.assertTrue(button_go_to_chat.is_displayed(), "Button 'go to chat' is not active.")
        self.assertTrue(button_go_to_good_page.is_displayed(), "Button 'go to good page' is not active.")
        button_go_to_chat.click()

        # В чате с продавцом есть отправленное сообщение и карточка товара. Проверить соответствие текста и товара.
        last_msg = HelpChatMethods.get_last_msg(self.driver)
        msg_error1 = "Экспресс карточка='%s' не совпадает с последним сообщением='%s'" % (good_str, last_msg)
        self.assertIn(good_str, last_msg, msg_error1)
        str_msg_to_good = HelpChatMethods.TEXT_MSG_TO_GOOD.replace(' ', '')
        msg_error2 = "Сообщение о товаре='%s' не совпадает с последним сообщением='%s'" % (str_msg_to_good, last_msg)
        self.assertIn(text, last_msg, msg_error2)

        # 6. Добавить контакт в контакт-лист
        HelpUserContactsMethods.click_in_contact(self.driver, ware_for_search["store_id"])

        # переходим в избранное и удаляем пользователя
        self.get_page(self.driver, self.path_user_contact.URL_FAVORITES_USERS)
        data_user = databases.db1.accounting.get_data_user_by_id(ware_for_search["store_id"])
        HelpUserContactsMethods.delete_first_user_in_cl(self.driver, fav_user=data_user[0])

        # 7.  Выполнить Logout и выполнить проверку.
        self.driver.refresh()
        Navigate.progress(self.driver)
        self.logout(self.driver)
        logo_main_page = self.driver.find_element_by_xpath(self.LOGO_HEADER_PAGE)
        self.assertIsNotNone(logo_main_page, u"Not found logo in main page.")
        self.go_to_main_page(self.driver)
        self.check_header_widget_visitor(self.driver)
        self.check_menu_no_prod()

# 需要导入模块: from tests.front_office.not_sorted.classes.class_navigate import HelpNavigateCheckMethods [as 别名]
# 或者: from tests.front_office.not_sorted.classes.class_navigate.HelpNavigateCheckMethods import progress [as 别名]
    def test_smoke_user_message(self):
        """
        Title: Тест сценарий отправки сообщения пользователем.
        Description: Предусловие:
            Перед тестом отправить (через api), пользователю под которым будет выполняться тест (Пользователь),
            два сообщения с текстом от разных контактов (Собеседник1 и Собеседник2)
            Есть два пользователя, от которых будет отправляться сообщения пользователю,
            под которым проходим тест (Собеседник 1 и Собеседник2)
            Существует пользователь зарегистрированный по e-mail - под ним будет выполняться тест (Пользователь).
        Шаги:
            1) Авторизоваться Пользователем через e-mail
                - Проверить, что отображается главная страница
                - Проверить наличие иконки 2х непрочитанных сообщений
            2) Перейти в "Сообщения":
                - Проверяем, что находимся на странице Сообщения с пользователем из предусловия,
                    который последним отправил сообщение (Собеседник2)
                - Проверяем, что в области переписки есть это сообщение и имя пользователя сообщения
                Проверяем, что счетчик непрочитанных сообщений в шапке, уменьшился на 1
                Проверяем, что в карточке с Собеседником2 нет иконки непрочитанных сообщений
                Проверяем, что  есть иконка 1 непрочитанного сообщения в карточке пользователя,
                    который первым отправлял сообщение (Собеседник1)
            3) Перейти на карточку Собеседника1
                Проверяем, что находимся на странице Сообщения с (Собеседник1)
                Проверяем, что в области переписки есть это сообщение  и имя пользователя сообщения
                Проверяем, что счетчик непрочитанных сообщений в шапке, исчез
                Проверяем, что в карточке с Собеседником1 нет иконки непрочитанных сообщений
                Проверяем, что  среди контактов нет иконок непрочитанных сообщений
            4) Написать сообщение Собеседнику1 и отправить
                Проверить, что сообщение отображается в области переписки, есть две галочки (сообщение пришло на сервер)
                Удостовериться что сообщение пришло на сервер.
            5) Выйти из аккаунта, со страницы "Сообщения"
                Проверить, что отображается страница Вход по электронная почта
        """
        service_log.run(self)

        # 1) Авторизоваться Пользователем через e-mail и проверить успешность операции.
        self.go_to_main_page(self.driver)
        self.click_reg_and_auth(self.driver)
        self.click_tab_login(self.driver)
        auth_form = self.get_auth_email_form(self.driver)
        auth_form["email_input"].send_keys(self.owner['email'])
        auth_form["password_input"].send_keys(self.default_passwd)
        self.element_click(self.driver, auth_form["login_btn"])
        self.check_header_widget_seller(self.driver, self.owner["id"])

        # Проверка количества новых сообщений в мессенждере
        msg_error1 = u"The message counter is not increased by %s" % self.new_messages
        msg_error2 = u"The message counter is decreased by 1"

        result = self.get_element_navigate(self.driver, self.check_main.ALL_NUMERATE_MSG)
        self.assertEqual(int(self.unread_message) + int(self.new_messages), int(result.text), msg_error1)

        # 2) Перейти в "Сообщения"
        self.driver.refresh()
        Navigate.progress(self.driver)
        obj_msgs = self.get_element_navigate(self.driver, self.check_main.ABSTRACT_MSG)
        obj_msgs.click()
        time.sleep(3)
        last_msg_for_user2 = self.get_last_msg2(self.driver)
        info_msg = last_msg_for_user2.split("\n")
        self.assertEqual(self.message2, info_msg[2], u"Not found message %s" % self.message2)
        #self.assertEqual(self.unread_message + (self.new_messages-1), int(result.text), msg_error2) # TODO
        self.assertEqual(self.user2['display_name'], info_msg[1], "Not found user2 %s" % self.user2['display_name'])

        # Warning: пользователи в чате нумеруются с нуля
        obj_counter_msgs_user2 = self.element_is_none(self.driver, self.check_main.COUNTER_MSG_USER % 0)
        obj_counter_msgs_user1 = self.get_element_navigate(self.driver, self.check_main.COUNTER_MSG_USER % 1)
        self.assertGreaterEqual(int(obj_counter_msgs_user1.text), 1)
        self.assertIsNone(obj_counter_msgs_user2)

        # 3) Перейти на карточку Собеседника1
        obj_counter_msgs_user1.click()
        time.sleep(3)
        last_msg_for_user1 = self.get_last_msg2(self.driver)
        info_msg = last_msg_for_user1.split("\n")
        self.assertEqual(self.message1, info_msg[2], u"Not found message %s" % self.message2)
        #self.assertEqual(self.unread_message, int(result.text), msg_error2) # TODO
        self.assertEqual(self.user1['display_name'], info_msg[1], u"Not found user2 %s" % self.user1['display_name'])

        obj_counter_msgs_user1 = self.element_is_none(self.driver, self.check_main.COUNTER_MSG_USER % 0)
        obj_counter_msgs_user2 = self.element_is_none(self.driver, self.check_main.COUNTER_MSG_USER % 1)
        self.assertIsNone(obj_counter_msgs_user1)
        self.assertIsNone(obj_counter_msgs_user2)

        # 4) Написать сообщение Собеседнику1 и отправить
        obj_area_text = self.get_element_navigate(self.driver, self.check_main.AREA_FOR_SEND_MSG)
        message_answer = "Autotests answer %s" % int(random.randint(10, 10000000))
        obj_area_text.send_keys(message_answer)
        obj_area_text = self.get_element_navigate(self.driver, self.click_chat.BTN_ANSWER)
        obj_area_text.click()
        time.sleep(3)
        last_msg_for_owner = self.get_last_msg2(self.driver)
        info_msg = last_msg_for_owner.split("\n")
        self.assertEqual(message_answer, info_msg[2], u"Not found message %s" % self.message2)
        self.assertEqual(self.owner['display_name'], info_msg[1], u"Not found owner %s" % self.owner['display_name'])

        # 5) Выйти из аккаунта, со страницы "Сообщения"
        self.driver.refresh()
        Navigate.progress(self.driver)
        self.logout(self.driver)
#.........这里部分代码省略.........

# 需要导入模块: from tests.front_office.not_sorted.classes.class_navigate import HelpNavigateCheckMethods [as 别名]
# 或者: from tests.front_office.not_sorted.classes.class_navigate.HelpNavigateCheckMethods import progress [as 别名]
    def test_add_good_in_deal_to_favorite_remove(self, test_data=HelpNavigateData.CATALOG_TO_GOOD, sleep=2):
        """
        Title: Добавить товар в избранное \ Удалить товар из избранного
        """
        service_log.run(self)

        # Берем тестового продавца на магазине которого будут проводиться проверки
        self.default_test_seller_id = AccountingMethods.get_default_user_id(role="buyer")
        self.user = databases.db1.accounting.get_user_by_account_id(self.default_test_seller_id)[0]
        AccountingMethods.save_user_password(user_id=self.user["id"], hash_passwd=self.user["code_value"])

        # Устанавливаем новый пароль для пользователя
        default_new_passwd = AccountingMethods.get_default_password()
        hash_res_new = generate_sha256(default_new_passwd, self.user["salt"])
        databases.db1.accounting.update_user_password(self.user["id"], hash_res_new)

        self.go_main(self.driver, phone=self.user["phone"], passwd=default_new_passwd, flag_auth=True)

        number_good = random.randrange(1, 10, 1)
        # test_data["start_xpath_good"] = self.click_catalog.GOOD_LNK

        # Переходим на все товары рандомной рутовой категории
        self.get_page(self.driver, self.path_category.URL_ALL_IN_CATEGORY % random.choice(self.ROOT_CATEGORY_SUITE))
        # Выбираем товар и сохраняем его имя
        service_log.put("Выбираем товар и сохраняем его имя")
        good_name = self.get_name(self.get_element_navigate(self.driver, test_data["start_xpath_good"] % number_good))
        # Переход на страницу товара
        service_log.put("Переход на страницу товара")
        self.check_navigate_in_good_page(self.driver, test_data, number_good)
        url_good = self.driver.current_url.encode("utf-8")
        good_id = url_good[url_good.rfind("/") + 1 :]
        # Жмем кнопку запросить цену по товару - товар в сделке, обновляем страницу
        service_log.put("Жмем кнопку запросить цену по товару - товар в сделке, обновляем страницу")
        btn_call_seller = self.get_element_navigate(self.driver, self.click_good.BTN_CALL_SELLER)
        self.click_button(btn_call_seller)
        input_msg = self.element_is_present(self.driver, self.input_good.POPUP_INPUT_MSG)
        input_msg.send_keys(str(time.time()))
        btn_send = self.get_element_navigate(self.driver, self.click_good.BTN_SEND)
        self.click_button(btn_send)
        btn_to_good = self.get_element_navigate(self.driver, self.click_good.BTN_TO_CARD_GOOD)
        self.click_button(btn_to_good)
        # Жмем кнопку добавить в избранное
        service_log.put("Жмем кнопку добавить в избранное")
        btn_add_to_favorite = self.get_element_navigate(self.driver, self.click_good.ADD_FAVORITE)
        btn_add_to_favorite.click()
        # Проверяем, что кнопка изменилась на удалить из избранного  остается такой же после обновления страницы
        service_log.put("Проверяем, что кнопка изменилась на удалить из избранного")
        self.get_element_navigate(self.driver, self.click_good.DEL_FAVORITE)
        self.driver.refresh()
        HelpNavigateCheckMethods.progress(self.driver)
        self.get_element_navigate(self.driver, self.click_good.DEL_FAVORITE)
        # Переходим в избранные товары
        service_log.put("Переходим в избранные товары")
        self.get_page(self.driver, self.path_favorites.URL_FAVORITES_GOODS)
        # Проверяем наличие товара в избранном
        service_log.put("Проверяем наличие товара в избранном")
        self.get_element_navigate(self.driver, self.click_favorite.GOOD_NAME_BY_ID_AND_TITLE % (good_name, good_id))
        # Удаляем из избранного
        service_log.put("Удаляем из избранного")
        del_favorite = self.get_element_navigate(self.driver, self.click_favorite.DEL_FAVORITE % (good_name, good_id))
        del_favorite.click()
        time.sleep(sleep)
        # Проверяем, что нет на странице избранного
        test_good = dict(
            xpath=(self.click_favorite.GOOD_NAME_BY_ID_AND_TITLE % (good_id, good_name)),
            err_msg="Товар остался в списке избранного после удаления",
        )
        self.check_no_such_element(self.driver, test_good)
        # Переходим на страницу товара и проверяем, что кнопка добавить в избранное
        service_log.put("Get page: %s" % url_good)
        do_get_work = time.time()
        self.driver.get(url_good)
        work_get_time = HelpNavigateCheckMethods.work_time(do_get_work)
        service_log.put("Onload event time: [%s]" % work_get_time)
        HelpNavigateCheckMethods.progress(self.driver)
        work_load_time = HelpNavigateCheckMethods.work_time(do_get_work)
        service_log.put("Page received: %s" % url_good)
        service_log.put("Page received time: %s" % work_load_time)
        self.get_element_navigate(self.driver, self.click_good.ADD_FAVORITE)

# 需要导入模块: from tests.front_office.not_sorted.classes.class_navigate import HelpNavigateCheckMethods [as 别名]
# 或者: from tests.front_office.not_sorted.classes.class_navigate.HelpNavigateCheckMethods import progress [as 别名]
    def test_add_good_to_favorite_remove(self, test_data=HelpNavigateData.CATALOG_TO_GOOD):
        """
        Title: Я могу добавить товар в избранное
        """
        service_log.run(self)

        # Берем тестового продавца на магазине которого будут проводиться проверки
        self.default_test_seller_id = AccountingMethods.get_default_user_id(role="buyer")
        self.user = databases.db1.accounting.get_user_by_account_id(self.default_test_seller_id)[0]
        AccountingMethods.save_user_password(user_id=self.user["id"], hash_passwd=self.user["code_value"])

        # Устанавливаем новый пароль для пользователя
        default_new_passwd = AccountingMethods.get_default_password()
        hash_res_new = generate_sha256(default_new_passwd, self.user["salt"])
        databases.db1.accounting.update_user_password(self.user["id"], hash_res_new)

        self.go_main(self.driver, phone=self.user["phone"], passwd=default_new_passwd, flag_auth=True)

        number_good = random.randrange(1, 5, 1)
        # Переходим на все товары рандомной рутовой категории
        self.get_page(self.driver, self.path_category.URL_ALL_IN_CATEGORY % random.choice(self.ROOT_CATEGORY_SUITE))
        # Выбираем товар и сохраняем его имя
        service_log.put("Выбираем товар и сохраняем его имя")
        good_name = self.get_name(self.get_element_navigate(self.driver, test_data["start_xpath_good"] % number_good))
        # Переход на страницу товара
        service_log.put("Переход на страницу товара")
        self.check_navigate_in_good_page(self.driver, test_data, number_good)
        url_good = self.driver.current_url.encode("utf-8")
        good_id = url_good[url_good.rfind("/") + 1 :]
        # Жмем кнопку добавить в избранное
        service_log.put("Жмем кнопку добавить в избранное")
        btn_add_to_favorite = self.element_is_present(self.driver, self.click_good.ADD_FAVORITE, wait=10)
        btn_add_to_favorite.click()
        # Проверяем, что кнопка изменилась на удалить из избранного  остается такой же после обновления страницы
        service_log.put("Проверяем, что кнопка изменилась на удалить из избранного")
        self.get_element_navigate(self.driver, self.click_good.DEL_FAVORITE)
        self.driver.refresh()
        HelpNavigateCheckMethods.progress(self.driver)
        self.get_element_navigate(self.driver, self.click_good.DEL_FAVORITE)
        # Переходим в избранные товары
        service_log.put("Переходим в избранные товары")
        self.get_page(self.driver, self.path_favorites.URL_FAVORITES_GOODS)
        # Проверяем наличие товара в избранном и переходим на страницу товара
        service_log.put("Проверяем наличие товара в избранном и переходим на страницу товара")
        good_name_lnk = self.get_element_navigate(self.driver, self.click_favorite.GOOD_NAME_BY_ID % good_id)
        good_name_lnk.click()
        # Удаляем из избранного
        service_log.put("Удаляем из избранного")
        del_favorite = self.get_element_navigate(self.driver, self.click_good.DEL_FAVORITE)
        del_favorite.click()
        # Проверяем, что кнопка изменилась на добавить в избранное
        service_log.put("Проверяем, что кнопка изменилась на добавить в избранное")
        self.get_element_navigate(self.driver, self.click_good.ADD_FAVORITE)
        # Переходим в избранные товары
        service_log.put("Переходим в избранные товары")
        self.get_page(self.driver, self.path_favorites.URL_FAVORITES_GOODS)
        test_good = dict(
            xpath=(self.click_favorite.GOOD_NAME_BY_ID_AND_TITLE % (good_name, good_id)),
            err_msg="Товар остался в списке избранного после удаления",
        )
        # Проверяем, что в избранном нет этого товара
        self.check_no_such_element(self.driver, test_good)