def test_pointcut_update(self):
"""tests PointCut.update()"""
other = PointCut()
other.add_method(self.an_obj, "method2")
self.pointcut.add_method(self.an_obj, "method1")
self.pointcut.update(other)
self.assertEquals(self.pointcut.values(), [["method1", "method2"]])
def test_pointcut_update(self):
"""tests PointCut.update()"""
other = PointCut()
other.add_method(self.an_obj, "method2")
self.pointcut.add_method(self.an_obj, "method1")
self.pointcut.update(other)
self.assertEquals(self.pointcut.values(), [["method1", "method2"]])
def weaveRuleCreator():
# Weaving Memoizing Aspect with XSLTElement
xsltElements = [
XsltElement,
TemplateElement,
ApplyImportsElement,
ApplyTemplatesElement,
CallTemplateElement,
ChooseElement,
ForEachElement,
IfElement,
SortElement,
OtherwiseElement,
WhenElement,
WithParamElement,
AttributeElement,
CommentElement,
CopyElement,
CopyOfElement,
ElementElement,
ProcessingInstructionElement,
NumberElement,
TextElement,
ValueOfElement,
ParamElement,
VariableElement
]
pcut = PointCut()
for e in xsltElements:
pcut.add_method(e, 'instantiate')
weaver.weave_pointcut(pcut, RuleCreator)
def setUp(self):
"""Initalizes observer / observable objects"""
self.obj = SillyClass()
pcut = PointCut()
pcut.add_method(self.obj, 'do_something')
self.obs = MyObserver()
weaver.weave_pointcut(pcut, ObserverAspect, [self.obs])
self.pcut = pcut
def setUp(self):
"""Initalizes observer / observable objects"""
self.obj = SillyClass()
pcut = PointCut()
pcut.add_method(self.obj, 'do_something')
self.obs = MyObserver()
weaver.weave_pointcut(pcut, ObserverAspect, [self.obs])
self.pcut = pcut
def test_unweave_pointcut(self):
"""tests unweave() for pointcuts"""
pcut = PointCut()
pcut.add_method(self.klass, 'foo')
weaver.weave_pointcut(pcut, ContractAspect)
self.assertEquals(len(weaver.get_aspects(self.klass, 'foo')), 1)
weaver.unweave_pointcut(pcut, ContractAspect)
self.assertEquals(weaver.get_aspect(ContractAspect), None)
def test_pointcut_difference(self):
"""tests PointCut.difference()"""
method_names = ['method1', 'method2', 'method3']
for name in method_names:
self.pointcut.add_method(self.an_obj, name)
other = PointCut()
other.add_method(self.an_obj, "method1")
result = self.pointcut - other
self.assertEquals(result.values(), [["method2", "method3"]])
def setUp(self):
"""Create a BaseJumper instance and weave ConfirmationAspect around
jump()
"""
self.guy = BaseJumper()
pcut = PointCut()
pcut.add_method(self.guy, "jump")
weaver.weave_pointcut(pcut, ConfirmationConcreteAspect)
self.pcut = pcut
def test_unweave_pointcut(self):
"""tests unweave() for pointcuts"""
pcut = PointCut()
pcut.add_method(self.klass, 'foo')
weaver.weave_pointcut(pcut, ContractAspect)
self.assertEquals(
len(weaver.get_aspects(self.klass, 'foo')), 1)
weaver.unweave_pointcut(pcut, ContractAspect)
self.assertEquals(weaver.get_aspect(ContractAspect), None)
def setUp(self):
"""Create a BaseJumper instance and weave ConfirmationAspect around
jump()
"""
self.guy = BaseJumper()
pcut = PointCut()
pcut.add_method(self.guy, "jump")
weaver.weave_pointcut(pcut, ConfirmationConcreteAspect)
self.pcut = pcut
def test_pointcut_difference(self):
"""tests PointCut.difference()"""
method_names = ['method1', 'method2', 'method3']
for name in method_names:
self.pointcut.add_method(self.an_obj, name)
other = PointCut()
other.add_method(self.an_obj, "method1")
result = self.pointcut - other
self.assertEquals(result.values(), [["method2", "method3"]])
def test_wrapped_method_doc(self):
"""ensures that wrapper and wrapped have the same docstring"""
# Memorize old method object
original_meth = self.instance.foo
# Build simple pointcut on self.instance.foo
pointcut = PointCut()
pointcut.add_method(self.instance, 'foo')
# Wrap method
wrap_method(ContractAspect(pointcut), self.instance, 'foo')
# Check new method object is not the old none
wrapped_meth = self.instance.foo
self.assert_(original_meth is not wrapped_meth,
"wrapped method should not have the same identity !")
# Check docstrings are equal
self.assertEquals(original_meth.__doc__, wrapped_meth.__doc__)
def test_wrapped_method_doc(self):
"""ensures that wrapper and wrapped have the same docstring"""
# Memorize old method object
original_meth = self.instance.foo
# Build simple pointcut on self.instance.foo
pointcut = PointCut()
pointcut.add_method(self.instance, 'foo')
# Wrap method
wrap_method(ContractAspect(pointcut), self.instance, 'foo')
# Check new method object is not the old none
wrapped_meth = self.instance.foo
self.assert_(original_meth is not wrapped_meth,
"wrapped method should not have the same identity !")
# Check docstrings are equal
self.assertEquals(original_meth.__doc__, wrapped_meth.__doc__)
def test_create_from_object(self):
"""tests PointCut.create_from_object()"""
pointcut = PointCut.create_from_object(Test)
keys = pointcut.keys()
values = pointcut.values()
values.sort()
self.assertEquals(keys, [Test])
self.assertEquals(values, [["foo", "bar"]])
def test_create_from_object(self):
"""tests PointCut.create_from_object()"""
pointcut = PointCut.create_from_object(Test)
keys = pointcut.keys()
values = pointcut.values()
values.sort()
self.assertEquals(keys, [Test])
self.assertEquals(values, [["foo", "bar"]])
def weaveRuleCreator():
# Weaving Memoizing Aspect with XSLTElement
xsltElements = [
XsltElement, TemplateElement, ApplyImportsElement,
ApplyTemplatesElement, CallTemplateElement, ChooseElement,
ForEachElement, IfElement, SortElement, OtherwiseElement, WhenElement,
WithParamElement, AttributeElement, CommentElement, CopyElement,
CopyOfElement, ElementElement, ProcessingInstructionElement,
NumberElement, TextElement, ValueOfElement, ParamElement,
VariableElement
]
pcut = PointCut()
for e in xsltElements:
pcut.add_method(e, 'instantiate')
weaver.weave_pointcut(pcut, RuleCreator)
def test_create_from_object_module(self):
"""tests PointCut.create_from_object when it's a module"""
pointcut = PointCut.create_from_object(module_test)
keys = Set([obj.__name__ for obj in pointcut.keys()])
self.assertEquals(keys, Set(['Stack', 'StackImpl', 'Sorter']))
stack_methods = Set(pointcut[module_test.Stack])
stackimpl_methods = Set(pointcut[module_test.Stack])
sorter_methods = Set(pointcut[module_test.Sorter])
self.assertEquals(stack_methods, Set(['is_empty', 'is_full', 'pop',
'push', 'size', 'top']))
self.assertEquals(stackimpl_methods, Set(['is_empty', 'is_full', 'pop',
'push', 'size', 'top']))
self.assertEquals(sorter_methods, Set(['sort']))
def run():
"""Observer example
"""
foreign = ForeignClass(10)
obs = MyObserver()
print "*"*30
print "Before weaving ObserverAspect, changes on foo won't be observerd"
print ""
print "Changing foo ..."
foreign.set_value(11)
print "Did the observer see anything ?"
print ""
print "Now : weave observer aspect, and re-change foo ..."
pcut = PointCut()
pcut.add_method(foreign, 'set_value')
weaver.weave_pointcut(pcut, ObserverAspect, [obs])
foreign.set_value(12)
print "Did the observer see anything ?"
print "*"*30
def test_create_from_object_module(self):
"""tests PointCut.create_from_object when it's a module"""
pointcut = PointCut.create_from_object(module_test)
keys = Set([obj.__name__ for obj in pointcut.keys()])
self.assertEquals(keys, Set(['Stack', 'StackImpl', 'Sorter']))
stack_methods = Set(pointcut[module_test.Stack])
stackimpl_methods = Set(pointcut[module_test.Stack])
sorter_methods = Set(pointcut[module_test.Sorter])
self.assertEquals(
stack_methods,
Set(['is_empty', 'is_full', 'pop', 'push', 'size', 'top']))
self.assertEquals(
stackimpl_methods,
Set(['is_empty', 'is_full', 'pop', 'push', 'size', 'top']))
self.assertEquals(sorter_methods, Set(['sort']))
class PointCutTC(unittest.TestCase):
"""Tests PointCut objects' behaviour"""
def setUp(self):
"""just build an empty pointcut, and a basic object"""
self.pointcut = PointCut()
self.an_obj = object()
def test_add_method(self):
"""tests PointCut.add_method()"""
self.pointcut.add_method(self.an_obj, "method1")
self.assertEquals(self.pointcut.items(), [(self.an_obj, ["method1"])])
self.pointcut.add_method(self.an_obj, "method2")
self.assertEquals(self.pointcut.items(),
[(self.an_obj, ["method1", "method2"])])
def test_remove_method(self):
"""tests PointCut.remove_method()"""
# We know this statement works thanks to test_add_method()
self.pointcut.add_method(self.an_obj, "method1")
self.pointcut.add_method(self.an_obj, "method2")
self.pointcut.remove_method(self.an_obj, "method1")
self.assertEquals(self.pointcut.items(), [(self.an_obj, ["method2"])])
self.pointcut.remove_method(self.an_obj, "method2")
self.assertEquals(self.pointcut.items(), [(self.an_obj, [])])
def test_remove_unadded_method(self):
"""ensures PointCut.remove_method() raises a KeyError"""
self.assertRaises(KeyError, self.pointcut.remove_method, self.an_obj,
"foo")
self.assertRaises(KeyError, self.pointcut.remove_method, object, "foo")
def test_remove_class_method(self):
"""tests the try...except statement of remove_method()
FIXME : Do we really want this behaviour ?!
"""
self.pointcut.add_method(object, "method1")
self.pointcut.remove_method(self.an_obj, "method1")
self.assertEquals(self.pointcut.items(), [(object, [])])
def test_remove_obj(self):
"""tests PointCut.remove_obj()"""
method_names = ['method1', 'method2', 'method3']
for name in method_names:
self.pointcut.add_method(self.an_obj, name)
removed_methods = self.pointcut.remove_obj(self.an_obj)
self.assertEquals(method_names, removed_methods)
self.assertEquals(len(self.pointcut), 0)
def test_remove_unadded_obj(self):
"""ensures removing unadded object returns None"""
removed_methods = self.pointcut.remove_obj(self.an_obj)
self.assertEquals(removed_methods, None)
def test_pointcut_update(self):
"""tests PointCut.update()"""
other = PointCut()
other.add_method(self.an_obj, "method2")
self.pointcut.add_method(self.an_obj, "method1")
self.pointcut.update(other)
self.assertEquals(self.pointcut.values(), [["method1", "method2"]])
def test_pointcut_update_notdict(self):
"""tests PointCut.update() when arg is not a dict"""
# Test updating with a list
other = []
self.assertEquals(self.pointcut.update([]), None)
self.assertEquals(len(self.pointcut), 0)
def test_pointcut_difference(self):
"""tests PointCut.difference()"""
method_names = ['method1', 'method2', 'method3']
for name in method_names:
self.pointcut.add_method(self.an_obj, name)
other = PointCut()
other.add_method(self.an_obj, "method1")
result = self.pointcut - other
self.assertEquals(result.values(), [["method2", "method3"]])
def test_same_pointcut_difference(self):
"""tests pcut - pcut == {} """
self.assertEquals(self.pointcut - self.pointcut, {})
def test_pointcut_difference_notpointcut(self):
"""ensures __sub__ raises a TypeError when not used with PointCut"""
other = []
self.assertRaises(TypeError, self.pointcut.difference, other)
def test_create_from_object(self):
"""tests PointCut.create_from_object()"""
pointcut = PointCut.create_from_object(Test)
keys = pointcut.keys()
values = pointcut.values()
values.sort()
self.assertEquals(keys, [Test])
self.assertEquals(values, [["foo", "bar"]])
def test_create_from_object_module(self):
"""tests PointCut.create_from_object when it's a module"""
pointcut = PointCut.create_from_object(module_test)
keys = Set([obj.__name__ for obj in pointcut.keys()])
self.assertEquals(keys, Set(['Stack', 'StackImpl', 'Sorter']))
stack_methods = Set(pointcut[module_test.Stack])
stackimpl_methods = Set(pointcut[module_test.Stack])
sorter_methods = Set(pointcut[module_test.Sorter])
self.assertEquals(
stack_methods,
Set(['is_empty', 'is_full', 'pop', 'push', 'size', 'top']))
self.assertEquals(
stackimpl_methods,
Set(['is_empty', 'is_full', 'pop', 'push', 'size', 'top']))
self.assertEquals(sorter_methods, Set(['sort']))
def setUp(self):
"""just build an empty pointcut, and a basic object"""
self.pointcut = PointCut()
self.an_obj = object()
class PointCutTC(unittest.TestCase):
"""Tests PointCut objects' behaviour"""
def setUp(self):
"""just build an empty pointcut, and a basic object"""
self.pointcut = PointCut()
self.an_obj = object()
def test_add_method(self):
"""tests PointCut.add_method()"""
self.pointcut.add_method(self.an_obj, "method1")
self.assertEquals(self.pointcut.items(), [(self.an_obj, ["method1"])])
self.pointcut.add_method(self.an_obj, "method2")
self.assertEquals(self.pointcut.items(),
[(self.an_obj, ["method1", "method2"])])
def test_remove_method(self):
"""tests PointCut.remove_method()"""
# We know this statement works thanks to test_add_method()
self.pointcut.add_method(self.an_obj, "method1")
self.pointcut.add_method(self.an_obj, "method2")
self.pointcut.remove_method(self.an_obj, "method1")
self.assertEquals(self.pointcut.items(), [(self.an_obj, ["method2"])])
self.pointcut.remove_method(self.an_obj, "method2")
self.assertEquals(self.pointcut.items(), [(self.an_obj, [])])
def test_remove_unadded_method(self):
"""ensures PointCut.remove_method() raises a KeyError"""
self.assertRaises(KeyError, self.pointcut.remove_method,
self.an_obj, "foo")
self.assertRaises(KeyError, self.pointcut.remove_method,
object, "foo")
def test_remove_class_method(self):
"""tests the try...except statement of remove_method()
FIXME : Do we really want this behaviour ?!
"""
self.pointcut.add_method(object, "method1")
self.pointcut.remove_method(self.an_obj, "method1")
self.assertEquals(self.pointcut.items(), [(object, [])])
def test_remove_obj(self):
"""tests PointCut.remove_obj()"""
method_names = ['method1', 'method2', 'method3']
for name in method_names:
self.pointcut.add_method(self.an_obj, name)
removed_methods = self.pointcut.remove_obj(self.an_obj)
self.assertEquals(method_names, removed_methods)
self.assertEquals(len(self.pointcut), 0)
def test_remove_unadded_obj(self):
"""ensures removing unadded object returns None"""
removed_methods = self.pointcut.remove_obj(self.an_obj)
self.assertEquals(removed_methods, None)
def test_pointcut_update(self):
"""tests PointCut.update()"""
other = PointCut()
other.add_method(self.an_obj, "method2")
self.pointcut.add_method(self.an_obj, "method1")
self.pointcut.update(other)
self.assertEquals(self.pointcut.values(), [["method1", "method2"]])
def test_pointcut_update_notdict(self):
"""tests PointCut.update() when arg is not a dict"""
# Test updating with a list
other = []
self.assertEquals(self.pointcut.update([]), None)
self.assertEquals(len(self.pointcut), 0)
def test_pointcut_difference(self):
"""tests PointCut.difference()"""
method_names = ['method1', 'method2', 'method3']
for name in method_names:
self.pointcut.add_method(self.an_obj, name)
other = PointCut()
other.add_method(self.an_obj, "method1")
result = self.pointcut - other
self.assertEquals(result.values(), [["method2", "method3"]])
def test_same_pointcut_difference(self):
"""tests pcut - pcut == {} """
self.assertEquals(self.pointcut - self.pointcut, {})
def test_pointcut_difference_notpointcut(self):
"""ensures __sub__ raises a TypeError when not used with PointCut"""
other = []
self.assertRaises(TypeError, self.pointcut.difference, other)
def test_create_from_object(self):
"""tests PointCut.create_from_object()"""
pointcut = PointCut.create_from_object(Test)
keys = pointcut.keys()
values = pointcut.values()
values.sort()
self.assertEquals(keys, [Test])
self.assertEquals(values, [["foo", "bar"]])
def test_create_from_object_module(self):
"""tests PointCut.create_from_object when it's a module"""
pointcut = PointCut.create_from_object(module_test)
keys = Set([obj.__name__ for obj in pointcut.keys()])
self.assertEquals(keys, Set(['Stack', 'StackImpl', 'Sorter']))
stack_methods = Set(pointcut[module_test.Stack])
stackimpl_methods = Set(pointcut[module_test.Stack])
sorter_methods = Set(pointcut[module_test.Sorter])
self.assertEquals(stack_methods, Set(['is_empty', 'is_full', 'pop',
'push', 'size', 'top']))
self.assertEquals(stackimpl_methods, Set(['is_empty', 'is_full', 'pop',
'push', 'size', 'top']))
self.assertEquals(sorter_methods, Set(['sort']))
def setUp(self):
"""just build an empty pointcut, and a basic object"""
self.pointcut = PointCut()
self.an_obj = object()
