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()