Python service_log.put函数代码示例

 def send_password(password_object, password_number):
     """ Ввести пароль.
     :param password_number: пароль
     :param password_object: объект формы для ввода пароля
     """
     service_log.put("Send password: %s" % password_number)
     password_object.send_keys(password_number)

    def test_makePublication_nothing(self):
        """ Опубликовать товар.
        Создаём товар. Проверяем, что по умолчанию статус опубликованности HIDDEN.
        Изменяем его статус. Проверяем, что по умолчанию статус опубликованности PUBLISHED.
        Снова изменяем его статус. Проверяем, что по умолчанию статус опубликованности HIDDEN.
        """
        service_log.run(self)
        msg_published = "Stock state not equal %s. Data from service."
        msg_published_db = "Stock state not equal %s. Data from DB."

        # создаём товар
        name_stock_state = 'HIDDEN'
        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)
        self.assertEqual(ware_warehouse.stockState, 3, msg_published % name_stock_state)
        ware_after_created = databases.db1.warehouse.get_wares_by_ware_id(ware_warehouse.wareId)[0]
        self.assertEqual(ware_after_created["stock_state_id"], 3, msg_published_db % name_stock_state)

        # выставляем состояние StockState Опубликованный товар. Доступен всем. Индексируется. HIDDEN = 3
        stock_state = self.get_StockState(name_stock_state)
        wh_ware_published = services.warehouse.root.tframed.makePublication(ware_warehouse.wareId, stock_state)
        self.assertEqual(wh_ware_published.stockState, stock_state, msg_published % name_stock_state)
        ware_after_changed = databases.db1.warehouse.get_wares_by_ware_id(ware_warehouse.wareId)[0]
        self.assertEqual(ware_after_changed["stock_state_id"], stock_state, msg_published_db % name_stock_state)

    def test_createWares(self):
        """ Создание нескольких товаров.
        Создаём дубликаты из существующих товаров.
        Сравниваем значения от сервиса со значениями из БД.
        """
        service_log.run(self)

        # создаём данные для товары
        wares_req = list()
        for ware in self.list_wares:
            duplicate_ware = self.duplicate_ware_req(shop_id=ware['shop_id'],
                                                     category=ware['managed_category_id'],
                                                     content=ware["content"],
                                                     stock_state=ware['stock_state_id'],
                                                     ware_import_id=None)  # TODO: ware_import_id - deprecate 22.06.15
            wares_req.append(duplicate_ware)

        # создаём несколько товаров
        wares_warehouse = services.warehouse.root.tframed.createWares(wares_req)
        service_log.put("Created wares: %s" % wares_warehouse)

        for ware in wares_warehouse:
            # Возьмём значение из БД только что созданного товара по его идентификатору
            ware_cassandra = databases.db1.warehouse.get_wares_by_ware_id(ware.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=ware, ware_dbase=ware_cassandra)

    def get_WareContentDto(int_fields=None, range_fields=None, enum_fields=None, multi_enum_fields=None,
                           currency_fields=None, text_fields=None, multi_text_fields=None, scale_fields=None,
                           file_fields=None):
        """Контентные поля товара.
        P.S: Должны соответствовать полям, определенным в описании категории товара.

        :param int_fields: Поле товара с целым значением, <IntegerFieldDto>
        :param range_fields: Поле товара со значением в виде целочисленного интервала, <IntegerRangeFieldDto>
        :param enum_fields: Поле товара с несколькими значениями из енума, <EnumFieldDto>
        :param multi_enum_fields: Поле товара с несколькими значениями из енума, <MultiEnumFieldDto>
        :param currency_fields: Поле товара со значением валютного типа, <CurrencyFieldDto>
        :param text_fields: Поле товара с текстовым значением, <TextFieldDto>
        :param multi_text_fields: Поле товара с несколькими текстовыми значениями, <MultiTextFieldDto>
        :param scale_fields: Поле товара, содержащее значение из какой-то шкалы, <ScaleFieldDto>
        :param file_fields: Поле товара с одним или несколькими файловыми значениями, <FileIdFieldDto>
        :return: <WareContentDto>
        """
        p = WareContentDto(integerFields=int_fields,
                           integerRangeFields=range_fields,
                           enumFields=enum_fields,
                           multiEnumFields=multi_enum_fields,
                           currencyFields=currency_fields,
                           textFields=text_fields,
                           multiTextFields=multi_text_fields,
                           scaleFields=scale_fields,
                           fileFields=file_fields)
        service_log.put("Get obj WaresFilterDto: %s" % str(p))
        return p

    def test_getWaresFilter_categories_and_states(self):
        """

        :return:
        """
        # TODO: лажает
        #  берём произвольный товар из бд и по его shop_id находим остальные товары продавца
        wares = databases.db1.warehouse.get_wares_with_limit(100)
        ware_cassandra = self.get_random_ware(wares)
        wares_cassandra = databases.db1.warehouse.get_wares_by_shop_id(shop_id=ware_cassandra['shop_id'])
        self.deserialize_and_update_all_contents(wares_cassandra)

        categories, moderation, stock = self.select_categories_moderation_stock(wares_cassandra, ware_cassandra)
        filtered_wares_cassandra = self.chose_ware_ids_with_requirement(wares_cassandra, categories, moderation, stock)

        # по user_id - находим все товары, т.к. None - должен выключать фильтр
        wares_filter_dto = self.get_WaresFilterDto(user_id=ware_cassandra['shop_id'],
                                                   categories=categories,
                                                   moderation_states=moderation,
                                                   stock_states=stock,
                                                   limit=None, offset=None)

        # делаем выборку товаров из воркера
        wares_warehouse = services.warehouse.root.tframed.getWaresFilter(wares_filter_dto)
        service_log.put("Response wares from worker: %s" % str(wares_warehouse))

        self.check_wares(wares_cassandra=filtered_wares_cassandra, wares_worker=wares_warehouse)

 def good_card_short(driver, good):
     """
     Метод получает объект короткая карточка товара по заданным данным
     :param good: данные товара
     :return:
     """
     main_picture = good["content"][u'pictures'][u'value'][0].encode('utf-8')
     title = good["content"][u'title'][u'value'].encode('utf-8')
     min_stock = good["content"][u'min_stock'][u'value']
     try:
         price = str(good["content"][u'price'][u'value'][u'significand'])
         if 3 < len(price) < 7:
             price = price[:-3] + " " + price[-3:]   # здесь в кавычках неразрывные пробелы
         elif len(price) >= 7:
             price = price[:-6] + " " + price[-6:-3] + " " + price[-3:]
     except Exception:
         price = "---"
     g_card = {
         "card": Navigate.element_is_present(driver, Navigate.click_search.GOOD_CARD_BY_ID % good["ware_id"]),
         "picture": Navigate.element_is_present(driver, Navigate.click_search.GOOD_PICTURE % (good["ware_id"],
                                                                                              main_picture)),
         "title": Navigate.element_is_present(driver, Navigate.click_search.GOOD_TITLE % (good["ware_id"], title)),
         "price": Navigate.element_is_present(driver, Navigate.click_search.GOOD_PRICE % (good["ware_id"], price)),
         "min_stock": Navigate.element_is_present(driver, Navigate.click_search.GOOD_MIN_STOCK % (good["ware_id"],
                                                                                                  min_stock)),
     }
     service_log.put("Короткая карточка товара найдена. Id: %s" % good["ware_id"])
     return g_card

 def modify(*args, **kwargs):
     request = func(*args, **kwargs)
     ex = args[0].__dict__["func"]
     service_log.put("Shell command: %s" % request)
     result = ex(request)
     service_log.put("Shell command result: %s" % result)
     return result

    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_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_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_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(self):
     """ Взять контексты сессии, выборка по типу и статусу контекста.
     :param only_active: Если only_active == true, контекст будет возвращен только если он активен.
     """
     # TODO: https://youtrack.home.oorraa.net/issue/M-143
     result = services.session.root.tframed.getContextForSession(self.session_id, self.context_type, False)
     service_log.put("Method getContextForSession returned result: %s" % result)

 def send_email(email_object, email_adress):
     """ Ввести e-mail пользователя.
     :param email_adress: e-mail пользователя
     :param email_object: объект формы для ввода e-mail
     """
     service_log.put("Send phone: %s" % email_adress)
     email_object.send_keys(email_adress)

 def send_phone(phone_object, phone_number):
     """ Ввести номер телефона.
     :param phone_number: номер телефона
     :param phone_object: объект формы для ввода телефона
     """
     service_log.put("Send phone: %s" % phone_number)
     phone_object.send_keys(phone_number)

 def cat_sub_cat(self, driver, name_ui, category_dict, section, section_name):
     """
     Проверка подкатегории у которой родительская категория - категория
     :param driver:
     :param name_ui:
     :param category_dict:
     :param section:
     :param section_name:
     :return:
     """
     # Получаем категории раздела
     category_id_list = self.get_categories_list(section)
     category_tree = self.get_categories_tree(category_dict, category_id_list)
     # Проверка, что из апи пришли категории которые принадлежат секции меню
     for name in name_ui:
         service_log.put("CHECK. Sub-category in category '%s'" % name)
         cat_clk = Navigate.get_element_navigate(driver, self.xpath_category % name, mode=None)
         Auth.click_button(cat_clk)
         category = [cat for cat in category_tree if cat.localizedName == name]
         # Получаем подкатегории из категории раздела
         sub_id_list = self.get_categories_list(category[0])
         sub_tree = self.get_categories_tree(category_dict, sub_id_list)
         sub_name_list = [sub.localizedName for sub in sub_tree]
         # Проверка возвращенных апи и показанных подкатегорий
         obj_ui_sub = self.get_sub_categories(driver)
         name_ui_sub = [obj.text.encode('utf-8') for obj in obj_ui_sub]
         # Получаем названия подкатегорий UI, которых нет в списке подкатегорий полученном из БД
         sub = lambda db, ui: filter(lambda x: x not in db, ui)
         sub_cat = sub(sub_name_list, name_ui_sub)
         err_msg = "В '%s -> %s' содержится подкатегория '%s', которой нет в ответе АПИ: %s"
         self.assertFalse(sub_cat, err_msg % (section_name, name, sub_cat, sub_name_list))
         service_log.put("PASS. Sub-category in category '%s'" % name)