def check_ware_message(self, driver, dialog, message, link_db):
"""
Проверить сообщение-карточка товара
:param messages:
:return:
"""
service_log.put("Checking Ware-message")
ware_id = message[u'wareId'].encode('utf-8')
ware = link_db.warehouse.get_wares_by_ware_id(ware_id)[0]
info = ware[u'content']
picture = info[u'pictures'][u'value'][0].encode('utf-8')
title = info[u'title'][u'value'].encode('utf-8')
p = [str(info[i][u'value'][u'significand']) for i in info if i == u'price']
p = ''.join(p)
prc = lambda s: "---" if s == '' else s
price = prc(p)
quantity = str(info[u'min_stock'][u'value'])
Navigate.element_is_present(driver, Navigate.check_chat.WARE_PICTURE % (dialog, ware_id, picture))
Navigate.element_is_present(driver, Navigate.check_chat.WARE_NAME % (dialog, ware_id, title))
price_web = Navigate.element_is_present(driver, Navigate.check_chat.WARE_PRICE % (dialog, ware_id)).text
price_web = price_web.encode('utf-8').replace(' ', '')
self.assertEqual("Заштуку\n%sруб." % price, price_web, "Цена из БД '%s', цена из web '%s'" % (price, price_web))
quantity_web = Navigate.element_is_present(driver, Navigate.check_chat.WARE_QUANTITY % (dialog, ware_id)).text
quantity_web = quantity_web.encode('utf-8').replace(' ', '')
self.assertEqual("Мин.заказ\n%sшт." % quantity, quantity_web, "Мин. заказ из БД '%s', и из web '%s'" %
(quantity, quantity_web))
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_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 close(self, cursor):
""" Закрываем соединение.
:param cursor: ссылка на курсор
"""
#cursor.close()
#self.conn.close()
service_log.put("Closing opened oracle connections.")
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 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_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 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 get_login(driver):
""" Ссылка на залогинивание.
:param driver: драйвер
"""
p = HelpNavigateCheckMethods.element_is_present(driver, HelpAuthData.MENU_LOGIN)
service_log.put("Submit button find.")
return p
def test_createWare(self, n=1):
""" Создание товара.
Создаём дубликат существующего товара.
Сравниваем значения от сервиса со значениями из БД.
"""
service_log.run(self)
# создаём товар
ware_req = self.duplicate_ware_req(shop_id=self.ware1['shop_id'],
category=self.ware1['managed_category_id'],
content=self.ware1["content"],
stock_state=self.ware1['stock_state_id'])
wares_warehouse = services.warehouse.root.tframed.createWare(ware_req)
service_log.put("Created 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 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 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 command_execution(self, cls, flag_output=True):
""" Выполнить оперцию на удалённой консоли.
:param client: ссылка на удалённую консоль
:param cls: команда, которую необходимо запустить
:param flag_output: если флаг False, то результат не возвращаем
:return: Результат выполненной операции, либо ничего
"""
if self.passwd is not None:
client = self.connect_by_user_password()
elif self.keyfile is not None:
client = self.connect_by_key_file()
else:
msg_error = "Not found password or keyfile for connect!"
service_log.error(msg_error)
raise AssertionError(msg_error)
try:
service_log.put("Execute: %s." % cls)
if flag_output is True:
stdin, stdout, stderr = client.exec_command("""%s""" % cls)
data = dict(stdout=stdout.read(), stderr=stderr.read())
if data["stderr"] != '':
service_log.put("Return. Output: %s" % str(stderr))
service_log.put("Execute success. Output: %s" % str(data))
raise AssertionError("Return error: %s" % str(stderr))
service_log.put("Execute success. Output: %s" % str(data))
return data
else:
client.exec_command("""%s""" % cls)
service_log.put("Execute success.")
return None
except Exception, tx:
service_log.error(str(tx))
raise AssertionError(str(tx))
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 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 convert_WareContentDto_to_dict(content):
""" Конвертировать словарь экземпляров класса для WareContentDto в словарь.
:return: словарь с данными
"""
wh = WarehouseMethods
fields_currency = wh.elem_WareContentDto_to_dict(content.currencyFields)
fields_enum = wh.elem_WareContentDto_to_dict(content.enumFields)
fields_file = wh.elem_WareContentDto_to_dict(content.fileFields, 2)
fields_integer = wh.elem_WareContentDto_to_dict(content.integerFields)
fields_integer_range = wh.elem_WareContentDto_to_dict(content.integerRangeFields)
fields_multi_enum = wh.elem_WareContentDto_to_dict(content.multiEnumFields, 2)
fields_multi_text = wh.elem_WareContentDto_to_dict(content.multiTextFields)
fields_scale = wh.elem_WareContentDto_to_dict(content.scaleFields)
fields_text = wh.elem_WareContentDto_to_dict(content.textFields)
p = dict(ENUM=fields_enum,
CURRENCY=fields_currency,
FILE_ID=fields_file,
INTEGER=fields_integer,
RANGE=fields_integer_range,
MULTI_ENUM=fields_multi_enum,
MULTI_TEXT=fields_multi_text,
SCALE=fields_scale,
TEXT=fields_text)
service_log.put("Convert instance WareContentDto to dict: %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 test_click_home(self):
"""
Title: Я могу находясь на любой странице сайта перейти на главную кликнув на "домик" в главном меню.
"""
parameters = {
'404': '',
'section': str(self.section.categoryId),
'category': str(self.category.categoryId),
'sub-category': str(self.sub_category.categoryId),
'shop': AccountingMethods.get_default_user_id('seller'),
}
url = lambda sm, p, ps: sm[p] if ps[p] is '' else sm[p] % ps[p]
for param in parameters:
service_log.put("Checking...['%s']" % param)
base_url = self.driver.current_url
source = self.driver.page_source
url_page = url(self.SITE_MAP, param, parameters)
self.get_page(self.driver, url_page)
source_new = self.driver.page_source
self.assertNotEqual(source, source_new, "Переход по url='%s' не произошел" % url)
btn_home = self.get_element_navigate(self.driver, self.click_main.MAIN_MENU_HOME)
HelpAuthCheckMethods.click_button(btn_home, sleep=3)
current_url = self.driver.current_url
source_home = self.driver.page_source
self.assertEqual(base_url, current_url, "Переход на главную не произошел")
self.assertNotEqual(source_home, source_new, "Переход на главную не произошел")
service_log.put("PASS...['%s']" % param)
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 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 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
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 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 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_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_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 execute(self, req, fetch='all'):
""" Выполнить запрос.
:param req: nosql-запрос
:param fetch: тип выборки строк запроса
:return: результат операции
"""
try:
self.cursor_now = self.connect()
# Динамическое выполнение кода, параметр type - название функции в пуле коннекта
if type(req) is dict:
local_code = {"cursor_now": self.cursor_now}
# Определяем количество параметров для передачи их функции
if len(req) > 1:
name_funct = req.pop("type")
code_execution = """result = cursor_now.%s(**%s)""" % (name_funct, req)
elif len(req) == 1:
code_execution = """result = cursor_now.%s()""" % (req.pop("type"))
else:
msg = "Params for function is empty."
service_log.error(msg)
raise AssertionError(msg)
service_log.put("Dynamic code execution: %s." % code_execution)
exec code_execution in local_code
service_log.put("Result dynamic code execution: %s." % local_code["result"])
return local_code["result"]
else:
msg = "Not found type operation for redis."
service_log.error(msg)
raise AssertionError(msg)
except Exception, tx:
service_log.error(str(tx))
raise AssertionError(str(tx))
def create_params_by_duplicate_for_UserDto(user_db):
""" Создаём общие параметры для UserDto.
:param user_db: дубликат пользователя
:return: словарь с данными
"""
import time
pr_name = int(time.time())
mas = {"user_id": None,
"reg_time": pr_name, "login_time": None, "activ_time": None,
"a_status": None,
"online_status": None,
"auth": None, "login": None,
"auth_type": None,
"avatar_id": user_db['avatar_id'],
"gender": 1,
"phone": None,
"email": "*****@*****.**" % (str(pr_name), random.randint(0, 1000)),
"name1": str(pr_name),
"name2": str(pr_name),
"name3": "autotest_" + str(pr_name),
"city": user_db['city'],
"country": user_db['country'],
"shop_address": user_db['shop_address'],
"inn": user_db['inn'], "kpp": user_db['kpp'], "ogrn": user_db['ogrn'],
"legal_address": user_db['legal_address'], "actual_address": user_db['actual_address'],
"b_bic": user_db['bank_bic'], "b_contact": user_db['bank_name_and_address'],
"b_account": user_db['bank_account'], "b_corr": user_db['bank_correspondent_account'],
"name4": str(user_db['legal_name']) + str(pr_name),
"r_news": user_db['receive_site_news'], "r_notifications": user_db['receive_notifications'],
"r_reminders": user_db['receive_reminders'], "wants_seller": user_db['wants_to_be_seller'],
"a_nonexpired": user_db['account_non_expired'], "a_nonlocked": user_db['account_non_locked'],
"locale": user_db['locale'],
"shop": None}
service_log.put("Dict for obj: %s" % str(mas))
return mas
def close(self, cursor):
""" Закрываем соединение.
:param cursor: ссылка на курсор
"""
# cursor.close()
# self.conn.close()
service_log.put("Closing opened oracle connections.")
def get_status_id(name):
""" Взять идентификатор аккаунт статуса пользователя.
:param name: наименование статуса
:return: идантификатор статуса
"""
service_log.put("Name account status: %s" % AccountStatus._NAMES_TO_VALUES[name])
return AccountStatus._NAMES_TO_VALUES[name]
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_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 turn_off_android_emulator(driver):
""" Выключить устройство.
:param driver: ссылка на драйвер
:return: True
"""
service_log.put(
"Initiated the process to TURN OFF the Android emulator...\n")
driver.long_press_keycode(26)
return True
def get_data_by_account(self, param):
""" Пример получения информацию из таблицы <name_table> по соответствию параметра param.
:param param: параметр для поиска условия
:return: данные таблицы <name_table>
"""
# todo: слишком общий метод - делает код запутанным
p = """SELECT * FROM tbg.crp_agreements WHERE accountid = %s""" % param
service_log.put("Select user data: %s" % p)
return p
def modify(*args, **kwargs):
print args
print kwargs
request = func(*args, **kwargs)
ex = args[0].__dict__["func"].im_self.execute2
service_log.put("Procedure SQL-query: %s" % request)
result = ex(request, args[1], args[2])
service_log.put("Procedure SQL-query result: %s" % result)
return result
def round_unix_to_sec(tk):
""" Округление unix-времени до секунд.
Пример: 1428410576941 -> 1428410577
:param tk: unix-время, type(long)
:return: округленное unix-время, type(long)
"""
ntk = int(round(float("%s.%s" % (tk[:-3], tk[-3:]))))
service_log.put(
"Round the UNIX time to seconds, source=%s -> convert=%s." % (tk, ntk))
return ntk
def connect(self):
""" Устанавливает коннект с redis.
Пример: redis.ConnectionPool(host='vm-fedor.home.oorraa.net', port=6379, db=0)
:return: ссылка на коннект
"""
self.pool = redis.ConnectionPool(**self.auth)
service_log.put("Create connection pool: %s" % self.pool)
r = redis.Redis(connection_pool=self.pool)
service_log.put("Connect with redis is success: %s" % r)
return r
def __init__(self, host, port, name, user=None, passwd=None):
# параметры аутетификации к БД
self.auth = {"host": host, "port": port, "db": name, "user": user, "password": passwd}
self.auth = funcy.compact(self.auth)
service_log.put("Get params for authenticate with redis: %s" % self.auth)
# параметры для работы внутри БД
self.pool = None
self.cursor = None
self.cursor_now = None
def connect(self):
""" Коннектимся с базой.
:param cursor_view: вид в котором возвращается ответ (по умолчанию - dict, словарь)
:return: возвращаем курсор
"""
connection_str = '%s/%s@%s:%s/%s' % (self.user, self.passwd, self.host,
self.port, self.name)
self.conn = cx_Oracle.connect(connection_str)
cursor = self.conn.cursor()
service_log.put("Open oracle connections.")
return cursor
def modify(*args, **kwargs):
params_funct = func(*args, **kwargs)
ex = args[0].__dict__["func"]
service_log.put("NoSQL-query: %s" % str(params_funct))
result = None
if type(params_funct) is dict:
result = ex(params_funct)
service_log.put("NoSQL-query result: %s" % result)
return result
def modify(*args, **kwargs):
params_funct = func(*args, **kwargs)
ex = args[0].__dict__["func"]
service_log.put("CQL-query: %s" % str(params_funct))
if isinstance(params_funct, tuple):
# если передали несколько параметров к методу
result = ex(*params_funct)
else:
result = ex(params_funct)
service_log.put("CQL-query result: %s" % result)
return result
def update_data_by_id(self, param1, param2):
""" Изменить соль пользователя.
:param param1: <param1>
:param param2: <param2>
:return: None
"""
# todo: слишком общий метод - делает код запутанным
p = "UPDATE <name_table> SET <param1>='%s' WHERE <param2>='%s';" % (
param1, param2)
service_log.put("Update user data: %s" % p)
return p
def modify(*args, **kwargs):
request = func(*args, **kwargs)
ex = args[0].__dict__["func"]
service_log.put("SQL-query: %s" % request)
if request[:6].upper() == "UPDATE":
result = ex(request, "update")
elif request[:6].upper() == "INSERT":
result = ex(request, "insert")
else:
result = ex(request, "all")
service_log.put("SQL-query result: %s" % result)
return result
def find_text_view_and_click(self, text, num_text_view, time_sleep=0):
""" Найти на странице TextView с определенным названием и нажать его.
:return: True
"""
el = self.driver.find_elements_by_class_name(
'android.widget.TextView')[num_text_view]
service_log.put("Element: %s" % str(el))
self.assertEqual(el.text, text,
"This element not have text - %s." % text)
el.click()
time.sleep(time_sleep)
return True
def command_exec(cmd, flag=False):
""" Выполнить комманду через консоль.
:param cmd: комманда для выполнения
:param flag: флаг, дожидаться ли завершения выполнения комманды
:return: ссылка на Popen
"""
service_log.put("Command execute: %s" % cmd)
pipe = subprocess.PIPE
s_process = subprocess.Popen(cmd, shell=True, stdin=pipe, stdout=pipe, stderr=subprocess.STDOUT)
if flag:
s_process.wait()
return s_process
def execute(self, req, fetch='all'):
""" Выполнить запрос.
:param req: sql-запрос
:param fetch: тип выборки строк запроса
:return: результат операции
"""
try:
self.cursor_now = self.connect()
self.cursor_now.execute(req)
if fetch == "all":
result = rows_to_dict_list(self.cursor_now)
service_log.put("Fetchall rows.")
return result
elif fetch == "one":
result = self.cursor_now.fetchone()
service_log.put("Fetchone rows.")
return result
elif fetch == "update" or fetch == "insert":
service_log.put("No fetch rows. Operation by UPDATE.")
self.conn.commit()
service_log.put("Commit operation UPDATE.")
return None
except Exception, tx:
service_log.error(str(tx))
raise AssertionError(str(tx))
def connect_plain_auth(self, user_name, password, port, key_space,
contacts_point):
""" Аутентификация cassandra через имя и пароль.
:param user_name: имя пользователя
:param password: пароль пользователя
:return: ссылка на сессию
"""
try:
service_log.put("Create obj PlainTextAuthProvider for cassandra.")
auth_provider = PlainTextAuthProvider(username=user_name,
password=password)
service_log.put("Create cluster for cassandra.")
self.cluster = Cluster(contact_points=contacts_point,
port=port,
auth_provider=auth_provider)
service_log.put("Create connect with cassandra.")
session = self.cluster.connect(keyspace=key_space)
service_log.put("Create session for cluster cassandra.")
return session
except Exception, tx:
msg_error = "Connect with casandra not success!"
service_log.error(msg_error)
service_log.error("%s" % str(tx))
raise msg_error
def execute(self, req, fetch='all', cursor_view="dict"):
""" Выполнить запрос.
:param req: sql-запрос
:param fetch: тип выборки строк запроса
:return: результат операции
"""
what_cursor_view = lambda view, element: dict(
element) if view == "dict" else element
try:
self.cursor_now = self.connect(cursor_view=cursor_view)
self.cursor_now.execute(req)
if fetch == "all":
result = self.cursor_now.fetchall()
service_log.put("Fetchall rows.")
return [what_cursor_view(cursor_view, elem) for elem in result]
elif fetch == "one":
result = self.cursor_now.fetchone()
service_log.put("Fetchone rows.")
return what_cursor_view(cursor_view, result)
elif fetch == "update" or fetch == "insert":
service_log.put("No fetch rows. Operation by UPDATE.")
self.conn.commit()
service_log.put("Commit operation UPDATE.")
return None
except Exception, tx:
service_log.error(str(tx))
raise AssertionError(str(tx))
def start_cmd_appium(self):
""" Запустить Appium через скрипт в консоле.
Вытягиваем из конфига main.cfg путь до Appium и стратуем через консоль.
P.S: http://www.guru99.com/introduction-to-appium.html
"""
appium = configs.config["mobile"]["windows_path_appium"]
name_machine = configs.config["env_info"]["android_name"]
cmd = """%s\\node_modules\.bin\\appium.cmd --avd %s""" % (appium, name_machine)
service_log.put("Command execute: %s" % cmd)
pipe = subprocess.PIPE
subprocess.Popen(cmd, shell=True, stdin=pipe, stdout=codecs.open("./appium_out.log", "a", encoding="utf-8"),
stderr=codecs.open("./appium_error.log", "a", encoding="utf-8"))
time.sleep(10)
return True
def sudo_command_execution(self, cls, passwd=None):
"""
Make a remote command execution with sudo by ssh
Return result
:param cls: remote command to run
"""
client = self.connect()
channel = None
try:
service_log.put("Open SSH chanel.")
channel = client.get_transport().open_session()
service_log.put("Open SSH chanel success.")
channel.get_pty()
channel.settimeout(5)
service_log.put("Execute: %s." % cls)
#self.channel.exec_command('sudo -i')
channel.exec_command('sudo %s' % cls)
if passwd is not None:
channel.send(self.passwd+'\n')
data = channel.recv(1024)
service_log.put("Execute success. Output: %s" % str(data))
return data
except Exception, tx:
service_log.error(str(tx))
raise AssertionError(str(tx))
def clear_connect_to_service():
""" Закрываем соединение.
"""
try:
if 'thrift_transport' in globals():
globals()['thrift_transport'].close()
del globals()['thrift_transport']
del globals()['prefix_serv']
del globals()['path_serv']
service_log.put("Transport - close.")
else:
service_log.put("Warning: The connection is already closed.")
except Thrift.TException, tx:
service_log.error(tx.message)
def import_libs(self, name_prefix):
try:
# Производим динамический импорт сгенериррованных файлов для Thrift
path = TVariables.thrift.imports[name_prefix + "_worker"]
service_log.put("Get path by worker: %s" % path)
get_lib = lambda path_lib: path_lib[path_lib.rfind(".") + 1:]
self.worker = __import__(path, fromlist=[get_lib(path)])
service_log.put("Import libs worker: path=%s, name=%s" %
(path, get_lib(path)))
return name_prefix
except ImportError, tx:
error_message = "Import lib for worker - %s" % tx
service_log.error(error_message)
raise AssertionError(error_message)
def get_an_error(funct, *params):
""" Ожидаем получить ошибку.
Например потому что элемент не должн быть найден.
:param funct: исполняемая функция
:param params: параметры к исполняемой функции
:return:
"""
tx = None
try:
funct(*params)
except Exception, tx:
service_log.put("Expected error - successful!")
service_log.put("Error: %s" % str(tx))
return True
def connect(self, cursor_view="dict"):
""" Коннектимся с базой.
:param cursor_view: вид в котором возвращается ответ (по умолчанию - dict, словарь)
:return: возвращаем курсор
"""
cursor_factory = psycopg2.extras.DictCursor if cursor_view == "dict" else psycopg2.extras.NamedTupleCursor
self.conn = psycopg2.connect(host=self.host,
port=self.port,
dbname=self.name,
user=self.user,
password=self.passwd,
cursor_factory=cursor_factory)
cursor = self.conn.cursor()
service_log.put("Open postgresql connections.")
return cursor
def connect_by_key_file(self):
""" Коннектимся к удалённой консоли по ключу.
:return: возвращаем ссылку на терминал
"""
try:
client = paramiko.SSHClient()
type_host_key = paramiko.AutoAddPolicy()
client.set_missing_host_key_policy(type_host_key) # add ssh-key in list keys — file .ssh/known_hosts
client.connect(hostname=self.host, username=self.user, port=int(self.port), key_filename=self.keyfile)
service_log.put("Open SSH connections.")
return client
except Exception, tx:
msg_error = "SSH not connections! /n %s" % tx
service_log.error(msg_error)
raise msg_error
def generate_sha256(source_str, salt=None):
""" Генератор строки в хеш SHA-256
:param source_str: исходная строка
:return: хеш
"""
hhh = hashlib.sha256()
# работа с паролем у которого есть соль
if salt is None or salt == '':
hhh.update(source_str)
else:
hhh.update(source_str + "{" + salt + "}")
new_hash = hhh.hexdigest()
service_log.put("Generate for new password (%s) its hash (%s)." %
(source_str, new_hash))
return new_hash
def kill_android_emulator(self, name="emulator-x86.exe"):
""" Убить процесс отвечающий за Android эмулятор. """
service_log.put("Initiated close process the Android emulator...\n")
result = self.find_process_by_name(name)
if not result:
service_log.warning("Process Android emulator not found!\n")
return False
cmd_work.kill_pid(result[0]["pid"])
flag = int(time.time())
while bool(self.find_process_by_name(name)):
# ждем 5 минут до завршения работы эмулятора
if flag + (60*5) > int(time.time()):
service_log.warning("Close process the Android emulator - Fail!\n")
return False
else:
time.sleep(5)
service_log.put("Close process the Android emulator - success.\n")
return True
