def setUp(self):
""" Prepares the test fixture before each test method is called. """
# An empty type manager.
self.type_manager = TypeManager()
return
def setUp(self):
""" Prepares the test fixture before each test method is called. """
# An empty type manager.
self.type_manager = TypeManager()
return
def test_type_manager_hierarchy(self):
""" type manager hierarchy """
# Register an adapter Foo->Bar.
self.type_manager.register_type_adapters(FooToBarAdapterFactory(), Foo)
# Create an empy type manager with the main type manager as its
# parent.
type_manager = TypeManager(parent=self.type_manager)
# Create a Foo.
foo = Foo(name='fred')
# Adapt it to a Bar.
bar = type_manager.object_as(foo, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Foo.foogle.fred')
return
def test_type_manager_hierarchy(self):
""" type manager hierarchy """
# Register an adapter Foo->Bar.
self.type_manager.register_type_adapters(FooToBarAdapterFactory(), Foo)
# Create an empy type manager with the main type manager as its
# parent.
type_manager = TypeManager(parent=self.type_manager)
# Create a Foo.
foo = Foo(name='fred')
# Adapt it to a Bar.
bar = type_manager.object_as(foo, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Foo.foogle.fred')
return
from apptools.naming.api import PyFSContext
from apptools.naming.adapter import *
from apptools.naming.ui.explorer import Explorer
from pyface.api import GUI
from traits.api import TraitDict, TraitList
from apptools.type_manager import TypeManager
from traits.util.resource import find_resource
# Application entry point.
if __name__ == '__main__':
# Create the GUI (this does NOT start the GUI event loop).
gui = GUI()
# Create a type manager to manage context adapters.
type_manager = TypeManager()
# Add some interesting context adapters.
#
# Trait dictionaries.
type_manager.register_type_adapters(
ContextAdapterFactory(
adaptee_class=TraitDict,
adapter_class=TraitDictContextAdapter,
), TraitDict)
# Trait lists.
type_manager.register_type_adapters(
ContextAdapterFactory(
adaptee_class=TraitList,
adapter_class=TraitListContextAdapter,
class TypeManagerTestCase(unittest.TestCase):
""" Tests the type manager. """
###########################################################################
# 'TestCase' interface.
###########################################################################
def setUp(self):
""" Prepares the test fixture before each test method is called. """
# An empty type manager.
self.type_manager = TypeManager()
return
def tearDown(self):
""" Called immediately after each test method has been called. """
return
###########################################################################
# Tests.
###########################################################################
def test_no_adapter_required(self):
""" no adapter required """
# Create a Bar.
b = Bar()
# Try to adapt it to a Bar.
bar = self.type_manager.object_as(b, Bar)
# The type manager should simply return the same object.
self.assert_(bar is b)
return
def test_no_adapter(self):
""" no adapter available """
# Create a Foo.
foo = Foo(name='fred')
# Try to adapt it to a bar.
bar = self.type_manager.object_as(foo, Bar)
# There should be no way to adapt a Foo to a Bar.
self.assertEqual(bar, None)
return
def test_instance_adapter(self):
""" instance adapter """
# Create a Foo.
foo = Foo(name='fred')
# Register an adapter Foo->Bar on the INSTANCE (this one should take
# precedence).
self.type_manager.register_instance_adapters(
FooToBarAdapterFactory(), foo
)
# Register an adapter Foo->Bar on the TYPE (this will fail if it gets
# picked up since it won't actually adapt 'Foo' objects!).
self.type_manager.register_instance_adapters(
SubOfFooToBarAdapterFactory(), Foo
)
# Adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Foo.foogle.fred')
return
def test_unregister_instance_adapter(self):
""" unregister instance adapter """
# Create a Foo.
foo = Foo(name='fred')
# The factory.
factory = FooToBarAdapterFactory()
# Register an adapter Foo->Bar on the INSTANCE (this one should take
# precedence).
self.type_manager.register_instance_adapters(factory, foo)
# Adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Foo.foogle.fred')
# Remove the adapter.
self.type_manager.unregister_instance_adapters(factory, foo)
# Now we shouldn't be able to adapt the object.
#
# Try to adapt it to a bar.
bar = self.type_manager.object_as(foo, Bar)
# There should be no way to adapt a Foo to a Bar.
self.assertEqual(bar, None)
return
def test_adapter_on_class(self):
""" an adapter registered on an object's actual class. """
# Register an adapter Foo->Bar.
self.type_manager.register_type_adapters(FooToBarAdapterFactory(), Foo)
# Create a Foo.
foo = Foo(name='fred')
# Adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Foo.foogle.fred')
return
def test_adapter_on_base_class(self):
""" an adapter registered on one of an object's base classes. """
# Register an adapter Foo->Bar.
self.type_manager.register_type_adapters(FooToBarAdapterFactory(), Foo)
# Create an instance of a class derived from Foo.
sub = SubOfFoo(name='fred')
# Adapt it to a Bar.
bar = self.type_manager.object_as(sub, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Sub.foogle.fred')
return
def test_ignore_adapter_on_class(self):
""" ignore an adapter on an object's actual class. """
# Register an adapter SubOfFoo->Bar on the Foo class.
self.type_manager.register_type_adapters(
SubOfFooToBarAdapterFactory(), Foo
)
# Create a Foo.
foo = Foo(name='fred')
# Adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
# There should be no way to adapt a Foo to a Bar.
self.assertEqual(bar, None)
return
def test_ignore_adapter_on_derived_class(self):
""" ignore an adapter registered on a derived class. """
# Register an adapter Foo->Bar on the SubOfFoo class.
self.type_manager.register_type_adapters(
FooToBarAdapterFactory(), SubOfFoo
)
# Create a Foo.
foo = Foo(name='fred')
# Adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
# There should be no way to adapt a Foo to a Bar.
self.assertEqual(bar, None)
return
def test_unregister_adapter(self):
""" unregister an adapter. """
factory = FooToBarAdapterFactory()
# Register an adapter Foo->Bar.
self.type_manager.register_type_adapters(factory, Foo)
# Create a Foo.
foo = Foo(name='fred')
# Adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Foo.foogle.fred')
# Unregister the adapter.
self.type_manager.unregister_type_adapters(factory)
# Try to adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
# There should be no way to adapt a Foo to a Bar.
self.assertEqual(bar, None)
return
def test_factory(self):
""" simple factory """
# Create a Bar factory.
factory = BarFactory()
# Try to create a Bar using the factory.
bar = self.type_manager.object_as(factory, Bar, name='joe')
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Bar.blargle.joe')
return
def test_pre_hook(self):
""" pre hook """
l = []
def hook(*args, **kw):
l.append('Hello')
# Create a Foo.
foo = Foo(name='fred')
# Hook a method.
self.type_manager.add_pre(Foo, 'foogle', hook)
# Call the method that we have hooked.
foo.foogle()
# Make sure that the hook was called.
self.assertEqual(len(l), 1)
# Remove the hook.
self.type_manager.remove_pre(Foo, 'foogle', hook)
# Call the method that we have hooked.
foo.foogle()
# Make sure that the hook was NOT called.
self.assertEqual(len(l), 1)
return
def test_post_hook(self):
""" post hook """
def hook(result, *args, **kw):
return 'Hello'
# Create a Foo.
foo = Foo(name='fred')
# Hook a method.
self.type_manager.add_post(Foo, 'foogle', hook)
# Call the method that we have hooked.
self.assertEqual(foo.foogle(), 'Hello')
# Remove the hook.
self.type_manager.remove_post(Foo, 'foogle', hook)
# Call the method that we have hooked.
foo.foogle()
# Make sure that the hook was NOT called.
self.assertEqual(foo.foogle(), 'Foo.foogle.fred')
return
def test_pre_hook_on_inherited_method(self):
""" test pre hook on an inherited method """
l = []
def hook(*args, **kw):
l.append('Hello')
# Create an instance of a subclass of Foo that does NOT override
# 'foogle'.
esof = EmptySubOfFoo(name='fred')
# Prove that it does not override 'foogle'!
method = EmptySubOfFoo.__dict__.get('foogle')
self.assertEqual(method, None)
# Hook a method.
self.type_manager.add_pre(EmptySubOfFoo, 'foogle', hook)
# Make sure that the method was added to the class dictionary.
method = EmptySubOfFoo.__dict__.get('foogle')
self.assertNotEqual(method, None)
# Call the method that we have hooked.
esof.foogle()
# Make sure that the hook was called.
self.assertEqual(len(l), 1)
# Remove the hook.
self.type_manager.remove_pre(EmptySubOfFoo, 'foogle', hook)
# Call the method that we have hooked.
esof.foogle()
# Make sure that the hook was NOT called.
self.assertEqual(len(l), 1)
# Make sure that we didn't put the original method back onto
# 'EmptySubOfFoo'(since it didn't override it in the first place).
method = EmptySubOfFoo.__dict__.get('foogle')
self.assertEqual(method, None)
return
def test_type_manager_hierarchy(self):
""" type manager hierarchy """
# Register an adapter Foo->Bar.
self.type_manager.register_type_adapters(FooToBarAdapterFactory(), Foo)
# Create an empy type manager with the main type manager as its
# parent.
type_manager = TypeManager(parent=self.type_manager)
# Create a Foo.
foo = Foo(name='fred')
# Adapt it to a Bar.
bar = type_manager.object_as(foo, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Foo.foogle.fred')
return
from apptools.naming.adapter import *
from apptools.naming.ui.explorer import Explorer
from pyface.api import GUI
from traits.api import TraitDict, TraitList
from apptools.type_manager import TypeManager
from traits.util.resource import find_resource
# Application entry point.
if __name__ == '__main__':
# Create the GUI (this does NOT start the GUI event loop).
gui = GUI()
# Create a type manager to manage context adapters.
type_manager = TypeManager()
# Add some interesting context adapters.
#
# Trait dictionaries.
type_manager.register_type_adapters(
ContextAdapterFactory(
adaptee_class=TraitDict, adapter_class=TraitDictContextAdapter,
),
TraitDict
)
# Trait lists.
type_manager.register_type_adapters(
ContextAdapterFactory(
class TypeManagerTestCase(unittest.TestCase):
""" Tests the type manager. """
###########################################################################
# 'TestCase' interface.
###########################################################################
def setUp(self):
""" Prepares the test fixture before each test method is called. """
# An empty type manager.
self.type_manager = TypeManager()
return
def tearDown(self):
""" Called immediately after each test method has been called. """
return
###########################################################################
# Tests.
###########################################################################
def test_no_adapter_required(self):
""" no adapter required """
# Create a Bar.
b = Bar()
# Try to adapt it to a Bar.
bar = self.type_manager.object_as(b, Bar)
# The type manager should simply return the same object.
self.assert_(bar is b)
return
def test_no_adapter(self):
""" no adapter available """
# Create a Foo.
foo = Foo(name='fred')
# Try to adapt it to a bar.
bar = self.type_manager.object_as(foo, Bar)
# There should be no way to adapt a Foo to a Bar.
self.assertEqual(bar, None)
return
def test_instance_adapter(self):
""" instance adapter """
# Create a Foo.
foo = Foo(name='fred')
# Register an adapter Foo->Bar on the INSTANCE (this one should take
# precedence).
self.type_manager.register_instance_adapters(FooToBarAdapterFactory(),
foo)
# Register an adapter Foo->Bar on the TYPE (this will fail if it gets
# picked up since it won't actually adapt 'Foo' objects!).
self.type_manager.register_instance_adapters(
SubOfFooToBarAdapterFactory(), Foo)
# Adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Foo.foogle.fred')
return
def test_unregister_instance_adapter(self):
""" unregister instance adapter """
# Create a Foo.
foo = Foo(name='fred')
# The factory.
factory = FooToBarAdapterFactory()
# Register an adapter Foo->Bar on the INSTANCE (this one should take
# precedence).
self.type_manager.register_instance_adapters(factory, foo)
# Adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Foo.foogle.fred')
# Remove the adapter.
self.type_manager.unregister_instance_adapters(factory, foo)
# Now we shouldn't be able to adapt the object.
#
# Try to adapt it to a bar.
bar = self.type_manager.object_as(foo, Bar)
# There should be no way to adapt a Foo to a Bar.
self.assertEqual(bar, None)
return
def test_adapter_on_class(self):
""" an adapter registered on an object's actual class. """
# Register an adapter Foo->Bar.
self.type_manager.register_type_adapters(FooToBarAdapterFactory(), Foo)
# Create a Foo.
foo = Foo(name='fred')
# Adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Foo.foogle.fred')
return
def test_adapter_on_base_class(self):
""" an adapter registered on one of an object's base classes. """
# Register an adapter Foo->Bar.
self.type_manager.register_type_adapters(FooToBarAdapterFactory(), Foo)
# Create an instance of a class derived from Foo.
sub = SubOfFoo(name='fred')
# Adapt it to a Bar.
bar = self.type_manager.object_as(sub, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Sub.foogle.fred')
return
def test_ignore_adapter_on_class(self):
""" ignore an adapter on an object's actual class. """
# Register an adapter SubOfFoo->Bar on the Foo class.
self.type_manager.register_type_adapters(SubOfFooToBarAdapterFactory(),
Foo)
# Create a Foo.
foo = Foo(name='fred')
# Adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
# There should be no way to adapt a Foo to a Bar.
self.assertEqual(bar, None)
return
def test_ignore_adapter_on_derived_class(self):
""" ignore an adapter registered on a derived class. """
# Register an adapter Foo->Bar on the SubOfFoo class.
self.type_manager.register_type_adapters(FooToBarAdapterFactory(),
SubOfFoo)
# Create a Foo.
foo = Foo(name='fred')
# Adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
# There should be no way to adapt a Foo to a Bar.
self.assertEqual(bar, None)
return
def test_unregister_adapter(self):
""" unregister an adapter. """
factory = FooToBarAdapterFactory()
# Register an adapter Foo->Bar.
self.type_manager.register_type_adapters(factory, Foo)
# Create a Foo.
foo = Foo(name='fred')
# Adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Foo.foogle.fred')
# Unregister the adapter.
self.type_manager.unregister_type_adapters(factory)
# Try to adapt it to a Bar.
bar = self.type_manager.object_as(foo, Bar)
# There should be no way to adapt a Foo to a Bar.
self.assertEqual(bar, None)
return
def test_factory(self):
""" simple factory """
# Create a Bar factory.
factory = BarFactory()
# Try to create a Bar using the factory.
bar = self.type_manager.object_as(factory, Bar, name='joe')
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Bar.blargle.joe')
return
def test_pre_hook(self):
""" pre hook """
l = []
def hook(*args, **kw):
l.append('Hello')
# Create a Foo.
foo = Foo(name='fred')
# Hook a method.
self.type_manager.add_pre(Foo, 'foogle', hook)
# Call the method that we have hooked.
foo.foogle()
# Make sure that the hook was called.
self.assertEqual(len(l), 1)
# Remove the hook.
self.type_manager.remove_pre(Foo, 'foogle', hook)
# Call the method that we have hooked.
foo.foogle()
# Make sure that the hook was NOT called.
self.assertEqual(len(l), 1)
return
def test_post_hook(self):
""" post hook """
def hook(result, *args, **kw):
return 'Hello'
# Create a Foo.
foo = Foo(name='fred')
# Hook a method.
self.type_manager.add_post(Foo, 'foogle', hook)
# Call the method that we have hooked.
self.assertEqual(foo.foogle(), 'Hello')
# Remove the hook.
self.type_manager.remove_post(Foo, 'foogle', hook)
# Call the method that we have hooked.
foo.foogle()
# Make sure that the hook was NOT called.
self.assertEqual(foo.foogle(), 'Foo.foogle.fred')
return
def test_pre_hook_on_inherited_method(self):
""" test pre hook on an inherited method """
l = []
def hook(*args, **kw):
l.append('Hello')
# Create an instance of a subclass of Foo that does NOT override
# 'foogle'.
esof = EmptySubOfFoo(name='fred')
# Prove that it does not override 'foogle'!
method = EmptySubOfFoo.__dict__.get('foogle')
self.assertEqual(method, None)
# Hook a method.
self.type_manager.add_pre(EmptySubOfFoo, 'foogle', hook)
# Make sure that the method was added to the class dictionary.
method = EmptySubOfFoo.__dict__.get('foogle')
self.assertNotEqual(method, None)
# Call the method that we have hooked.
esof.foogle()
# Make sure that the hook was called.
self.assertEqual(len(l), 1)
# Remove the hook.
self.type_manager.remove_pre(EmptySubOfFoo, 'foogle', hook)
# Call the method that we have hooked.
esof.foogle()
# Make sure that the hook was NOT called.
self.assertEqual(len(l), 1)
# Make sure that we didn't put the original method back onto
# 'EmptySubOfFoo'(since it didn't override it in the first place).
method = EmptySubOfFoo.__dict__.get('foogle')
self.assertEqual(method, None)
return
def test_type_manager_hierarchy(self):
""" type manager hierarchy """
# Register an adapter Foo->Bar.
self.type_manager.register_type_adapters(FooToBarAdapterFactory(), Foo)
# Create an empy type manager with the main type manager as its
# parent.
type_manager = TypeManager(parent=self.type_manager)
# Create a Foo.
foo = Foo(name='fred')
# Adapt it to a Bar.
bar = type_manager.object_as(foo, Bar)
self.assertNotEqual(bar, None)
self.assertEqual(bar.blargle(), 'Foo.foogle.fred')
return