def parse(self, data: dict) -> dict:
"""
general dict parser after parsing environments
"""
_dict = data
for _ in range(5):
self._parse_dict(_dict)
for failed in self.get_variables(str(_dict)):
Logger.get().debug('[JsParser]', 'failed to find env value of "',
failed, '"')
return _dict
def tests_enabled(self) -> bool:
if self.body.is_json():
_data = self.body.get_json().get('__tests__enabled__', True)
if type(_data) is not bool:
Logger.get().debug('[RequestModel]',
'wrong __tests__enabled__ format expected bool got {0}'.format(type(_data)),
'for:',
str(_data))
return True
# check if all records in __tags__ are string
return _data
else:
return True
def eval(self) -> str:
_method_name = self._get_method_name()
if _method_name == ray_token_gen.__js_name__:
return ray_token_gen(
self.environment_parser.get('KEYGEN_SECRET', default=''),
self.environment_parser.get('KEYGEN_SALT', default=''),
self.parameters[0],
self.parameters[1],
self.parameters[2],
)
else:
Logger.get().debug('[MethodEvaluator]', 'failed to eval : {%',
self.body, '%}')
return ''
def tests_tags(self) -> List[str]:
if self.body.is_json():
_data = self.body.get_json().get('__tags__', [])
if type(_data) is not list:
Logger.get().debug('[RequestModel]',
'wrong __tags__ format expected list got {0}'.format(type(_data)),
'for:',
str(_data))
return []
# check if all records in __tags__ are string
for tag in _data:
if type(tag) is not str:
Logger.get().debug('[RequestModel]',
'wrong tag format expected str got {0}'.format(type(tag)),
'for:',
str(tag))
return []
return _data
else:
return []
def __init__(self, __test__: dict, request_model: RequestModel,
environment: EnvironmentVariableParser):
# setting default values
self._name = ''
self._reports = []
self._environment = None
self._enabled = True
self._expressions = None
self._request_model = None
self._headers_add = None
self._headers_remove = None
self._headers_ignore_defaults = None
self._headers = {}
self._body_add = None
self._body_remove = None
self._body_ignore_default = None
self._body = {}
self._tags = []
self._enabled_condition = None
# request model will be useful with url, request mode, naming, ...
self._request_model = request_model
# environment will be useful for default headers
self._environment = environment
# parse __test__ to fill properties
# name
_name = __test__.get('name', '')
if _name == '':
self._name = self._request_model.name + '@' + self.generate_name()
else:
self._name = _name
self._url_override = __test__.get('url', None)
# enabled
_data = __test__.get('enabled', True)
if not isinstance(_data, bool) and not isinstance(_data, str):
Logger.get().debug(
'[TestCase]',
'expected bool or str got {0}'.format(type(_data)), 'for:',
str(_data))
_data = True
self._enabled = self._request_model.tests_enabled and _data
if type(_data) is str:
self._enabled_condition = _data
# body
# TODO: add type validation for body
self._body_add = __test__.get('+b', None)
self._body_remove = __test__.get('-b', None)
self._body_ignore_default = __test__.get('b', None)
# create current body
# TODO: add validation to check if body is json
_body = self._request_model.body.get_json_for_request()
# check if current body is ignored
if self._body_ignore_default is None:
# add extra body elements
if self._body_add is not None:
_body.update(self._body_add)
# remove elements from default body ( and elements added in via _body_add)
if self._body_remove is not None:
for element in self._body_remove:
if type(element) is str:
if _body.get(element, None) is not None:
del _body[element]
else:
Logger.get().debug(
'[TestCase]',
'-b must be list of string but an element is {0}'.
format(type(element)))
else:
_body = self._body_ignore_default
self._body = _body
# headers
# TODO: add type validation for headers
self._headers_add = __test__.get('+h', None)
self._headers_remove = __test__.get('-h', None)
self._headers_ignore_defaults = __test__.get('h', None)
_headers = self._request_model.headers
# check if current headers is ignored
if self._headers_ignore_defaults is None:
# check for insomnia DEFAULT_HEADERS plugin
_DEFAULT_HEADERS = self._environment.get('DEFAULT_HEADERS', None)
if _DEFAULT_HEADERS is not None:
assert isinstance(_DEFAULT_HEADERS, dict)
_temp = _DEFAULT_HEADERS.copy()
_temp.update(_headers.copy())
_headers = _temp
# add extra header elements
if self._headers_add is not None:
_headers.update(self._headers_add)
# remove elements from default headers ( and elements added in via _headers_add)
if self._headers_remove is not None:
for element in self._headers_remove:
if type(element) is str:
if _body.get(element, None) is not None:
del _headers[element]
else:
Logger.get().debug(
'[TestCase]',
'-h must be list of string but an element is {0}'.
format(type(element)))
else:
_headers = self._headers_ignore_defaults
self._headers = _headers
# tags
self._tags = __test__.get('tags', [])
self._tags += self._request_model.tests_tags
# expression
_expressions = __test__.get('expects', [])
self._expressions = []
for expr in _expressions:
if type(expr) is str:
self._expressions.append(ExpectSolver(expr))
elif type(expr) is dict:
for key in expr:
self._expressions.append(ExpectSolver(expr[key], name=key))
else:
Logger.get().debug(
'[TestCase]',
'expect case must be either str or dict but is {0}'.format(
type(expr)))
# save variables
_save = __test__.get('save', [])
self._save = []
for save in _save:
if type(save) is str:
self._save.append(VariableSave(save))
else:
Logger.get().debug(
'[TestCase]',
'save variables must be str but is {0}'.format(type(save)))
fmt = '%d %s %s %s %s'
print("Starting log")
userInput = input("Do you wish to reset data ? y/N")
if userInput == "y":
os.system("rm -r journal/")
lowWatermark = l.id_low
highWatermark = l.id_high
assert lowWatermark <= highWatermark
record = fmt % (current_time(), trId, "Begin", "dependency", " ")
n = l.append(record)
l.flush()
assert l.get(n) == record
assert l.get(lowWatermark - 1) is None
assert l.get(highWatermark + 1) is None
assert lowWatermark <= highWatermark
for i in range(lowWatermark, highWatermark):
assert l.get(i) is not None
userInput = input("Do you wish to launch interactive mode? y/N ")
if userInput == "y":
print("Type command in the following format:")
print("Get the high watermark")
print("high")
print()
print("Get the low watermark")
print("low")
