def set_up(self):
super(BaseTestCaseWithConfiguration, self).set_up()
# Create and configure a new testing registry.
reg = Registry('testing')
self.config = Configurator(registry=reg,
package=self.package_name)
if not self.ini_section_name is None:
settings = self.ini.get_settings(self.ini_section_name)
else:
try:
settings = self.ini.get_settings('DEFAULT')
except configparser.NoSectionError:
settings = None
self.config.setup_registry(settings=settings)
if not self.package_name is None:
if not settings is None:
cfg_zcml = settings.get('configure_zcml',
self.config_file_name)
else:
cfg_zcml = self.config_file_name
self.config.begin()
try:
self.config.load_zcml(cfg_zcml)
finally:
self.config.end()
def test_configure_with_full_zcml(self):
reg = self._registry
# Check adapters.
ent = FooEntity()
member = object.__new__(FooMember)
coll = object.__new__(FooCollection)
# Make sure no adapters are in the registry.
self.assert_is_none(
reg.queryAdapter(coll, IMemberResource, name='member-class'))
self.assert_is_none(
reg.queryAdapter(member,
ICollectionResource,
name='collection-class'))
self.assert_is_none(
reg.queryAdapter(member, IEntity, name='entity-class'))
self.assert_is_none(reg.queryAdapter(ent, IMemberResource))
self.assert_is_none(
reg.queryAdapter(coll, IRepresenter,
name=CsvMime.mime_type_string))
# Load the configuration.
config = Configurator(registry=reg, package=package)
config.load_zcml('everest.tests.simple_app:configure.zcml')
self.__check(reg, member, ent, coll)
rpr = as_representer(coll, CsvMime)
self.assert_true(isinstance(rpr, Representer))
def set_up(self):
testing_set_up()
reg = self._registry = get_current_registry()
self._config = Configurator(registry=reg, package=package)
self._config.setup_registry()
repo_mgr = self._config.get_registered_utility(IRepositoryManager)
repo_mgr.initialize_all()
def simple_config(request):
set_up_testing()
reg = get_current_registry()
config = Configurator(registry=reg, package=package)
config.setup_registry()
request.addfinalizer(tear_down_testing)
return config
def simple_config(request):
set_up_testing()
reg = get_current_registry()
config = Configurator(registry=reg, package=package)
config.setup_registry()
request.addfinalizer(tear_down_testing)
return config
def app_factory(global_settings, **local_settings): # pylint: disable=W0613
config = Configurator()
config.setup_registry(settings=local_settings, root_factory=RootFactory())
# reg = get_current_registry()
# repo_mgr = reg.getUtility(IRepositoryManager)
# repo_mgr.initialize_all()
return config.make_wsgi_app()
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 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 app_factory(global_settings, **local_settings): # pylint: disable=W0613
config = Configurator()
config.setup_registry(settings=local_settings,
root_factory=RootFactory())
# reg = get_current_registry()
# repo_mgr = reg.getUtility(IRepositoryManager)
# repo_mgr.initialize_all()
return config.make_wsgi_app()
def set_up(self):
super(FunctionalTestCase, self).set_up()
# Create the WSGI application and set up a configurator.
wsgiapp = self._load_wsgiapp()
self.config = Configurator(registry=wsgiapp.registry,
package=self.package_name)
self.config.begin()
self.app = TestApp(wsgiapp,
extra_environ=self._create_extra_environment())
def set_up(self):
super(BaseTestCaseWithConfiguration, self).set_up()
# Create and configure a new testing registry.
reg = Registry('testing')
self.config = Configurator(registry=reg, package=self.package_name)
if not self.ini_section_name is None:
settings = self.ini.get_settings(self.ini_section_name)
self.config.setup_registry(settings=settings)
else:
self.config.setup_registry()
def __create(cls, ini):
reg = Registry('testing')
conf = Configurator(registry=reg, package=ini.package_name)
conf.setup_registry(settings=ini.settings)
if not ini.config_file_name is None and not ini.package_name is None:
conf.begin()
try:
conf.load_zcml(ini.config_file_name)
finally:
conf.end()
return conf
def after(self):
discriminator = \
('representer',
self.content_type or self.representer_class.content_type)
self.action(discriminator=discriminator) # pylint: disable=E1101
# Representers are created eagerly so the resource declarations can use
# them.
reg = get_current_registry()
config = Configurator(reg, package=self.context.package)
config.add_representer(content_type=self.content_type,
representer_class=self.representer_class,
options=self.options)
def nosql_repository(_context, name=None, make_default=False,
aggregate_class=None, repository_class=None,
db_host='localhost', db_port=27017, db_name='test'):
repo_type = REPOSITORY_TYPES.NO_SQL
# Apply eagerly so custom configuration can assume the repo is there.
discriminator = (repo_type, name)
_context.action(discriminator=discriminator)
reg = get_current_registry()
cnf = dict(db_host=db_host, db_port=db_port, db_name=db_name)
config = Configurator(reg, package=_context.package)
config.add_repository(name, repo_type, repository_class,
aggregate_class, make_default, cnf)
def after(self):
discriminator = \
('representer',
self.content_type or self.representer_class.content_type)
self.action(discriminator=discriminator) # pylint: disable=E1101
# Representers are created eagerly so the resource declarations can use
# them.
reg = get_current_registry()
config = Configurator(reg, package=self.context.package)
config.add_representer(content_type=self.content_type,
representer_class=self.representer_class,
options=self.options)
def __create(cls, ini):
reg = Registry('testing')
conf = Configurator(registry=reg, package=ini.package_name)
conf.setup_registry(settings=ini.settings)
if not ini.config_file_name is None and not ini.package_name is None:
conf.begin()
try:
conf.load_zcml(ini.config_file_name)
finally:
conf.end()
return conf
def create_config(settings, package='thelma', registry=None):
"""
Returns a configurator for TheLMA.
"""
config = Configurator(package=package,
registry=registry)
if registry is None:
config.setup_registry(settings=settings,
root_factory=RootFactory())
config.load_zcml('configure.zcml')
# tractor registration
tractor_config_file = settings['tractor_config_file']
tractor_api = make_api_from_config(tractor_config_file)
config.registry.registerUtility(tractor_api, ITractor) # pylint: disable=E1103
return config
def set_up(self):
testing_set_up()
reg = self._registry = get_current_registry()
self._config = Configurator(registry=reg, package=package)
self._config.setup_registry()
repo_mgr = self._config.get_registered_utility(IRepositoryManager)
repo_mgr.initialize_all()
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 set_up(self):
super(FunctionalTestCase, self).set_up()
# Create the WSGI application and set up a configurator.
wsgiapp = self._load_wsgiapp()
self.config = Configurator(registry=wsgiapp.registry,
package=self.package_name)
self.config.begin()
self.app = TestApp(wsgiapp,
extra_environ=self._create_extra_environment())
class FunctionalTestCase(TestCaseWithIni, ResourceCreatorMixin):
"""
Use this for test cases that need access to a WSGI application.
:ivar app: :class:`webtest.TestApp` instance wrapping our WSGI app to test.
"""
#: The name of the application to test. Must be set in derived classes.
app_name = None
#: The name of the package where the tests reside. Override as needed.
package_name = 'everest'
def set_up(self):
super(FunctionalTestCase, self).set_up()
# Create the WSGI application and set up a configurator.
wsgiapp = self.__load_wsgiapp()
self.config = Configurator(registry=wsgiapp.registry,
package=self.package_name)
self.config.begin()
self.app = \
EverestTestApp(wsgiapp,
self.package_name,
extra_environ=self._create_extra_environment())
def tear_down(self):
super(FunctionalTestCase, self).tear_down()
transaction.abort()
self.config.end()
tear_down_registry(self.config.registry)
try:
del self.app
except AttributeError:
pass
def _create_extra_environment(self):
"""
Returns the value for the `extra_environ` argument for the test
app. Override as needed.
"""
return {}
def __load_wsgiapp(self):
wsgiapp = loadapp('config:' + self.ini.ini_file_path,
name=self.app_name)
return wsgiapp
def set_up(self):
super(BaseTestCaseWithConfiguration, self).set_up()
# Create and configure a new testing registry.
reg = Registry('testing')
self.config = Configurator(registry=reg,
package=self.package_name)
if not self.ini_section_name is None:
settings = self.ini.get_settings(self.ini_section_name)
self.config.setup_registry(settings=settings)
else:
self.config.setup_registry()
def app_factory(global_settings, **local_settings): # pylint: disable=W0613
reg = get_current_registry()
config = Configurator(reg)
config.setup_registry(settings=local_settings, root_factory=RootFactory())
zcml_file = local_settings.get("configure_zcml", "configure.zcml")
config.load_zcml(zcml_file)
return config.make_wsgi_app()
class BaseTestCaseWithConfiguration(TestCaseWithIni):
"""
Base class for test cases that access an initialized (but not configured)
registry.
:ivar config: The registry configurator. This is set in the set_up method.
"""
# : The name of a ZCML configuration file to use.
config_file_name = 'configure.zcml'
def set_up(self):
super(BaseTestCaseWithConfiguration, self).set_up()
# Create and configure a new testing registry.
reg = Registry('testing')
self.config = Configurator(registry=reg,
package=self.package_name)
if not self.ini_section_name is None:
settings = self.ini.get_settings(self.ini_section_name)
else:
try:
settings = self.ini.get_settings('DEFAULT')
except configparser.NoSectionError:
settings = None
self.config.setup_registry(settings=settings)
def tear_down(self):
super(BaseTestCaseWithConfiguration, self).tear_down()
tear_down_registry(self.config.registry)
try:
del self.config
except AttributeError:
pass
def _get_config_file_name(self):
if self.ini.has_setting(self.ini_section_name, 'configure_zcml'):
cfg_zcml = self.ini.get_setting(self.ini_section_name,
'configure_zcml')
else:
cfg_zcml = self.config_file_name
return cfg_zcml
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)
class BaseTestCaseWithConfiguration(TestCaseWithIni):
"""
Base class for test cases that access an initialized (but not configured)
registry.
:ivar config: The registry configurator. This is set in the set_up method.
"""
#: The name of a package containing a configuration file to load.
#: Defaults to `None` indicating that no configuration applies.
package_name = None
# : The name of a ZCML configuration file to use.
config_file_name = 'configure.zcml'
# : The section name in the ini file to look for settings. Override as
# : needed in derived classes.
ini_section_name = None
def set_up(self):
super(BaseTestCaseWithConfiguration, self).set_up()
# Create and configure a new testing registry.
reg = Registry('testing')
self.config = Configurator(registry=reg,
package=self.package_name)
if not self.ini_section_name is None:
settings = self.ini.get_settings(self.ini_section_name)
else:
try:
settings = self.ini.get_settings('DEFAULT')
except configparser.NoSectionError:
settings = None
self.config.setup_registry(settings=settings)
if not self.package_name is None:
if not settings is None:
cfg_zcml = settings.get('configure_zcml',
self.config_file_name)
else:
cfg_zcml = self.config_file_name
self.config.begin()
try:
self.config.load_zcml(cfg_zcml)
finally:
self.config.end()
def tear_down(self):
super(BaseTestCaseWithConfiguration, self).tear_down()
tear_down_registry(self.config.registry)
try:
del self.config
except AttributeError:
pass
def test_configure_with_full_zcml(self):
reg = self._registry
# Check adapters.
ent = FooEntity()
member = object.__new__(FooMember)
coll = object.__new__(FooCollection)
# Make sure no adapters are in the registry.
self.assert_is_none(reg.queryAdapter(coll, IMemberResource,
name='member-class'))
self.assert_is_none(reg.queryAdapter(member, ICollectionResource,
name='collection-class'))
self.assert_is_none(reg.queryAdapter(member, IEntity,
name='entity-class'))
self.assert_is_none(reg.queryAdapter(ent, IMemberResource))
self.assert_is_none(reg.queryAdapter(coll, IRepresenter,
name=CsvMime.mime_type_string))
# Load the configuration.
config = Configurator(registry=reg, package=package)
config.load_zcml('everest.tests.simple_app:configure.zcml')
self.__check(reg, member, ent, coll)
rpr = as_representer(coll, CsvMime)
self.assert_true(isinstance(rpr, Representer))
def set_up(self):
super(BaseTestCaseWithConfiguration, self).set_up()
# Create and configure a new testing registry.
reg = Registry('testing')
self.config = Configurator(registry=reg,
package=self.package_name)
if not self.ini_section_name is None:
settings = self.ini.get_settings(self.ini_section_name)
else:
try:
settings = self.ini.get_settings('DEFAULT')
except configparser.NoSectionError:
settings = None
self.config.setup_registry(settings=settings)
def _repository(_context, name, make_default, agg_cls, repo_cls, repo_type,
config_method, cnf):
# Repository directives are applied eagerly. Note that custom repositories
# must be declared *before* they can be referenced in resource directives.
discriminator = (repo_type, name)
_context.action(discriminator=discriminator)
reg = get_current_registry()
config = Configurator(reg, package=_context.package)
method = getattr(config, config_method)
method(name,
aggregate_class=agg_cls,
repository_class=repo_cls,
configuration=cnf,
make_default=make_default)
class BaseTestCaseWithConfiguration(TestCaseWithIni):
"""
Base class for test cases that access an initialized (but not configured)
registry.
:ivar config: The registry configurator. This is set in the set_up method.
"""
# : The name of a ZCML configuration file to use.
config_file_name = 'configure.zcml'
def set_up(self):
super(BaseTestCaseWithConfiguration, self).set_up()
# Create and configure a new testing registry.
reg = Registry('testing')
self.config = Configurator(registry=reg, package=self.package_name)
if not self.ini_section_name is None:
settings = self.ini.get_settings(self.ini_section_name)
self.config.setup_registry(settings=settings)
else:
self.config.setup_registry()
def tear_down(self):
super(BaseTestCaseWithConfiguration, self).tear_down()
tear_down_registry(self.config.registry)
try:
del self.config
except AttributeError:
pass
def _get_config_file_name(self):
if self.ini.has_setting(self.ini_section_name, 'configure_zcml'):
cfg_zcml = self.ini.get_setting(self.ini_section_name,
'configure_zcml')
else:
cfg_zcml = self.config_file_name
return cfg_zcml
class FunctionalTestCase(TestCaseWithIni):
"""
Use this for test cases that need access to a WSGI application.
:ivar app: :class:`webtest.TestApp` instance wrapping our WSGI app to test.
"""
# : The name of the application to test.
app_name = None
def set_up(self):
super(FunctionalTestCase, self).set_up()
# Create the WSGI application and set up a configurator.
wsgiapp = self._load_wsgiapp()
self.config = Configurator(registry=wsgiapp.registry,
package=self.package_name)
self.config.begin()
self.app = TestApp(wsgiapp,
extra_environ=self._create_extra_environment())
def tear_down(self):
super(FunctionalTestCase, self).tear_down()
transaction.abort()
self.config.end()
tear_down_registry(self.config.registry)
try:
del self.app
except AttributeError:
pass
def _load_wsgiapp(self):
wsgiapp = loadapp('config:' + self.ini.ini_file_path,
name=self.app_name)
return wsgiapp
def _create_extra_environment(self):
return {}
class FunctionalTestCase(TestCaseWithIni):
"""
Use this for test cases that need access to a WSGI application.
:ivar app: :class:`webtest.TestApp` instance wrapping our WSGI app to test.
"""
# : The name of the application to test.
app_name = None
def set_up(self):
super(FunctionalTestCase, self).set_up()
# Create the WSGI application and set up a configurator.
wsgiapp = self._load_wsgiapp()
self.config = Configurator(registry=wsgiapp.registry,
package=self.package_name)
self.config.begin()
self.app = TestApp(wsgiapp,
extra_environ=self._create_extra_environment())
def tear_down(self):
super(FunctionalTestCase, self).tear_down()
transaction.abort()
self.config.end()
tear_down_registry(self.config.registry)
try:
del self.app
except AttributeError:
pass
def _load_wsgiapp(self):
wsgiapp = loadapp('config:' + self.ini.ini_file_path,
name=self.app_name)
return wsgiapp
def _create_extra_environment(self):
return {}
def messaging(_context, repository, reset_on_start=False):
"""
Directive for setting up the user message resource in the appropriate
repository.
:param str repository: The repository to create the user messages resource
in.
"""
discriminator = ('messaging', repository)
reg = get_current_registry()
config = Configurator(reg, package=_context.package)
_context.action(
discriminator=discriminator, # pylint: disable=E1101
callable=config.setup_system_repository,
args=(repository, ),
kw=dict(reset_on_start=reset_on_start))
def _resource_view(_context, for_, default_content_type,
default_response_content_type, config_callable_name, kw):
reg = get_current_registry()
config = Configurator(reg, package=_context.package)
config_callable = getattr(config, config_callable_name)
option_tuples = tuple(sorted([(k, str(v)) for (k, v) in kw.items()]))
kw['default_content_type'] = default_content_type
kw['default_response_content_type'] = default_response_content_type
for rc in for_:
discriminator = ('resource_view', rc, config_callable_name) \
+ option_tuples
_context.action(
discriminator=discriminator, # pylint: disable=E1101
callable=config_callable,
args=(rc, ),
kw=kw)
def create_config(settings, package='thelma', registry=None):
"""
Returns a configurator for TheLMA.
"""
config = Configurator(package=package, registry=registry)
if registry is None:
config.setup_registry(settings=settings, root_factory=RootFactory())
config.load_zcml('configure.zcml')
# tractor registration
tractor_config_file = settings['tractor_config_file']
tractor_api = make_api_from_config(tractor_config_file)
config.registry.registerUtility(tractor_api, ITractor) # pylint: disable=E1103
return config
def app_factory(global_settings, **local_settings): # pylint: disable=W0613
"""
Default factory for creating a WSGI application using the everest
configurator and root factory.
:param dict global_settings: Global settings extracted from an ini file.
Not used in this default app factory.
:param dict local_settings: App settings extracted from an ini file.
"""
config = Configurator()
config.setup_registry(settings=local_settings, root_factory=RootFactory())
if 'configure_zcml' in local_settings:
config.load_zcml(local_settings['configure_zcml'])
app = config.make_wsgi_app()
# In the absence of an application name in the settings, we have to
# extract the main app's name from the ini file, which unfortunately
# means parsing it again.
app_name = app_name_from_ini_file(global_settings['__file__'])
ep_group = "%s.plugins" % app_name
plugin_mgr = config.get_registered_utility(IPluginManager)
plugin_mgr.load_all(ep_group)
return app
def app_factory(global_settings, **local_settings): # pylint: disable=W0613
"""
Default factory for creating a WSGI application using the everest
configurator and root factory.
:param dict global_settings: Global settings extracted from an ini file.
Not used in this default app factory.
:param dict local_settings: App settings extracted from an ini file.
"""
config = Configurator()
config.setup_registry(settings=local_settings,
root_factory=RootFactory())
if 'configure_zcml' in local_settings:
config.load_zcml(local_settings['configure_zcml'])
app = config.make_wsgi_app()
# In the absence of an application name in the settings, we have to
# extract the main app's name from the ini file, which unfortunately
# means parsing it again.
app_name = app_name_from_ini_file(global_settings['__file__'])
ep_group = "%s.plugins" % app_name
plugin_mgr = config.get_registered_utility(IPluginManager)
plugin_mgr.load_all(ep_group)
return app
def set_up(self):
testing_set_up()
reg = self._registry = get_current_registry()
self._config = Configurator(registry=reg, package=package)
self._config.setup_registry()
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)
def app_factory(global_settings, **local_settings): # pylint: disable=W0613
config = Configurator()
config.setup_registry(settings=local_settings, root_factory=RootFactory())
return config.make_wsgi_app()
def app_factory(global_settings, **local_settings): # pylint: disable=W0613
config = Configurator()
config.setup_registry(settings=local_settings,
root_factory=RootFactory())
return config.make_wsgi_app()
class DirectivesTestCase(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()
repo_mgr = self._config.get_registered_utility(IRepositoryManager)
repo_mgr.initialize_all()
def tear_down(self):
testing_tear_down()
def test_configure_with_simple_zcml(self):
# Load the configuration.
self._config.load_zcml('everest.tests.simple_app:configure_simple.zcml')
reg = self._registry
# Check adapters.
ent = FooEntity()
member = object.__new__(FooMember)
coll_cls = reg.queryUtility(IFoo, name='collection-class')
self.assert_is_not_none(coll_cls)
self.assert_is_not_none(coll_cls.root_name)
self.assert_is_not_none(coll_cls.title)
coll = object.__new__(coll_cls)
self.__check(reg, member, ent, coll)
# Check service.
srvc = reg.queryUtility(IService)
self.assert_is_not_none(srvc)
srvc.start()
self.assert_true(isinstance(srvc.get('foos'), Collection))
self.assert_is_none(srvc.get(coll_cls))
self.assert_is_none(srvc.get(IBar))
def test_configure_with_full_zcml(self):
reg = self._registry
# Check adapters.
ent = FooEntity()
member = object.__new__(FooMember)
coll = object.__new__(FooCollection)
# Make sure no adapters are in the registry.
self.assert_is_none(reg.queryAdapter(coll, IMemberResource,
name='member-class'))
self.assert_is_none(reg.queryAdapter(member, ICollectionResource,
name='collection-class'))
self.assert_is_none(reg.queryAdapter(member, IEntity,
name='entity-class'))
self.assert_is_none(reg.queryAdapter(ent, IMemberResource))
self.assert_is_none(reg.queryAdapter(coll, IRepresenter,
name=CsvMime.mime_type_string))
# Load the configuration.
config = Configurator(registry=reg, package=package)
config.load_zcml('everest.tests.simple_app:configure.zcml')
self.__check(reg, member, ent, coll)
rpr = as_representer(coll, CsvMime)
self.assert_true(isinstance(rpr, Representer))
def test_configure_with_custom_repo_zcml(self):
repo_mgr = self._registry.queryUtility(IRepositoryManager)
self.assert_is_none(repo_mgr.get('CUSTOM_MEMORY'))
self.assert_is_none(repo_mgr.get('CUSTOM_FILESYSTEM'))
self.assert_is_none(repo_mgr.get('CUSTOM_RDB'))
self._config.load_zcml('everest.tests.simple_app:configure_repos.zcml')
self.assert_is_not_none(repo_mgr.get('CUSTOM_MEMORY'))
self.assert_is_not_none(repo_mgr.get('CUSTOM_FILESYSTEM'))
self.assert_is_not_none(repo_mgr.get('CUSTOM_RDB'))
def __check(self, reg, member, ent, coll):
for idx, obj in enumerate((member, coll, ent)):
self.assert_equal(reg.queryAdapter(obj, IMemberResource,
name='member-class'),
type(member))
self.assert_equal(reg.queryAdapter(obj, ICollectionResource,
name='collection-class'),
type(coll))
self.assert_equal(reg.queryAdapter(obj, IEntity,
name='entity-class'),
type(ent))
if idx < 2: # lookup with class only for member/collection.
self.assert_equal(reg.queryAdapter(type(obj), IMemberResource,
name='member-class'),
type(member))
self.assert_equal(reg.queryAdapter(type(obj),
ICollectionResource,
name='collection-class'),
type(coll))
self.assert_equal(reg.queryAdapter(type(obj), IEntity,
name='entity-class'),
type(ent))
# Check instance adapters.
self.assert_is_not_none(reg.queryAdapter(ent, IMemberResource))
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 __init__(self, app, package_name, **kw):
TestApp.__init__(self, app, **kw)
self.__config = Configurator(registry=app.registry,
package=package_name)
class DirectivesTestCase(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()
repo_mgr = self._config.get_registered_utility(IRepositoryManager)
repo_mgr.initialize_all()
def tear_down(self):
testing_tear_down()
def test_configure_with_simple_zcml(self):
# Load the configuration.
self._config.load_zcml(
'everest.tests.simple_app:configure_simple.zcml')
reg = self._registry
# Check adapters.
ent = FooEntity()
member = object.__new__(FooMember)
coll_cls = reg.queryUtility(IFoo, name='collection-class')
self.assert_is_not_none(coll_cls)
self.assert_is_not_none(coll_cls.root_name)
self.assert_is_not_none(coll_cls.title)
coll = object.__new__(coll_cls)
self.__check(reg, member, ent, coll)
# Check service.
srvc = reg.queryUtility(IService)
self.assert_is_not_none(srvc)
srvc.start()
self.assert_true(isinstance(srvc.get('foos'), Collection))
self.assert_is_none(srvc.get(coll_cls))
self.assert_is_none(srvc.get(IBar))
def test_configure_with_full_zcml(self):
reg = self._registry
# Check adapters.
ent = FooEntity()
member = object.__new__(FooMember)
coll = object.__new__(FooCollection)
# Make sure no adapters are in the registry.
self.assert_is_none(
reg.queryAdapter(coll, IMemberResource, name='member-class'))
self.assert_is_none(
reg.queryAdapter(member,
ICollectionResource,
name='collection-class'))
self.assert_is_none(
reg.queryAdapter(member, IEntity, name='entity-class'))
self.assert_is_none(reg.queryAdapter(ent, IMemberResource))
self.assert_is_none(
reg.queryAdapter(coll, IRepresenter,
name=CsvMime.mime_type_string))
# Load the configuration.
config = Configurator(registry=reg, package=package)
config.load_zcml('everest.tests.simple_app:configure.zcml')
self.__check(reg, member, ent, coll)
rpr = as_representer(coll, CsvMime)
self.assert_true(isinstance(rpr, Representer))
def test_configure_with_custom_repo_zcml(self):
repo_mgr = self._registry.queryUtility(IRepositoryManager)
self.assert_is_none(repo_mgr.get('CUSTOM_MEMORY'))
self.assert_is_none(repo_mgr.get('CUSTOM_FILESYSTEM'))
self.assert_is_none(repo_mgr.get('CUSTOM_RDB'))
self._config.load_zcml('everest.tests.simple_app:configure_repos.zcml')
self.assert_is_not_none(repo_mgr.get('CUSTOM_MEMORY'))
self.assert_is_not_none(repo_mgr.get('CUSTOM_FILESYSTEM'))
self.assert_is_not_none(repo_mgr.get('CUSTOM_RDB'))
def __check(self, reg, member, ent, coll):
for idx, obj in enumerate((member, coll, ent)):
self.assert_equal(
reg.queryAdapter(obj, IMemberResource, name='member-class'),
type(member))
self.assert_equal(
reg.queryAdapter(obj,
ICollectionResource,
name='collection-class'), type(coll))
self.assert_equal(
reg.queryAdapter(obj, IEntity, name='entity-class'), type(ent))
if idx < 2: # lookup with class only for member/collection.
self.assert_equal(
reg.queryAdapter(type(obj),
IMemberResource,
name='member-class'), type(member))
self.assert_equal(
reg.queryAdapter(type(obj),
ICollectionResource,
name='collection-class'), type(coll))
self.assert_equal(
reg.queryAdapter(type(obj), IEntity, name='entity-class'),
type(ent))
# Check instance adapters.
self.assert_is_not_none(reg.queryAdapter(ent, IMemberResource))
