def unitTest(testModule, testName, data, testReturns, logResult):
discountTimeEnd = time.time()
unitTestException = None
if logResult:
LogHelper.test(unitTest,
f'{testName}{c.DOT}{data[1]} test started')
moduleTestStartTime = time.time()
try:
testReturns[data[1]] = data[0]()
LogHelper.printSuccess(
f'{data[0].__module__}{c.DOT}{data[0].__name__} succeed',
condition=logResult,
newLine=False,
margin=False)
except Exception as exception:
LogHelper.printError(
f'{data[0].__module__}{c.DOT}{data[0].__name__} failed',
condition=True,
newLine=False,
margin=False,
exception=exception)
unitTestException = exception
if logResult:
LogHelper.test(
unitTest,
f'{testName}{c.DOT}{data[1]} test completed in {time.time() - moduleTestStartTime} seconds'
)
if ObjectHelper.isNotNone(unitTestException):
raise unitTestException
someDidRun = True
return testName, data, testReturns, someDidRun, logResult, discountTimeEnd
def tddModule(testName, testModule, dataList, times, runSpecificTests,
testsToRun, allShouldRun, someShouldRun, logResult):
import globals
tddModuleGlobalsInstance = globals.newGlobalsInstance(
testModule.__file__,
successStatus=globalsInstance.successStatus,
errorStatus=globalsInstance.errorStatus,
settingStatus=globalsInstance.settingStatus or inspectGlobals,
debugStatus=globalsInstance.debugStatus,
warningStatus=globalsInstance.warningStatus,
wrapperStatus=globalsInstance.wrapperStatus,
testStatus=globalsInstance.testStatus,
logStatus=globalsInstance.logStatus)
LogHelper.test(tddModule, f'{testName} started')
testReturns = {}
testTime = 0
for data in dataList:
testMustRun = isTestToRun(testModule, data, runSpecificTests,
testsToRun)
LogHelper.prettyPython(tddModule,
f'test attribute or method',
data[0],
logLevel=LogHelper.TEST)
LogHelper.prettyPython(tddModule,
f'isTestToRun',
testMustRun,
logLevel=LogHelper.TEST)
if testMustRun:
for index in range(times):
testTimeStart = time.time()
if times - 1 == index:
runnableUnitTest = getUnitTest(inspectGlobals,
globalsInstance)
testName, data, testReturns, someDidRun, logResult, discountTimeEnd = runnableUnitTest(
testModule, testName, data, testReturns, logResult)
else:
runnableUnitTestBatch = getUnitTestBatch(
inspectGlobals, globalsInstance)
discountTimeEnd = runnableUnitTestBatch(
testModule, data)
testTime += time.time() - discountTimeEnd
else:
allDidRun = False
if not allShouldRun == allDidRun and someShouldRun == someDidRun:
amountAlthought = getAmmount(allShouldRun, someShouldRun)
shouldOrShouldnt = getShouldOrShouldntAsString(
allShouldRun, someShouldRun)
amountAfterAlthought = getAmmount(allDidRun, someDidRun)
didOrDidnt = getSomeDidOrDidntAsString(allDidRun, someDidRun)
errorMessage = f'Inconsistenc{StringHelper.getS(allShouldRun or someShouldRun, es=True)} detected. Although {amountAlthought} test{StringHelper.getS(allShouldRun or someShouldRun)} {shouldOrShouldnt} run, {amountAfterAlthought} {didOrDidnt} run'
exception = Exception(errorMessage)
raise exception
return allDidRun, someDidRun, testTime, testReturns
def handle(resourceInstanceMethod, actionClass, args, kwargs, returns, moment, returnKey) :
try :
returnCall = None
if actionIsPresent(actionClass) :
argsMessage = getArgsLogMessage(args)
kwargsMessage = getKwargsLogMessage(kwargs)
returnCall = getRetrunValue(actionClass, args, kwargs)
LogHelper.test(resourceInstanceMethod, f'{ReflectionHelper.getName(actionClass)}({argsMessage}, {kwargsMessage}): {returnCall}')
else :
LogHelper.test(resourceInstanceMethod, f'Test handler to perform actions {moment} the test is not defined')
if returnsValueIsPresent(returns) :
returns[returnKey] = returnCall
except Exception as exception :
LogHelper.printError(f'{ReflectionHelper.getMethodModuleNameDotName(resourceInstanceMethod)} test went wrong while handling actions {moment} the test. *args: {args}, **kwargs: {kwargs}. Enable test logs for more information', condition=True, newLine=False, margin=False, exception=exception)
return exception
def handleAfter(resourceInstanceMethod, actionClass, args, kwargs, returns, methodReturn, inspectGlobals, methodReturnException=None, logResult=True) :
inspectGlobalsIfNeeded(inspectGlobals, resourceInstanceMethod, 'did run')
if ObjectHelper.isNone(methodReturnException) :
LogHelper.printSuccess(f'{ReflectionHelper.getMethodModuleNameDotName(resourceInstanceMethod)} test succeed', condition=logResult, newLine=False, margin=False)
else :
LogHelper.printError(f'{ReflectionHelper.getMethodModuleNameDotName(resourceInstanceMethod)} test failed', condition=logResult, newLine=False, margin=False, exception=methodReturnException)
actionHandlerException = handle(resourceInstanceMethod, actionClass, args, kwargs, returns, AFTER_THE_TEST, RETURN_VALUE_FROM_CALL_AFTER)
LogHelper.test(resourceInstanceMethod, 'Test completed')
if ObjectHelper.isNotNone(methodReturnException) or ObjectHelper.isNotNone(actionHandlerException) :
if ObjectHelper.isNotNone(methodReturnException) and ObjectHelper.isNotNone(actionHandlerException) :
raise Exception(f'{LogHelper.getExceptionMessage(methodReturnException)}. Followed by: {LogHelper.getExceptionMessage(actionHandlerException)}')
elif ObjectHelper.isNotNone(methodReturnException) :
raise methodReturnException
raise actionHandlerException
if not TEST_VALUE_NOT_SET == methodReturn :
return methodReturn
def runModuleTests(testName, runnableTddModule, times, runSpecificTests,
testsToRun, logResult, globalsInstance):
import globals
testModule = globals.importModule(testName)
dataList = ReflectionHelper.getAttributeDataList(testModule)
LogHelper.prettyPython(
runnableTddModule,
f'{ReflectionHelper.getName(testModule)} tests loaded',
dataList,
logLevel=LogHelper.TEST)
allShouldRun, someShouldRun, allDidRun, someDidRun = getRunStatus(
testModule, dataList, runSpecificTests, testsToRun)
testReturns = {}
testTime = 0
totalTestTimeStart = time.time()
if someShouldRun:
defaultMessage = f'{testName}{StringHelper.getS(allShouldRun)}'
methodReturnException = None
LogHelper.test(runModuleTests, f'{defaultMessage} started')
try:
allDidRun, someDidRun, testTime, testReturns = runnableTddModule(
testName, testModule, dataList, times, runSpecificTests,
testsToRun, allShouldRun, someShouldRun, logResult)
LogHelper.printSuccess(
f'{defaultMessage} succeed. {getTestRuntimeInfo(times, testTime, time.time() - totalTestTimeStart)}',
condition=logResult,
newLine=True,
margin=False)
except Exception as exception:
methodReturnException = exception
LogHelper.printError(f'{defaultMessage} failed',
condition=True,
newLine=True,
margin=False,
exception=methodReturnException)
exceptionRaised = ObjectHelper.isNotNone(methodReturnException)
defaultMessage = f'{testName}{StringHelper.getS(not exceptionRaised and allDidRun)}'
if exceptionRaised:
raise methodReturnException
return allDidRun, someDidRun, testTime, testReturns
def handleBefore(resourceInstanceMethod, actionClass, args, kwargs, returns, inspectGlobals) :
LogHelper.test(resourceInstanceMethod, 'Test started')
actionHandlerException = handle(resourceInstanceMethod, actionClass, args, kwargs, returns, BEFORE_THE_TEST, RETURN_VALUE_FROM_CALL_BEFORE)
if ObjectHelper.isNotNone(actionHandlerException) :
raise actionHandlerException
inspectGlobalsIfNeeded(inspectGlobals, resourceInstanceMethod, 'will run')
def returnsValueIsPresent(returns) :
isPresent = ObjectHelper.isDictionary(returns)
if not isPresent :
LogHelper.test(returnsValueIsPresent, f'the key "returns" from {ReflectionHelper.getMethodModuleNameDotName(Test)} annotation call was not defined')
return isPresent
