summaryrefslogtreecommitdiff
path: root/tests/test_scripts
diff options
context:
space:
mode:
Diffstat (limited to 'tests/test_scripts')
-rw-r--r--tests/test_scripts/__init__.py1
-rw-r--r--tests/test_scripts/dummy.py220
-rw-r--r--tests/test_scripts/pystartup.txt3
-rw-r--r--tests/test_scripts/test_common.py16
-rw-r--r--tests/test_scripts/test_pdistreport.py84
-rw-r--r--tests/test_scripts/test_prequest.py258
-rw-r--r--tests/test_scripts/test_proutes.py823
-rw-r--r--tests/test_scripts/test_pserve.py139
-rw-r--r--tests/test_scripts/test_pshell.py431
-rw-r--r--tests/test_scripts/test_ptweens.py69
-rw-r--r--tests/test_scripts/test_pviews.py597
11 files changed, 2641 insertions, 0 deletions
diff --git a/tests/test_scripts/__init__.py b/tests/test_scripts/__init__.py
new file mode 100644
index 000000000..5bb534f79
--- /dev/null
+++ b/tests/test_scripts/__init__.py
@@ -0,0 +1 @@
+# package
diff --git a/tests/test_scripts/dummy.py b/tests/test_scripts/dummy.py
new file mode 100644
index 000000000..8e340f645
--- /dev/null
+++ b/tests/test_scripts/dummy.py
@@ -0,0 +1,220 @@
+from zope.interface import implementer
+from pyramid.interfaces import IMultiView
+
+
+class DummyTweens(object):
+ def __init__(self, implicit, explicit):
+ self._implicit = implicit
+ self.explicit = explicit
+ self.name_to_alias = {}
+
+ def implicit(self):
+ return self._implicit
+
+
+class Dummy:
+ pass
+
+
+dummy_root = Dummy()
+
+
+class DummyRegistry(object):
+ settings = {}
+
+ def queryUtility(self, iface, default=None, name=''):
+ return default
+
+
+dummy_registry = DummyRegistry()
+
+
+class DummyShell(object):
+ env = {}
+ help = ''
+ called = False
+ dummy_attr = 1
+
+ def __call__(self, env, help):
+ self.env = env
+ self.help = help
+ self.called = True
+ self.env['request'].dummy_attr = self.dummy_attr
+
+
+class DummyInteractor:
+ def __call__(self, banner, local):
+ self.banner = banner
+ self.local = local
+
+
+class DummyApp:
+ def __init__(self):
+ self.registry = dummy_registry
+
+
+class DummyMapper(object):
+ def __init__(self, *routes):
+ self.routes = routes
+
+ def get_routes(self, include_static=False):
+ return self.routes
+
+
+class DummyRoute(object):
+ def __init__(
+ self, name, pattern, factory=None, matchdict=None, predicate=None
+ ):
+ self.name = name
+ self.path = pattern
+ self.pattern = pattern
+ self.factory = factory
+ self.matchdict = matchdict
+ self.predicates = []
+ if predicate is not None:
+ self.predicates = [predicate]
+
+ def match(self, route):
+ return self.matchdict
+
+
+class DummyRequest:
+ application_url = 'http://example.com:5432'
+ script_name = ''
+
+ def __init__(self, environ):
+ self.environ = environ
+ self.matchdict = {}
+
+
+class DummyView(object):
+ def __init__(self, **attrs):
+ self.__request_attrs__ = attrs
+
+ def view(context, request): # pragma: no cover
+ pass
+
+
+@implementer(IMultiView)
+class DummyMultiView(object):
+ def __init__(self, *views, **attrs):
+ self.views = [(None, view, None) for view in views]
+ self.__request_attrs__ = attrs
+
+
+class DummyCloser(object):
+ def __call__(self):
+ self.called = True
+
+
+class DummyBootstrap(object):
+ def __init__(
+ self,
+ app=None,
+ registry=None,
+ request=None,
+ root=None,
+ root_factory=None,
+ closer=None,
+ ):
+ self.app = app or DummyApp()
+ if registry is None:
+ registry = DummyRegistry()
+ self.registry = registry
+ if request is None:
+ request = DummyRequest({})
+ self.request = request
+ if root is None:
+ root = Dummy()
+ self.root = root
+ if root_factory is None:
+ root_factory = Dummy()
+ self.root_factory = root_factory
+ if closer is None:
+ closer = DummyCloser()
+ self.closer = closer
+
+ def __call__(self, *a, **kw):
+ self.a = a
+ self.kw = kw
+ registry = kw.get('registry', self.registry)
+ request = kw.get('request', self.request)
+ request.registry = registry
+ return {
+ 'app': self.app,
+ 'registry': registry,
+ 'request': request,
+ 'root': self.root,
+ 'root_factory': self.root_factory,
+ 'closer': self.closer,
+ }
+
+
+class DummyEntryPoint(object):
+ def __init__(self, name, module):
+ self.name = name
+ self.module = module
+
+ def load(self):
+ return self.module
+
+
+class DummyPkgResources(object):
+ def __init__(self, entry_point_values):
+ self.entry_points = []
+
+ for name, module in entry_point_values.items():
+ self.entry_points.append(DummyEntryPoint(name, module))
+
+ def iter_entry_points(self, name):
+ return self.entry_points
+
+
+class dummy_setup_logging(object):
+ def __call__(self, config_uri, global_conf):
+ self.config_uri = config_uri
+ self.defaults = global_conf
+
+
+class DummyLoader(object):
+ def __init__(
+ self, settings=None, app_settings=None, app=None, server=None
+ ):
+ if not settings:
+ settings = {}
+ if not app_settings:
+ app_settings = {}
+ self.settings = settings
+ self.app_settings = app_settings
+ self.app = app
+ self.server = server
+ self.calls = []
+
+ def __call__(self, uri):
+ import plaster
+
+ self.uri = plaster.parse_uri(uri)
+ return self
+
+ def add_call(self, op, name, defaults):
+ self.calls.append({'op': op, 'name': name, 'defaults': defaults})
+
+ def get_settings(self, name=None, defaults=None):
+ self.add_call('settings', name, defaults)
+ return self.settings.get(name, {})
+
+ def get_wsgi_app(self, name=None, defaults=None):
+ self.add_call('app', name, defaults)
+ return self.app
+
+ def get_wsgi_app_settings(self, name=None, defaults=None):
+ self.add_call('app_settings', name, defaults)
+ return self.app_settings
+
+ def get_wsgi_server(self, name=None, defaults=None):
+ self.add_call('server', name, defaults)
+ return self.server
+
+ def setup_logging(self, defaults):
+ self.add_call('logging', None, defaults)
+ self.defaults = defaults
diff --git a/tests/test_scripts/pystartup.txt b/tests/test_scripts/pystartup.txt
new file mode 100644
index 000000000..c62c4ca74
--- /dev/null
+++ b/tests/test_scripts/pystartup.txt
@@ -0,0 +1,3 @@
+# this file has a .txt extension to avoid coverage reports
+# since it is not imported but rather the contents are read and exec'd
+foo = 1
diff --git a/tests/test_scripts/test_common.py b/tests/test_scripts/test_common.py
new file mode 100644
index 000000000..e286d3c3e
--- /dev/null
+++ b/tests/test_scripts/test_common.py
@@ -0,0 +1,16 @@
+import unittest
+
+
+class TestParseVars(unittest.TestCase):
+ def test_parse_vars_good(self):
+ from pyramid.scripts.common import parse_vars
+
+ vars = ['a=1', 'b=2']
+ result = parse_vars(vars)
+ self.assertEqual(result, {'a': '1', 'b': '2'})
+
+ def test_parse_vars_bad(self):
+ from pyramid.scripts.common import parse_vars
+
+ vars = ['a']
+ self.assertRaises(ValueError, parse_vars, vars)
diff --git a/tests/test_scripts/test_pdistreport.py b/tests/test_scripts/test_pdistreport.py
new file mode 100644
index 000000000..031a6ff2b
--- /dev/null
+++ b/tests/test_scripts/test_pdistreport.py
@@ -0,0 +1,84 @@
+import unittest
+
+
+class TestPDistReportCommand(unittest.TestCase):
+ def _callFUT(self, **kw):
+ argv = []
+ from pyramid.scripts.pdistreport import main
+
+ return main(argv, **kw)
+
+ def test_no_dists(self):
+ def platform():
+ return 'myplatform'
+
+ pkg_resources = DummyPkgResources()
+ L = []
+
+ def out(*args):
+ L.extend(args)
+
+ result = self._callFUT(
+ pkg_resources=pkg_resources, platform=platform, out=out
+ )
+ self.assertEqual(result, None)
+ self.assertEqual(
+ L,
+ ['Pyramid version:', '1', 'Platform:', 'myplatform', 'Packages:'],
+ )
+
+ def test_with_dists(self):
+ def platform():
+ return 'myplatform'
+
+ working_set = (DummyDistribution('abc'), DummyDistribution('def'))
+ pkg_resources = DummyPkgResources(working_set)
+ L = []
+
+ def out(*args):
+ L.extend(args)
+
+ result = self._callFUT(
+ pkg_resources=pkg_resources, platform=platform, out=out
+ )
+ self.assertEqual(result, None)
+ self.assertEqual(
+ L,
+ [
+ 'Pyramid version:',
+ '1',
+ 'Platform:',
+ 'myplatform',
+ 'Packages:',
+ ' ',
+ 'abc',
+ '1',
+ ' ',
+ '/projects/abc',
+ ' ',
+ 'def',
+ '1',
+ ' ',
+ '/projects/def',
+ ],
+ )
+
+
+class DummyPkgResources(object):
+ def __init__(self, working_set=()):
+ self.working_set = working_set
+
+ def get_distribution(self, name):
+ return Version('1')
+
+
+class Version(object):
+ def __init__(self, version):
+ self.version = version
+
+
+class DummyDistribution(object):
+ def __init__(self, name):
+ self.project_name = name
+ self.version = '1'
+ self.location = '/projects/%s' % name
diff --git a/tests/test_scripts/test_prequest.py b/tests/test_scripts/test_prequest.py
new file mode 100644
index 000000000..1521172bc
--- /dev/null
+++ b/tests/test_scripts/test_prequest.py
@@ -0,0 +1,258 @@
+import unittest
+from . import dummy
+
+
+class TestPRequestCommand(unittest.TestCase):
+ def _getTargetClass(self):
+ from pyramid.scripts.prequest import PRequestCommand
+
+ return PRequestCommand
+
+ def _makeOne(self, argv, headers=None):
+ cmd = self._getTargetClass()(argv)
+
+ def helloworld(environ, start_request):
+ self._environ = environ
+ self._path_info = environ['PATH_INFO']
+ start_request('200 OK', headers or [])
+ return [b'abc']
+
+ self.loader = dummy.DummyLoader(app=helloworld)
+ self._out = []
+ cmd._get_config_loader = self.loader
+ cmd.out = self.out
+ return cmd
+
+ def out(self, msg):
+ self._out.append(msg)
+
+ def test_command_not_enough_args(self):
+ command = self._makeOne([])
+ command.run()
+ self.assertEqual(
+ self._out, ['You must provide at least two arguments']
+ )
+
+ def test_command_two_args(self):
+ command = self._makeOne(
+ ['', 'development.ini', '/'],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ command.run()
+ self.assertEqual(self._path_info, '/')
+ self.assertEqual(self.loader.uri.path, 'development.ini')
+ self.assertEqual(self.loader.calls[0]['op'], 'logging')
+ self.assertEqual(self.loader.calls[1]['op'], 'app')
+ self.assertEqual(self.loader.calls[1]['name'], None)
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_path_doesnt_start_with_slash(self):
+ command = self._makeOne(
+ ['', 'development.ini', 'abc'],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ command.run()
+ self.assertEqual(self._path_info, '/abc')
+ self.assertEqual(self.loader.uri.path, 'development.ini')
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_has_bad_config_header(self):
+ command = self._makeOne(['', '--header=name', 'development.ini', '/'])
+ command.run()
+ self.assertEqual(
+ self._out[0],
+ (
+ "Bad --header=name option, value must be in the form "
+ "'name:value'"
+ ),
+ )
+
+ def test_command_has_good_header_var(self):
+ command = self._makeOne(
+ ['', '--header=name:value', 'development.ini', '/'],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ command.run()
+ self.assertEqual(self._environ['HTTP_NAME'], 'value')
+ self.assertEqual(self._path_info, '/')
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_w_basic_auth(self):
+ command = self._makeOne(
+ [
+ '',
+ '--login=user:password',
+ '--header=name:value',
+ 'development.ini',
+ '/',
+ ],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ command.run()
+ self.assertEqual(self._environ['HTTP_NAME'], 'value')
+ self.assertEqual(
+ self._environ['HTTP_AUTHORIZATION'], 'Basic dXNlcjpwYXNzd29yZA=='
+ )
+ self.assertEqual(self._path_info, '/')
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_has_content_type_header_var(self):
+ command = self._makeOne(
+ ['', '--header=content-type:app/foo', 'development.ini', '/'],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ command.run()
+ self.assertEqual(self._environ['CONTENT_TYPE'], 'app/foo')
+ self.assertEqual(self._path_info, '/')
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_has_multiple_header_vars(self):
+ command = self._makeOne(
+ [
+ '',
+ '--header=name:value',
+ '--header=name2:value2',
+ 'development.ini',
+ '/',
+ ],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ command.run()
+ self.assertEqual(self._environ['HTTP_NAME'], 'value')
+ self.assertEqual(self._environ['HTTP_NAME2'], 'value2')
+ self.assertEqual(self._path_info, '/')
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_method_get(self):
+ command = self._makeOne(
+ ['', '--method=GET', 'development.ini', '/'],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ command.run()
+ self.assertEqual(self._environ['REQUEST_METHOD'], 'GET')
+ self.assertEqual(self._path_info, '/')
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_method_post(self):
+ from pyramid.compat import NativeIO
+
+ command = self._makeOne(
+ ['', '--method=POST', 'development.ini', '/'],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ stdin = NativeIO()
+ command.stdin = stdin
+ command.run()
+ self.assertEqual(self._environ['REQUEST_METHOD'], 'POST')
+ self.assertEqual(self._environ['CONTENT_LENGTH'], '-1')
+ self.assertEqual(self._environ['wsgi.input'], stdin)
+ self.assertEqual(self._path_info, '/')
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_method_put(self):
+ from pyramid.compat import NativeIO
+
+ command = self._makeOne(
+ ['', '--method=PUT', 'development.ini', '/'],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ stdin = NativeIO()
+ command.stdin = stdin
+ command.run()
+ self.assertEqual(self._environ['REQUEST_METHOD'], 'PUT')
+ self.assertEqual(self._environ['CONTENT_LENGTH'], '-1')
+ self.assertEqual(self._environ['wsgi.input'], stdin)
+ self.assertEqual(self._path_info, '/')
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_method_patch(self):
+ from pyramid.compat import NativeIO
+
+ command = self._makeOne(
+ ['', '--method=PATCH', 'development.ini', '/'],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ stdin = NativeIO()
+ command.stdin = stdin
+ command.run()
+ self.assertEqual(self._environ['REQUEST_METHOD'], 'PATCH')
+ self.assertEqual(self._environ['CONTENT_LENGTH'], '-1')
+ self.assertEqual(self._environ['wsgi.input'], stdin)
+ self.assertEqual(self._path_info, '/')
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_method_propfind(self):
+ from pyramid.compat import NativeIO
+
+ command = self._makeOne(
+ ['', '--method=PROPFIND', 'development.ini', '/'],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ stdin = NativeIO()
+ command.stdin = stdin
+ command.run()
+ self.assertEqual(self._environ['REQUEST_METHOD'], 'PROPFIND')
+ self.assertEqual(self._path_info, '/')
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_method_options(self):
+ from pyramid.compat import NativeIO
+
+ command = self._makeOne(
+ ['', '--method=OPTIONS', 'development.ini', '/'],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ stdin = NativeIO()
+ command.stdin = stdin
+ command.run()
+ self.assertEqual(self._environ['REQUEST_METHOD'], 'OPTIONS')
+ self.assertEqual(self._path_info, '/')
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_with_query_string(self):
+ command = self._makeOne(
+ ['', 'development.ini', '/abc?a=1&b=2&c'],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ command.run()
+ self.assertEqual(self._environ['QUERY_STRING'], 'a=1&b=2&c')
+ self.assertEqual(self._path_info, '/abc')
+ self.assertEqual(self._out, ['abc'])
+
+ def test_command_display_headers(self):
+ command = self._makeOne(
+ ['', '--display-headers', 'development.ini', '/'],
+ [('Content-Type', 'text/html; charset=UTF-8')],
+ )
+ command.run()
+ self.assertEqual(self._path_info, '/')
+ self.assertEqual(
+ self._out,
+ ['200 OK', 'Content-Type: text/html; charset=UTF-8', 'abc'],
+ )
+
+ def test_command_response_has_no_charset(self):
+ command = self._makeOne(
+ ['', '--method=GET', 'development.ini', '/'],
+ headers=[('Content-Type', 'image/jpeg')],
+ )
+ command.run()
+ self.assertEqual(self._path_info, '/')
+
+ self.assertEqual(self._out, [b'abc'])
+
+ def test_command_method_configures_logging(self):
+ command = self._makeOne(['', 'development.ini', '/'])
+ command.run()
+ self.assertEqual(self.loader.calls[0]['op'], 'logging')
+
+
+class Test_main(unittest.TestCase):
+ def _callFUT(self, argv):
+ from pyramid.scripts.prequest import main
+
+ return main(argv, True)
+
+ def test_it(self):
+ result = self._callFUT(['prequest'])
+ self.assertEqual(result, 2)
diff --git a/tests/test_scripts/test_proutes.py b/tests/test_scripts/test_proutes.py
new file mode 100644
index 000000000..5e3f359f6
--- /dev/null
+++ b/tests/test_scripts/test_proutes.py
@@ -0,0 +1,823 @@
+import os
+import unittest
+from . import dummy
+
+
+class DummyIntrospector(object):
+ def __init__(self):
+ self.relations = {}
+ self.introspectables = {}
+
+ def get(self, name, discrim):
+ pass
+
+
+class TestPRoutesCommand(unittest.TestCase):
+ def _getTargetClass(self):
+ from pyramid.scripts.proutes import PRoutesCommand
+
+ return PRoutesCommand
+
+ def _makeOne(self):
+ cmd = self._getTargetClass()([])
+ cmd.bootstrap = dummy.DummyBootstrap()
+ cmd.get_config_loader = dummy.DummyLoader()
+ cmd.args.config_uri = '/foo/bar/myapp.ini#myapp'
+
+ return cmd
+
+ def _makeRegistry(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ registry.introspector = DummyIntrospector()
+ return registry
+
+ def _makeConfig(self, *arg, **kw):
+ from pyramid.config import Configurator
+
+ config = Configurator(*arg, **kw)
+ return config
+
+ def test_good_args(self):
+ cmd = self._getTargetClass()([])
+ cmd.bootstrap = dummy.DummyBootstrap()
+ cmd.get_config_loader = dummy.DummyLoader()
+ cmd.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ cmd.args.config_args = ('a=1',)
+ route = dummy.DummyRoute('a', '/a')
+ mapper = dummy.DummyMapper(route)
+ cmd._get_mapper = lambda *arg: mapper
+ registry = self._makeRegistry()
+ cmd.bootstrap = dummy.DummyBootstrap(registry=registry)
+ L = []
+ cmd.out = lambda msg: L.append(msg)
+ cmd.run()
+ self.assertTrue('<unknown>' in ''.join(L))
+
+ def test_bad_args(self):
+ cmd = self._getTargetClass()([])
+ cmd.bootstrap = dummy.DummyBootstrap()
+ cmd.get_config_loader = dummy.DummyLoader()
+ cmd.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ cmd.args.config_vars = ('a',)
+ route = dummy.DummyRoute('a', '/a')
+ mapper = dummy.DummyMapper(route)
+ cmd._get_mapper = lambda *arg: mapper
+
+ self.assertRaises(ValueError, cmd.run)
+
+ def test_no_routes(self):
+ command = self._makeOne()
+ mapper = dummy.DummyMapper()
+ command._get_mapper = lambda *arg: mapper
+ L = []
+ command.out = L.append
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L, [])
+
+ def test_no_mapper(self):
+ command = self._makeOne()
+ command._get_mapper = lambda *arg: None
+ L = []
+ command.out = L.append
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L, [])
+
+ def test_single_route_no_route_registered(self):
+ command = self._makeOne()
+ route = dummy.DummyRoute('a', '/a')
+ mapper = dummy.DummyMapper(route)
+ command._get_mapper = lambda *arg: mapper
+ registry = self._makeRegistry()
+ command.bootstrap = dummy.DummyBootstrap(registry=registry)
+
+ L = []
+ command.out = L.append
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ self.assertEqual(L[-1].split(), ['a', '/a', '<unknown>', '*'])
+
+ def test_route_with_no_slash_prefix(self):
+ command = self._makeOne()
+ route = dummy.DummyRoute('a', 'a')
+ mapper = dummy.DummyMapper(route)
+ command._get_mapper = lambda *arg: mapper
+ L = []
+ command.out = L.append
+ registry = self._makeRegistry()
+ command.bootstrap = dummy.DummyBootstrap(registry=registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ self.assertEqual(L[-1].split(), ['a', '/a', '<unknown>', '*'])
+
+ def test_single_route_no_views_registered(self):
+ from zope.interface import Interface
+ from pyramid.interfaces import IRouteRequest
+
+ registry = self._makeRegistry()
+
+ def view(): # pragma: no cover
+ pass
+
+ class IMyRoute(Interface):
+ pass
+
+ 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)
+ self.assertEqual(L[-1].split()[:3], ['a', '/a', '<unknown>'])
+
+ def test_single_route_one_view_registered(self):
+ from zope.interface import Interface
+ from pyramid.interfaces import IRouteRequest
+ from pyramid.interfaces import IViewClassifier
+ from pyramid.interfaces import IView
+
+ registry = self._makeRegistry()
+
+ def view(): # pragma: no cover
+ 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', 'tests.test_scripts.test_proutes.view']
+ )
+
+ def test_one_route_with_long_name_one_view_registered(self):
+ from zope.interface import Interface
+ from pyramid.interfaces import IRouteRequest
+ from pyramid.interfaces import IViewClassifier
+ from pyramid.interfaces import IView
+
+ registry = self._makeRegistry()
+
+ def view(): # pragma: no cover
+ pass
+
+ class IMyRoute(Interface):
+ pass
+
+ registry.registerAdapter(
+ view, (IViewClassifier, IMyRoute, Interface), IView, ''
+ )
+
+ registry.registerUtility(
+ IMyRoute, IRouteRequest, name='very_long_name_123'
+ )
+
+ command = self._makeOne()
+ route = dummy.DummyRoute(
+ 'very_long_name_123', '/and_very_long_pattern_as_well'
+ )
+ 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,
+ [
+ 'very_long_name_123',
+ '/and_very_long_pattern_as_well',
+ 'tests.test_scripts.test_proutes.view',
+ ],
+ )
+
+ def test_class_view(self):
+ from pyramid.renderers import null_renderer as nr
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b')
+ config.add_view(
+ route_name='foo',
+ view=dummy.DummyView,
+ attr='view',
+ renderer=nr,
+ request_method='POST',
+ )
+
+ command = self._makeOne()
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = [
+ 'foo',
+ '/a/b',
+ 'tests.test_scripts.dummy.DummyView.view',
+ 'POST',
+ ]
+ self.assertEqual(compare_to, expected)
+
+ def test_single_route_one_view_registered_with_factory(self):
+ from zope.interface import Interface
+ from pyramid.interfaces import IRouteRequest
+ from pyramid.interfaces import IViewClassifier
+ from pyramid.interfaces import IView
+
+ registry = self._makeRegistry()
+
+ def view(): # pragma: no cover
+ 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): # pragma: no cover
+ 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, 0)
+ self.assertEqual(len(L), 3)
+ self.assertEqual(L[-1].split()[:3], ['a', '/a', '<unknown>'])
+
+ def test_single_route_multiview_registered(self):
+ from zope.interface import Interface
+ from pyramid.interfaces import IRouteRequest
+ from pyramid.interfaces import IViewClassifier
+ from pyramid.interfaces import IMultiView
+
+ registry = self._makeRegistry()
+
+ def view(): # pragma: no cover
+ pass
+
+ class IMyRoute(Interface):
+ pass
+
+ multiview1 = dummy.DummyMultiView(
+ view, context='context', view_name='a1'
+ )
+
+ registry.registerAdapter(
+ multiview1, (IViewClassifier, IMyRoute, Interface), IMultiView, ''
+ )
+ 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]
+ view_module = 'tests.test_scripts.dummy'
+ view_str = '<tests.test_scripts.dummy.DummyMultiView'
+ final = '%s.%s' % (view_module, view_str)
+
+ self.assertEqual(compare_to, ['a', '/a', final])
+
+ def test__get_mapper(self):
+ from pyramid.urldispatch import RoutesMapper
+
+ command = self._makeOne()
+ registry = self._makeRegistry()
+
+ result = command._get_mapper(registry)
+ self.assertEqual(result.__class__, RoutesMapper)
+
+ def test_one_route_all_methods_view_only_post(self):
+ from pyramid.renderers import null_renderer as nr
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b')
+ config.add_view(
+ route_name='foo', view=view1, renderer=nr, request_method='POST'
+ )
+
+ command = self._makeOne()
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = [
+ 'foo',
+ '/a/b',
+ 'tests.test_scripts.test_proutes.view1',
+ 'POST',
+ ]
+ self.assertEqual(compare_to, expected)
+
+ def test_one_route_only_post_view_all_methods(self):
+ from pyramid.renderers import null_renderer as nr
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b', request_method='POST')
+ config.add_view(route_name='foo', view=view1, renderer=nr)
+
+ command = self._makeOne()
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = [
+ 'foo',
+ '/a/b',
+ 'tests.test_scripts.test_proutes.view1',
+ 'POST',
+ ]
+ self.assertEqual(compare_to, expected)
+
+ def test_one_route_only_post_view_post_and_get(self):
+ from pyramid.renderers import null_renderer as nr
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b', request_method='POST')
+ config.add_view(
+ route_name='foo',
+ view=view1,
+ renderer=nr,
+ request_method=('POST', 'GET'),
+ )
+
+ command = self._makeOne()
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = [
+ 'foo',
+ '/a/b',
+ 'tests.test_scripts.test_proutes.view1',
+ 'POST',
+ ]
+ self.assertEqual(compare_to, expected)
+
+ def test_route_request_method_mismatch(self):
+ from pyramid.renderers import null_renderer as nr
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b', request_method='POST')
+ config.add_view(
+ route_name='foo', view=view1, renderer=nr, request_method='GET'
+ )
+
+ command = self._makeOne()
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = [
+ 'foo',
+ '/a/b',
+ 'tests.test_scripts.test_proutes.view1',
+ '<route',
+ 'mismatch>',
+ ]
+ self.assertEqual(compare_to, expected)
+
+ def test_route_static_views(self):
+ config = self._makeConfig(autocommit=True)
+ config.add_static_view('static', 'static', cache_max_age=3600)
+ path2 = os.path.normpath('/var/www/static')
+ config.add_static_view(name='static2', path=path2)
+ config.add_static_view(
+ name='pyramid_scaffold',
+ path='pyramid:scaffolds/starter/+package+/static',
+ )
+
+ command = self._makeOne()
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 5)
+
+ expected = [
+ [
+ '__static/',
+ '/static/*subpath',
+ 'tests.test_scripts:static/',
+ '*',
+ ],
+ ['__static2/', '/static2/*subpath', path2 + os.sep, '*'],
+ [
+ '__pyramid_scaffold/',
+ '/pyramid_scaffold/*subpath',
+ 'pyramid:scaffolds/starter/+package+/static/',
+ '*',
+ ],
+ ]
+
+ for index, line in enumerate(L[2:]):
+ data = line.split()
+ self.assertEqual(data, expected[index])
+
+ def test_route_no_view(self):
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b', request_method='POST')
+
+ command = self._makeOne()
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = ['foo', '/a/b', '<unknown>', 'POST']
+ self.assertEqual(compare_to, expected)
+
+ def test_route_as_wsgiapp(self):
+ from pyramid.wsgi import wsgiapp2
+
+ config1 = self._makeConfig(autocommit=True)
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ config1.add_route('foo', '/a/b', request_method='POST')
+ config1.add_view(view=view1, route_name='foo')
+
+ config2 = self._makeConfig(autocommit=True)
+ config2.add_route('foo', '/a/b', request_method='POST')
+ config2.add_view(wsgiapp2(config1.make_wsgi_app()), route_name='foo')
+
+ command = self._makeOne()
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config2.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = ['foo', '/a/b', '<wsgiapp>', 'POST']
+ self.assertEqual(compare_to, expected)
+
+ def test_route_is_get_view_request_method_not_post(self):
+ from pyramid.renderers import null_renderer as nr
+ from pyramid.config import not_
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b', request_method='GET')
+ config.add_view(
+ route_name='foo',
+ view=view1,
+ renderer=nr,
+ request_method=not_('POST'),
+ )
+
+ command = self._makeOne()
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = [
+ 'foo',
+ '/a/b',
+ 'tests.test_scripts.test_proutes.view1',
+ 'GET',
+ ]
+ self.assertEqual(compare_to, expected)
+
+ def test_view_request_method_not_post(self):
+ from pyramid.renderers import null_renderer as nr
+ from pyramid.config import not_
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b')
+ config.add_view(
+ route_name='foo',
+ view=view1,
+ renderer=nr,
+ request_method=not_('POST'),
+ )
+
+ command = self._makeOne()
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = [
+ 'foo',
+ '/a/b',
+ 'tests.test_scripts.test_proutes.view1',
+ '!POST,*',
+ ]
+ self.assertEqual(compare_to, expected)
+
+ def test_view_glob(self):
+ from pyramid.renderers import null_renderer as nr
+ from pyramid.config import not_
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ def view2(context, request): # pragma: no cover
+ return 'view2'
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b')
+ config.add_view(
+ route_name='foo',
+ view=view1,
+ renderer=nr,
+ request_method=not_('POST'),
+ )
+
+ config.add_route('bar', '/b/a')
+ config.add_view(
+ route_name='bar',
+ view=view2,
+ renderer=nr,
+ request_method=not_('POST'),
+ )
+
+ command = self._makeOne()
+ command.args.glob = '*foo*'
+
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = [
+ 'foo',
+ '/a/b',
+ 'tests.test_scripts.test_proutes.view1',
+ '!POST,*',
+ ]
+ self.assertEqual(compare_to, expected)
+
+ def test_good_format(self):
+ from pyramid.renderers import null_renderer as nr
+ from pyramid.config import not_
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b')
+ config.add_view(
+ route_name='foo',
+ view=view1,
+ renderer=nr,
+ request_method=not_('POST'),
+ )
+
+ command = self._makeOne()
+ command.args.glob = '*foo*'
+ command.args.format = 'method,name'
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = ['!POST,*', 'foo']
+
+ self.assertEqual(compare_to, expected)
+ self.assertEqual(L[0].split(), ['Method', 'Name'])
+
+ def test_bad_format(self):
+ from pyramid.renderers import null_renderer as nr
+ from pyramid.config import not_
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b')
+ config.add_view(
+ route_name='foo',
+ view=view1,
+ renderer=nr,
+ request_method=not_('POST'),
+ )
+
+ command = self._makeOne()
+ command.args.glob = '*foo*'
+ command.args.format = 'predicates,name,pattern'
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ expected = (
+ "You provided invalid formats ['predicates'], "
+ "Available formats are ['name', 'pattern', 'view', 'method']"
+ )
+ result = command.run()
+ self.assertEqual(result, 2)
+ self.assertEqual(L[0], expected)
+
+ def test_config_format_ini_newlines(self):
+ from pyramid.renderers import null_renderer as nr
+ from pyramid.config import not_
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b')
+ config.add_view(
+ route_name='foo',
+ view=view1,
+ renderer=nr,
+ request_method=not_('POST'),
+ )
+
+ command = self._makeOne()
+
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ command.get_config_loader = dummy.DummyLoader(
+ {'proutes': {'format': 'method\nname'}}
+ )
+
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = ['!POST,*', 'foo']
+
+ self.assertEqual(compare_to, expected)
+ self.assertEqual(L[0].split(), ['Method', 'Name'])
+
+ def test_config_format_ini_spaces(self):
+ from pyramid.renderers import null_renderer as nr
+ from pyramid.config import not_
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b')
+ config.add_view(
+ route_name='foo',
+ view=view1,
+ renderer=nr,
+ request_method=not_('POST'),
+ )
+
+ command = self._makeOne()
+
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ command.get_config_loader = dummy.DummyLoader(
+ {'proutes': {'format': 'method name'}}
+ )
+
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = ['!POST,*', 'foo']
+
+ self.assertEqual(compare_to, expected)
+ self.assertEqual(L[0].split(), ['Method', 'Name'])
+
+ def test_config_format_ini_commas(self):
+ from pyramid.renderers import null_renderer as nr
+ from pyramid.config import not_
+
+ def view1(context, request): # pragma: no cover
+ return 'view1'
+
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', '/a/b')
+ config.add_view(
+ route_name='foo',
+ view=view1,
+ renderer=nr,
+ request_method=not_('POST'),
+ )
+
+ command = self._makeOne()
+
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ command.get_config_loader = dummy.DummyLoader(
+ {'proutes': {'format': 'method,name'}}
+ )
+
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = ['!POST,*', 'foo']
+
+ self.assertEqual(compare_to, expected)
+ self.assertEqual(L[0].split(), ['Method', 'Name'])
+
+ def test_static_routes_included_in_list(self):
+ config = self._makeConfig(autocommit=True)
+ config.add_route('foo', 'http://example.com/bar.aspx', static=True)
+
+ command = self._makeOne()
+ L = []
+ command.out = L.append
+ command.bootstrap = dummy.DummyBootstrap(registry=config.registry)
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(len(L), 3)
+ compare_to = L[-1].split()
+ expected = ['foo', 'http://example.com/bar.aspx', '<unknown>', '*']
+ self.assertEqual(compare_to, expected)
+
+
+class Test_main(unittest.TestCase):
+ def _callFUT(self, argv):
+ from pyramid.scripts.proutes import main
+
+ return main(argv, quiet=True)
+
+ def test_it(self):
+ result = self._callFUT(['proutes'])
+ self.assertEqual(result, 2)
diff --git a/tests/test_scripts/test_pserve.py b/tests/test_scripts/test_pserve.py
new file mode 100644
index 000000000..b85f4ddb7
--- /dev/null
+++ b/tests/test_scripts/test_pserve.py
@@ -0,0 +1,139 @@
+import os
+import unittest
+from . import dummy
+
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+
+class TestPServeCommand(unittest.TestCase):
+ def setUp(self):
+ from pyramid.compat import NativeIO
+
+ self.out_ = NativeIO()
+
+ def out(self, msg):
+ self.out_.write(msg)
+
+ def _getTargetClass(self):
+ from pyramid.scripts.pserve import PServeCommand
+
+ return PServeCommand
+
+ def _makeOne(self, *args):
+ effargs = ['pserve']
+ effargs.extend(args)
+ cmd = self._getTargetClass()(effargs)
+ cmd.out = self.out
+ self.loader = dummy.DummyLoader()
+ cmd._get_config_loader = self.loader
+ return cmd
+
+ def test_run_no_args(self):
+ inst = self._makeOne()
+ result = inst.run()
+ self.assertEqual(result, 2)
+ self.assertEqual(self.out_.getvalue(), 'You must give a config file')
+
+ def test_parse_vars_good(self):
+ inst = self._makeOne('development.ini', 'a=1', 'b=2')
+ app = dummy.DummyApp()
+
+ def get_app(name, global_conf):
+ app.name = name
+ app.global_conf = global_conf
+ return app
+
+ self.loader.get_wsgi_app = get_app
+ self.loader.server = lambda x: x
+
+ inst.run()
+ self.assertEqual(app.global_conf, {'a': '1', 'b': '2'})
+
+ def test_parse_vars_bad(self):
+ inst = self._makeOne('development.ini', 'a')
+ self.assertRaises(ValueError, inst.run)
+
+ def test_config_file_finds_watch_files(self):
+ inst = self._makeOne('development.ini')
+ loader = self.loader('/base/path.ini')
+ loader.settings = {
+ 'pserve': {'watch_files': 'foo\n/baz\ntests.test_scripts:*.py'}
+ }
+ inst.pserve_file_config(loader, global_conf={'a': '1'})
+ self.assertEqual(loader.calls[0]['defaults'], {'a': '1'})
+ self.assertEqual(
+ inst.watch_files,
+ set(
+ [
+ os.path.abspath('/base/foo'),
+ os.path.abspath('/baz'),
+ os.path.abspath(os.path.join(here, '*.py')),
+ ]
+ ),
+ )
+
+ def test_config_file_finds_open_url(self):
+ inst = self._makeOne('development.ini')
+ loader = self.loader('/base/path.ini')
+ loader.settings = {'pserve': {'open_url': 'http://127.0.0.1:8080/'}}
+ inst.pserve_file_config(loader, global_conf={'a': '1'})
+ self.assertEqual(loader.calls[0]['defaults'], {'a': '1'})
+ self.assertEqual(inst.open_url, 'http://127.0.0.1:8080/')
+
+ def test_guess_server_url(self):
+ inst = self._makeOne('development.ini')
+ loader = self.loader('/base/path.ini')
+ loader.settings = {'server:foo': {'port': '8080'}}
+ url = inst.guess_server_url(loader, 'foo', global_conf={'a': '1'})
+ self.assertEqual(loader.calls[0]['defaults'], {'a': '1'})
+ self.assertEqual(url, 'http://127.0.0.1:8080')
+
+ def test_reload_call_hupper_with_correct_args(self):
+ from pyramid.scripts import pserve
+
+ class AttrDict(dict):
+ def __init__(self, *args, **kwargs):
+ super(AttrDict, self).__init__(*args, **kwargs)
+ self.__dict__ = self
+
+ def dummy_start_reloader(*args, **kwargs):
+ dummy_start_reloader.args = args
+ dummy_start_reloader.kwargs = kwargs
+
+ orig_hupper = pserve.hupper
+ try:
+ pserve.hupper = AttrDict(
+ is_active=lambda: False, start_reloader=dummy_start_reloader
+ )
+
+ inst = self._makeOne('--reload', 'development.ini')
+ inst.run()
+ finally:
+ pserve.hupper = orig_hupper
+
+ self.assertEquals(
+ dummy_start_reloader.args, ('pyramid.scripts.pserve.main',)
+ )
+ self.assertEquals(
+ dummy_start_reloader.kwargs,
+ {
+ 'reload_interval': 1,
+ 'verbose': 1,
+ 'worker_kwargs': {
+ 'argv': ['pserve', '--reload', 'development.ini'],
+ 'quiet': False,
+ },
+ },
+ )
+
+
+class Test_main(unittest.TestCase):
+ def _callFUT(self, argv):
+ from pyramid.scripts.pserve import main
+
+ return main(argv, quiet=True)
+
+ def test_it(self):
+ result = self._callFUT(['pserve'])
+ self.assertEqual(result, 2)
diff --git a/tests/test_scripts/test_pshell.py b/tests/test_scripts/test_pshell.py
new file mode 100644
index 000000000..6beaacda6
--- /dev/null
+++ b/tests/test_scripts/test_pshell.py
@@ -0,0 +1,431 @@
+import os
+import unittest
+from . import dummy
+
+
+class TestPShellCommand(unittest.TestCase):
+ def _getTargetClass(self):
+ from pyramid.scripts.pshell import PShellCommand
+
+ return PShellCommand
+
+ def _makeOne(
+ self,
+ patch_bootstrap=True,
+ patch_loader=True,
+ patch_args=True,
+ patch_options=True,
+ ):
+ cmd = self._getTargetClass()([])
+
+ if patch_bootstrap:
+ self.bootstrap = dummy.DummyBootstrap()
+ cmd.bootstrap = self.bootstrap
+ if patch_loader:
+ self.loader = dummy.DummyLoader()
+ cmd.get_config_loader = self.loader
+ if patch_args:
+
+ class Args(object):
+ pass
+
+ self.args = Args()
+ self.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ cmd.args.config_uri = self.args.config_uri
+ if patch_options:
+
+ class Options(object):
+ pass
+
+ self.options = Options()
+ self.options.python_shell = ''
+ self.options.setup = None
+ self.options.list = None
+ cmd.options = self.options
+
+ # default to None to prevent side-effects from running tests in
+ # unknown environments
+ cmd.pystartup = None
+ return cmd
+
+ def _makeEntryPoints(self, command, shells):
+ command.pkg_resources = dummy.DummyPkgResources(shells)
+
+ def test_command_loads_default_shell(self):
+ command = self._makeOne()
+ shell = dummy.DummyShell()
+ self._makeEntryPoints(command, {})
+
+ command.default_runner = shell
+ command.run()
+ self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
+ self.assertEqual(
+ shell.env,
+ {
+ 'app': self.bootstrap.app,
+ 'root': self.bootstrap.root,
+ 'registry': self.bootstrap.registry,
+ 'request': self.bootstrap.request,
+ 'root_factory': self.bootstrap.root_factory,
+ },
+ )
+ self.assertTrue(self.bootstrap.closer.called)
+ self.assertTrue(shell.help)
+
+ def test_command_errors_with_unknown_shell(self):
+ command = self._makeOne()
+ out_calls = []
+
+ def out(msg):
+ out_calls.append(msg)
+
+ command.out = out
+
+ shell = dummy.DummyShell()
+
+ self._makeEntryPoints(command, {})
+
+ command.default_runner = shell
+ command.args.python_shell = 'unknown_python_shell'
+ result = command.run()
+ self.assertEqual(result, 1)
+ self.assertEqual(
+ out_calls, ['could not find a shell named "unknown_python_shell"']
+ )
+ self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
+ self.assertTrue(self.bootstrap.closer.called)
+
+ def test_command_loads_ipython(self):
+ command = self._makeOne()
+ shell = dummy.DummyShell()
+ bad_shell = dummy.DummyShell()
+ self._makeEntryPoints(
+ command, {'ipython': shell, 'bpython': bad_shell}
+ )
+
+ command.args.python_shell = 'ipython'
+
+ command.run()
+ self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
+ self.assertEqual(
+ shell.env,
+ {
+ 'app': self.bootstrap.app,
+ 'root': self.bootstrap.root,
+ 'registry': self.bootstrap.registry,
+ 'request': self.bootstrap.request,
+ 'root_factory': self.bootstrap.root_factory,
+ },
+ )
+ self.assertTrue(self.bootstrap.closer.called)
+ self.assertTrue(shell.help)
+
+ def test_shell_entry_points(self):
+ command = self._makeOne()
+ dshell = dummy.DummyShell()
+
+ self._makeEntryPoints(command, {'ipython': dshell, 'bpython': dshell})
+
+ command.default_runner = None
+ shell = command.make_shell()
+ self.assertEqual(shell, dshell)
+
+ def test_shell_override(self):
+ command = self._makeOne()
+ ipshell = dummy.DummyShell()
+ bpshell = dummy.DummyShell()
+ dshell = dummy.DummyShell()
+
+ self._makeEntryPoints(command, {})
+
+ command.default_runner = dshell
+
+ shell = command.make_shell()
+ self.assertEqual(shell, dshell)
+
+ command.args.python_shell = 'ipython'
+ self.assertRaises(ValueError, command.make_shell)
+
+ self._makeEntryPoints(
+ command, {'ipython': ipshell, 'bpython': bpshell, 'python': dshell}
+ )
+
+ command.args.python_shell = 'ipython'
+ shell = command.make_shell()
+ self.assertEqual(shell, ipshell)
+
+ command.args.python_shell = 'bpython'
+ shell = command.make_shell()
+ self.assertEqual(shell, bpshell)
+
+ command.args.python_shell = 'python'
+ shell = command.make_shell()
+ self.assertEqual(shell, dshell)
+
+ def test_shell_ordering(self):
+ command = self._makeOne()
+ ipshell = dummy.DummyShell()
+ bpshell = dummy.DummyShell()
+ dshell = dummy.DummyShell()
+
+ self._makeEntryPoints(
+ command, {'ipython': ipshell, 'bpython': bpshell, 'python': dshell}
+ )
+
+ command.default_runner = dshell
+
+ command.preferred_shells = ['ipython', 'bpython']
+ shell = command.make_shell()
+ self.assertEqual(shell, ipshell)
+
+ command.preferred_shells = ['bpython', 'python']
+ shell = command.make_shell()
+ self.assertEqual(shell, bpshell)
+
+ command.preferred_shells = ['python', 'ipython']
+ shell = command.make_shell()
+ self.assertEqual(shell, dshell)
+
+ def test_command_loads_custom_items(self):
+ command = self._makeOne()
+ model = dummy.Dummy()
+ user = dummy.Dummy()
+ self.loader.settings = {'pshell': {'m': model, 'User': user}}
+ shell = dummy.DummyShell()
+ command.run(shell)
+ self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
+ self.assertEqual(
+ shell.env,
+ {
+ 'app': self.bootstrap.app,
+ 'root': self.bootstrap.root,
+ 'registry': self.bootstrap.registry,
+ 'request': self.bootstrap.request,
+ 'root_factory': self.bootstrap.root_factory,
+ 'm': model,
+ 'User': user,
+ },
+ )
+ self.assertTrue(self.bootstrap.closer.called)
+ self.assertTrue(shell.help)
+
+ def test_command_setup(self):
+ command = self._makeOne()
+
+ def setup(env):
+ env['a'] = 1
+ env['root'] = 'root override'
+ env['none'] = None
+
+ self.loader.settings = {'pshell': {'setup': setup}}
+ shell = dummy.DummyShell()
+ command.run(shell)
+ self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
+ self.assertEqual(
+ shell.env,
+ {
+ 'app': self.bootstrap.app,
+ 'root': 'root override',
+ 'registry': self.bootstrap.registry,
+ 'request': self.bootstrap.request,
+ 'root_factory': self.bootstrap.root_factory,
+ 'a': 1,
+ 'none': None,
+ },
+ )
+ self.assertTrue(self.bootstrap.closer.called)
+ self.assertTrue(shell.help)
+
+ def test_command_setup_generator(self):
+ command = self._makeOne()
+ did_resume_after_yield = {}
+
+ def setup(env):
+ env['a'] = 1
+ env['root'] = 'root override'
+ env['none'] = None
+ request = env['request']
+ yield
+ did_resume_after_yield['result'] = True
+ self.assertEqual(request.dummy_attr, 1)
+
+ self.loader.settings = {'pshell': {'setup': setup}}
+ shell = dummy.DummyShell()
+ command.run(shell)
+ self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
+ self.assertEqual(
+ shell.env,
+ {
+ 'app': self.bootstrap.app,
+ 'root': 'root override',
+ 'registry': self.bootstrap.registry,
+ 'request': self.bootstrap.request,
+ 'root_factory': self.bootstrap.root_factory,
+ 'a': 1,
+ 'none': None,
+ },
+ )
+ self.assertTrue(did_resume_after_yield['result'])
+ self.assertTrue(self.bootstrap.closer.called)
+ self.assertTrue(shell.help)
+
+ def test_command_default_shell_option(self):
+ command = self._makeOne()
+ ipshell = dummy.DummyShell()
+ dshell = dummy.DummyShell()
+ self._makeEntryPoints(command, {'ipython': ipshell, 'python': dshell})
+ self.loader.settings = {
+ 'pshell': {'default_shell': 'bpython python\nipython'}
+ }
+ command.run()
+ self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
+ self.assertTrue(dshell.called)
+
+ def test_command_loads_check_variable_override_order(self):
+ command = self._makeOne()
+ model = dummy.Dummy()
+
+ def setup(env):
+ env['a'] = 1
+ env['m'] = 'model override'
+ env['root'] = 'root override'
+
+ self.loader.settings = {'pshell': {'setup': setup, 'm': model}}
+ shell = dummy.DummyShell()
+ command.run(shell)
+ self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
+ self.assertEqual(
+ shell.env,
+ {
+ 'app': self.bootstrap.app,
+ 'root': 'root override',
+ 'registry': self.bootstrap.registry,
+ 'request': self.bootstrap.request,
+ 'root_factory': self.bootstrap.root_factory,
+ 'a': 1,
+ 'm': 'model override',
+ },
+ )
+ self.assertTrue(self.bootstrap.closer.called)
+ self.assertTrue(shell.help)
+
+ def test_command_loads_setup_from_options(self):
+ command = self._makeOne()
+
+ def setup(env):
+ env['a'] = 1
+ env['root'] = 'root override'
+
+ model = dummy.Dummy()
+ self.loader.settings = {'pshell': {'setup': 'abc', 'm': model}}
+ command.args.setup = setup
+ shell = dummy.DummyShell()
+ command.run(shell)
+ self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
+ self.assertEqual(
+ shell.env,
+ {
+ 'app': self.bootstrap.app,
+ 'root': 'root override',
+ 'registry': self.bootstrap.registry,
+ 'request': self.bootstrap.request,
+ 'root_factory': self.bootstrap.root_factory,
+ 'a': 1,
+ 'm': model,
+ },
+ )
+ self.assertTrue(self.bootstrap.closer.called)
+ self.assertTrue(shell.help)
+
+ def test_command_custom_section_override(self):
+ command = self._makeOne()
+ dummy_ = dummy.Dummy()
+ self.loader.settings = {
+ 'pshell': {
+ 'app': dummy_,
+ 'root': dummy_,
+ 'registry': dummy_,
+ 'request': dummy_,
+ }
+ }
+ shell = dummy.DummyShell()
+ command.run(shell)
+ self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
+ self.assertEqual(
+ shell.env,
+ {
+ 'app': dummy_,
+ 'root': dummy_,
+ 'registry': dummy_,
+ 'request': dummy_,
+ 'root_factory': self.bootstrap.root_factory,
+ },
+ )
+ self.assertTrue(self.bootstrap.closer.called)
+ self.assertTrue(shell.help)
+
+ def test_command_loads_pythonstartup(self):
+ command = self._makeOne()
+ command.pystartup = os.path.abspath(
+ os.path.join(os.path.dirname(__file__), 'pystartup.txt')
+ )
+ shell = dummy.DummyShell()
+ command.run(shell)
+ self.assertEqual(self.bootstrap.a[0], '/foo/bar/myapp.ini#myapp')
+ self.assertEqual(
+ shell.env,
+ {
+ 'app': self.bootstrap.app,
+ 'root': self.bootstrap.root,
+ 'registry': self.bootstrap.registry,
+ 'request': self.bootstrap.request,
+ 'root_factory': self.bootstrap.root_factory,
+ 'foo': 1,
+ },
+ )
+ self.assertTrue(self.bootstrap.closer.called)
+ self.assertTrue(shell.help)
+
+ def test_list_shells(self):
+ command = self._makeOne()
+
+ dshell = dummy.DummyShell()
+ out_calls = []
+
+ def out(msg):
+ out_calls.append(msg)
+
+ command.out = out
+
+ self._makeEntryPoints(command, {'ipython': dshell, 'python': dshell})
+
+ command.args.list = True
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(
+ out_calls, ['Available shells:', ' ipython', ' python']
+ )
+
+
+class Test_python_shell_runner(unittest.TestCase):
+ def _callFUT(self, env, help, interact):
+ from pyramid.scripts.pshell import python_shell_runner
+
+ return python_shell_runner(env, help, interact=interact)
+
+ def test_it(self):
+ interact = dummy.DummyInteractor()
+ self._callFUT({'foo': 'bar'}, 'a help message', interact)
+ self.assertEqual(interact.local, {'foo': 'bar'})
+ self.assertTrue('a help message' in interact.banner)
+
+
+class Test_main(unittest.TestCase):
+ def _callFUT(self, argv):
+ from pyramid.scripts.pshell import main
+
+ return main(argv, quiet=True)
+
+ def test_it(self):
+ result = self._callFUT(['pshell'])
+ self.assertEqual(result, 2)
diff --git a/tests/test_scripts/test_ptweens.py b/tests/test_scripts/test_ptweens.py
new file mode 100644
index 000000000..ee50887f6
--- /dev/null
+++ b/tests/test_scripts/test_ptweens.py
@@ -0,0 +1,69 @@
+import unittest
+from . import dummy
+
+
+class TestPTweensCommand(unittest.TestCase):
+ def _getTargetClass(self):
+ from pyramid.scripts.ptweens import PTweensCommand
+
+ return PTweensCommand
+
+ def _makeOne(self):
+ cmd = self._getTargetClass()([])
+ cmd.bootstrap = dummy.DummyBootstrap()
+ cmd.setup_logging = dummy.dummy_setup_logging()
+ cmd.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ return cmd
+
+ def test_command_no_tweens(self):
+ command = self._makeOne()
+ command._get_tweens = lambda *arg: None
+ L = []
+ command.out = L.append
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L, [])
+
+ def test_command_implicit_tweens_only(self):
+ command = self._makeOne()
+ tweens = dummy.DummyTweens([('name', 'item')], None)
+ command._get_tweens = lambda *arg: tweens
+ L = []
+ command.out = L.append
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(
+ L[0],
+ '"pyramid.tweens" config value NOT set (implicitly ordered tweens '
+ 'used)',
+ )
+
+ def test_command_implicit_and_explicit_tweens(self):
+ command = self._makeOne()
+ tweens = dummy.DummyTweens([('name', 'item')], [('name2', 'item2')])
+ command._get_tweens = lambda *arg: tweens
+ L = []
+ command.out = L.append
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(
+ L[0],
+ '"pyramid.tweens" config value set (explicitly ordered tweens '
+ 'used)',
+ )
+
+ def test__get_tweens(self):
+ command = self._makeOne()
+ registry = dummy.DummyRegistry()
+ self.assertEqual(command._get_tweens(registry), None)
+
+
+class Test_main(unittest.TestCase):
+ def _callFUT(self, argv):
+ from pyramid.scripts.ptweens import main
+
+ return main(argv, quiet=True)
+
+ def test_it(self):
+ result = self._callFUT(['ptweens'])
+ self.assertEqual(result, 2)
diff --git a/tests/test_scripts/test_pviews.py b/tests/test_scripts/test_pviews.py
new file mode 100644
index 000000000..0b26a9cf3
--- /dev/null
+++ b/tests/test_scripts/test_pviews.py
@@ -0,0 +1,597 @@
+import unittest
+from . import dummy
+
+
+class TestPViewsCommand(unittest.TestCase):
+ def _getTargetClass(self):
+ from pyramid.scripts.pviews import PViewsCommand
+
+ return PViewsCommand
+
+ def _makeOne(self, registry=None):
+ cmd = self._getTargetClass()([])
+ cmd.bootstrap = dummy.DummyBootstrap(registry=registry)
+ cmd.setup_logging = dummy.dummy_setup_logging()
+ cmd.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ return cmd
+
+ def _makeRequest(self, url, registry):
+ from pyramid.request import Request
+
+ request = Request.blank('/a')
+ request.registry = registry
+ return request
+
+ def _register_mapper(self, registry, routes):
+ from pyramid.interfaces import IRoutesMapper
+
+ mapper = dummy.DummyMapper(*routes)
+ registry.registerUtility(mapper, IRoutesMapper)
+
+ def test__find_view_no_match(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ self._register_mapper(registry, [])
+ command = self._makeOne(registry)
+ request = self._makeRequest('/a', registry)
+ result = command._find_view(request)
+ self.assertEqual(result, None)
+
+ def test__find_view_no_match_multiview_registered(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({'PATH_INFO': '/a'})
+ root = DefaultRootFactory(request)
+ root_iface = providedBy(root)
+ registry.registerAdapter(
+ View1(), (IViewClassifier, IRequest, root_iface), IMultiView
+ )
+ self._register_mapper(registry, [])
+ command = self._makeOne(registry=registry)
+ request = self._makeRequest('/x', registry)
+ result = command._find_view(request)
+ self.assertEqual(result, None)
+
+ def test__find_view_traversal(self):
+ from zope.interface import providedBy
+ from pyramid.interfaces import IRequest
+ from pyramid.interfaces import IViewClassifier
+ from pyramid.interfaces import IView
+ from pyramid.traversal import DefaultRootFactory
+ from pyramid.registry import Registry
+
+ registry = Registry()
+
+ def view1(): # pragma: no cover
+ pass
+
+ request = dummy.DummyRequest({'PATH_INFO': '/a'})
+ root = DefaultRootFactory(request)
+ root_iface = providedBy(root)
+ registry.registerAdapter(
+ view1, (IViewClassifier, IRequest, root_iface), IView, name='a'
+ )
+ self._register_mapper(registry, [])
+ command = self._makeOne(registry=registry)
+ request = self._makeRequest('/a', registry)
+ result = command._find_view(request)
+ self.assertEqual(result, view1)
+
+ 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({'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(): # pragma: no cover
+ 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)
+ request = self._makeRequest('/a', registry)
+ result = command._find_view(request)
+ self.assertEqual(result, 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(): # pragma: no cover
+ pass
+
+ def view2(): # pragma: no cover
+ 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)
+ request = self._makeRequest('/a', registry)
+ result = command._find_view(request)
+ self.assertTrue(IMultiView.providedBy(result))
+
+ def test__find_view_route_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.interfaces import IMultiView
+ from pyramid.interfaces import IRootFactory
+ from pyramid.registry import Registry
+
+ registry = Registry()
+
+ def view1(): # pragma: no cover
+ pass
+
+ def view2(): # pragma: no cover
+ pass
+
+ class IMyRoot(Interface):
+ pass
+
+ class IMyRoute1(Interface):
+ pass
+
+ class IMyRoute2(Interface):
+ pass
+
+ registry.registerAdapter(
+ view1, (IViewClassifier, IMyRoute1, IMyRoot), IView, ''
+ )
+ registry.registerAdapter(
+ view2, (IViewClassifier, IMyRoute2, IMyRoot), IView, ''
+ )
+ 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)
+ request = self._makeRequest('/a', registry)
+ result = command._find_view(request)
+ self.assertTrue(IMultiView.providedBy(result))
+ self.assertEqual(len(result.views), 2)
+ self.assertTrue((None, view1, None) in result.views)
+ self.assertTrue((None, view2, None) in result.views)
+
+ def test__find_multi_routes_all_match(self):
+ command = self._makeOne()
+
+ def factory(request): # pragma: no cover
+ pass
+
+ routes = [
+ dummy.DummyRoute('a', '/a', factory=factory, matchdict={}),
+ dummy.DummyRoute('b', '/a', factory=factory, matchdict={}),
+ ]
+ mapper = dummy.DummyMapper(*routes)
+ request = dummy.DummyRequest({'PATH_INFO': '/a'})
+ result = command._find_multi_routes(mapper, request)
+ self.assertEqual(
+ result,
+ [
+ {'match': {}, 'route': routes[0]},
+ {'match': {}, 'route': routes[1]},
+ ],
+ )
+
+ def test__find_multi_routes_some_match(self):
+ command = self._makeOne()
+
+ def factory(request): # pragma: no cover
+ pass
+
+ routes = [
+ dummy.DummyRoute('a', '/a', factory=factory),
+ dummy.DummyRoute('b', '/a', factory=factory, matchdict={}),
+ ]
+ mapper = dummy.DummyMapper(*routes)
+ request = dummy.DummyRequest({'PATH_INFO': '/a'})
+ result = command._find_multi_routes(mapper, request)
+ self.assertEqual(result, [{'match': {}, 'route': routes[1]}])
+
+ def test__find_multi_routes_none_match(self):
+ command = self._makeOne()
+
+ def factory(request): # pragma: no cover
+ pass
+
+ routes = [
+ dummy.DummyRoute('a', '/a', factory=factory),
+ dummy.DummyRoute('b', '/a', factory=factory),
+ ]
+ mapper = dummy.DummyMapper(*routes)
+ request = dummy.DummyRequest({'PATH_INFO': '/a'})
+ result = command._find_multi_routes(mapper, request)
+ self.assertEqual(result, [])
+
+ def test_views_command_not_found(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ command = self._makeOne(registry=registry)
+ L = []
+ command.out = L.append
+ command._find_view = lambda arg1: None
+ command.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ command.args.url = '/a'
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L[1], 'URL = /a')
+ self.assertEqual(L[3], ' Not found.')
+
+ def test_views_command_not_found_url_starts_without_slash(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ command = self._makeOne(registry=registry)
+ L = []
+ command.out = L.append
+ command._find_view = lambda arg1: None
+ command.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ command.args.url = 'a'
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L[1], 'URL = /a')
+ self.assertEqual(L[3], ' Not found.')
+
+ def test_views_command_single_view_traversal(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ command = self._makeOne(registry=registry)
+ L = []
+ command.out = L.append
+ view = dummy.DummyView(context='context', view_name='a')
+ command._find_view = lambda arg1: view
+ command.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ command.args.url = '/a'
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L[1], 'URL = /a')
+ self.assertEqual(L[3], ' context: context')
+ self.assertEqual(L[4], ' view name: a')
+ self.assertEqual(L[8], ' tests.test_scripts.dummy.DummyView')
+
+ def test_views_command_single_view_function_traversal(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ command = self._makeOne(registry=registry)
+ L = []
+ command.out = L.append
+
+ def view(): # pragma: no cover
+ pass
+
+ view.__request_attrs__ = {'context': 'context', 'view_name': 'a'}
+ command._find_view = lambda arg1: view
+ command.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ command.args.url = '/a'
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L[1], 'URL = /a')
+ self.assertEqual(L[3], ' context: context')
+ self.assertEqual(L[4], ' view name: a')
+ self.assertEqual(L[8], ' tests.test_scripts.test_pviews.view')
+
+ def test_views_command_single_view_traversal_with_permission(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ command = self._makeOne(registry=registry)
+ L = []
+ command.out = L.append
+ view = dummy.DummyView(context='context', view_name='a')
+ view.__permission__ = 'test'
+ command._find_view = lambda arg1: view
+ command.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ command.args.url = '/a'
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L[1], 'URL = /a')
+ self.assertEqual(L[3], ' context: context')
+ self.assertEqual(L[4], ' view name: a')
+ self.assertEqual(L[8], ' tests.test_scripts.dummy.DummyView')
+ self.assertEqual(L[9], ' required permission = test')
+
+ def test_views_command_single_view_traversal_with_predicates(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ command = self._makeOne(registry=registry)
+ L = []
+ command.out = L.append
+
+ def predicate(): # pragma: no cover
+ pass
+
+ predicate.text = lambda *arg: "predicate = x"
+ view = dummy.DummyView(context='context', view_name='a')
+ view.__predicates__ = [predicate]
+ command._find_view = lambda arg1: view
+ command.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ command.args.url = '/a'
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L[1], 'URL = /a')
+ self.assertEqual(L[3], ' context: context')
+ self.assertEqual(L[4], ' view name: a')
+ self.assertEqual(L[8], ' tests.test_scripts.dummy.DummyView')
+ self.assertEqual(L[9], ' view predicates (predicate = x)')
+
+ def test_views_command_single_view_route(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ command = self._makeOne(registry=registry)
+ L = []
+ command.out = L.append
+ route = dummy.DummyRoute('a', '/a', matchdict={})
+ view = dummy.DummyView(
+ context='context', view_name='a', matched_route=route, subpath=''
+ )
+ command._find_view = lambda arg1: view
+ command.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ command.args.url = '/a'
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L[1], 'URL = /a')
+ self.assertEqual(L[3], ' context: context')
+ self.assertEqual(L[4], ' view name: a')
+ self.assertEqual(L[6], ' Route:')
+ self.assertEqual(L[8], ' route name: a')
+ self.assertEqual(L[9], ' route pattern: /a')
+ self.assertEqual(L[10], ' route path: /a')
+ self.assertEqual(L[11], ' subpath: ')
+ self.assertEqual(L[15], ' tests.test_scripts.dummy.DummyView')
+
+ def test_views_command_multi_view_nested(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ command = self._makeOne(registry=registry)
+ L = []
+ command.out = L.append
+ view1 = dummy.DummyView(context='context', view_name='a1')
+ view1.__name__ = 'view1'
+ view1.__view_attr__ = 'call'
+ multiview1 = dummy.DummyMultiView(
+ view1, context='context', view_name='a1'
+ )
+ multiview2 = dummy.DummyMultiView(
+ multiview1, context='context', view_name='a'
+ )
+ command._find_view = lambda arg1: multiview2
+ command.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ command.args.url = '/a'
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L[1], 'URL = /a')
+ self.assertEqual(L[3], ' context: context')
+ self.assertEqual(L[4], ' view name: a')
+ self.assertEqual(L[8], ' tests.test_scripts.dummy.DummyMultiView')
+ self.assertEqual(L[12], ' tests.test_scripts.dummy.view1.call')
+
+ def test_views_command_single_view_route_with_route_predicates(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ command = self._makeOne(registry=registry)
+ L = []
+ command.out = L.append
+
+ def predicate(): # pragma: no cover
+ pass
+
+ predicate.text = lambda *arg: "predicate = x"
+ route = dummy.DummyRoute('a', '/a', matchdict={}, predicate=predicate)
+ view = dummy.DummyView(
+ context='context', view_name='a', matched_route=route, subpath=''
+ )
+ command._find_view = lambda arg1: view
+ command.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ command.args.url = '/a'
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L[1], 'URL = /a')
+ self.assertEqual(L[3], ' context: context')
+ self.assertEqual(L[4], ' view name: a')
+ self.assertEqual(L[6], ' Route:')
+ self.assertEqual(L[8], ' route name: a')
+ self.assertEqual(L[9], ' route pattern: /a')
+ self.assertEqual(L[10], ' route path: /a')
+ self.assertEqual(L[11], ' subpath: ')
+ self.assertEqual(L[12], ' route predicates (predicate = x)')
+ self.assertEqual(L[16], ' tests.test_scripts.dummy.DummyView')
+
+ def test_views_command_multiview(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ command = self._makeOne(registry=registry)
+ L = []
+ command.out = L.append
+ view = dummy.DummyView(context='context')
+ view.__name__ = 'view'
+ view.__view_attr__ = 'call'
+ multiview = dummy.DummyMultiView(
+ view, context='context', view_name='a'
+ )
+ command._find_view = lambda arg1: multiview
+ command.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ command.args.url = '/a'
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L[1], 'URL = /a')
+ self.assertEqual(L[3], ' context: context')
+ self.assertEqual(L[4], ' view name: a')
+ self.assertEqual(L[8], ' tests.test_scripts.dummy.view.call')
+
+ def test_views_command_multiview_with_permission(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ command = self._makeOne(registry=registry)
+ L = []
+ command.out = L.append
+ view = dummy.DummyView(context='context')
+ view.__name__ = 'view'
+ view.__view_attr__ = 'call'
+ view.__permission__ = 'test'
+ multiview = dummy.DummyMultiView(
+ view, context='context', view_name='a'
+ )
+ command._find_view = lambda arg1: multiview
+ command.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ command.args.url = '/a'
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L[1], 'URL = /a')
+ self.assertEqual(L[3], ' context: context')
+ self.assertEqual(L[4], ' view name: a')
+ self.assertEqual(L[8], ' tests.test_scripts.dummy.view.call')
+ self.assertEqual(L[9], ' required permission = test')
+
+ def test_views_command_multiview_with_predicates(self):
+ from pyramid.registry import Registry
+
+ registry = Registry()
+ command = self._makeOne(registry=registry)
+ L = []
+ command.out = L.append
+
+ def predicate(): # pragma: no cover
+ pass
+
+ predicate.text = lambda *arg: "predicate = x"
+ view = dummy.DummyView(context='context')
+ view.__name__ = 'view'
+ view.__view_attr__ = 'call'
+ view.__predicates__ = [predicate]
+ multiview = dummy.DummyMultiView(
+ view, context='context', view_name='a'
+ )
+ command._find_view = lambda arg1: multiview
+ command.args.config_uri = '/foo/bar/myapp.ini#myapp'
+ command.args.url = '/a'
+ result = command.run()
+ self.assertEqual(result, 0)
+ self.assertEqual(L[1], 'URL = /a')
+ self.assertEqual(L[3], ' context: context')
+ self.assertEqual(L[4], ' view name: a')
+ self.assertEqual(L[8], ' tests.test_scripts.dummy.view.call')
+ self.assertEqual(L[9], ' view predicates (predicate = x)')
+
+
+class Test_main(unittest.TestCase):
+ def _callFUT(self, argv):
+ from pyramid.scripts.pviews import main
+
+ return main(argv, quiet=True)
+
+ def test_it(self):
+ result = self._callFUT(['pviews'])
+ self.assertEqual(result, 2)
generated by cgit v1.2.3 (git 2.25.1) at 2026-02-27 12:15:11 +0000