import time
|
|
import logging
|
from webodm import settings
|
|
logger = logging.getLogger('app.logger')
|
|
class TestWatch:
|
def __init__(self):
|
self.clear()
|
|
def func_to_name(f):
|
return "{}.{}".format(f.__module__, f.__name__)
|
|
def clear(self):
|
self._calls = {}
|
self._intercept_list = {}
|
|
def intercept(self, fname, f = None):
|
self._intercept_list[fname] = f if f is not None else True
|
|
def intercept_list_has(self, fname):
|
return fname in self._intercept_list
|
|
def execute_intercept_function_replacement(self, fname, *args, **kwargs):
|
if self.intercept_list_has(fname) and callable(self._intercept_list[fname]):
|
(self._intercept_list[fname])(*args, **kwargs)
|
|
def get_calls(self, fname):
|
return self._calls[fname] if fname in self._calls else []
|
|
def set_calls(self, fname, value):
|
self._calls[fname] = value
|
|
def should_prevent_execution(self, func):
|
return self.intercept_list_has(TestWatch.func_to_name(func))
|
|
def get_calls_count(self, fname):
|
return len(self.get_calls(fname))
|
|
def wait_until_call(self, fname, count = 1, timeout = 30):
|
SLEEP_INTERVAL = 0.125
|
TIMEOUT_LIMIT = timeout / SLEEP_INTERVAL
|
c = 0
|
while self.get_calls_count(fname) < count and c < TIMEOUT_LIMIT:
|
time.sleep(SLEEP_INTERVAL)
|
c += 1
|
|
if c >= TIMEOUT_LIMIT:
|
raise TimeoutError("wait_until_call has timed out waiting for {}".format(fname))
|
|
return self.get_calls(fname)
|
|
def log_call(self, func, *args, **kwargs):
|
fname = TestWatch.func_to_name(func)
|
self.manual_log_call(fname, *args, **kwargs)
|
|
def manual_log_call(self, fname, *args, **kwargs):
|
if settings.TESTING:
|
list = self.get_calls(fname)
|
list.append({'f': fname, 'args': args, 'kwargs': kwargs})
|
self.set_calls(fname, list)
|
|
def hook_pre(self, func, *args, **kwargs):
|
if settings.TESTING and self.should_prevent_execution(func):
|
fname = TestWatch.func_to_name(func)
|
logger.info(fname + " intercepted")
|
self.execute_intercept_function_replacement(fname, *args, **kwargs)
|
self.log_call(func, *args, **kwargs)
|
return True # Intercept
|
return False # Do not intercept
|
|
def hook_post(self, func, *args, **kwargs):
|
if settings.TESTING:
|
self.log_call(func, *args, **kwargs)
|
|
def watch(**kwargs):
|
"""
|
Decorator that adds pre/post hook calls
|
"""
|
tw = kwargs.get('testWatch', testWatch)
|
def outer(func):
|
def wrapper(*args, **kwargs):
|
if tw.hook_pre(func, *args, **kwargs): return
|
ret = func(*args, **kwargs)
|
tw.hook_post(func, *args, **kwargs)
|
return ret
|
return wrapper
|
return outer
|
|
testWatch = TestWatch()
|
