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)

    def get_js_scripts2(segment_url='http://example.com/segment'):
        """ Получить JavaScript для внедренния его в страницу и перехвата метрик.
        P.S: Обновленный скрипт
        :param: url-адрес для отсылки перехваченного сообщения.
        :return: type(str)
        """

        service_log.put("Response url for script: %s" % segment_url)
        p = """(function(url){

                function sendData(method, args) {
                    var data = {
                        segmentMethod: method,
                        // Делаем из args нормальный массив
                        params: Array.prototype.slice.call(args, 0)
                    };
                    var xhr = new XMLHttpRequest();
                    xhr.open("POST", url);
                    xhr.send(JSON.stringify(data));
                }

                ["identify", "track", "page", "alias"].forEach(function(method){
                    var oldMeth = analytics[method];

                    analytics[method] = function() {
                        sendData(method, arguments);
                        oldMeth.apply(this, arguments);
                    };
                });

            })('%s' /* урл для отправки данных */);""" % segment_url
        service_log.put("Get JavaScript for load in page")
        return p

    def execute(self, req, parameters=None):
        """ Выполнить запрос.
        :param req: сql-запрос
        :return: результат операции
        """

        session = None
        try:
            session = self.connect_plain_auth(user_name=self.user, password=self.passwd, port=self.port,
                                              key_space=self.name, contacts_point=self.host)
            if parameters is not None:
                # вариант с предварительной привязкой параметров, для работы с BLOB
                prepare_params = session.prepare(req)
                bound_params = prepare_params.bind(parameters)
                result = session.execute(bound_params)
            else:
                result = session.execute(req)
            service_log.put("Response from cassandra.")
            if isinstance(result, list):
                if len(result) > 0:
                    return [dict(index.__dict__) for index in result]
                else:
                    return None
            else:
                return result
        except Exception, tx:
            service_log.error(str(tx))
            raise AssertionError(str(tx))

 def generate_session_id():
     """ Сгенерировать идентификатор сессии.
     :return: строка
     """
     session_id = str(random.randint(1000000000, 100000000000000))
     service_log.put("Session id for user: %s" % session_id)
     return session_id

 def close(self, cursor):
     """ Закрываем соединение.
     :param cursor: ссылка на курсор
     """
     # cursor.close()
     # self.conn.close()
     service_log.put("Closing opened oracle connections.")

    def recover_user_password(link_db):
        """ Восстановить пароль пользователя и соль пользователя.
        Если переменная с паролем и идентификатором пользователь не пустые, обновлем пароль у этого пользователя.
        Если переменная с солью пользователя не пустая, восстанавливаем и её (обратная совеместимость).
        Если переменная с паролем и идентификатором пользователь были пустые, возвращаем False.
        :param link_db: ссылка на коннектор БД, например: databases.db1 (для гибкости схем запуска автотестов)
        :return: type(bool)
        """
        # TODO: Т.к. номер БД влияет на корректность запросов, передаем линк на коннектор БД для заданной схемы
        if AccountingMethods.SAVE_HASH_USER_PASSWORD and AccountingMethods.SAVE_HASH_USER_ID is not None:
            service_log.put("Try recover password hash for user ID's: %s" % AccountingMethods.SAVE_HASH_USER_ID)
            # databases.db1.accounting.update_user_password(AccountingMethods.SAVE_HASH_USER_ID,
            # AccountingMethods.SAVE_HASH_USER_PASSWORD)
            link_db.accounting.update_user_password(AccountingMethods.SAVE_HASH_USER_ID,
                                                    AccountingMethods.SAVE_HASH_USER_PASSWORD)
            service_log.put("Recovered password hash: %s" % AccountingMethods.SAVE_HASH_USER_PASSWORD)

            # если соль была сохранена
            if AccountingMethods.SAVE_HASH_USER_SALT is not None:
                service_log.put("Try recover salt for user ID's: %s" % AccountingMethods.SAVE_HASH_USER_SALT)
                # databases.db1.accounting.update_user_salt(AccountingMethods.SAVE_HASH_USER_ID,
                # AccountingMethods.SAVE_HASH_USER_SALT)
                link_db.accounting.update_user_salt(AccountingMethods.SAVE_HASH_USER_ID,
                                                    AccountingMethods.SAVE_HASH_USER_SALT)
                service_log.put("Recovered salt: %s" % AccountingMethods.SAVE_HASH_USER_SALT)

            AccountingMethods.SAVE_HASH_USER_ID = None
            AccountingMethods.SAVE_HASH_USER_PASSWORD = None
            AccountingMethods.SAVE_HASH_USER_SALT = None
            return True
        else:
            service_log.put("The variable with the user's password or ID is empty. Password recovery user cancelled.")
            return False