def test_quickstart_example_1(self):
def handler(func, *args, **kwargs):
return func(*args, **kwargs) * 2
intercepts.register(sum, handler)
self.assertEqual(sum([2, 2]), 8)
self.assertEqual(sum([1, 2, 3, 4, 5, 6]), 42)
def _test_open_helper(self, *args, **kwargs):
from io import TextIOBase
builtin_func = open
result = builtin_func(*args, **kwargs)
stdout = get_stdout()
intercepts.register(builtin_func, handler)
handled_str, handled_result = builtin_func(*args, **kwargs)
handled_stdout = get_stdout()
self.assertEqual(handled_str, "handled")
self.assertEqual(result.name, handled_result.name)
self.assertEqual(type(result), type(handled_result))
if isinstance(result, TextIOBase):
self.assertEqual(result.mode, handled_result.mode)
self.assertEqual(result.encoding, handled_result.encoding)
self.assertEqual(stdout, handled_stdout, "stdout should not change")
intercepts.unregister(builtin_func)
unhandled_result = builtin_func(*args, **kwargs)
unhandled_stdout = get_stdout()
self.assertEqual(
unhandled_result.name,
result.name,
"function should no longer be intercepted",
)
self.assertEqual(type(result), type(unhandled_result))
if isinstance(result, TextIOBase):
self.assertEqual(result.mode, unhandled_result.mode)
self.assertEqual(result.encoding, unhandled_result.encoding)
self.assertEqual(stdout, unhandled_stdout, "stdout should not change")
result.close()
handled_result.close()
unhandled_result.close()
def test_unregister_all(self):
t = TestClass()
result1 = t.method_no_arg()
result2 = t.method_one_arg(1)
intercepts.register(t.method_no_arg, handler)
intercepts.register(t.method_one_arg, handler)
self.assertEqual(
t.method_no_arg(),
("handled", result1),
"handler function should modify first output",
)
self.assertEqual(
t.method_one_arg(1),
("handled", result2),
"handler function should modify second output",
)
intercepts.unregister_all()
self.assertEqual(
t.method_no_arg(), result1, "first function should no longer be intercepted"
)
self.assertEqual(
t.method_one_arg(1),
result2,
"second function should no longer be intercepted",
)
self.assertEqual(
intercepts.registration._HANDLERS,
{},
"All function intercept handlers should be unregistered.",
)
def test_quickstart_example_2(self):
def pre_handler(func, *args, **kwargs):
print("Executing function:", func.__name__)
return func(*args, **kwargs)
def post_handler(func, *args, **kwargs):
result = func(*args, **kwargs)
print("Executed function:", func.__name__)
return result
intercepts.register(sum, pre_handler)
intercepts.register(sum, post_handler)
self.assertEqual(sum([1, 2, 3, 4, 5, 6]), 21)
self.assertEqual(
sys.stdout.out,
[
"Executing function:",
" ",
"sum",
"\n",
"Executed function:",
" ",
"sum",
"\n",
],
)
def test_unregister_all(self):
result = func_no_args()
intercepts.register(func_no_args, handler)
intercepts.register(func_no_return, handler)
self.assertEqual(
func_no_args(),
("handled", result),
"handler function should modify first output",
)
self.assertEqual(
func_no_return(),
("handled", None),
"handler function should modify second output",
)
intercepts.unregister_all()
self.assertEqual(
func_no_args(), result, "first function should no longer be intercepted"
)
self.assertIsNone(
func_no_return(), "second function should no longer be intercepted"
)
self.assertEqual(
intercepts.registration._HANDLERS,
{},
"All function intercept handlers should be unregistered.",
)
def test_register_func_one_kwarg_1(self):
result = func_one_kwarg()
intercepts.register(func_one_kwarg, handler)
self.assertEqual(
func_one_kwarg(),
("handled", result),
"handler function should modify output",
)
def test_resister_print_call(self):
args = ("test message", )
result = print(*args)
self.assertEqual(sys.stdout.out, [" ".join(args), "\n"])
intercepts.register(print, handler)
self.assertEqual(print(*args), ("handled", result),
"handler function should modify output")
self.assertEqual(sys.stdout.out, [" ".join(args), "\n"] * 2)
def test_register_func_two_args(self):
arg1, arg2 = 1, 2
result = func_two_args(arg1, arg2)
intercepts.register(func_two_args, handler)
self.assertEqual(
func_two_args(arg1, arg2),
("handled", result),
"handler function should modify output",
)
def test_readme_example(self):
self.assertEqual(increment(41), 42)
intercepts.register(increment, handler)
self.assertEqual(increment(41), 40)
intercepts.unregister(increment)
intercepts.register(increment, handler2)
self.assertEqual(increment(41), "The answer is: 42")
intercepts.unregister_all()
self.assertEqual(increment(41), 42)
def test_unregister(self):
args = (5, 11)
result = pow(*args)
intercepts.register(pow, handler)
self.assertEqual(pow(*args), ("handled", result),
"handler function should modify output")
intercepts.unregister(pow)
self.assertEqual(pow(*args), result,
"function should no longer be intercepted")
def test_unregister(self):
result = func_no_args()
intercepts.register(func_no_args, handler)
self.assertEqual(
func_no_args(), ("handled", result), "handler function should modify output"
)
intercepts.unregister(func_no_args)
self.assertEqual(
func_no_args(), result, "function should no longer be intercepted"
)
def test_unregister_multiple_handlers(self):
args = (self, )
result = repr(*args)
intercepts.register(repr, handler)
intercepts.register(repr, handler)
self.assertEqual(
repr(*args),
("handled", ("handled", result)),
"handler functions should modify output",
)
intercepts.unregister(repr)
self.assertEqual(repr(*args), result,
"function should no longer be intercepted")
def test_register_sorted_rev(self):
args = ([1, 4, 6, 2, 9, 5, 10, 11, 11, 3, -18], )
result = sorted(*args)
def handler_rev(func, *args, **kwargs):
return ("handled", list(reversed(func(*args, **kwargs))))
intercepts.register(sorted, handler_rev)
self.assertEqual(
sorted(*args),
("handled", list(reversed(result))),
"handler function should modify output",
)
def test_unregister(self):
t = TestClass()
result = t.method_no_arg()
intercepts.register(t.method_no_arg, handler)
self.assertEqual(
t.method_no_arg(),
("handled", result),
"handler function should modify output",
)
intercepts.unregister(t.method_no_arg)
self.assertEqual(
t.method_no_arg(), result, "method should no longer be intercepted"
)
def test_unregister_multiple_mixed_handlers_4(self):
t = TestClass()
result = t.method_no_arg()
intercepts.register(TestClass.method_no_arg, handler)
intercepts.register(t.method_no_arg, handler_0)
self.assertEqual(
t.method_no_arg(),
("handled_0", ("handled", result)),
"handler function should modify output",
)
intercepts.unregister(TestClass.method_no_arg, 1)
self.assertEqual(
t.method_no_arg(), ("handled", result), "method should still be intercepted"
)
def test_register_import(self):
result = __import__("os", globals(), locals(), level=0)
intercepts.register(
__import__,
lambda func, *args, **kwargs:
[print(args[0]), func(*args, **kwargs)][-1],
)
result_ = __import__("os", globals(), locals(), level=0)
self.assertEqual(result_, result,
"handler function should not modify output")
self.assertEqual(
sys.stdout.out,
["os", "\n"],
"handler function should print the name of the imported module",
)
def test_register_method_one_arg(self):
t = TestClass()
t2 = TestClass()
result = t.method_one_arg(1)
intercepts.register(t.method_one_arg, handler)
self.assertEqual(
t.method_one_arg(1),
("handled", result),
"handler function should modify output",
)
self.assertEqual(
t2.method_one_arg(1),
("handled", result),
"handler function should modify output of other methods",
)
def test_register_class_function(self):
t = TestClass()
result = t.method_no_arg()
intercepts.register(TestClass.method_no_arg, handler)
self.assertEqual(
t.method_no_arg(),
("handled", result),
"handler function should modify output",
)
t2 = TestClass()
self.assertEqual(
t2.method_no_arg(),
("handled", result),
"handler function should modify output",
)
def run_test(self, builtin_func, *args, **kwargs):
result = builtin_func(*args, **kwargs)
stdout = get_stdout()
intercepts.register(builtin_func, handler)
handled_result = builtin_func(*args, **kwargs)
handled_stdout = get_stdout()
intercepts.unregister(builtin_func)
self.assertEqual(handled_result, ("handled", result),
"handler function should modify output")
self.assertEqual(stdout, handled_stdout, "stdout should not change")
unhandled_result = builtin_func(*args, **kwargs)
unhandled_stdout = get_stdout()
self.assertEqual(unhandled_result, result,
"function should no longer be intercepted")
self.assertEqual(stdout, unhandled_stdout, "stdout should not change")
def test_unregister_multiple_handlers_depth_1(self):
result = func_no_args()
intercepts.register(func_no_args, handler)
intercepts.register(func_no_args, handler)
self.assertEqual(
func_no_args(),
("handled", ("handled", result)),
"handler functions should modify output",
)
intercepts.unregister(func_no_args, depth=1)
self.assertEqual(
func_no_args(),
("handled", result),
"one handler function should modify output",
)
def test_resister_print(self):
self.assertEqual(
intercepts.register(print, handler),
print,
"intercepts.register should return the handled function",
)
self.assertTrue(isinstance(print, types.BuiltinFunctionType))
def test_unregister_multiple_handlers_depth_1(self):
t = TestClass()
result = t.method_no_arg()
intercepts.register(t.method_no_arg, handler)
intercepts.register(t.method_no_arg, handler)
self.assertEqual(
t.method_no_arg(),
("handled", ("handled", result)),
"handler function should modify output",
)
intercepts.unregister(t.method_no_arg, depth=1)
self.assertEqual(
t.method_no_arg(),
("handled", result),
"one handler function should modify output",
)
def test_unregister_multiple_handlers_depth_1(self):
func = round
args = (3.14159265358979, 2)
result = func(*args)
intercepts.register(func, handler)
intercepts.register(func, handler)
self.assertEqual(
func(*args),
("handled", ("handled", result)),
"handler functions should modify output",
)
intercepts.unregister(func, depth=1)
self.assertEqual(
func(*args),
("handled", result),
"one handler function should modify output",
)
def _test_iter_helper(self, *args, **kwargs):
builtin_func = iter
result = list(builtin_func(*args, **kwargs))
stdout = get_stdout()
intercepts.register(builtin_func, handler)
handled_result = builtin_func(*args, **kwargs)
handled_stdout = get_stdout()
intercepts.unregister(builtin_func)
self.assertTrue(isinstance(handled_result, tuple))
self.assertEqual(handled_result[0], "handled")
self.assertEqual(list(handled_result[1]), result)
self.assertEqual(stdout, handled_stdout, "stdout should not change")
unhandled_result = list(builtin_func(*args, **kwargs))
unhandled_stdout = get_stdout()
self.assertEqual(unhandled_result, result,
"function should no longer be intercepted")
self.assertEqual(stdout, unhandled_stdout, "stdout should not change")
def test_quickstart_example_3(self):
def handler_0(func, *args, **kwargs):
print("handler 0")
return func(*args, **kwargs)
def handler_1(func, *args, **kwargs):
print("handler 1")
return func(*args, **kwargs)
intercepts.register(abs, handler_0)
intercepts.register(abs, handler_1)
self.assertEqual(abs(33), 33)
self.assertEqual(sys.stdout.out,
["handler 1", "\n", "handler 0", "\n"])
sys.stdout.out = []
self.assertEqual(abs(-6), 6)
self.assertEqual(sys.stdout.out,
["handler 1", "\n", "handler 0", "\n"])
def run_local_isolated_test(self, builtin_func, *args, **kwargs):
# run the function in local isolation to prevent changes due to changing local environment
def isolated_func(func, *args, **kwargs):
a = 0
b = 1
c = []
return func(*args, **kwargs)
result = isolated_func(builtin_func, *args, **kwargs)
stdout = get_stdout()
intercepts.register(builtin_func, handler)
handled_result = isolated_func(builtin_func, *args, **kwargs)
handled_stdout = get_stdout()
self.assertEqual(handled_result, ("handled", result),
"handler function should modify output")
self.assertEqual(stdout, handled_stdout, "stdout should not change")
intercepts.unregister(builtin_func)
unhandled_result = isolated_func(builtin_func, *args, **kwargs)
unhandled_stdout = get_stdout()
self.assertEqual(unhandled_result, result,
"function should no longer be intercepted")
self.assertEqual(stdout, unhandled_stdout, "stdout should not change")
def test_register_func_no_args(self):
result = func_no_args()
intercepts.register(func_no_args, handler)
self.assertEqual(
func_no_args(), ("handled", result), "handler function should modify output"
)
def test_register_func_no_return(self):
intercepts.register(func_no_return, handler)
self.assertEqual(
func_no_return(), ("handled", None), "handler function should modify output"
)
def test_handle_handler(self):
with self.assertRaises(ValueError):
intercepts.register(handler, handler)
handler(func)
def test_register_sum(self):
args = ([1, 4, 6, 2, 9, 5, 10, 11, 11, 3, -18], )
result = sum(*args)
intercepts.register(sum, handler)
self.assertEqual(sum(*args), ("handled", result),
"handler function should modify output")
