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 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 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 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 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 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 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
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 {}
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 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()
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 __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))