def validateGeneralSessionAndReturnItDecoded(self,
rawJwt=None,
options=None):
decodedSessionToken = rawJwt
try:
decodedSessionToken = self.getDecodedToken(
rawJwt=decodedSessionToken, options=options)
assert ObjectHelper.isDictionary(
decodedSessionToken
), f'Invalid session payload type. It should be a dictionary, bu it is {type(decodedSessionToken)}'
assert ObjectHelper.isNotEmpty(
decodedSessionToken), 'Session cannot be empty'
jti = getJti(rawJwt=decodedSessionToken)
assert ObjectHelper.isNotNone(jti), f'JWT jti cannot be None'
assert jti not in BLACK_LIST, f'Session {jti} already revoked'
nbf = getNfb(rawJwt=decodedSessionToken)
assert ObjectHelper.isNotNone(nbf), f'JWT nbf cannot be None'
assert UtcDateTimeUtil.now() >= UtcDateTimeUtil.ofTimestamp(
nbf
), f'JWT session token not valid before {UtcDateTimeUtil.ofTimestamp(nbf)}'
expiration = getExpiration(rawJwt=decodedSessionToken)
assert UtcDateTimeUtil.now() <= UtcDateTimeUtil.ofTimestamp(
expiration
), f'JWT session token expired at {UtcDateTimeUtil.ofTimestamp(expiration)}'
except Exception as exception:
addAccessTokenToBlackList(rawJwt=decodedSessionToken)
log.log(self.validateGeneralSessionAndReturnItDecoded,
f'Adding {rawJwt} (or current accces) to blackList',
exception=exception,
muteStackTrace=True)
raise exception
return decodedSessionToken
def prettifyPerformance():
# arrange
TEST_SIZE = 100
dictionaryToPrettify = {}
for index in range(TEST_SIZE):
dictionaryToPrettify[f'key_{index}'] = DICTIONARY_INSTANCE
# act
performanceTime = 0
performanceTimeInit = time.time()
toAssertPython = StringHelper.prettyPython(dictionaryToPrettify,
tabCount=1,
withColors=True)
toAssertJson = StringHelper.prettyJson(dictionaryToPrettify,
tabCount=1,
withColors=True)
performanceTime += time.time() - performanceTimeInit
###- 10000 returning f'{strInstance}{strInstance}' : 365.3402144908905 seconds
###- 10000 returning ''.join([strInstance, strInstance]) : 46.94538736343384 seconds
# assert
assert ObjectHelper.isNotNone(toAssertPython) and StringHelper.isNotBlank(
toAssertPython)
assert ObjectHelper.isNotNone(toAssertJson) and StringHelper.isNotBlank(
toAssertJson)
log.test(
prettifyPerformance,
f'performance time on a {len(str(dictionaryToPrettify))} dictionary size: {performanceTime} seconds',
None)
def getErrorMessage(clientResponse, exception=None):
completeErrorMessage = f'{HttpClientConstant.ERROR_AT_CLIENT_CALL_MESSAGE}{c.DOT_SPACE}{HttpClientConstant.CLIENT_DID_NOT_SENT_ANY_MESSAGE}'
errorMessage = HttpClientConstant.CLIENT_DID_NOT_SENT_ANY_MESSAGE
possibleErrorMessage = None
bodyAsJson = {}
try :
bodyAsJson = clientResponse.json()
except Exception as innerException :
bodyAsJsonException = FlaskUtil.safellyGetResponseJson(clientResponse)
log.log(getErrorMessage, f'Invalid client response: {bodyAsJsonException}', exception=innerException)
log.debug(getErrorMessage, f'Not possible to get error message from client response: {bodyAsJsonException}. Proceeding with value {bodyAsJson} by default', exception=innerException, muteStackTrace=True)
try:
if ObjectHelper.isNotNone(clientResponse):
if ObjectHelper.isDictionary(bodyAsJson):
possibleErrorMessage = bodyAsJson.get('message', bodyAsJson.get('error')).strip()
if ObjectHelper.isList(bodyAsJson) and 0 < len(bodyAsJson):
possibleErrorMessage = bodyAsJson[0].get('message', bodyAsJson[0].get('error')).strip()
if ObjectHelper.isNotNone(possibleErrorMessage) and StringHelper.isNotBlank(possibleErrorMessage):
errorMessage = f'{c.LOG_CAUSE}{possibleErrorMessage}'
else:
log.debug(getErrorMessage, f'Client response {FlaskUtil.safellyGetResponseJson(clientResponse)}')
exceptionPortion = HttpClientConstant.ERROR_AT_CLIENT_CALL_MESSAGE if ObjectHelper.isNone(exception) or StringHelper.isBlank(exception) else str(exception)
completeErrorMessage = f'{exceptionPortion}{c.DOT_SPACE}{errorMessage}'
except Exception as exception:
log.warning(getErrorMessage, f'Not possible to get error message. Returning {completeErrorMessage} by default', exception=exception)
return completeErrorMessage
def __init__(self,
message=None,
logMessage=None,
status=None,
logResource=None,
logResourceMethod=None,
verb=None,
url=None,
logPayload=None,
logHeaders=None,
context=None):
self.timeStamp = DateTimeHelper.now()
self.status = HttpStatus.map(DEFAULT_STATUS if ObjectHelper.
isNone(status) else status).enumValue
self.message = message if ObjectHelper.isNotEmpty(
message
) and StringHelper.isNotBlank(
message
) else DEFAULT_MESSAGE if 500 <= self.status else self.status.enumName
self.verb = verb if ObjectHelper.isNotNone(
verb) else self.getRequestVerb()
self.url = url if ObjectHelper.isNotNone(url) else self.getRequestUrl()
self.logMessage = DEFAULT_LOG_MESSAGE if ObjectHelper.isNone(
logMessage) or StringHelper.isBlank(logMessage) else logMessage
self.logResource = DEFAULT_LOG_RESOURCE if ObjectHelper.isNone(
logResource) else logResource
self.logResourceMethod = DEFAULT_LOG_RESOURCE_METHOD if ObjectHelper.isNone(
logResourceMethod) else logResourceMethod
self.logPayload = logPayload if ObjectHelper.isNotNone(
logPayload) else self.getRequestBody()
self.logHeaders = logHeaders if ObjectHelper.isNotNone(
logHeaders) else self.getRequestHeaders()
self.context = HttpDomain.CONTROLLER_CONTEXT if ObjectHelper.isNone(
context) else context
def findAllByQueryAndCommit(self, query, modelClass):
if ObjectHelper.isNotNone(query):
objectList = self.session.query(modelClass).filter_by(
**
{k: v
for k, v in query.items()
if ObjectHelper.isNotNone(v)}).all()
self.session.commit()
return objectList
def handleEnvironmentChangesProperly_withError():
beforeTestEnvironmentSettings = {**EnvironmentHelper.getSet()}
inBetweenTestEnvironmentSettings = None
afterTestEnvironmentSettings = None
someExceptionMessage = 'some exception message'
# Arrange
def myBeforeAction(c, d=None):
return d + c
def myAfterAction(c, d=None):
return c + d
def myFunction(a):
raise Exception(someExceptionMessage)
returns = {}
@Test(callBefore=myBeforeAction,
argsOfCallBefore='f',
kwargsOfCallBefore={'d': 'g'},
callAfter=myAfterAction,
argsOfCallAfter='h',
kwargsOfCallAfter={'d': 'i'},
returns=returns,
environmentVariables={
SettingHelper.ACTIVE_ENVIRONMENT: None,
**MUTED_LOG_HELPER_SETTINGS
})
def myTest():
inBetweenTestEnvironmentSettings = EnvironmentHelper.getSet()
assert ObjectHelper.isNotNone(inBetweenTestEnvironmentSettings)
assert ObjectHelper.isDictionary(inBetweenTestEnvironmentSettings)
assert 'a' == myFunction('a')
return inBetweenTestEnvironmentSettings
# Act
try:
inBetweenTestEnvironmentSettings = myTest()
except Exception as e:
exception = e
afterTestEnvironmentSettings = {**EnvironmentHelper.getSet()}
# Assert
assert 'gf' == returns['returnOfCallBefore']
assert 'hi' == returns['returnOfCallAfter']
assert ObjectHelper.isNotEmpty(exception)
assert someExceptionMessage == str(exception)
assert ObjectHelper.isNotNone(beforeTestEnvironmentSettings)
assert ObjectHelper.isDictionary(beforeTestEnvironmentSettings)
assert ObjectHelper.isNone(inBetweenTestEnvironmentSettings)
assert ObjectHelper.isNotNone(afterTestEnvironmentSettings)
assert ObjectHelper.isDictionary(afterTestEnvironmentSettings)
assert afterTestEnvironmentSettings == beforeTestEnvironmentSettings
assert not beforeTestEnvironmentSettings == inBetweenTestEnvironmentSettings
def getTag(self, link, soupBody=None):
result = None
if ObjectHelper.isNotNone(link):
for font in GoogleSearchConstants.POSSIBLE_FONTS:
if link.startswith(font):
result = self.getResult(
soup.find_all(
GoogleSearchConstants.POSSIBLE_FONTS[font][
GoogleSearchConstants.KEY_TAG],
GoogleSearchConstants.POSSIBLE_FONTS[font][
GoogleSearchConstants.KEY_ATTRIBUTE]))
break
return result if ObjectHelper.isNotNone(result) else soupBody
def addHeadersListToUrlVerb(verb, url, endPointUrl, requestHeaderClass,
documentation):
if ObjectHelper.isList(requestHeaderClass) and 0 == len(
requestHeaderClass):
log.warning(
addHeadersListToUrlVerb,
f'Invalid request header class. requestHeaderClass: {requestHeaderClass}'
)
if ObjectHelper.isNotNone(requestHeaderClass):
log.log(
addHeadersListToUrlVerb,
f'verb: {verb}, url: {url}, requestHeaderClass: {requestHeaderClass}'
)
if ObjectHelper.isNotList(requestHeaderClass):
for attributeName in ReflectionHelper.getAttributeOrMethodNameList(
requestHeaderClass):
documentation[k.PATHS][url][verb][k.PARAMETERS].append({
k.NAME:
attributeName,
k.IN:
v.HEADER,
k.TYPE:
v.STRING,
k.REQUIRED:
True,
k.DESCRIPTION:
None
})
elif 1 == len(requestHeaderClass):
if ObjectHelper.isNotNone(requestHeaderClass[0]):
if ObjectHelper.isNotList(requestHeaderClass[0]):
addHeadersListToUrlVerb(verb, url, endPointUrl,
requestHeaderClass[0],
documentation) ###-, where=where
elif ObjectHelper.isList(requestHeaderClass[0]) and 1 == len(
requestHeaderClass[0]):
if ObjectHelper.isNotNone(requestHeaderClass[0]
[0]) and ObjectHelper.isNotList(
requestHeaderClass[0][0]):
# addHeadersListToUrlVerb(verb, url, endPointUrl, requestHeaderClass[0][0], documentation) ###-, where=where
log.warning(
addHeadersListToUrlVerb,
f'Request header class as list not implemented yet. requestHeaderClass: {requestHeaderClass}'
)
else:
log.warning(
addHeadersListToUrlVerb,
f'Unexpected request header class. requestHeaderClass: {requestHeaderClass}'
)
def osIdentifierTest() :
# arrange
# act
isWindows = EnvironmentHelper.isWindows()
isLinux = EnvironmentHelper.isLinux()
# assert
assert ObjectHelper.isNotNone(isWindows)
assert ObjectHelper.isNotNone(isLinux)
assert ObjectHelper.isNativeClassInstance(isWindows)
assert ObjectHelper.isNativeClassInstance(isLinux)
assert bool == type(isWindows)
assert bool == type(isLinux)
assert isLinux or isWindows
def handleEnvironmentChangesProperly_withSuccess_whenActionsHaveNoArguments():
beforeTestEnvironmentSettings = {**EnvironmentHelper.getSet()}
inBetweenTestEnvironmentSettings = None
afterTestEnvironmentSettings = None
MY_BEFORE_ACTION_RETURN = RandomHelper.string(minimum=10)
MY_AFTER_ACTION_RETURN = RandomHelper.string(minimum=10)
# Arrange
def myBeforeAction():
return MY_BEFORE_ACTION_RETURN
def myAfterAction():
return MY_AFTER_ACTION_RETURN
def myFunction(a):
return a
returns = {}
@Test(callBefore=myBeforeAction,
callAfter=myAfterAction,
returns=returns,
environmentVariables={
SettingHelper.ACTIVE_ENVIRONMENT: None,
**MUTED_LOG_HELPER_SETTINGS
})
def myTest():
inBetweenTestEnvironmentSettings = EnvironmentHelper.getSet()
assert ObjectHelper.isNotNone(inBetweenTestEnvironmentSettings)
assert ObjectHelper.isDictionary(inBetweenTestEnvironmentSettings)
assert 'a' == myFunction('a')
return inBetweenTestEnvironmentSettings
# Act
inBetweenTestEnvironmentSettings = myTest()
afterTestEnvironmentSettings = {**EnvironmentHelper.getSet()}
# Assert
assert MY_BEFORE_ACTION_RETURN == returns['returnOfCallBefore']
assert MY_AFTER_ACTION_RETURN == returns['returnOfCallAfter']
assert ObjectHelper.isNotNone(beforeTestEnvironmentSettings)
assert ObjectHelper.isDictionary(beforeTestEnvironmentSettings)
assert ObjectHelper.isNotNone(inBetweenTestEnvironmentSettings)
assert ObjectHelper.isDictionary(inBetweenTestEnvironmentSettings)
assert ObjectHelper.isNotNone(afterTestEnvironmentSettings)
assert ObjectHelper.isDictionary(afterTestEnvironmentSettings)
assert afterTestEnvironmentSettings == beforeTestEnvironmentSettings
assert not beforeTestEnvironmentSettings == inBetweenTestEnvironmentSettings
def innerMethodWrapper(resourceInstanceMethod, *innerMethodArgs,
**innerMethodKwargs):
log.debug(SchedulerMethod,
f'''wrapping {resourceInstanceMethod.__name__}''')
apiInstance = FlaskManager.getApi()
methodClassName = ReflectionHelper.getMethodClassName(
resourceInstanceMethod)
methodName = ReflectionHelper.getName(resourceInstanceMethod)
methodKwargs['id'] = methodKwargs.get(
'id', f'{methodClassName}{c.DOT}{methodName}')
instancesUpTo = methodKwargs.pop('instancesUpTo', 1)
weekDays = methodKwargs.pop('weekDays', None)
if ObjectHelper.isNotEmpty(
methodArgs
) and SchedulerType.CRON == methodArgs[0] and ObjectHelper.isNotNone(
weekDays) and StringHelper.isNotBlank(weekDays):
methodKwargs['day_of_week'] = weekDays
if ObjectHelper.isNotNone(instancesUpTo):
methodKwargs['max_instances'] = instancesUpTo
shedulerArgs = [*methodArgs]
shedulerKwargs = {**methodKwargs}
@apiInstance.scheduler.task(*shedulerArgs, **shedulerKwargs)
def innerResourceInstanceMethod(*args, **kwargs):
resourceInstanceName = methodClassName[:-len(
FlaskManager.KW_SCHEDULER_RESOURCE)]
resourceInstanceName = f'{resourceInstanceName[0].lower()}{resourceInstanceName[1:]}'
args = FlaskManager.getArgumentInFrontOfArgs(
args,
ReflectionHelper.getAttributeOrMethod(
apiInstance.resource.scheduler, resourceInstanceName))
resourceInstance = args[0]
methodReturn = None
try:
FlaskManager.validateArgs(args, requestClass,
innerResourceInstanceMethod)
methodReturn = resourceInstanceMethod(*args, **kwargs)
except Exception as exception:
FlaskManager.raiseGlobalException(exception, resourceInstance,
resourceInstanceMethod)
log.log(innerResourceInstanceMethod,
f'Not possible to run {shedulerId} properly',
exception=exception)
return methodReturn
ReflectionHelper.overrideSignatures(innerResourceInstanceMethod,
resourceInstanceMethod)
return innerResourceInstanceMethod
def validateArgs(args, requestClass, resourceInstanceMethod):
if ObjectHelper.isNotNone(requestClass):
resourceInstance = args[0]
if Serializer.isSerializerList(requestClass):
if 0 < len(requestClass):
for index in range(len(requestClass)):
if Serializer.isSerializerList(
args[index + 1]) and len(args[index + 1]) > 0:
expecteObjectClass = requestClass[index][0]
for objectInstance in args[index + 1]:
ExceptionHandler.validateArgs(
resourceInstance, resourceInstanceMethod,
objectInstance, expecteObjectClass)
else:
objectRequest = args[index + 1]
expecteObjectClass = requestClass[index]
ExceptionHandler.validateArgs(resourceInstance,
resourceInstanceMethod,
objectRequest,
expecteObjectClass)
else:
objectRequest = args[1]
expecteObjectClass = requestClass
ExceptionHandler.validateArgs(resourceInstance,
resourceInstanceMethod,
objectRequest, expecteObjectClass)
def mustRun_withFailre_ExecutingActionLater():
# Arrange
def myAction(c, d=None):
return c + d
def myFunction(a):
return a
returns = {}
@Test(callAfter=myAction,
argsOfCallAfter='f',
kwargsOfCallAfter={'d': 'g'},
returns=returns,
environmentVariables={
SettingHelper.ACTIVE_ENVIRONMENT: None,
**MUTED_LOG_HELPER_SETTINGS
})
def myTest():
assert 'a' == myFunction('b')
exception = None
# Act
try:
myTest()
except Exception as e:
exception = e
# Assert
assert ObjectHelper.isNotNone(exception)
assert 'fg' == returns['returnOfCallAfter']
def mustRun_withSuccess_ExecutingActionFirst_withFailure():
# Arrange
exceptionMessage = 'some exception'
def myAction(c, d=None):
raise Exception(exceptionMessage)
def myFunction(a):
return a
returns = {}
@Test(callBefore=myAction,
argsOfCallBefore='f',
kwargsOfCallBefore={'d': 'g'},
returns=returns,
environmentVariables={
SettingHelper.ACTIVE_ENVIRONMENT: None,
**MUTED_LOG_HELPER_SETTINGS
})
def myTest():
assert 'a' == myFunction('a')
exception = None
# Act
try:
myTest()
except Exception as e:
exception = e
# Assert
assert ObjectHelper.isNotNone(exception)
assert exceptionMessage == str(exception)
def validateResponseClass(responseClass, controllerResponse):
if isNotPythonFrameworkHttpsResponse(controllerResponse):
raiseBadResponseImplementation(
f'Python Framework response cannot be null. It should be a list like this: [{"RESPONSE_CLASS" if ObjectHelper.isNone(responseClass) else responseClass if ObjectHelper.isNotList(responseClass) else responseClass[0]}, HTTPS_CODE]'
)
if ObjectHelper.isNotNone(responseClass):
if Serializer.isSerializerList(responseClass):
if 0 == len(responseClass):
log.warning(validateResponseClass,
f'"responseClass" was not defined')
elif 1 == len(responseClass):
if ObjectHelper.isNotList(responseClass[0]):
if not isinstance(controllerResponse[0], responseClass[0]):
raiseBadResponseImplementation(
f'Response class does not match expected class. Expected "{responseClass[0].__name__}", response "{controllerResponse[0].__class__.__name__}"'
)
elif ObjectHelper.isNotList(responseClass[0][0]):
if ObjectHelper.isNotList(controllerResponse[0]):
raiseBadResponseImplementation(
f'Response is not a list. Expected "{responseClass[0].__class__.__name__}", but found "{controllerResponse[0].__class__.__name__}"'
)
elif Serializer.isSerializerList(
controllerResponse[0]
) and 0 < len(controllerResponse[0]) and not isinstance(
controllerResponse[0][0], responseClass[0][0]):
raiseBadResponseImplementation(
f'Response element class does not match expected element class. Expected "{responseClass[0][0].__name__}", response "{controllerResponse[0][0].__class__.__name__}"'
)
else:
if not isinstance(controllerResponse[0], responseClass):
raiseBadResponseImplementation(
f'Response class does not match expected class. Expected "{responseClass.__name__}", response "{controllerResponse[0].__class__.__name__}"'
)
else:
log.warning(validateResponseClass, f'"responseClass" was not defined')
def Function_withSuccess():
# Arrange
TEST = RandomHelper.string(minimum=10)
@Function
def myFunction(something):
return TEST, something
@Function
def myOtherFunction(something):
raise Exception(TEST)
SOMETHING = RandomHelper.string(minimum=10)
exception = None
# Act
myRestult = myFunction(SOMETHING)
myOtherResult = None
try:
myOtherResult = myOtherFunction(SOMETHING)
except Exception as ext:
exception = ext
# Assert
assert (TEST, SOMETHING) == myRestult
assert ObjectHelper.isNone(myOtherResult)
assert ObjectHelper.isNotNone(exception)
assert TEST == str(exception)
def validateCompleteResponse(responseClass, completeResponse):
if isNotPythonFrameworkHttpsResponseBody(completeResponse):
raiseBadResponseImplementation(
f'It should be a tuple like this: ({"RESPONSE_CLASS" if ObjectHelper.isNone(responseClass) else responseClass if ObjectHelper.isNotList(responseClass) else responseClass[0]}, HEADERS, HTTPS_CODE). But it is: {completeResponse}'
)
if ObjectHelper.isNotNone(responseClass):
if Serializer.isSerializerList(responseClass):
if 0 == len(responseClass):
log.log(validateCompleteResponse,
f'"responseClass" was not defined')
elif 1 == len(responseClass):
if ObjectHelper.isNotList(responseClass[0]):
if not isinstance(completeResponse[0], responseClass[0]):
raiseBadResponseImplementation(
f'Response does not match expected class. Expected "{responseClass[0].__name__}", but got "{completeResponse[0].__class__.__name__}"'
)
elif ObjectHelper.isNotList(responseClass[0][0]):
if ObjectHelper.isNotList(completeResponse[0]):
raiseBadResponseImplementation(
f'Response is not a list. Expected "{responseClass[0].__class__.__name__}", but found "{completeResponse[0].__class__.__name__}"'
)
elif Serializer.isSerializerList(
completeResponse[0]
) and 0 < len(completeResponse[0]) and not isinstance(
completeResponse[0][0], responseClass[0][0]):
raiseBadResponseImplementation(
f'Response element class does not match expected element class. Expected "{responseClass[0][0].__name__}", response "{completeResponse[0][0].__class__.__name__}"'
)
else:
if not isinstance(completeResponse[0], responseClass):
raiseBadResponseImplementation(
f'Response does not match expected class. Expected "{responseClass.__name__}", but got "{completeResponse[0].__class__.__name__}"'
)
else:
log.log(validateCompleteResponse, f'"responseClass" was not defined')
def addResource(apiInstance, appInstance, baseModel=None, echo=False):
apiInstance.repository = SqlAlchemyProxy(baseModel,
apiInstance.globals,
echo=echo)
if ObjectHelper.isNotNone(apiInstance.repository):
log.success(addResource, 'SqlAlchemyProxy database connection created')
return apiInstance.repository
def mustRun_withFailre_ExecutingActionLater_withFailre():
# Arrange
exceptionMessage = 'some exception'
def myAction(c, d=None):
raise Exception(exceptionMessage)
def myFunction(a):
return a
returns = {}
@Test(callAfter=myAction,
argsOfCallAfter='f',
kwargsOfCallAfter={'d': 'g'},
returns=returns,
environmentVariables={
SettingHelper.ACTIVE_ENVIRONMENT: None,
**MUTED_LOG_HELPER_SETTINGS
})
def myTest():
assert 'a' == myFunction('b')
exception = None
# Act
try:
myTest()
except Exception as e:
exception = e
# Assert
assert ObjectHelper.isNotNone(exception)
assert not exceptionMessage == str(exception)
assert 'AssertionError. Followed by: some exception' == str(exception)
def apiKeyManager_worksProperly():
# arrange
SECRET = 'abcd'
SESSION_DURATION = 10 + 360
ALGORITHM = 'HS256'
HEADER_NAME = 'Context'
HEADER_TYPE = 'ApiKey '
IDENTITY = RandomHelper.string(minimum=100, maximum=150)
CONTEXT = 'ABCD'
CONTEXT_LIST = [CONTEXT]
DATA = {'personal': 'data'}
deltaMinutes = DateTimeHelper.timeDelta(minutes=SESSION_DURATION)
apiKeyManager = ApiKeyManager.JwtManager(SECRET, ALGORITHM, HEADER_NAME,
HEADER_TYPE)
timeNow = DateTimeHelper.dateTimeNow()
payload = {
JwtConstant.KW_IAT: timeNow,
JwtConstant.KW_NFB: timeNow,
JwtConstant.KW_JTI:
f"{int(f'{time.time()}'.replace('.', ''))+int(f'{time.time()}'.replace('.', ''))}",
JwtConstant.KW_EXPIRATION: timeNow + deltaMinutes,
JwtConstant.KW_IDENTITY: IDENTITY,
JwtConstant.KW_FRESH: False,
JwtConstant.KW_TYPE: JwtConstant.ACCESS_VALUE_TYPE,
JwtConstant.KW_CLAIMS: {
JwtConstant.KW_CONTEXT: CONTEXT_LIST,
JwtConstant.KW_DATA: DATA
}
}
# act
totalRuns = 10000
lines = 3
initTime = time.time()
for i in range(totalRuns):
encodedPayload = apiKeyManager.encode(payload)
decodedPayload = apiKeyManager.decode(encodedPayload)
accessException = TestHelper.getRaisedException(
apiKeyManager.validateAccessApiKey, rawJwt=decodedPayload)
refreshException = TestHelper.getRaisedException(
apiKeyManager.validateRefreshApiKey, rawJwt=decodedPayload)
endTime = time.time() - initTime
# assert
assert lines * .0001 > endTime / totalRuns, (lines * .0001,
endTime / totalRuns)
assert ObjectHelper.equals(payload,
decodedPayload), (payload, decodedPayload)
assert ObjectHelper.isNone(accessException), accessException
assert ObjectHelper.isNotNone(refreshException), refreshException
assert ObjectHelper.equals(
GlobalException.__name__,
type(refreshException).__name__), (GlobalException.__name__,
type(refreshException).__name__,
refreshException)
assert ObjectHelper.equals(401, refreshException.status)
assert ObjectHelper.equals('Invalid apiKey', refreshException.message)
assert ObjectHelper.equals(
'Refresh apiKey should have type refresh, but it is access',
refreshException.logMessage)
def getCurrentUser(userClass=None, apiInstance=None):
currentUsert = get_current_user()
if ObjectHelper.isNotNone(currentUsert):
return currentUsert
else:
rawJwt = getJwtBody()
identity = getIdentity(rawJwt=rawJwt)
context = getContext(rawJwt=rawJwt)
data = getData(rawJwt=rawJwt)
if ObjectHelper.isNone(userClass):
return {
JwtConstant.KW_IDENTITY: identity,
JwtConstant.KW_CONTEXT: context,
JwtConstant.KW_DATA: data
}
else:
currentUsert = userClass()
currentUsert._contextInfo = {
JwtConstant.KW_IDENTITY: identity,
JwtConstant.KW_CONTEXT: context
}
for attributeName in data:
if ReflectionHelper.hasAttributeOrMethod(
currentUsert, attributeName):
ReflectionHelper.setAttributeOrMethod(
currentUsert, attributeName, data.get(attributeName))
return currentUsert
def innerResourceInstanceMethod(*args,**kwargs) :
resourceInstance = args[0]
completeResponse = None
if logRequest :
log.prettyJson(
resourceInstanceMethod,
'bodyRequest',
json.loads(Serializer.jsonifyIt(args[1:])),
condition = logRequest,
logLevel = log.DEBUG
)
try :
FlaskManager.validateKwargs(
kwargs,
resourceInstance,
innerResourceInstanceMethod,
requestHeaderClass = requestHeaderClass,
requestParamClass = requestParamClass
)
FlaskManager.validateArgs(args, requestClass, innerResourceInstanceMethod)
completeResponse = resourceInstanceMethod(*args,**kwargs)
FlaskManager.validateResponseClass(responseClass, completeResponse)
except Exception as exception :
log.warning(innerResourceInstanceMethod, 'Not posssible to complete request', exception=exception)
raise exception
controllerResponse = completeResponse[0] if ObjectHelper.isNotNone(completeResponse[0]) else {'message' : completeResponse[1].enumName}
if logResponse :
log.prettyJson(
resourceInstanceMethod,
'bodyResponse',
json.loads(Serializer.jsonifyIt(controllerResponse)),
condition = logResponse,
logLevel = log.DEBUG
)
return completeResponse[0]
def getText(soupElement):
# log.prettyPython(self.poolMessagesFromOriginToDestiny, 'soupElement', ReflectionHelper.getItNaked(soupElement), logLevel=log.DEBUG)
# log.prettyPython(self.poolMessagesFromOriginToDestiny, 'soupElement.__dict__', soupElement.__dict__, logLevel=log.DEBUG)
if ObjectHelper.isNotNone(soupElement) and not isinstance(
soupElement, str):
return soupElement.text ###- soupElement.string
else:
return str(soupElement)
def getNewBrowser(self, options=None, hidden=False) :
options = options if ObjectHelper.isNotNone(options) else self.getBrowserOptions()
browser = BrowserConstants.BOWSER_CLASS(ChromeDriverManager().install(), chrome_options=options)
browser.execute_cdp_cmd('Network.setUserAgentOverride', {"userAgent": f'{USER_AGENT}'})
browser.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")
log.debug(self.getNewBrowser, f'session_id: {browser.session_id}')
log.debug(self.getNewBrowser, f'command_executor: {browser.command_executor._url}')
return browser
def innerResourceInstanceMethod(*args, **kwargs):
f'''(*args, {FlaskUtil.KW_HEADERS}={{}}, {FlaskUtil.KW_PARAMETERS}={{}}, **kwargs)'''
resourceInstance = args[0]
clientResponse = None
completeResponse = None
try :
FlaskManager.validateKwargs(
kwargs,
resourceInstance,
resourceInstanceMethod,
requestHeaderClass,
requestParamClass
)
FlaskManager.validateArgs(args, requestClass, resourceInstanceMethod)
clientResponse = None
httpClientEvent = getHttpClientEvent(resourceInstanceMethod, *args, **kwargs)
if isinstance(httpClientEvent, ManualHttpClientEvent):
completeResponse = httpClientEvent.completeResponse
elif isinstance(httpClientEvent, HttpClientEvent):
try :
clientResponse = HTTP_CLIENT_RESOLVERS_MAP.get(
httpClientEvent.verb,
raiseHttpClientEventNotFoundException
)(
resourceInstance,
*httpClientEvent.args,
**httpClientEvent.kwargs
)
except Exception as exception:
raiseException(clientResponse, exception)
raiseExceptionIfNeeded(clientResponse)
completeResponse = getCompleteResponse(clientResponse, responseClass, produces)
FlaskManager.validateCompleteResponse(responseClass, completeResponse)
else:
raise Exception('Unknown http client event')
except Exception as exception:
log.log(innerResourceInstanceMethod, 'Failure at client method execution', exception=exception, muteStackTrace=True)
FlaskManager.raiseAndPersistGlobalException(exception, resourceInstance, resourceInstanceMethod, context=HttpDomain.CLIENT_CONTEXT)
clientResponseStatus = completeResponse[-1]
clientResponseHeaders = completeResponse[1]
clientResponseBody = completeResponse[0] if ObjectHelper.isNotNone(completeResponse[0]) else {'message' : HttpStatus.map(clientResponseStatus).enumName}
if resourceInstance.logResponse or logResponse :
log.prettyJson(
resourceInstanceMethod,
'[CLIENT ] Response',
{
'headers': clientResponseHeaders,
'body': Serializer.getObjectAsDictionary(clientResponseBody),
'status': clientResponseStatus
},
condition = True,
logLevel = log.INFO
)
if returnOnlyBody:
return completeResponse[0]
else:
return completeResponse
def findAllByPartialAttributeValue(soup, tag, attributeName,
partialAttributeValue):
if ObjectHelper.isNotNone(soup):
return soup.find_all(tag,
attrs={
attributeName:
lambda e: partialAttributeValue in e
if e else False
})
def getEncodedTokenWithoutType(self):
encodedPayload = self.captureTokenFromRequestHeader()
assert ObjectHelper.isNotNone(
encodedPayload
), f'JWT session token cannot be None. Header: {self.headerName}'
assert encodedPayload.startswith(
f'{self.headerType} '
), f'JWT session token must starts with {self.headerType}'
return encodedPayload[len(f'{self.headerType} '):].encode()
def Method_withSuccess():
# Arrange
TEST = RandomHelper.string(minimum=10)
class MyClass:
@Method
def myMethod(self, something):
return TEST, something
@Method
def myOtherMethod(self, something):
raise Exception(TEST)
@Method
def myNotMethod(self, something):
raise Exception(TEST)
SOMETHING = RandomHelper.string(minimum=10)
methodException = None
notMethodEception = None
myClass = MyClass()
# Act
myRestult = myClass.myMethod(SOMETHING)
myOtherResult = None
try:
myOtherResult = myClass.myOtherMethod(SOMETHING)
except Exception as ext:
methodException = ext
myNotMethodResult = None
try:
myNotMethodResult = myNotMethod(None, SOMETHING)
except Exception as ext:
notMethodEception = ext
# print(notMethodEception)
# Assert
assert (TEST, SOMETHING) == myRestult
assert ObjectHelper.isNone(myOtherResult)
assert ObjectHelper.isNotNone(methodException)
assert TEST == str(methodException)
assert ObjectHelper.isNone(myNotMethodResult)
assert ObjectHelper.isNotNone(notMethodEception)
assert TEST == str(notMethodEception)
def getHttpClientEvent(resourceInstanceMethod, *args, **kwargs):
completeResponse = None
try:
completeResponse = resourceInstanceMethod(*args, **kwargs)
except HttpClientEvent as httpClientEvent:
return httpClientEvent
except Exception as exception:
raise exception
if ObjectHelper.isNotNone(completeResponse):
return ManualHttpClientEvent(completeResponse)
def safellyGetArgs():
args = None
try:
args = dict(request.args)
except Exception as exception:
args = {}
log.log(safellyGetArgs,
f'Not possible to get args. Returning {args} by default',
exception=exception)
return args if ObjectHelper.isNotNone(args) else dict()
