def test__find_view_traversal_multiview(self):
        from zope.interface import implementer
        from zope.interface import providedBy
        from pyramid.interfaces import IRequest
        from pyramid.interfaces import IViewClassifier
        from pyramid.interfaces import IMultiView
        from pyramid.traversal import DefaultRootFactory
        from pyramid.registry import Registry

        registry = Registry()

        @implementer(IMultiView)
        class View1(object):
            pass

        request = dummy.DummyRequest()
        request.path_info = '/a'
        root = DefaultRootFactory(request)
        root_iface = providedBy(root)
        view = View1()
        registry.registerAdapter(
            view, (IViewClassifier, IRequest, root_iface), IMultiView, name='a'
        )
        self._register_mapper(registry, [])
        command = self._makeOne(registry=registry)
        request = self._makeRequest('/a', registry)
        result = command._find_view(request)
        self.assertEqual(result, view)

 def test__find_view_route_no_multiview(self):
     from zope.interface import Interface
     from zope.interface import implementer
     from pyramid.interfaces import IRouteRequest
     from pyramid.interfaces import IViewClassifier
     from pyramid.interfaces import IView
     from pyramid.registry import Registry
     registry = Registry()
     def view():pass
     class IMyRoot(Interface):
         pass
     class IMyRoute(Interface):
         pass
     registry.registerAdapter(view,
                              (IViewClassifier, IMyRoute, IMyRoot),
                              IView, '')
     registry.registerUtility(IMyRoute, IRouteRequest, name='a')
     @implementer(IMyRoot)
     class Factory(object):
         def __init__(self, request):
             pass
     routes = [dummy.DummyRoute('a', '/a', factory=Factory, matchdict={}),
               dummy.DummyRoute('b', '/b', factory=Factory)]
     self._register_mapper(registry, routes)
     command = self._makeOne(registry=registry)
     result = command._find_view('/a', registry)
     self.assertEqual(result, view)

 def setUp(self):
     self.__request = DummyRequest()
     self.__request.matchdict['registration_id'] = 'a1-b2-c3-d4-e5'
     self.__request.headers['File-Name'] = 'dummy.zip'
     reg = Registry()
     reg.settings = {'hpz.frs.upload_base_path': '/dev/null', 'hpz.frs.file_size_limit': '1024'}
     self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False)

 def test_single_route_one_view_registered_with_factory(self):
     from zope.interface import Interface
     from pyramid.registry import Registry
     from pyramid.interfaces import IRouteRequest
     from pyramid.interfaces import IViewClassifier
     from pyramid.interfaces import IView
     registry = Registry()
     def view():pass
     class IMyRoot(Interface):
         pass
     class IMyRoute(Interface):
         pass
     registry.registerAdapter(view,
                              (IViewClassifier, IMyRoute, IMyRoot),
                              IView, '')
     registry.registerUtility(IMyRoute, IRouteRequest, name='a')
     command = self._makeOne()
     def factory(request): pass
     route = dummy.DummyRoute('a', '/a', factory=factory)
     mapper = dummy.DummyMapper(route)
     command._get_mapper = lambda *arg: mapper
     L = []
     command.out = L.append
     command.bootstrap = (dummy.DummyBootstrap(registry=registry),)
     result = command.run()
     self.assertEqual(result, None)
     self.assertEqual(len(L), 3)
     self.assertEqual(L[-1].split()[:3], ['a', '/a', '<unknown>'])

 def setUp(self):
     self.__workspace = tempfile.mkdtemp()
     self.__staging = tempfile.mkdtemp()
     # setup request
     self.__request = DummyRequest()
     self.__request.method = 'POST'
     # setup settings
     # use the one for UDL
     here = os.path.abspath(os.path.dirname(__file__))
     self.gpg_home = os.path.abspath(os.path.join(here, '..', '..', '..', '..', 'config', 'gpg'))
     self.settings = {
         'smarter_score_batcher.gpg.keyserver': None,
         'smarter_score_batcher.gpg.homedir': self.gpg_home,
         'smarter_score_batcher.gpg.public_key.ca': '[email protected]',
         'smarter_score_batcher.gpg.public_key.cat': '[email protected]',
         'smarter_score_batcher.gpg.public_key.fish': '[email protected]',
         'smarter_score_batcher.gpg.path': 'gpg',
         'smarter_score_batcher.base_dir.working': self.__workspace,
         'smarter_score_batcher.base_dir.staging': self.__staging
     }
     # setup registr
     reg = Registry()
     reg.settings = self.settings
     self.__config = testing.setUp(registry=reg, request=self.__request, hook_zca=False)
     self._prepare_testing_files()

    def test_single_route_one_view_registered(self):
        from zope.interface import Interface
        from pyramid.registry import Registry
        from pyramid.interfaces import IRouteRequest
        from pyramid.interfaces import IViewClassifier
        from pyramid.interfaces import IView

        registry = Registry()

        def view():
            pass

        class IMyRoute(Interface):
            pass

        registry.registerAdapter(view, (IViewClassifier, IMyRoute, Interface), IView, "")
        registry.registerUtility(IMyRoute, IRouteRequest, name="a")
        command = self._makeOne()
        route = DummyRoute("a", "/a")
        mapper = DummyMapper(route)
        command._get_mapper = lambda *arg: mapper
        L = []
        command.out = L.append
        app = DummyApp()
        app.registry = registry
        loadapp = DummyLoadApp(app)
        command.loadapp = (loadapp,)
        command.args = ("/foo/bar/myapp.ini", "myapp")
        result = command.command()
        self.assertEqual(result, None)
        self.assertEqual(len(L), 3)
        self.assertEqual(L[-1].split()[:4], ["a", "/a", "<function", "view"])

 def test_single_route_one_view_registered(self):
     from zope.interface import Interface
     from pyramid.registry import Registry
     from pyramid.interfaces import IRouteRequest
     from pyramid.interfaces import IViewClassifier
     from pyramid.interfaces import IView
     registry = Registry()
     def view():pass
     class IMyRoute(Interface):
         pass
     registry.registerAdapter(view,
                              (IViewClassifier, IMyRoute, Interface),
                              IView, '')
     registry.registerUtility(IMyRoute, IRouteRequest, name='a')
     command = self._makeOne()
     route = dummy.DummyRoute('a', '/a')
     mapper = dummy.DummyMapper(route)
     command._get_mapper = lambda *arg: mapper
     L = []
     command.out = L.append
     command.bootstrap = (dummy.DummyBootstrap(registry=registry),)
     result = command.run()
     self.assertEqual(result, 0)
     self.assertEqual(len(L), 3)
     compare_to = L[-1].split()[:3]
     self.assertEqual(
         compare_to,
         ['a', '/a', 'pyramid.tests.test_scripts.test_proutes.view']
     )

 def test__find_view_route_multiview_no_view_registered(self):
     from zope.interface import Interface
     from zope.interface import implementer
     from pyramid.interfaces import IRouteRequest
     from pyramid.interfaces import IMultiView
     from pyramid.interfaces import IRootFactory
     from pyramid.registry import Registry
     registry = Registry()
     def view1():pass
     def view2():pass
     class IMyRoot(Interface):
         pass
     class IMyRoute1(Interface):
         pass
     class IMyRoute2(Interface):
         pass
     registry.registerUtility(IMyRoute1, IRouteRequest, name='a')
     registry.registerUtility(IMyRoute2, IRouteRequest, name='b')
     @implementer(IMyRoot)
     class Factory(object):
         def __init__(self, request):
             pass
     registry.registerUtility(Factory, IRootFactory)
     routes = [dummy.DummyRoute('a', '/a', matchdict={}),
               dummy.DummyRoute('b', '/a', matchdict={})]
     self._register_mapper(registry, routes)
     command = self._makeOne(registry=registry)
     result = command._find_view('/a', registry)
     self.assertTrue(IMultiView.providedBy(result))

 def test_single_route_one_view_registered_with_factory(self):
     from zope.interface import Interface
     from pyramid.registry import Registry
     from pyramid.interfaces import IRouteRequest
     from pyramid.interfaces import IViewClassifier
     from pyramid.interfaces import IView
     registry = Registry()
     def view():pass
     class IMyRoot(Interface):
         pass
     class IMyRoute(Interface):
         pass
     registry.registerAdapter(view,
                              (IViewClassifier, IMyRoute, IMyRoot),
                              IView, '')
     registry.registerUtility(IMyRoute, IRouteRequest, name='a')
     command = self._makeOne()
     def factory(request): pass
     route = DummyRoute('a', '/a', factory=factory)
     mapper = DummyMapper(route)
     command._get_mapper = lambda *arg: mapper
     L = []
     command.out = L.append
     app = DummyApp()
     app.registry = registry
     loadapp = DummyLoadApp(app)
     command.loadapp = (loadapp,)
     command.args = ('/foo/bar/myapp.ini', 'myapp')
     result = command.command()
     self.assertEqual(result, None)
     self.assertEqual(len(L), 3)
     self.assertEqual(L[-1].split()[:3], ['a', '/a', '<unknown>'])

 def _makeRequest(self, **kwargs):
     """:rtype: pyramid.request.Request"""
     from pyramid.registry import Registry
     registry = Registry()
     registry.settings = {'app.timezone': 'Asia/Bangkok'}
     testing.setUp(registry=registry)
     return testing.DummyRequest(**kwargs)

 def test_dn_with_one_base_element(self):
     reg = Registry()
     reg.settings = {}
     reg.settings['ldap.base.dn'] = 'ou=dummy'
     self.__config = testing.setUp(registry=reg, request=DummyRequest(), hook_zca=False)
     attributes = {'dn': ['ou=dummyOrg,ou=dummy']}
     tenant = BasicIdentityParser.get_tenant_name(attributes)
     self.assertEqual(tenant[0], 'dummyorg')

 def setUp(self):
     reg = Registry()
     reg.settings = {'store_type':'rdflib',
                     'debug_sparql':True}
     self.config = testing.setUp(reg)
     self.config.add_settings({'mako.directories':'plingback.sparql:templates'})
     self.config.add_renderer(None, mako_renderer_factory)
     self.config.begin()

 def test_add_settings_settings_None(self):
     from pyramid.registry import Registry
     from pyramid.interfaces import ISettings
     reg = Registry()
     config = self._makeOne(reg)
     config.add_settings(None, a=1)
     settings = reg.getUtility(ISettings)
     self.assertEqual(settings['a'], 1)

def get_registry(settings):
    registry = Registry('testing')
    config = Configurator(registry=registry)
    if getattr(registry, 'settings', None) is None:
        config._set_settings(settings)
    registry.registerUtility(RoutesMapper(), IRoutesMapper)
    config.commit()
    return registry

    def test_setup_registry_debug_logger_None_default(self):
        from pyramid.registry import Registry
        from pyramid.interfaces import IDebugLogger

        reg = Registry()
        config = self._makeOne(reg)
        config.setup_registry()
        logger = reg.getUtility(IDebugLogger)
        self.assertEqual(logger.name, 'tests.test_config')

def _set_local_roles(resource, new_local_roles: dict, registry: Registry):
    old_local_roles = getattr(resource, '__local_roles__', None)
    if new_local_roles == old_local_roles:
        return
    else:
        resource.__local_roles__ = new_local_roles
    event = LocalRolesModified(resource, new_local_roles, old_local_roles,
                               registry)
    registry.notify(event)

 def setUp(self):
     reg = Registry()
     reg.settings = {}
     reg.settings['session.backend.type'] = 'beaker'
     reg.settings['cache.expire'] = 10
     reg.settings['cache.regions'] = 'session'
     reg.settings['cache.type'] = 'memory'
     reg.settings['batch.user.session.timeout'] = 15
     component.provideUtility(SessionBackend(reg.settings), ISessionBackend)

    def test_setup_registry_default_permission(self):
        from pyramid.registry import Registry
        from pyramid.interfaces import IDefaultPermission

        reg = Registry()
        config = self._makeOne(reg)
        config.setup_registry(default_permission='view')
        config.commit()
        self.assertEqual(reg.getUtility(IDefaultPermission), 'view')

    def test_setup_registry_no_default_root_factory(self):
        from pyramid.registry import Registry
        from pyramid.interfaces import IRootFactory

        reg = Registry()
        config = self._makeOne(reg)
        config.setup_registry()
        config.commit()
        self.assertEqual(reg.queryUtility(IRootFactory), None)

    def test_setup_registry_debug_logger_name(self):
        from pyramid.registry import Registry
        from pyramid.interfaces import IDebugLogger

        reg = Registry()
        config = self._makeOne(reg)
        config.setup_registry(debug_logger='foo')
        result = reg.getUtility(IDebugLogger)
        self.assertEqual(result.name, 'foo')