Python service_log.run函数代码示例

    def test_search_not_auth_user(self):
        """ Проверка поиска по сайту, не авторизованным пользователем.
        Ищем заданного пользователя по сайту.
        Свяеряем поисковый запрос и запрос на страницу поиска.
        """
        service_log.run(self)

        # Берем тестового продавца на магазине которого будут проводиться проверки
        default_test_seller_id = AccountingMethods.get_default_user_id(role='seller')
        user = databases.db1.accounting.get_user_by_account_id(default_test_seller_id)[0]

        # Переходим на главную страницу и получаем инпут поиска и кнопку поиска
        self.go_main(self.driver, flag_auth=False)
        input_search = HelpNavigateMethods.get_element_navigate(self.driver, HelpNavigateMethods.input_main.SEARCH)
        btn_search = HelpNavigateMethods.get_element_navigate(self.driver, HelpNavigateMethods.click_main.BTN_SEARCH)

        # Вводим имя продавца и жмем кнопку поиска
        query = user["display_name"].decode('utf-8')
        input_search.send_keys(query)

        # интегрируем скрипт, запускаем сервер
        self.inclusion_js_script(self.driver)
        server = start_WebServer()

        # нажимаем кнопку поиска
        btn_search.click()

        # получаем ответ и проверяем данные счетчиков
        output_server = get_response_by_WebServer(server, 2)
        segment_data_query = self.parsing_segment_data(output_server[0]["body"])
        segment_data_visit = self.parsing_segment_data(output_server[1]["body"])
        self.check_search_query(segment_data=segment_data_query, query=query)
        self.check_search_result(segment_data=segment_data_visit, query=query)

    def test_makeModeration_new_ware_accepted(self):
        """ Проверяем метод для модерации товара.
        Создаём товар. Проверяем его статус - BELIEVED.
        Отсылаем запрос на перевод его в другой статус.
        Проверяем, что статус изменился на ACCEPTED.
        """
        service_log.run(self)
        # создаём товар
        ware_req = self.duplicate_ware_req(self.ware['shop_id'], self.ware['managed_category_id'],
                                           self.ware["content"], self.ware['stock_state_id'])

        ware_warehouse = services.warehouse.root.tframed.createWare(ware_req)
        service_log.put("Created ware: %s" % ware_warehouse)
        # Возьмём значение из БД только что созданного товара №1 по его идентификатору
        ware_believed_dbase = databases.db1.warehouse.get_wares_by_ware_id(ware_warehouse.wareId)
        service_log.put("Ware created from BD: %s" % ware_believed_dbase)
        # Проверяем, что статус товара - BELIEVED.
        self.assertEqual(ware_believed_dbase[0]['moderation_state_id'], 1, "Ware moderation status not BELIEVED.")
        # Меняем статус
        ware_warehouse = services.warehouse.root.tframed.makeModeration(ware_warehouse.wareId, True, self.moderator_id)
        # Возьмём значение из БД только что созданного товара №1 по его идентификатору
        ware_accepted_warehouse = databases.db1.warehouse.get_wares_by_ware_id(ware_warehouse.wareId)
        service_log.put("Ware created from BD: %s" % ware_accepted_warehouse)
        # Проверяем, что статус изменился на ACCEPTED.
        self.assertEqual(ware_accepted_warehouse[0]['moderation_state'], 2, "Ware moderation status not ACCEPTED by BD")
        self.assertEqual(ware_warehouse.moderationState, 2, "Ware moderation status not ACCEPTED by service")

    def test_new_importWare(self):
        """ Импорт премодерированного товара
        Товар проходит базовую валидацию, переводится в указанное состояние
        и помечается как отмодерированный.
        """
        # TODO: Ошибка "https://jira.oorraa.net/browse/RT-290"
        service_log.run(self)

        # импортируем новый товар
        ware_req = self.duplicate_import_ware_req(shop_id=self.ware1['shop_id'],
                                                  category=self.ware1['managed_category'],
                                                  content=self.ware1["content"],
                                                  moderator_id=int(self.get_default_user_id("moderator")),
                                                  stock_state=self.get_StockState("PUBLISHED"),
                                                  ware_import_id=str(unique_number()))
        wares_warehouse = services.warehouse.root.tframed.importWare(ware_req)
        service_log.put("Import ware: %s" % wares_warehouse)

        # Возьмём значение из БД только что импортированного товара по его идентификатору
        ware_cassandra = databases.db1.warehouse.get_wares_by_ware_id(wares_warehouse.wareId)
        service_log.put("Ware from BD: %s" % ware_cassandra)

        # проверяем, что вернулось только один товар
        self.assertEqual(len(ware_cassandra), 1, "Found more than one item.")
        ware_cassandra = ware_cassandra[0]

        self.update_data_content(ware_cassandra, self.deserialize_content(ware_cassandra['content']))

        #  проверяем полученно значение от сервиса со значениями из БД
        self.check_ware(ware_worker=wares_warehouse, ware_dbase=ware_cassandra)

    def test_restorePassword_by_phone_resend_password(self):
        """
        Title: Я могу запросить Повторную отправку пароля, при восстановлении пароля по телефону
        Description:
            * Отображается соответствующее сообщение
        """
        service_log.run(self)
        self.go_authorization_page(self.driver)
        self.go_restore_page(self.driver)
        self.click_to_phone(self.driver)
        phone, sent_passwd_button = self.get_data_restore(self.driver)
        user = databases.db1.accounting.get_for_restore()[0]
        AccountingMethods.save_user_password(user_id=user["id"], hash_passwd=user["code_value"], salt=user["salt"])

        phone.send_keys(user["phone"][1:])
        self.click_button(sent_passwd_button)
        self.check_password_is_sent(self.driver)
        self.check_form_sent_passwd(self.get_form_note(self.driver))
        data1 = databases.db1.accounting.get_sms(phone=user["phone"])[0]
        self.check_sms_status(data1)


        not_get_passwd = self.get_message_have_not_receiver_passwd(self.driver)
        self.click_button(not_get_passwd)
        self.check_instruction_not_receiver_passwd(self.driver)
        self.click_button(self.get_repeat_send_passwd(self.driver))

        data2 = databases.db1.accounting.get_sms(phone=user["phone"])[0]
        self.check_sms_status(data2)
        new_passwd1 = data1["message"][-5:]
        new_passwd2 = data2["message"][-5:]
        msg_error = "ОШИБКА: Первый высланный пароль совпадает с повторно высланным паролем"
        self.assertNotEqual(new_passwd1, new_passwd2, msg_error)

    def test_restorePassword_by_phone_incorrect_password(self):
        """
        Title: Я не могу войти в систему, если некорректно введу полученный при восстановлении по телефону пароль.
        Description:
            * Отобразится сообщение "Пароль неверен"
        """
        service_log.run(self)
        password = ['incorrect pass', '123']
        self.go_authorization_page(self.driver)
        self.go_restore_page(self.driver)
        self.click_to_phone(self.driver)

        phone, sent_passwd_button = self.get_data_restore(self.driver)
        user = databases.db1.accounting.get_users_with_status()[0]
        AccountingMethods.save_user_password(user_id=user["id"], hash_passwd=user["code_value"], salt=user["salt"])
        default_new_passwd = AccountingMethods.get_default_password(4)
        override_passwd_hash = generate_sha256(default_new_passwd, user["salt"])
        databases.db1.accounting.update_passwd_hash_by_phone(passwd_hash=override_passwd_hash, phone=user["phone"])

        # вводим номер телефона
        phone.send_keys(user["phone"][1:])
        self.click_button(sent_passwd_button)
        self.check_password_is_sent(self.driver)

        pass_input = self.get_pass_input(self.driver)
        submit_button = self.get_login(self.driver)

        self.check_form_sent_passwd(self.get_form_note(self.driver))

        pass_input.send_keys(password[1])
        self.click_button(submit_button)

        time.sleep(1)
        self.check_incorrect_passwd_or_phone(self.driver)

    def test_authorization_by_phone_correct(self, type_password="CORRECT"):
        """
        Title: Я могу войти в систему введя корректный телефон и пароль
        Description:
        Проверка:
            * Наличие профиля пользователя
            * Имя в профиле совпадает с именем пользователя
            * Аватар пользователя совпадает с аватаром пользователя
            * Номер телефона совпадает с номером телефона пользователя
        """
        service_log.run(self)
        # Устанавливаем новый пароль для пользователя
        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_authorization_page(self.driver)

        # Проверка страница авторизации
        self.check_page_authorization(self.driver)

        obj_phone, obj_password, obj_submit_button = self.get_data_authorization(self.driver)
        changed_passwd = self.get_password(type_passwd=type_password, source_passwd=default_new_passwd)
        changed_phone = self.get_phone(type_phone=self.type_phone, source_phone=self.user["phone"])

        # Вводим данные на авторизацию
        self.send_password(password_object=obj_password, password_number=changed_passwd)
        self.send_phone(phone_object=obj_phone, phone_number=changed_phone)

        # Нажатие на кнопку авторизации
        Navigate.element_click(self.driver, obj_submit_button, change_page_url=True)

        # Проверка виджета профиля
        self.user_profile_menu(self.driver, self.user)

    def test_authorization_by_phone_incorrect_password(self, type_password="INCORRECT"):
        """
        Title: Я не могу войти в систему, введя корректный телефон и неверный пароль.
        Description:
        * Отображается сообщение "Проверьте правильность ввода номера телефона и пароля"
        """
        service_log.run(self)
        # Устанавливаем новый пароль для пользователя
        default_new_passwd = AccountingMethods.get_default_password(num=3)
        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_authorization_page(self.driver)
        obj_phone, obj_password, obj_submit_button = self.get_data_authorization(self.driver)
        changed_passwd = self.get_password(type_passwd=type_password, source_passwd=default_new_passwd)
        changed_phone = self.get_phone(type_phone=self.type_phone, source_phone=self.user["phone"])

        # Вводим данные на авторизацию
        self.send_password(password_object=obj_password, password_number=changed_passwd)
        self.send_phone(phone_object=obj_phone, phone_number=changed_phone)

        # Нажатие на кнопку авторизации
        self.submit_button(obj_submit_button)

        # Проверка формы при не корректном пароле
        self.check_incorrect_passwd(self.driver)

    def test_getSessionById_one_ctx(self, only_active=True):
        """ Проверка getSessionById с одним контекстом.
        Возвращает сессию по ID. Сессия включает все свои контексты.
        Если onlyActive == true, возвращаются только активные контексты.
        :return:
        """
        service_log.run(self)
        # Создаем новую сессию, дополнительные котексты для неё
        context_params = self.generate_default_session()
        params_req = self.get_SessionContextRequestDto(**context_params)
        session = services.session.root.tframed.initSession(params_req)
        service_log.put("Get session data: %s" % session)

        # собираем информацию о контекстах до инвалидации и получаем контекс сессии по его идентификатору
        before_meta_context, before_data_context = self.get_contexts_from_redis(session.contexts[0].contextId)
        result = services.session.root.tframed.getSessionById(session.sessionId, only_active)

        # собираем информацию о контекстах и сессии после инвалидации
        after_meta_context, after_data_context = self.get_contexts_from_redis(session.contexts[0].contextId)
        this_session, list_context_ids = self.get_information_about_session(session.sessionId)

        self.check_session_changed_last_timestamp(this_session, session)
        self.assertEqual(len(session.contexts), len(list_context_ids), "Not equal to data from redis.")
        self.assertEqual(len(list_context_ids), 1, "Too many contexts")
        self.assertDictEqual(after_data_context, before_data_context)
        self.check_context_meta_data(after_meta_context, before_meta_context)
        self.check_context(session.sessionId, result.contexts[0], meta_context=after_meta_context, data_context=after_data_context)

    def test_refresh_on_get_false_getContextForSession(self):
        """ Проверка что флаг refresh_on_get = False работает для метода getContextForSession.
        Создаем новую сессию с флагом refresh_on_get = False.
        Вызываем методы getContextForSession.
        Проверяем, что время не изменилось.
        """
        service_log.run(self)
        # Создаем новую сессию с флагом refresh_on_get = False
        context_params = self.generate_default_session()
        context_params.update({"refresh_on_get": False})
        params_req = self.get_SessionContextRequestDto(**context_params)
        session = services.session.root.tframed.initSession(params_req)

        # собираем информацию о сессии и контекстах до всех операций
        before_meta_context = self.get_contexts_from_redis(session.contexts[0].contextId)[0]
        before_this_session = self.get_information_about_session(session.sessionId)[0]

        result03 = services.session.root.tframed.getContextForSession(session.sessionId,
                                                                      context_params["context_type"], False)
        self.assertEqual(int(before_meta_context['creationTimeStamp']), int(result03.creationTimestamp))
        self.assertEqual(int(before_meta_context['expirationTimeStamp']), int(result03.expirationTimestamp))
        self.assertEqual(int(before_meta_context['lastAccessTimeStamp']), int(result03.lastAccessTimestamp))

        # собираем информацию о сессии и контекстах после всех операций
        after_this_session = self.get_information_about_session(session.sessionId)[0]
        after_meta_context = self.get_contexts_from_redis(session.contexts[0].contextId)[0]
        self.assertEqual(before_this_session['creationTime'], after_this_session['creationTime'])
        self.assertEqual(before_this_session['lastAccessTimeStamp'], after_this_session['lastAccessTimeStamp'])
        self.assertEqual(before_meta_context['creationTimeStamp'], after_meta_context['creationTimeStamp'])
        self.assertEqual(before_meta_context['expirationTimeStamp'], after_meta_context['expirationTimeStamp'])
        self.assertEqual(before_meta_context['lastAccessTimeStamp'], after_meta_context['lastAccessTimeStamp'])

    def test_getContextById_one_inactive_ctx_onlyActive_true(self):
        """ Проверка возвращения контекста для одной сессии с одним контекстом, onlyActive флаг = False и True.
        Если onlyActive == true, контекст будет возвращен только если он активен.
        Если контекст активен и refresh == true, его lastAccessTimestamp и expirationTimestamp будут обновлены.
        """
        service_log.run(self)
        only_active = True
        # Создаем новую сессию, дополнительные котексты для неё
        params_req = self.get_SessionContextRequestDto(**self.generate_default_session())
        session = services.session.root.tframed.initSession(params_req)
        service_log.put("Get session data: %s" % session)
        # инвалидируем контекст
        services.session.root.tframed.invalidateContext(session.contexts[0].contextId)
        service_log.put("Get session data after invalidate context: %s" % session)

        # собираем информацию о контекстах до инвалидации и получаем контекс сессии по его идентификатору
        before_meta_context, before_data_context = self.get_contexts_from_redis(session.contexts[0].contextId)
        result = services.session.root.tframed.getContextById(session.contexts[0].contextId, only_active)

        # собираем информацию о контекстах после инвалидации
        this_session, list_context_ids = self.get_information_about_session(session.sessionId)
        after_meta_context, after_data_context = self.get_contexts_from_redis(session.contexts[0].contextId)

        self.assertIsNone(result)
        self.check_session_changed_last_timestamp(this_session, session)
        self.assertEqual(len(session.contexts), len(list_context_ids), "Not equal to data from redis.")
        self.assertEqual(len(list_context_ids), 1, "Too many contexts")
        self.assertDictEqual(after_data_context, before_data_context)
        self.check_context_meta_data(after_meta_context, before_meta_context)

    def test_getContextForSession_one_ctx(self, context_type="auth", only_active=True):
        """ Проверка getContextForSession с одним контекстом и разнами типа контекстов.
        Возвращает контекст данного типа для данной сессии.
        Если onlyActive == true, контекст будет возвращен только если он активен.
        """
        service_log.run(self)
        # Создаем новую сессию, дополнительные котексты для неё
        context_params = self.generate_default_session(context_type)
        params_req = self.get_SessionContextRequestDto(**context_params)
        session = services.session.root.tframed.initSession(params_req)
        service_log.put("Get session data: %s" % session)

        # собираем информацию о контекстах до инвалидации и получаем контекс сессии по его идентификатору
        before_meta_context, before_data_context = self.get_contexts_from_redis(session.contexts[0].contextId)
        result = services.session.root.tframed.getContextForSession(session.sessionId, context_type, only_active)

        # собираем информацию о контекстах и сессии после инвалидации
        after_meta_context, after_data_context = self.get_contexts_from_redis(session.contexts[0].contextId)
        this_session, list_context_ids = self.get_information_about_session(session.sessionId)

        self.check_session_changed_last_timestamp(this_session, session)
        self.assertEqual(len(session.contexts), len(list_context_ids), "Not equal to data from redis.")
        self.assertEqual(len(list_context_ids), 1, "Too many contexts")
        self.assertDictEqual(after_data_context, before_data_context)
        self.check_context_meta_data(after_meta_context, before_meta_context)
        self.check_context(session.sessionId, result, meta_context=after_meta_context, data_context=after_data_context)

    def test_invalidateSession(self):
        """ Проверка инвалидации всех активных контекстов сессии.
        """
        service_log.run(self)
        # Создаем новую сессию, дополнительные котексты для неё
        params_req = self.get_SessionContextRequestDto(**self.generate_default_session())
        session = services.session.root.tframed.initSession(params_req)
        service_log.put("Get session data: %s" % session)

        # собираем информацию о контекстах до инвалидации и инвалидируем контектсы сессии
        before_meta_context, before_data_context = self.get_contexts_from_redis(session.contexts[0].contextId)
        result = services.session.root.tframed.invalidateSession(session.sessionId)
        service_log.put("Get session data after invalidate context: %s" % session)

        # собираем информацию о сессии и контекстах после инвалидации
        this_session, list_context_ids = self.get_information_about_session(session.sessionId)
        after_meta_context, after_data_context = self.get_contexts_from_redis(session.contexts[0].contextId)

        # проверка, что данные кроме статуса не изменились (и кроме некоторых таймеров)
        self.assertIsNone(result)
        self.check_session(this_session, session)
        self.check_context_meta_data_without_status_and_not_changed_expiration(after_meta_context, before_meta_context)
        self.assertEqual(len(session.contexts), len(list_context_ids), "Not equal to data from redis.")
        self.assertEqual(len(list_context_ids), 1, "Too many contexts")
        self.assertDictEqual(after_data_context, before_data_context)
        self.assertEqual(self.get_context_status(after_meta_context['contextStatus']), 2, "Status context not REVOKED.")

    def test_first_visit_login(self, role="seller"):
        """ Проверка авторизации на сайте.
        Переходим на главную страницу. Переходим на страницк авторизации.
        Интегрируем в неё скрипт для перехвата сообщений и отправки их на наш тестовый сервер.
        Авторизуемся под пользователем.
        Получаем ответ и проверяем его.
        """
        service_log.run(self)

        # делаем выборку пользователя и устанавливаем новый пароль для пользователя
        user_id = AccountingMethods.get_default_user_id(role=role)
        user = databases.db1.accounting.get_user_by_account_id(user_id)[0]
        default_new_passwd = AccountingMethods.get_default_password()
        hash_res_new = generate_sha256(default_new_passwd, user["salt"])
        databases.db1.accounting.update_user_password(user["id"], hash_res_new)

        # переходим на страницу авторизации
        HelpAuthMethods.go_authorization_page(self.driver)

        # интегрируем скрипт, запускаем сервер
        self.inclusion_js_script(self.driver)
        server = start_WebServer()

        self.auth_to_website(passwd=default_new_passwd, phone=user["phone"])

        output_server = get_response_by_WebServer(server, 2)
        segment_data1 = self.parsing_segment_data(output_server[0]["body"])
        segment_data2 = self.parsing_segment_data(output_server[1]["body"])
        self.check_login(role=role, segment_data=segment_data1)
        self.check_first_visit_for_auth(segment_data=segment_data2, role=role, page="index")

    def test_search_auth_user(self):
        """ Проверка поиска по сайту, авторизованным пользователем.
        Ищем заданного пользователя по сайту.
        Свяеряем поисковый запрос и запрос на страницу поиска.
        """
        service_log.run(self)

        # делаем выборку пользователя и устанавливаем новый пароль для пользователя
        user_id = AccountingMethods.get_default_user_id(role="buyer")
        user = databases.db1.accounting.get_user_by_account_id(user_id)[0]
        default_new_passwd = AccountingMethods.get_default_password()
        hash_res_new = generate_sha256(default_new_passwd, user["salt"])
        databases.db1.accounting.update_user_password(user["id"], hash_res_new)

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

        # вводим строку для поиска
        input_search = HelpNavigateMethods.get_element_navigate(self.driver, HelpNavigateMethods.input_main.SEARCH)
        btn_search = HelpNavigateMethods.get_element_navigate(self.driver, HelpNavigateMethods.click_main.BTN_SEARCH)
        query = user["display_name"].decode('utf-8')
        input_search.send_keys(query)

        # интегрируем скрипт, запускаем сервер
        self.inclusion_js_script(self.driver)
        server = start_WebServer()

        # нажимаем кнопку поиска
        btn_search.click()

        # получаем ответ и проверяем данные счетчиков
        output_server = get_response_by_WebServer(server, 2)
        segment_data_query = self.parsing_segment_data(output_server[0]["body"])
        segment_data_visit = self.parsing_segment_data(output_server[1]["body"])
        self.check_search_query(segment_data=segment_data_query, query=query, role=u'registered')
        self.check_search_result(segment_data=segment_data_visit, query=query, role=u'registered')

    def test_authorization_by_phone_incorrect_user_disabled(self, type_password="CORRECT"):
        """
        Title: Я не могу войти в систему по телефону, если  мой пользователь в статусе DISABLED
        (пользователь Заблокирован)
        Description:
        * Отображается соответствующее сообщение
        """
        service_log.run(self)
        status = "DISABLED"
        user = databases.db1.accounting.get_not_enabled_user(status=status)[0]
        AccountingMethods.save_user_password(user_id=user["id"], hash_passwd=user["code_value"])

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

        # Переходим на страницу авторизации
        self.go_authorization_page(self.driver)
        obj_phone, obj_password, obj_submit_button = self.get_data_authorization(self.driver)
        changed_passwd = self.get_password(type_passwd=type_password, source_passwd=default_new_passwd)
        changed_phone = self.get_phone(type_phone=self.type_phone, source_phone=user["phone"])

        # Вводим данные на авторизацию
        self.send_password(password_object=obj_password, password_number=changed_passwd)
        self.send_phone(phone_object=obj_phone, phone_number=changed_phone)

        # Нажатие на кнопку авторизации
        self.submit_button(obj_submit_button)

        # Проверка блокировки пользователя
        Navigate.get_element_navigate(self.driver, self.check_auth.ERR_CHECK_DISABLED)
        Navigate.go_to_main_page(self.driver)
        self.check_header_widget_visitor(self.driver)