class TestLazyLoading(TestCase):
''' Test concentrating on lazy-loading and actions via the assembler. '''
def setUp(self):
self.locator = Locator()
self.transformer = Transformer(self.locator)
self.assembler = Assembler(self.transformer)
filename = 'locator-lazy-action.xml'
filepath = abspath(join(dirname(__file__), '..', 'data', filename))
self.assembler.load(filepath)
def tearDown(self):
del self.locator
del self.transformer
del self.assembler
def test_lazy_initialization(self):
self.assertIsInstance(self.locator.get('alpha').call_accompany(), Beta)
self.assertIsInstance(self.locator.get('beta'), Beta)
self.assertEquals(self.locator.get('alpha').call_accompany(), self.locator.get('beta'))
# Test for actionable events... due to be in a seperate files.
def test_actions_without_events(self):
c = self.locator.get('charlie')
self.assertIsInstance(c.introduce, Action, c.introduce.__class__)
def test_actions(self):
self.locator.get('charlie').cook()
def setUp(self):
self.locator = Locator()
self.transformer = Transformer(self.locator)
self.assembler = Assembler(self.transformer)
filename = 'locator-lazy-action.xml'
filepath = abspath(join(dirname(__file__), '..', 'data', filename))
self.assembler.load(filepath)
def __init__(self, locator=None):
self.logger = get_logger('{}.{}'.format(__name__, self.__class__.__name__))
self.locator = Locator()
self.transformer = Transformer(self.locator)
self.assembler = Assembler(self.transformer)
self.default_services = [
('finder', 'tori.common.Finder', [], {}),
('renderer', 'tori.template.service.RenderingService', [], {}),
('db', 'passerine.db.manager.ManagerFactory', [], {})
]
self.cache_map = None
self._register_default_services()
def setUp(self):
self.locator = Locator()
self.transformer = Transformer(self.locator)
self.assembler = Assembler(self.transformer)
class test_locator_with_proxy_and_factorization(TestCase):
'''
Test the locator via the assembler for factorization.
'''
def setUp(self):
self.locator = Locator()
self.transformer = Transformer(self.locator)
self.assembler = Assembler(self.transformer)
def tearDown(self):
del self.locator
del self.transformer
del self.assembler
def test_good_locator_xml_on_entity_registration(self):
self.__prepare_good_locator_from_xml()
# Normal entity
self.assertTrue(self.locator.has('manager'), self.locator._entities)
# Factorized entities
self.assertTrue(self.locator.has('worker.alpha'))
self.assertTrue(self.locator.has('worker.bravo'))
self.assertTrue(self.locator.has('def.doubler'))
self.assertTrue(self.locator.has('def.trippler'))
def test_get_object(self):
self.__prepare_good_locator_from_xml()
ticker = self.locator.get('ticker')
trigger = self.locator.get('something')
entity = self.locator.get('worker.alpha')
self.assertIsInstance(entity, Worker)
self.assertEqual(entity.name, 'Alpha')
self.assertEqual(0, len(ticker.sequence))
trigger.alpha()
self.assertEqual(1, len(ticker.sequence))
def test_get_callback(self):
self.__prepare_good_locator_from_xml()
ticker = self.locator.get('ticker')
trigger = self.locator.get('something')
doubler = self.locator.get('def.doubler')
self.assertTrue(callable(doubler))
self.assertEqual(12, doubler(6))
self.assertEqual(0, len(ticker.sequence))
trigger.doubler()
# No interception for callable object as of 1.9.
self.assertEqual(0, len(ticker.sequence))
def __get_data_path(self, filename):
return abspath(join(dirname(__file__), '..', 'data', filename))
def __load_from_xml(self, path_from_data):
test_file = self.__get_data_path(path_from_data)
self.assembler.load(test_file)
def __prepare_good_locator_from_xml(self):
self.__load_from_xml('locator-factorization.xml')
class TestAction(TestCase):
''' Test concentrating on lazy-loading and actions via the assembler. '''
def setUp(self):
self.locator = Locator()
self.transformer = Transformer(self.locator)
self.assembler = Assembler(self.transformer)
filename = 'locator-lazy-action.xml'
filepath = abspath(join(dirname(__file__), '..', 'data', filename))
self.assembler.load(filepath)
def tearDown(self):
del self.locator
del self.transformer
del self.assembler
def test_interceptable_method(self):
c = self.locator.get('charlie')
self.assertIsInstance(c.introduce, Action)
self.assertEquals(c.name, c.introduce())
def test_normal_execution(self):
''' This is a sanity test. '''
expected_log_sequence = [
# sequence as charlie cooks
'Charlie: introduce itself as "Charlie"',
'Alpha: order "egg and becon"',
'Charlie: repeat "egg and becon"',
'Alpha: confirm for egg and becon',
'Charlie: respond "wilco"',
'Charlie: cook',
# sequence as charlie serves
'Alpha: speak to Beta, "watch your hand"',
'Beta: acknowledge',
'Alpha: wash hands',
'Charlie: serve'
]
alpha = self.locator.get('alpha')
charlie = self.locator.get('charlie')
charlie.cook()
charlie.serve()
self.assertEquals(
len(expected_log_sequence),
len(Conversation.logs),
'The number of sequences in the mock scenario must be the same.'
)
for step in range(len(Conversation.logs)):
expectation = expected_log_sequence[step]
actual = Conversation.logs[step]
self.assertEquals(
expectation,
actual,
'Failed at step {step}: should be "{expectation}", not "{actual}"'.format(
step=step,
expectation=expectation,
actual=actual
)
)
#print '\n'.join(Conversation.logs)
class TestLocator(TestCase):
'''
Test the locator via the assembler.
'''
class UnknownEntity(object): pass
def setUp(self):
self.locator = Locator()
self.transformer = Transformer(self.locator)
self.assembler = Assembler(self.transformer)
def tearDown(self):
del self.locator
del self.transformer
del self.assembler
def test_checker(self):
entity = self.__make_good_entity()
self.assertFalse(self.locator.has('poo'))
self.assertRaises(UnknownEntityError, self.locator.get, ('poo'))
def test_before_activation(self):
entity = self.__make_good_entity()
self.locator.set('poo', entity)
self.assertTrue(self.locator.has('poo'))
self.assertFalse(entity.activated)
def test_after_activation(self):
entity = self.__make_good_entity()
self.locator.set('poo', entity)
self.assertIsInstance(self.locator.get('poo'), PlainOldObject)
self.assertTrue(entity.activated)
def test_good_locator_xml_on_entity_registration(self):
self.__prepare_good_locator_from_xml()
self.assertTrue(self.locator.has('poo'))
self.assertTrue(self.locator.has('poow-1'))
self.assertTrue(self.locator.has('poow-2'))
self.assertTrue(self.locator.has('dioc'))
self.assertTrue(self.locator.has('dioe'))
def test_good_locator_xml_on_class_injection(self):
self.__prepare_good_locator_from_xml()
self.assertEqual(self.locator.get('dioc').r, PlainOldObject)
def test_good_locator_xml_on_class_injection(self):
self.__prepare_good_locator_from_xml()
self.assertIsInstance(self.locator.get('dioe').e, PlainOldObjectWithParameters)
def test_entities_with_same_class(self):
self.__prepare_good_locator_from_xml()
self.assertIsInstance(self.locator.get('poow-1'), PlainOldObjectWithParameters)
self.assertIsInstance(self.locator.get('poow-2'), PlainOldObjectWithParameters)
self.assertNotEquals(self.locator.get('poow-1').method(), self.locator.get('poow-2').method())
self.assertEquals('%.2f' % self.locator.get('poow-1').method(), '0.67')
self.assertEquals(self.locator.get('poow-2').method(), 35)
def __make_good_entity(self):
return Entity(
'poo', Loader('dummy.core.PlainOldObject')
)
def __get_data_path(self, filename):
return abspath(join(dirname(__file__), '..', 'data', filename))
def __load_from_xml(self, path_from_data):
test_file = self.__get_data_path(path_from_data)
self.assembler.load(test_file)
def __prepare_good_locator_from_xml(self):
self.__load_from_xml('locator.xml')
class Container(object):
def __init__(self, locator=None):
self.logger = get_logger('{}.{}'.format(__name__, self.__class__.__name__))
self.locator = Locator()
self.transformer = Transformer(self.locator)
self.assembler = Assembler(self.transformer)
self.default_services = [
('finder', 'tori.common.Finder', [], {}),
('renderer', 'tori.template.service.RenderingService', [], {}),
('db', 'passerine.db.manager.ManagerFactory', [], {})
]
self.cache_map = None
self._register_default_services()
@contextmanager
def passive_mode(self):
self.assembler.activate_passive_loading()
yield
self.assembler.deactivate_passive_loading()
def get(self, id):
return self.locator.get(id)
def load(self, *paths):
with self.passive_mode():
[
self.assembler.load(path)
for path in paths
]
self.cache_map = None
def all(self):
if not self.cache_map:
self.cache_map = {
i: self.locator.get(i)
for i in self.locator.entity_identifiers
}
return self.cache_map
def _register_default_services(self):
for entity_id, package_path, args, kwargs in self.default_services:
try:
entity = self._create_entity(entity_id, package_path, *args, **kwargs)
self.locator.set(entity_id, entity)
except ImportError as exception:
if entity_id == "db":
self.logger.info('Ignored {} as package "passerine" is neither available or loadable (containing errors).'.format(package_path))
continue
raise ImportError('Failed to register {} ({})'.format(entity_id, package_path))
def _create_entity(self, id, package_path, *args, **kwargs):
loader = Loader(package_path)
return Entity(id, loader, *args, **kwargs)
