def test_send_raw_to_validator(self, KAFKAjson, KAFKAjson2):
allure.description('Testing send raw json to validator topic')
allure.label('kafka operations')
d1 = nistest.KafkaDriver(topic=config.get('kafka_topic_raw'),
server=config.get('kafka_server'),
schema_registry=config.get('kafka_schema'))
offset1 = d1.get_last_offset()
rawData = {
"producer": "test",
"sessionKey": "123e4567-e89b-12d3-a456-426655440002",
"termId": 123,
"protocolId": 1,
"deviceTypeId": 100,
"timePlatformFrom1970": 1527601137000,
"timeDeviceFrom1970": 1527601137000,
"activityInfo": 1
}
rawData = json.dumps(rawData, sort_keys=True).encode('utf-8')
last_offset = d1.get_last_offset()
d1.send(msg=rawData, lang='json', schema=None)
res = d1.read_from_offset(offset1)
result = d1.read_from_offset(offset=last_offset,
lang='json',
schema=None)
log.debug('result: ' + str(result))
assert rawData == result
res_delete = d1.delete_topic()
assert res_delete == 0
def test_get_history(self, HDS, KAFKAavro):
'''
Create device test
Send http request to read history
'''
allure.description('Testing hds get history')
'''
-----------------------------------------------------------------------------
send message
-----------------------------------------------------------------------------
'''
startTime = '2018-06-20T09:08:28+03:00'
endTime = '2018-07-29T09:08:28+03:00'
dateFrom = '2018-06-27T09:08:28+03:00'
dateTo = '2018-06-27T09:08:28+03:00'
log.debug('[test_get_history] dateFrom: ' + str(dateFrom))
device_v_term_id = random.randint(1, 100000)
filter = 'null'
limit = 1
sort = 'asc'
device_activity_info = random.randint(1, 100000)
expected = []
for tim in range(2):
device_time_device = 1530523171000 + 1000 * tim
device_time_device_utc = datetime.fromtimestamp(
int(device_time_device / 1000)).strftime('%Y-%m-%dT%H:%M:%SZ')
expected_dict = {}
expected_dict['activityInfo'] = device_activity_info
expected_dict['termId'] = device_v_term_id
expected_dict['timeDevice'] = device_time_device_utc
expected.append(expected_dict)
KAFKAavro.send_valid(termId=device_v_term_id,
time_platform=device_time_device,
time_device=device_time_device,
activity_info=device_activity_info)
'''
-----------------------------------------------------------------------------
get history
-----------------------------------------------------------------------------
'''
response = HDS.get_history(expected=expected,
termId=device_v_term_id,
limit=None,
sort='asc',
filter=None,
startTime=startTime,
endTime=endTime,
dateFrom=dateFrom,
dateTo=dateTo)
def test_validator_processing_message_new(self, ServiceObjKAFKAavro):
allure.description('Testing validator processing message new')
allure.label('validator operations')
startTime = '2018-06-20T09:08:28+03:00'
endTime = '2018-07-29T09:08:28+03:00'
dateFrom = '2018-07-02T09:19:32+03:00'
dateTo = '2018-07-02T09:19:32+03:00'
log.debug('[test_get_history] dateFrom: ' + str(dateFrom))
device_v_term_id = random.randint(1, 100000)
filter = 'null'
limit = 1
sort = 'asc'
expected = []
for time in range(2):
device_activity_info = random.randint(1, 100000)
device_time_device = 1530523171000 + 1000 * time
device_time_device_utc = datetime.fromtimestamp(
int(device_time_device / 1000)).strftime('%Y-%m-%dT%H:%M:%SZ')
ServiceObjKAFKAavro.send_valid(termId=device_v_term_id,
time_platform=device_time_device,
time_device=device_time_device,
activity_info=device_activity_info)
def test_get_history_hide_interval(self, HDS, KAFKAavro, DBHistory):
'''
Create device test
Send http request to read history
'''
allure.description('Test get history hide interval')
'''
-----------------------------------------------------------------------------
send message
-----------------------------------------------------------------------------
'''
device_v_term_id = random.randint(1, 100000)
filter = 'null'
limit = 1
sort = 'asc'
device_activity_info = random.randint(1, 100)
for t in range(5):
device_activity_info += 1
device_time_device = datetime.strptime(
'2018-07-02 09:19:3' + str(t),
"%Y-%m-%d %H:%M:%S").strftime('%s000')
KAFKAavro.send_valid(termId=device_v_term_id,
time_platform=int(device_time_device),
time_device=int(device_time_device),
activity_info=device_activity_info)
'''
-----------------------------------------------------------------------------
get history
-----------------------------------------------------------------------------
'''
startTime = '2018-06-20T09:08:28+03:00'
endTime = '2018-07-29T09:08:28+03:00'
dateFrom = '2018-07-02T09:19:30+03:00'
dateTo = '2018-07-02T09:19:33+03:00'
device_time_device_utc = '2018-07-02T09:19:34Z'
expected = [{
"activityInfo": device_activity_info,
"termId": device_v_term_id,
"timeDevice": device_time_device_utc
}]
response = HDS.get_history(expected=expected,
termId=device_v_term_id,
limit=None,
sort='asc',
filter=None,
startTime=startTime,
endTime=endTime,
dateFrom=dateFrom,
dateTo=dateTo)
def test_create_kafka(self):
allure.description('Testing create topic')
allure.label('kafka operations')
log.debug('start test_kafka')
d1 = nistest.KafkaDriver(topic=config.get('kafka_topic_raw'))
res_create = d1.create_topic('testtopic2')
assert res_create == None
def test_invalid_auth(self, HDS):
'''
Create device test
Send http request to read history
'''
allure.description('Testing hds http 400 invalid json')
'''
-----------------------------------------------------------------------------
send message
-----------------------------------------------------------------------------
'''
startTime = '2018-06-20T09:08:28+03:00'
endTime = '2018-07-29T09:08:28+03:00'
dateFrom = '2018-06-27T09:08:28+03:00'
dateTo = '2018-06-27T09:08:28+03:00'
termId = '1'
filter = '1'
limit = 1
sort = 'asc'
device_activity_info = random.randint(1, 100000)
params = 'termId={0}&filter={1}&limit={2}&sort={3}'.format(
str(termId), str(filter), str(limit), str(sort))
payload = '''{
"startTime": ''' + str(startTime) + ''',
"endTime": ''' + str(endTime) + ''',
"hideTimes": [
{ "from": ''' + str(dateFrom) + ''', "to": ''' + str(
dateTo) + '''}
]
'''
HDS.service.authorise.set('pwd', '123')
headers = {
'Authorization': str(HDS.service.authorise.get_basic_auth()),
'Content-Type': 'application/json'
}
response = HDS.service.request(
method='get_history',
path=HDS.service.paths.get('get_history') + str(params),
payload=payload,
headers=headers)
assert response.status_code == 400
assert response.text == 'absent header x-sender'
def test_send_raw_to_validator_new(self, KAFKAjson, KAFKAjson2):
allure.description('Testing send raw json to validator topic')
allure.label('kafka operations')
device_time_device = 1530523171000
device_time_device_utc = datetime.fromtimestamp(
int(device_time_device / 1000)).strftime('%Y-%m-%dT%H:%M:%SZ')
KAFKAjson.send_raw(termId=100,
protocolId=200,
deviceTypeId=100,
timePlatformFrom1970=device_time_device,
timeDeviceFrom1970=device_time_device,
activityInfo=300)
def test_login(self, listcases):
'''
登录成功的用例
:param listcases:
:return: None
'''
allure.dynamic.title(listcases['title'])
allure.description(listcases['description']) #添加描述
testcases = listcases['cases']
for cases in testcases:
listcase = list(cases.values())
with allure.step(listcase[0]): #用例执行步骤
func = getattr(self.web, listcase[1])
values = listcase[2:]
func(*values)
def test_login_plus(self, list_cases):
"""
数据驱动方式
执行登录
:return: None
"""
allure.dynamic.title(list_cases['title'])
allure.description(list_cases['description'])
login_case = list_cases['cases']
for cases in login_case:
list_case = list(cases.values())
with allure.step(list_case[0]):
function = getattr(self.web, list_case[1])
values = list_case[2:]
function(*values)
def test_create_device(self, DB):
'''
Create device test
Send http request to create device
'''
allure.description('Testing info get device')
expected_list = {'v_device_type': 'hub'}
response = DB.create_device(p_device_type='hub',
p_model='OVI-BOVI',
p_hub_id=0,
p_sensor_id=101)
ids = response.get('v_term_id')
log.debug('ids: ' + str(ids))
def test_excel_case(self, mokuai, case_name, url, data_method, data,
result_method, result):
# print(mokuai, case_name, url, data_method, data, result_method, result)
# 应该再封装一个base, case层调用base的方法即可
allure.description(mokuai + " " + case_name)
if data_method == 'get':
response = requests.get(url).json()
elif data_method == 'post':
# 格式化请求数据， 发送post请求
params = data
response = requests.post(url, data=params)
else:
raise TypeError("暂不支持此类型请求")
if result_method == '包含':
assert result in response
elif result_method == '等于':
assert result == response
def test_get_history_empty_term_id(self, HDS, KAFKAavro):
'''
Create device test
Send http request to read history
'''
allure.description('Testing hds get history')
'''
-----------------------------------------------------------------------------
send message
-----------------------------------------------------------------------------
'''
startTime = '2018-06-20T09:08:28+03:00'
endTime = '2018-07-29T09:08:28+03:00'
dateFrom = '2018-06-27T09:08:28+03:00'
dateTo = '2018-06-27T09:08:28+03:00'
'''
-----------------------------------------------------------------------------
get history
-----------------------------------------------------------------------------
'''
response = HDS.get_history(expected=None,
termId=None,
limit=None,
sort='asc',
filter=None,
startTime=startTime,
endTime=endTime,
dateFrom=dateFrom,
dateTo=dateTo,
no_check=True)
assert response.status_code == 400
expected = {
"developerMessage": "Required query parameter in URI 'termId'",
"errorCode": 1,
"errorMessage": "Required query parameter in URI 'termId'"
}
assert nistest.basic.CompareDriver(data_result=response.json(),
data_expected=expected,
lang='json',
dump=False)
def test_create_device(self, DRS):
'''
Create device test
Send http request to create device
'''
allure.description('Testing drs creating device')
devicetype = 'ovibovi'
model = 'OVI-BOVI'
hubId = 0
device2 = DRS.create_device(deviceType=devicetype,
model=model,
hubId=hubId,
sensorId=random.randint(1, 100000))
def test_create_device_raw(self, DRS):
'''
Create device test
Send http request to create device
'''
allure.description('Testing drs creating device from raw')
json_data = {
"deviceType": 'ovibovi',
"model": 'OVI-BOVI',
"hubId": 0,
"sensorId": random.randint(1, 100000)
}
DRS.create_device_raw(payload=json_data)
def test_create_device_set_and_check_status(self, DB):
'''
Create device test
Send http request to create device, set and check status
'''
allure.description('Testing info set status')
expected_list = {'v_device_type': 'hub'}
response = DB.create_device(p_device_type='hub',
p_model='OVI-BOVI',
p_hub_id=0,
p_sensor_id=1010)
ids = response.get('v_term_id')
DB.set_status(p_term_id=ids, p_status_id=3)
expected_list = {'v_status_id': '3'}
response = DB.get_device(expected_list=expected_list, p_term_id=ids)
def test_db_interface(self, name, describe, url, request_data, method,
except_desc, except_content):
allure.description(name + " " + describe)
if method == 'get':
response = requests.get(url).text
# print(response)
elif method == 'post':
# 格式化请求数据， 发送post请求
params = request_data
response = requests.post(url, data=params).text
else:
raise TypeError("暂不支持此类型请求")
print(except_desc)
if except_desc == 'contains':
assert except_content in response
elif except_desc == 'equal':
assert except_content == response
else:
assert False is True
def test_create_and_delete_device(self, DRS):
'''
Create and delete device test
Send http request to create and then delete device
'''
allure.description('Testing drs creating and delete device')
deviceType = 'ovibovi'
model = 'OVI-BOVI'
hubId = 0
device = DRS.create_device(deviceType=deviceType,
model=model,
hubId=hubId,
sensorId=random.randint(1, 100000))
DRS.delete_device(device=device)
device = DRS.get_device(termId=device.termId)
def test_add_monitor(self, add_monitor):
"""
测试添加监测设备（传感器）
:param add_monitor:
:return:
"""
allure.dynamic.title(add_monitor["title"]) # 动态获取yaml中的title
allure.description(add_monitor["description"]) # 用例描述
test_cases = add_monitor["cases"]
for cases in test_cases:
list_case = list(cases.values())
with allure.step(list_case[0]): # 0在yaml文件中为name字段；1为方法名称；2为方法参数
func = getattr(self.base_action, list_case[1])
values = list_case[2:]
try:
func(*values)
except Exception as e:
png = self.base_action.driver.get_screenshot_as_png()
name = time.strftime('%Y-%m-%d %H:%M:%S')+list_case[0]
allure.attach(png, name, allure.attachment_type.PNG)
raise e
def test_add_nvr(self, add_nvr):
"""
测试添加NVR
:param add_nvr:
:return:
"""
allure.dynamic.title(add_nvr["title"])
allure.description(add_nvr["description"])
test_cases = add_nvr["cases"]
for cases in test_cases:
list_case = list(cases.values())
with allure.step(list_case[0]):
func = getattr(self.base_action, list_case[1])
values = list_case[2:]
try:
func(*values)
except Exception as e:
png = self.base_action.driver.get_screenshot_as_png()
name = time.strftime('%Y-%m-%d %H:%M:%S')+list_case[0]
allure.attach(png, name, allure.attachment_type.PNG)
raise e
def test_send_to_validator(self, KAFKAavro, HDS):
'''
Create device test
Send http request to read history
'''
allure.description('Testing hds send to validator')
'''
-----------------------------------------------------------------------------
send message
-----------------------------------------------------------------------------
'''
startTime = '2018-06-20T09:08:28+03:00'
endTime = '2018-07-29T09:08:28+03:00'
dateFrom = '2018-07-02T09:19:32+03:00'
dateTo = '2018-07-02T09:19:32+03:00'
log.debug('[test_get_history] dateFrom: ' + str(dateFrom))
device_v_term_id = random.randint(1, 100000)
filter = 'null'
limit = 1
sort = 'asc'
expected = []
for tim in range(2):
device_activity_info = random.randint(1, 100000)
device_time_device = 1530523171000 + 1000 * tim
device_time_device_utc = datetime.fromtimestamp(
int(device_time_device / 1000)).strftime('%Y-%m-%dT%H:%M:%SZ')
KAFKAavro.send_valid(termId=device_v_term_id,
time_platform=device_time_device,
time_device=device_time_device,
activity_info=device_activity_info)
def test_create_device_if_exist(self, DB):
'''
Create device test
Send http request to create device
'''
allure.description('Testing info get device')
expected_list = {'v_device_type': 'hub'}
response = DB.create_device(p_device_type='hub',
p_model='OVI-BOVI',
p_hub_id=0,
p_sensor_id=102)
ids = response.get('v_term_id')
log.debug('ids: ' + str(ids))
with pytest.raises(sqlalchemy.exc.InternalError) as excinfo:
response = DB.create_device(p_device_type='hub',
p_model='OVI-BOVI',
p_hub_id=0,
p_sensor_id=102)
log.debug('response: ' + str(response))
log.debug('excinfo: ' + str(excinfo))
def test_create_device_if_exist(self, DRS):
'''
Create device test
Send http request to create device if exist
'''
allure.description('Testing drs creating device if exist')
deviceType = 'ovibovi'
model = 'OVI-BOVI'
hubId = 0
sensorId = random.randint(1, 100000000)
device = DRS.create_device(deviceType=deviceType,
model=model,
hubId=hubId,
sensorId=sensorId)
device2 = DRS.create_device(deviceType=deviceType,
model=model,
hubId=hubId,
sensorId=sensorId,
no_check=True)
assert device2.response.status_code == 400, 'response: ' + str(
device2.response.text)
expected_response = {
"developerMessage": "Can't registrate terminal",
"errorCode": 1,
"errorMessage": "Can't registrate terminal"
}
assert device2.response.json(
) == expected_response, 'response: ' + str(device2.resp.text)
# -*- coding: utf-8 -*-
import pytest
from requests import Response
from rest_framework.status import HTTP_200_OK
import allure
from directory_tests_shared import URLs
from tests.smoke.cms_api_helpers import get_and_assert, status_error
pytestmark = [
allure.suite("HttpOnly Cookie flag"),
allure.feature("HttpOnly Cookie flag"),
allure.description(
"The HttpOnly flag should be set by including this attribute within "
"the relevant Set-cookie directive. Alternatively, URL rewriting could be used,"
" as is detailed in the following example"
),
]
USER_AGENT = {"user-agent": "automated smoke tests"}
@allure.step("Assert that HttpOnly Cookie flag is set")
def assert_httponly_cookie_flag_is_set(response: Response):
without_httponly = {
c.name: c.__dict__
for c in response.cookies
if not c.has_nonstandard_attr("HttpOnly")
}
error = (
f"Following cookies on {response.url} are set without 'HttpOnly' flag: "
def test_create_device_by_db_read_history(self, KAFKAavro, KAFKAchanged, KAFKAjson, DRS, HDS, INFO, DB, DBHistory):
'''
Create device test
Send http request to create device
'''
allure.description('Testing e2e creating device and read history')
'''
-----------------------------------------------------------------------------
prepare kafka
-----------------------------------------------------------------------------
'''
KAFKAjson.service.delete_topic()
'''
-----------------------------------------------------------------------------
create device
-----------------------------------------------------------------------------
'''
device_v_device_type = 'hub'
device_v_model = 'OVI-BOVI'
hubId = 0
device_sensorId = random.randint(1, 100000)
response = DB.create_device(p_device_type=device_v_device_type, p_model=device_v_model, p_hub_id=hubId,
p_sensor_id=device_sensorId)
device_v_term_id = response.get('v_term_id')
device_v_protocol_family_id = response.get('v_protocol_family_id')
device_v_status_id = response.get('v_status_id')
device_activity_info = 1
'''
-----------------------------------------------------------------------------
check device in db
-----------------------------------------------------------------------------
'''
expected = {'v_status_id': '2'}
response = DB.get_device(expected=expected, p_term_id=device_v_term_id)
'''
-----------------------------------------------------------------------------
change status
-----------------------------------------------------------------------------
'''
response = DB.set_status(p_term_id=device_v_term_id, p_status_id = 3)
'''
-----------------------------------------------------------------------------
send raw
-----------------------------------------------------------------------------
'''
device_time_device = 1530523171000
device_time_device_utc = datetime.fromtimestamp(int(device_time_device/1000)).strftime('%Y-%m-%dT%H:%M:%SZ')
KAFKAjson.send_raw(termId=device_v_term_id, protocolId=device_v_protocol_family_id, deviceTypeId=100,
timePlatformFrom1970=device_time_device, timeDeviceFrom1970=device_time_device, activityInfo=device_activity_info)
'''
-----------------------------------------------------------------------------
check raw
-----------------------------------------------------------------------------
'''
KAFKAjson.read_raw(termId=device_v_term_id, protocolId=device_v_protocol_family_id, deviceTypeId=100,
timePlatformFrom1970=device_time_device, timeDeviceFrom1970=device_time_device, activityInfo=device_activity_info)
'''
-----------------------------------------------------------------------------
check valid
-----------------------------------------------------------------------------
'''
log.debug('sleep')
time.sleep(20)
log.debug('sleep')
KAFKAavro.read_valid(term_id=device_v_term_id, time_platform=device_time_device, time_device=device_time_device, activity_info=device_activity_info )
'''
-----------------------------------------------------------------------------
check history db
-----------------------------------------------------------------------------
'''
startTime = '2018-06-20T09:08:28+03:00'
endTime = '2018-07-29T09:08:28+03:00'
dateFrom = '2018-06-27T09:08:28+03:00'
dateTo = '2018-06-27T09:08:28+03:00'
response = DBHistory.get_history(in_term_id=device_v_term_id, in_time_start=startTime, in_time_end=endTime)
'''
-----------------------------------------------------------------------------
get history
-----------------------------------------------------------------------------
'''
response = HDS.get_history(termId=device_v_term_id, limit=None, sort='asc', filter=None,
startTime=startTime, endTime=endTime, dateFrom=dateFrom, dateTo=dateTo, activityInfo=device_activity_info, timeDevice=device_time_device_utc)
class Test_baba:
allure.description("Adding Student Details")
def test_addStudent_Details(self):
apiURL = "http://thetestingworldapi.com/api/studentsDetails"
file = open("D:\\Pycharm\\API\\PostRequest.json", "r")
#Global variables
global myid
myid = ''
global json_payload
#Loading file into the JSON
json_payload = json.loads(file.read())
#Making request
response = requests.post(apiURL, json_payload)
#Extracting data from respose
extract_id = jsonpath.jsonpath(response.json(), 'id')
myid = extract_id[0]
print("Global id is ", myid)
allure.description("Getting student details")
def test_getStudentdata(self):
apiURL = "http://thetestingworldapi.com/api/studentsDetails/" + str(
myid)
# Making request
reponse = requests.get(apiURL)
#Extracting response
firstname = jsonpath.jsonpath(reponse.json(), 'data.first_name')
print(firstname[0])
assert json_payload['first_name'] == firstname[0]
# print(reponse.text)
allure.description("Adding tech details")
def test_addTechincaldetails(self):
appurl = "http://thetestingworldapi.com/api/technicalskills"
fileaddtech = open("D:\\Pycharm\\API\\addtech.json", "r")
json_payload = json.loads(fileaddtech.read())
json_payload['id'] = myid
json_payload['st_id'] = int(myid)
reponse = requests.post(appurl, json_payload)
# print(json_payload)
allure.step("Veifing details")
def test_getTechincaldetails(self):
appurl = "http://thetestingworldapi.com/api/technicalskills/"
reponse = requests.get(appurl)
std_id = jsonpath.jsonpath(reponse.json(), 'data[*].st_id')
print(std_id)
assert str(myid) in std_id
print("Global id is ", myid)
# -*- coding: utf-8 -*-
import pytest
from requests import Response
from rest_framework.status import HTTP_200_OK
import allure
from directory_tests_shared import URLs
from tests.smoke.cms_api_helpers import get_and_assert, status_error
pytestmark = [
allure.suite("Secure Cookie flag"),
allure.feature("Secure Cookie flag"),
allure.description(
"The Secure flag should be set on all cookies that are used for transmitting "
"sensitive data when accessing content over HTTPS. If cookies are used to "
"transmit session"),
]
@allure.step("Assert that Secure Cookie flag is set")
def assert_secure_cookie_flag_is_set(response: Response):
cookie_dict = {c.name: c.__dict__ for c in response.cookies}
insecure_cookies = [c.name for c in response.cookies if not c.secure]
error = (f"Not all cookies on {response.url} are set with 'Secure' flag: "
f"{insecure_cookies} → {cookie_dict}")
assert all(c.secure for c in response.cookies), error
@allure.issue("TT-1614", "Cookies Not Set With Secure Flag")
@pytest.mark.parametrize(
"url",
# -*- coding: utf-8 -*-
import pytest
from bs4 import BeautifulSoup
from rest_framework.status import HTTP_200_OK
import allure
from directory_tests_shared import URLs
from directory_tests_shared.settings import BASICAUTH_PASS, BASICAUTH_USER
from tests.smoke.cms_api_helpers import get_and_assert
pytestmark = [
allure.suite("sitemap.xml"),
allure.feature("sitemap.xml"),
allure.description(
"A service which handles our Top Level Domain should expose a valid sitemap.xml"
" which enables various Search Engines/Web Crawlers (like Google) to discover "
"what pages are present and which change frequently. This allows them to crawl "
"our site accordingly"
),
]
@allure.step("Check if sitemap.xml is present")
def get_urls_from_sitemap(sitemap_url: str, *, ignore_404: bool = False) -> list:
result = []
try:
response = get_and_assert(
url=sitemap_url,
status_code=HTTP_200_OK,
auth=(BASICAUTH_USER, BASICAUTH_PASS),
)
xml_soup = BeautifulSoup(response.content, "xml")
def test_get_history_hide(self, HDS, KAFKAavro, DBHistory):
'''
Create device test
Send http request to read history
'''
allure.description('Testing hds get history hide equal time')
'''
-----------------------------------------------------------------------------
prepare infra
-----------------------------------------------------------------------------
'''
KAFKAavro.service.delete_topic()
'''
-----------------------------------------------------------------------------
send message
-----------------------------------------------------------------------------
'''
startTime = '2018-06-20T09:08:28+03:00'
endTime = '2018-07-29T09:08:28+03:00'
dateFrom = '2018-07-02T09:19:32+03:00'
dateTo = '2018-07-02T09:19:32+03:00'
log.debug('[test_get_history] dateFrom: ' + str(dateFrom))
device_v_term_id = random.randint(1, 100000)
filter = 'null'
limit = 1
sort = 'asc'
expected = []
device_activity_info = random.randint(1, 100000)
for tim in range(2):
device_activity = device_activity_info + tim
device_time_device = 1530523171000 + 1000 * tim
device_time_device_utc = datetime.fromtimestamp(
int(device_time_device / 1000)).strftime('%Y-%m-%dT%H:%M:%SZ')
KAFKAavro.send_valid(termId=device_v_term_id,
time_platform=device_time_device,
time_device=device_time_device,
activity_info=device_activity)
'''
-----------------------------------------------------------------------------
get history
-----------------------------------------------------------------------------
'''
device_time_device_utc = datetime.fromtimestamp(
int(1530523171000 / 1000)).strftime('%Y-%m-%dT%H:%M:%SZ')
expected = [{
"activityInfo": device_activity_info,
"termId": device_v_term_id,
"timeDevice": device_time_device_utc
}]
response = HDS.get_history(expected=expected,
termId=device_v_term_id,
limit=None,
sort='asc',
filter=None,
startTime=startTime,
endTime=endTime,
dateFrom=dateFrom,
dateTo=dateTo)
def test_kafka_send_avro(self, KAFKAjson, KAFKAjson2):
allure.description('Testing send raw json to validator topic')
allure.label('kafka operations')
d2 = nistest.KafkaDriver(topic=config.get('kafka_topic_valid'),
server=config.get('kafka_server'),
schema_registry=config.get('kafka_schema'))
res_delete = d2.delete_topic()
offset2 = d2.get_last_offset()
schemaSF = '''{
"type":"record",
"name":"Farming",
"namespace":"nis.dev.validator.avro",
"fields":[
{
"name": "term_id",
"type": "long"
},
{
"name": "time_platform",
"type": {
"type": "long",
"logicalType": "timestamp-millis"
}
},
{
"name": "time_device",
"type": {
"type": "long",
"logicalType": "timestamp-millis"
}
},
{
"name": "activity_info",
"type": "int"
}
]
}'''
rawData2 = {
"term_id": 100,
"time_platform": 1527685363266,
"time_device": 1527685363266,
"activity_info": 300
}
expected = json.dumps(rawData2, indent=4, sort_keys=True, default=str)
last_offset = d2.get_last_offset()
d2.send(msg=rawData2, lang='avro', schema=schemaSF)
res = d2.read_from_offset(offset2, 'avro', schemaSF)
result = d2.read_from_offset(offset=offset2,
lang='avro',
schema=schemaSF)
log.debug('result: ' + str(result))
assert expected == result
res_delete = d2.delete_topic()
assert res_delete == 0
def test_get_history_hide_interval_empty_response(self, HDS, KAFKAavro,
DBHistory):
'''
Create device test
Send http request to read history
'''
allure.description(
'Test get history hide interval equals and response empty')
'''
-----------------------------------------------------------------------------
send message
-----------------------------------------------------------------------------
'''
device_v_term_id = random.randint(1, 100000)
filter = 'null'
limit = 1
sort = 'asc'
device_activity_info = random.randint(1, 100)
expected = []
for t in range(2):
device_time_device = datetime.strptime(
'2018-07-02 09:19:3' + str(t),
"%Y-%m-%d %H:%M:%S").strftime('%s000')
KAFKAavro.send_valid(termId=device_v_term_id,
time_platform=int(device_time_device),
time_device=int(device_time_device),
activity_info=device_activity_info)
'''
-----------------------------------------------------------------------------
get history
-----------------------------------------------------------------------------
'''
startTime = '2018-06-20T09:08:28+03:00'
endTime = '2018-07-29T09:08:28+03:00'
dateFrom = '2018-07-02T09:19:30+03:00'
dateTo = '2018-07-02T09:19:33+03:00'
device_time_device_utc = '2018-07-02T09:19:30Z'
expected = [{
"activityInfo": device_activity_info,
"termId": device_v_term_id,
"timeDevice": device_time_device_utc
}]
response = HDS.get_history(expected=expected,
termId=device_v_term_id,
limit=None,
sort='asc',
filter=None,
startTime=startTime,
endTime=endTime,
dateFrom=dateFrom,
dateTo=dateTo,
no_check=True)
assert response.status_code == 200
expected = ["Data not found"]
assert nistest.basic.CompareDriver(data_result=response.json(),
data_expected=expected,
lang='json',
dump=False)
