def test_custom_repository(self, simple_config):
class MyMemoryAggregate(Aggregate):
pass
reg = simple_config.registry
config = Configurator(registry=reg)
config.add_memory_repository('test',
aggregate_class=MyMemoryAggregate)
repo_mgr = config.get_registered_utility(IRepositoryManager)
repo = repo_mgr.get('test')
config.add_resource(IFoo, FooMember, FooEntity,
collection_root_name="foos",
repository='test')
with pytest.raises(RuntimeError):
repo.get_collection(IFoo)
with pytest.raises(RuntimeError):
repo.get_aggregate(IFoo)
repo.initialize()
coll = repo.get_collection(IFoo)
agg = coll.get_aggregate()
assert isinstance(agg, MyMemoryAggregate)
entity = FooEntity(id=1)
agg.add(entity)
assert agg.count() == 1
assert list(agg.iterator())[0].id == entity.id
assert agg.get_by_id(1).id == entity.id
assert agg.get_by_slug('1').slug == entity.slug
agg.remove(entity)
assert agg.count() == 0
def test_custom_repository(self):
class MyMemoryAggregate(Aggregate):
pass
reg = self._registry
config = Configurator(registry=reg)
config.add_memory_repository('test',
aggregate_class=MyMemoryAggregate)
repo_mgr = config.get_registered_utility(IRepositoryManager)
repo = repo_mgr.get('test')
config.add_resource(IFoo, FooMember, FooEntity,
collection_root_name="foos",
repository='test')
self.assert_raises(RuntimeError, repo.get_collection, IFoo)
self.assert_raises(RuntimeError, repo.get_aggregate, IFoo)
repo.initialize()
coll = repo.get_collection(IFoo)
agg = coll.get_aggregate()
self.assert_true(isinstance(agg, MyMemoryAggregate))
entity = FooEntity(id=1)
agg.add(entity)
self.assert_true(agg.count() == 1)
self.assert_equal(list(agg.iterator())[0].id, entity.id)
self.assert_equal(agg.get_by_id(1).id, entity.id)
self.assert_equal(agg.get_by_slug('1').slug, entity.slug)
agg.remove(entity)
self.assert_true(agg.count() == 0)
def after(self):
# Register resources eagerly so the various adapters and utilities are
# available for other directives.
discriminator = ('resource', self.interface)
reg = get_current_registry()
config = Configurator(reg, package=self.context.package)
config.add_resource(self.interface,
self.member,
self.entity,
collection=self.collection,
collection_root_name=self.collection_root_name,
collection_title=self.collection_title,
repository=self.repository,
expose=self.expose,
_info=self.context.info)
for key, value in self.representers.iteritems():
cnt_type, rc_kind = key
opts, mp_opts = value
if rc_kind == RESOURCE_KINDS.member:
rc = get_member_class(self.interface)
elif rc_kind == RESOURCE_KINDS.collection:
rc = get_collection_class(self.interface)
else: # None
rc = self.interface
discriminator = ('resource_representer', rc, cnt_type, rc_kind)
self.action(
discriminator=discriminator, # pylint: disable=E1101
callable=config.add_resource_representer,
args=(rc, cnt_type),
kw=dict(options=opts,
attribute_options=mp_opts,
_info=self.context.info),
)
def after(self):
# Register resources eagerly so the various adapters and utilities are
# available for other directives.
discriminator = ('resource', self.interface)
reg = get_current_registry()
config = Configurator(reg, package=self.context.package)
config.add_resource(self.interface, self.member, self.entity,
collection=self.collection,
collection_root_name=self.collection_root_name,
collection_title=self.collection_title,
repository=self.repository,
expose=self.expose,
_info=self.context.info)
for key, value in iteritems_(self.representers):
cnt_type, rc_kind = key
opts, mp_opts = value
if rc_kind == RESOURCE_KINDS.MEMBER:
rc = get_member_class(self.interface)
elif rc_kind == RESOURCE_KINDS.COLLECTION:
rc = get_collection_class(self.interface)
else: # None
rc = self.interface
discriminator = ('resource_representer', rc, cnt_type, rc_kind)
self.action(discriminator=discriminator, # pylint: disable=E1101
callable=config.add_resource_representer,
args=(rc, cnt_type),
kw=dict(options=opts,
attribute_options=mp_opts,
_info=self.context.info),
)
def test_custom_repository(self):
class MyMemoryAggregate(Aggregate):
pass
reg = self._registry
config = Configurator(registry=reg)
config.add_memory_repository('test', aggregate_class=MyMemoryAggregate)
repo_mgr = config.get_registered_utility(IRepositoryManager)
repo = repo_mgr.get('test')
config.add_resource(IFoo,
FooMember,
FooEntity,
collection_root_name="foos",
repository='test')
self.assert_raises(RuntimeError, repo.get_collection, IFoo)
self.assert_raises(RuntimeError, repo.get_aggregate, IFoo)
repo.initialize()
coll = repo.get_collection(IFoo)
agg = coll.get_aggregate()
self.assert_true(isinstance(agg, MyMemoryAggregate))
entity = FooEntity(id=1)
agg.add(entity)
self.assert_true(agg.count() == 1)
self.assert_equal(list(agg.iterator())[0].id, entity.id)
self.assert_equal(agg.get_by_id(1).id, entity.id)
self.assert_equal(agg.get_by_slug('1').slug, entity.slug)
agg.remove(entity)
self.assert_true(agg.count() == 0)
def test_custom_repository(self, simple_config):
class MyMemoryAggregate(Aggregate):
pass
reg = simple_config.registry
config = Configurator(registry=reg)
config.add_memory_repository('test', aggregate_class=MyMemoryAggregate)
repo_mgr = config.get_registered_utility(IRepositoryManager)
repo = repo_mgr.get('test')
config.add_resource(IFoo,
FooMember,
FooEntity,
collection_root_name="foos",
repository='test')
with pytest.raises(RuntimeError):
repo.get_collection(IFoo)
with pytest.raises(RuntimeError):
repo.get_aggregate(IFoo)
repo.initialize()
coll = repo.get_collection(IFoo)
agg = coll.get_aggregate()
assert isinstance(agg, MyMemoryAggregate)
entity = FooEntity(id=1)
agg.add(entity)
assert agg.count() == 1
assert list(agg.iterator())[0].id == entity.id
assert agg.get_by_id(1).id == entity.id
assert agg.get_by_slug('1').slug == entity.slug
agg.remove(entity)
assert agg.count() == 0
class ConfiguratorTestCase(Pep8CompliantTestCase):
def set_up(self):
testing_set_up()
reg = self._registry = get_current_registry()
self._config = Configurator(registry=reg, package=package)
self._config.setup_registry()
def tear_down(self):
testing_tear_down()
def test_registry_setup(self):
reg = self._registry
self.assert_is_not_none(reg.queryUtility(IRepositoryManager))
self.assert_is_not_none(reg.queryUtility(IFilterSpecificationFactory))
self.assert_is_not_none(reg.queryUtility(IOrderSpecificationFactory))
self.assert_is_not_none(reg.queryUtility(IService))
self.assert_is_not_none(reg.queryUtility(IFilterSpecificationVisitor,
name=EXPRESSION_KINDS.CQL))
self.assert_is_not_none(reg.queryUtility(IFilterSpecificationVisitor,
name=EXPRESSION_KINDS.SQL))
self.assert_is_not_none(reg.queryUtility(IFilterSpecificationVisitor,
name=EXPRESSION_KINDS.EVAL))
self.assert_is_not_none(reg.queryUtility(IOrderSpecificationVisitor,
name=EXPRESSION_KINDS.CQL))
self.assert_is_not_none(reg.queryUtility(IOrderSpecificationVisitor,
name=EXPRESSION_KINDS.SQL))
self.assert_is_not_none(reg.queryUtility(IOrderSpecificationVisitor,
name=EXPRESSION_KINDS.EVAL))
reg = self._registry
req = DummyRequest()
self.assert_is_not_none(reg.queryAdapter(req, IResourceUrlConverter))
def test_add_resource(self):
self.assert_raises(ValueError, self._config.add_resource,
NotAnInterface, FooMember, FooEntity, expose=False)
self.assert_raises(ValueError, self._config.add_resource,
IFoo, NotAMember, FooEntity, expose=False)
self.assert_raises(ValueError, self._config.add_resource,
IFoo, FooMember, NotAnEntity, expose=False)
self.assert_raises(ValueError, self._config.add_resource,
IFoo, FooMember, FooEntity, expose=False,
collection=NotACollection)
self.assert_raises(ValueError, self._config.add_resource,
IFoo, UnrelatedMember, FooEntity, expose=False)
self.assert_raises(ValueError, self._config.add_resource,
IFoo, FooMember, FooEntity, expose=False,
repository='UNKNOWN')
self.assert_raises(ValueError, self._config.add_resource,
IFoo, FooMember, FooEntity, expose=True)
def test_add_resource_with_collection_title(self):
title = 'myfoos'
self._config.add_resource(IFoo, FooMember, FooEntity, expose=False,
collection_title=title)
self.assert_equal(get_collection_class(IFoo).title, title)
def test_add_resource_with_root_name(self):
root_name = 'myfoos'
self._config.add_resource(IFoo, FooMember, FooEntity, expose=True,
collection_root_name=root_name)
self.assert_equal(get_collection_class(IFoo).root_name, root_name)
def test_add_resource_with_rdb_repo(self):
self._config.add_resource(IFoo, FooMember, FooEntity, expose=False,
repository=REPOSITORY_TYPES.RDB)
reg = self._registry
repo_mgr = reg.queryUtility(IRepositoryManager)
self.assert_is_not_none(repo_mgr.get(REPOSITORY_TYPES.RDB))
def test_have_memory_repo(self):
reg = self._registry
repo_mgr = reg.queryUtility(IRepositoryManager)
self.assert_is_not_none(repo_mgr.get(REPOSITORY_TYPES.MEMORY))
def test_add_resource_with_filesystem_repo(self):
self._config.add_resource(IFoo, FooMember, FooEntity, expose=False,
repository=REPOSITORY_TYPES.FILE_SYSTEM)
reg = self._registry
repo_mgr = reg.queryUtility(IRepositoryManager)
self.assert_is_not_none(repo_mgr.get(REPOSITORY_TYPES.FILE_SYSTEM))
def test_add_representer(self):
self.assert_raises(ValueError, self._config.add_representer)
self.assert_raises(ValueError, self._config.add_representer,
content_type=CsvMime,
representer_class=CsvResourceRepresenter)
def test_add_representer_with_representer_class(self):
self._config.add_representer(representer_class=MyRepresenterClass)
rpr_reg = self._registry.queryUtility(IRepresenterRegistry)
self.assert_true(rpr_reg.is_registered_representer_class(
MyRepresenterClass))
def test_add_resource_representer(self):
self.assert_raises(ValueError, self._config.add_resource_representer,
NotAMember, CsvMime)
def test_custom_repository(self):
class MyMemoryAggregate(Aggregate):
pass
reg = self._registry
config = Configurator(registry=reg)
config.add_memory_repository('test',
aggregate_class=MyMemoryAggregate)
repo_mgr = config.get_registered_utility(IRepositoryManager)
repo = repo_mgr.get('test')
config.add_resource(IFoo, FooMember, FooEntity,
collection_root_name="foos",
repository='test')
self.assert_raises(RuntimeError, repo.get_collection, IFoo)
self.assert_raises(RuntimeError, repo.get_aggregate, IFoo)
repo.initialize()
coll = repo.get_collection(IFoo)
agg = coll.get_aggregate()
self.assert_true(isinstance(agg, MyMemoryAggregate))
entity = FooEntity(id=1)
agg.add(entity)
self.assert_true(agg.count() == 1)
self.assert_equal(list(agg.iterator())[0].id, entity.id)
self.assert_equal(agg.get_by_id(1).id, entity.id)
self.assert_equal(agg.get_by_slug('1').slug, entity.slug)
agg.remove(entity)
self.assert_true(agg.count() == 0)
class ConfiguratorTestCase(Pep8CompliantTestCase):
def set_up(self):
testing_set_up()
reg = self._registry = get_current_registry()
self._config = Configurator(registry=reg, package=package)
self._config.setup_registry()
def tear_down(self):
testing_tear_down()
def test_registry_setup(self):
reg = self._registry
self.assert_is_not_none(reg.queryUtility(IRepositoryManager))
self.assert_is_not_none(reg.queryUtility(IFilterSpecificationFactory))
self.assert_is_not_none(reg.queryUtility(IOrderSpecificationFactory))
self.assert_is_not_none(reg.queryUtility(IService))
self.assert_is_not_none(
reg.queryUtility(IFilterSpecificationVisitor,
name=EXPRESSION_KINDS.CQL))
self.assert_is_not_none(
reg.queryUtility(IFilterSpecificationVisitor,
name=EXPRESSION_KINDS.SQL))
self.assert_is_not_none(
reg.queryUtility(IFilterSpecificationVisitor,
name=EXPRESSION_KINDS.EVAL))
self.assert_is_not_none(
reg.queryUtility(IOrderSpecificationVisitor,
name=EXPRESSION_KINDS.CQL))
self.assert_is_not_none(
reg.queryUtility(IOrderSpecificationVisitor,
name=EXPRESSION_KINDS.SQL))
self.assert_is_not_none(
reg.queryUtility(IOrderSpecificationVisitor,
name=EXPRESSION_KINDS.EVAL))
reg = self._registry
req = DummyRequest()
self.assert_is_not_none(reg.queryAdapter(req, IResourceUrlConverter))
def test_add_resource(self):
self.assert_raises(ValueError,
self._config.add_resource,
NotAnInterface,
FooMember,
FooEntity,
expose=False)
self.assert_raises(ValueError,
self._config.add_resource,
IFoo,
NotAMember,
FooEntity,
expose=False)
self.assert_raises(ValueError,
self._config.add_resource,
IFoo,
FooMember,
NotAnEntity,
expose=False)
self.assert_raises(ValueError,
self._config.add_resource,
IFoo,
FooMember,
FooEntity,
expose=False,
collection=NotACollection)
self.assert_raises(ValueError,
self._config.add_resource,
IFoo,
UnrelatedMember,
FooEntity,
expose=False)
self.assert_raises(ValueError,
self._config.add_resource,
IFoo,
FooMember,
FooEntity,
expose=False,
repository='UNKNOWN')
self.assert_raises(ValueError,
self._config.add_resource,
IFoo,
FooMember,
FooEntity,
expose=True)
def test_add_resource_with_collection_title(self):
title = 'myfoos'
self._config.add_resource(IFoo,
FooMember,
FooEntity,
expose=False,
collection_title=title)
self.assert_equal(get_collection_class(IFoo).title, title)
def test_add_resource_with_root_name(self):
root_name = 'myfoos'
self._config.add_resource(IFoo,
FooMember,
FooEntity,
expose=True,
collection_root_name=root_name)
self.assert_equal(get_collection_class(IFoo).root_name, root_name)
def test_add_resource_with_rdb_repo(self):
self._config.add_resource(IFoo,
FooMember,
FooEntity,
expose=False,
repository=REPOSITORY_TYPES.RDB)
reg = self._registry
repo_mgr = reg.queryUtility(IRepositoryManager)
self.assert_is_not_none(repo_mgr.get(REPOSITORY_TYPES.RDB))
def test_have_memory_repo(self):
reg = self._registry
repo_mgr = reg.queryUtility(IRepositoryManager)
self.assert_is_not_none(repo_mgr.get(REPOSITORY_TYPES.MEMORY))
def test_add_resource_with_filesystem_repo(self):
self._config.add_resource(IFoo,
FooMember,
FooEntity,
expose=False,
repository=REPOSITORY_TYPES.FILE_SYSTEM)
reg = self._registry
repo_mgr = reg.queryUtility(IRepositoryManager)
self.assert_is_not_none(repo_mgr.get(REPOSITORY_TYPES.FILE_SYSTEM))
def test_add_representer(self):
self.assert_raises(ValueError, self._config.add_representer)
self.assert_raises(ValueError,
self._config.add_representer,
content_type=CsvMime,
representer_class=CsvResourceRepresenter)
def test_add_representer_with_representer_class(self):
self._config.add_representer(representer_class=MyRepresenterClass)
rpr_reg = self._registry.queryUtility(IRepresenterRegistry)
self.assert_true(
rpr_reg.is_registered_representer_class(MyRepresenterClass))
def test_add_resource_representer(self):
self.assert_raises(ValueError, self._config.add_resource_representer,
NotAMember, CsvMime)
def test_custom_repository(self):
class MyMemoryAggregate(Aggregate):
pass
reg = self._registry
config = Configurator(registry=reg)
config.add_memory_repository('test', aggregate_class=MyMemoryAggregate)
repo_mgr = config.get_registered_utility(IRepositoryManager)
repo = repo_mgr.get('test')
config.add_resource(IFoo,
FooMember,
FooEntity,
collection_root_name="foos",
repository='test')
self.assert_raises(RuntimeError, repo.get_collection, IFoo)
self.assert_raises(RuntimeError, repo.get_aggregate, IFoo)
repo.initialize()
coll = repo.get_collection(IFoo)
agg = coll.get_aggregate()
self.assert_true(isinstance(agg, MyMemoryAggregate))
entity = FooEntity(id=1)
agg.add(entity)
self.assert_true(agg.count() == 1)
self.assert_equal(list(agg.iterator())[0].id, entity.id)
self.assert_equal(agg.get_by_id(1).id, entity.id)
self.assert_equal(agg.get_by_slug('1').slug, entity.slug)
agg.remove(entity)
self.assert_true(agg.count() == 0)
