def test_methods(self, _getmembers):
_getmembers.return_value = [("A", 1), ("B", 2)]
cls = Mock()
collator = Collator()
methods = collator._Collator__methods(cls)
_getmembers.assert_called_with(cls, inspect.ismethod)
self.assertEqual(methods, [v for n, v in _getmembers()])
def test_function(self, _getmembers):
_getmembers.return_value = [("A", 1)]
method = Mock()
collator = Collator()
function = collator._Collator__function(method)
_getmembers.assert_called_with(method, inspect.isfunction)
self.assertEqual(function, _getmembers()[0][1])
def test_dictionary(self):
decorated = {os.path.join: {"A": 1}, Test.read.im_func: {"B": 2}, Test.write.im_func: {"C": 3}}
collator = Collator()
classes, functions = collator.collate(decorated)
self.assertEqual(classes, {Test: [(Test.read, {"B": 2}), (Test.write, {"C": 3})]})
self.assertEqual(len(functions), 1)
self.assertEqual(functions.keys()[0].__name__, os.path.__name__)
self.assertEqual(functions.values()[0], [(os.path.join, {"A": 1})])
def test_classes(self, _isclass):
func_globals = Mock()
func_globals.values.return_value = [1, 2, 3]
_isclass.side_effect = [True, False, True]
collator = Collator()
classes = collator._Collator__classes(func_globals)
_isclass.assert_has_calls([call(c) for c in func_globals.values()])
self.assertEqual(classes, [1, 3])
def test_classes(self, _isclass):
func_globals = Mock()
func_globals.values.return_value = [1, 2, 3]
_isclass.side_effect = [True, False, True]
collator = Collator()
classes = collator._Collator__classes(func_globals)
_isclass.assert_has_calls([call(c) for c in func_globals.values()])
self.assertEqual(classes, [1, 3])
def test_list(self):
decorated = [os.path.join, Test.read.im_func, Test.write.im_func]
collator = Collator()
classes, functions = collator.collate(decorated)
self.assertEqual(classes, {Test: [(Test.read, None), (Test.write, None)]})
self.assertEqual(len(functions), 1)
self.assertEqual(functions.keys()[0].__name__, os.path.__name__)
self.assertEqual(functions.values()[0], [(os.path.join, None)])
def collated(cls):
collated = []
c = Collator()
classes, functions = c.collate(cls.functions)
for c in classes.keys():
collated.append(c)
for m in functions.keys():
collated.append(m)
return collated
def collated():
collated = []
c = Collator()
classes, functions = c.collate(Remote.functions)
for c in classes.keys():
collated.append(c)
for m in functions.keys():
m.__name__ = m.__name__.split('.')[-1]
collated.append(m)
return collated
def test_dictionary(self):
decorated = {
os.path.join: {'A': 1},
Test.read.im_func: {'B': 2},
Test.write.im_func: {'C': 3},
}
collator = Collator()
classes, functions = collator.collate(decorated)
self.assertEqual(classes, {Test: [(Test.read, {'B': 2}), (Test.write, {'C': 3})]})
self.assertEqual(len(functions), 1)
self.assertEqual(functions.keys()[0].__name__, os.path.__name__)
self.assertEqual(functions.values()[0], [(os.path.join, {'A': 1})])
def test_list(self):
decorated = [
os.path.join,
Test.read.im_func,
Test.write.im_func,
]
collator = Collator()
classes, functions = collator.collate(decorated)
self.assertEqual(classes, {Test: [(Test.read, None), (Test.write, None)]})
self.assertEqual(len(functions), 1)
self.assertEqual(functions.keys()[0].__name__, os.path.__name__)
self.assertEqual(functions.values()[0], [(os.path.join, None)])
def test_collate(self, _functions, _map):
func_globals = {"A": 1}
_fn1 = Mock()
_fn1.func_globals = func_globals
_fn2 = Mock()
_fn2.func_globals = func_globals
decorated = [_fn1, _fn2]
collator = Collator()
classes, functions = collator.collate(decorated)
_functions.assert_called_with()
_map.assert_called_with(func_globals)
self.assertEqual(id(classes), id(collator.classes))
self.assertEqual(functions, _functions())
def test_collate(self, _functions, _map):
func_globals = {'A': 1}
_fn1 = Mock()
_fn1.func_globals = func_globals
_fn2 = Mock()
_fn2.func_globals = func_globals
decorated = [_fn1, _fn2]
collator = Collator()
classes, functions = collator.collate(decorated)
_functions.assert_called_with()
_map.assert_called_with(func_globals)
self.assertEqual(id(classes), id(collator.classes))
self.assertEqual(functions, _functions())
def test_map(self, _decorated, _function, _methods, _classes):
func_globals = {"A": 1, "B": 2}
methods = ["m1", "m2", "m3", "m4", "m5", "m6", "m7", "m8", "m9"]
functions = ["f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9"]
_classes.return_value = ["c1", "c2", "c3"]
_methods.side_effect = [methods[0:3], methods[3:6], methods[6:9]]
_function.side_effect = functions
_decorated.side_effect = [(fn, None) for fn in functions]
collator = Collator()
collator._Collator__map(func_globals)
_classes.assert_called_with(func_globals)
_methods.assert_has_calls([call(c) for c in _classes.return_value])
_function.assert_has_calls([call(m) for m in methods])
self.assertEqual(collator.bound, set(functions))
def collated():
collated = []
collator = Collator()
classes, functions = collator.collate(Actions.functions)
for _class, methods in classes.items():
inst = _class()
for method, options in methods:
method = getattr(inst, method.__name__)
action = Action(method, **options)
collated.append(action)
for module, fn_list in functions.items():
for function, options in fn_list:
action = Action(function, **options)
collated.append(action)
return collated
def collated():
collated = []
collator = Collator()
classes, functions = collator.collate(Actions.functions)
for _class, methods in classes.items():
inst = _class()
for method, options in methods:
method = getattr(inst, method.__name__)
action = Action(method, **options)
collated.append(action)
for module, fn_list in functions.items():
for function, options in fn_list:
action = Action(function, **options)
collated.append(action)
return collated
def collated(cls):
collated = []
c = Collator()
classes, functions = c.collate(cls.functions)
for c, m in classes.items():
inst = c()
for m, d in m:
m = getattr(inst, m.__name__)
action = Action(m, **d)
collated.append(action)
for m, f in functions.items():
for f, d in f:
action = Action(f, **d)
collated.append(action)
return collated
def test_map(self, _decorated, _function, _methods, _classes):
func_globals = {'A': 1, 'B': 2}
methods = [
'm1',
'm2',
'm3',
'm4',
'm5',
'm6',
'm7',
'm8',
'm9'
]
functions = [
'f1',
'f2',
'f3',
'f4',
'f5',
'f6',
'f7',
'f8',
'f9'
]
_classes.return_value = [
'c1',
'c2',
'c3'
]
_methods.side_effect = [
methods[0:3],
methods[3:6],
methods[6:9]
]
_function.side_effect = functions
_decorated.side_effect = [(fn, None) for fn in functions]
collator = Collator()
collator._Collator__map(func_globals)
_classes.assert_called_with(func_globals)
_methods.assert_has_calls([call(c) for c in _classes.return_value])
_function.assert_has_calls([call(m) for m in methods])
self.assertEqual(collator.bound, set(functions))
def test_decorated(self):
collator = Collator()
collator.functions = []
# not found
fn = collator._Collator__decorated(1)
self.assertTrue(fn is None)
# found in list
collator.functions = [1]
fn = collator._Collator__decorated(1)
self.assertEqual(fn, (1, None))
# found in dictionary
collator.functions = {1: {'A': 1}}
fn = collator._Collator__decorated(1)
self.assertEqual(fn, (1, {'A': 1}))
def test_functions(self, _decorated, _getmodule):
m1 = Module("m1")
m2 = Module("m2")
modules = [m1, m2, m2]
_decorated.side_effect = lambda x: (x, None)
_getmodule.side_effect = modules
collator = Collator()
for n in range(4):
name = "f%d" % n
fn = Mock(name=name)
fn.__name__ = name
collator.functions.append(fn)
collator.bound.add(collator.functions[1])
functions = collator._Collator__functions()
for module, fns in functions.items():
if module == m1:
self.assertTrue(hasattr(module, "f0"))
self.assertEqual(fns, [(f, None) for f in collator.functions[0:1]])
continue
if module == m2:
self.assertTrue(hasattr(module, "f2"))
self.assertTrue(hasattr(module, "f3"))
self.assertEqual(fns, [(f, None) for f in collator.functions[2:4]])
continue
def test_functions(self, _decorated, _getmodule):
m1 = Module('m1')
m2 = Module('m2')
modules = [m1, m2, m2]
_decorated.side_effect = lambda x: (x, None)
_getmodule.side_effect = modules
collator = Collator()
for n in range(4):
name = 'f%d' % n
fn = Mock(name=name)
fn.__name__ = name
collator.functions.append(fn)
collator.bound.add(collator.functions[1])
functions = collator._Collator__functions()
for module, fns in functions.items():
if module == m1:
self.assertTrue(hasattr(module, 'f0'))
self.assertEqual(fns, [(f, None) for f in collator.functions[0:1]])
continue
if module == m2:
self.assertTrue(hasattr(module, 'f2'))
self.assertTrue(hasattr(module, 'f3'))
self.assertEqual(fns, [(f, None) for f in collator.functions[2:4]])
continue
def test_decorated(self):
collator = Collator()
collator.functions = []
# not found
fn = collator._Collator__decorated(1)
self.assertTrue(fn is None)
# found in list
collator.functions = [1]
fn = collator._Collator__decorated(1)
self.assertEqual(fn, (1, None))
# found in dictionary
collator.functions = {1: {"A": 1}}
fn = collator._Collator__decorated(1)
self.assertEqual(fn, (1, {"A": 1}))
def test_init(self):
collator = Collator()
self.assertEqual(collator.classes, {})
self.assertEqual(collator.bound, set())
self.assertEqual(collator.functions, [])
