move tests out of the package

12 files changed, 2687 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..f1ef403f8
--- /dev/null
+++ b/tests/test_scripts/dummy.py
@@ -0,0 +1,190 @@
+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): pass
+
+from zope.interface import implementer
+from pyramid.interfaces import IMultiView
+@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..60741db92
--- /dev/null
+++ b/tests/test_scripts/test_common.py
@@ -0,0 +1,13 @@
+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_pcreate.py b/tests/test_scripts/test_pcreate.py
new file mode 100644
index 000000000..0286614ce
--- /dev/null
+++ b/tests/test_scripts/test_pcreate.py
@@ -0,0 +1,309 @@
+import unittest
+
+
+class TestPCreateCommand(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.pcreate import PCreateCommand
+        return PCreateCommand
+
+    def _makeOne(self, *args, **kw):
+        effargs = ['pcreate']
+        effargs.extend(args)
+        tgt_class = kw.pop('target_class', self._getTargetClass())
+        cmd = tgt_class(effargs, **kw)
+        cmd.out = self.out
+        return cmd
+
+    def test_run_show_scaffolds_exist(self):
+        cmd = self._makeOne('-l')
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        out = self.out_.getvalue()
+        self.assertTrue(out.count('Available scaffolds'))
+
+    def test_run_show_scaffolds_none_exist(self):
+        cmd = self._makeOne('-l')
+        cmd.scaffolds = []
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        out = self.out_.getvalue()
+        self.assertTrue(out.count('No scaffolds available'))
+
+    def test_run_no_scaffold_no_args(self):
+        cmd = self._makeOne(quiet=True)
+        result = cmd.run()
+        self.assertEqual(result, 2)
+
+    def test_run_no_scaffold_name(self):
+        cmd = self._makeOne('dummy')
+        result = cmd.run()
+        self.assertEqual(result, 2)
+        out = self.out_.getvalue()
+        self.assertTrue(out.count(
+            'You must provide at least one scaffold name'))
+
+    def test_no_project_name(self):
+        cmd = self._makeOne('-s', 'dummy')
+        result = cmd.run()
+        self.assertEqual(result, 2)
+        out = self.out_.getvalue()
+        self.assertTrue(out.count('You must provide a project name'))
+
+    def test_unknown_scaffold_name(self):
+        cmd = self._makeOne('-s', 'dummyXX', 'distro')
+        result = cmd.run()
+        self.assertEqual(result, 2)
+        out = self.out_.getvalue()
+        self.assertTrue(out.count('Unavailable scaffolds'))
+
+    def test_known_scaffold_single_rendered(self):
+        import os
+        cmd = self._makeOne('-s', 'dummy', 'Distro')
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("0.1")
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold.output_dir,
+            os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
+            )
+        self.assertEqual(
+            scaffold.vars,
+            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
+             'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
+
+    def test_scaffold_with_package_name(self):
+        import os
+        cmd = self._makeOne('-s', 'dummy', '--package-name', 'dummy_package',
+                            'Distro')
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("0.1")
+        result = cmd.run()
+
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold.output_dir,
+            os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
+            )
+        self.assertEqual(
+            scaffold.vars,
+            {'project': 'Distro', 'egg': 'dummy_package',
+             'package': 'dummy_package', 'pyramid_version': '0.1',
+             'pyramid_docs_branch':'0.1-branch'})
+
+
+    def test_scaffold_with_hyphen_in_project_name(self):
+        import os
+        cmd = self._makeOne('-s', 'dummy', 'Distro-')
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("0.1")
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold.output_dir,
+            os.path.normpath(os.path.join(os.getcwd(), 'Distro-'))
+            )
+        self.assertEqual(
+            scaffold.vars,
+            {'project': 'Distro-', 'egg': 'Distro_', 'package': 'distro_',
+             'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
+
+    def test_known_scaffold_absolute_path(self):
+        import os
+        path = os.path.abspath('Distro')
+        cmd = self._makeOne('-s', 'dummy', path)
+        cmd.pyramid_dist = DummyDist("0.1")
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("0.1")
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold.output_dir,
+            os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
+            )
+        self.assertEqual(
+            scaffold.vars,
+            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
+             'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
+
+    def test_known_scaffold_multiple_rendered(self):
+        import os
+        cmd = self._makeOne('-s', 'dummy1', '-s', 'dummy2', 'Distro')
+        scaffold1 = DummyScaffold('dummy1')
+        scaffold2 = DummyScaffold('dummy2')
+        cmd.scaffolds = [scaffold1, scaffold2]
+        cmd.pyramid_dist = DummyDist("0.1")
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold1.output_dir,
+            os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
+            )
+        self.assertEqual(
+            scaffold1.vars,
+            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
+             'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
+        self.assertEqual(
+            scaffold2.output_dir,
+            os.path.normpath(os.path.join(os.getcwd(), 'Distro'))
+            )
+        self.assertEqual(
+            scaffold2.vars,
+            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
+             'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
+
+    def test_known_scaffold_with_path_as_project_target_rendered(self):
+        import os
+        cmd = self._makeOne('-s', 'dummy', '/tmp/foo/Distro/')
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("0.1")
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold.output_dir,
+            os.path.normpath(os.path.join(os.getcwd(), '/tmp/foo/Distro'))
+            )
+        self.assertEqual(
+            scaffold.vars,
+            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
+             'pyramid_version': '0.1', 'pyramid_docs_branch':'0.1-branch'})
+
+
+    def test_scaffold_with_prod_pyramid_version(self):
+        cmd = self._makeOne('-s', 'dummy', 'Distro')
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("0.2")
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold.vars,
+            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
+             'pyramid_version': '0.2', 'pyramid_docs_branch':'0.2-branch'})
+
+    def test_scaffold_with_prod_pyramid_long_version(self):
+        cmd = self._makeOne('-s', 'dummy', 'Distro')
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("0.2.1")
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold.vars,
+            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
+             'pyramid_version': '0.2.1', 'pyramid_docs_branch':'0.2-branch'})
+
+    def test_scaffold_with_prod_pyramid_unparsable_version(self):
+        cmd = self._makeOne('-s', 'dummy', 'Distro')
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("abc")
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold.vars,
+            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
+             'pyramid_version': 'abc', 'pyramid_docs_branch':'latest'})
+
+    def test_scaffold_with_dev_pyramid_version(self):
+        cmd = self._makeOne('-s', 'dummy', 'Distro')
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("0.12dev")
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold.vars,
+            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
+             'pyramid_version': '0.12dev',
+             'pyramid_docs_branch': 'master'})
+
+    def test_scaffold_with_dev_pyramid_long_version(self):
+        cmd = self._makeOne('-s', 'dummy', 'Distro')
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("0.10.1dev")
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold.vars,
+            {'project': 'Distro', 'egg': 'Distro', 'package': 'distro',
+             'pyramid_version': '0.10.1dev',
+             'pyramid_docs_branch': 'master'})
+
+    def test_confirm_override_conflicting_name(self):
+        from pyramid.scripts.pcreate import PCreateCommand
+        class YahInputPCreateCommand(PCreateCommand):
+            def confirm_bad_name(self, pkg_name):
+                return True
+        cmd = self._makeOne('-s', 'dummy', 'Unittest', target_class=YahInputPCreateCommand)
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("0.10.1dev")
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold.vars,
+            {'project': 'Unittest', 'egg': 'Unittest', 'package': 'unittest',
+             'pyramid_version': '0.10.1dev',
+             'pyramid_docs_branch': 'master'})
+
+    def test_force_override_conflicting_name(self):
+        cmd = self._makeOne('-s', 'dummy', 'Unittest', '--ignore-conflicting-name')
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("0.10.1dev")
+        result = cmd.run()
+        self.assertEqual(result, 0)
+        self.assertEqual(
+            scaffold.vars,
+            {'project': 'Unittest', 'egg': 'Unittest', 'package': 'unittest',
+             'pyramid_version': '0.10.1dev',
+             'pyramid_docs_branch': 'master'})
+
+    def test_force_override_site_name(self):
+        from pyramid.scripts.pcreate import PCreateCommand
+        class NayInputPCreateCommand(PCreateCommand):
+            def confirm_bad_name(self, pkg_name):
+                return False
+        cmd = self._makeOne('-s', 'dummy', 'Site', target_class=NayInputPCreateCommand)
+        scaffold = DummyScaffold('dummy')
+        cmd.scaffolds = [scaffold]
+        cmd.pyramid_dist = DummyDist("0.10.1dev")
+        result = cmd.run()
+        self.assertEqual(result, 2)
+
+
+class Test_main(unittest.TestCase):
+    def _callFUT(self, argv):
+        from pyramid.scripts.pcreate import main
+        return main(argv, quiet=True)
+
+    def test_it(self):
+        result = self._callFUT(['pcreate'])
+        self.assertEqual(result, 2)
+
+class DummyScaffold(object):
+    def __init__(self, name):
+        self.name = name
+
+    def run(self, command, output_dir, vars):
+        self.command = command
+        self.output_dir = output_dir
+        self.vars = vars
+
+class DummyDist(object):
+    def __init__(self, version):
+        self.version = version
diff --git a/tests/test_scripts/test_pdistreport.py b/tests/test_scripts/test_pdistreport.py
new file mode 100644
index 000000000..e229667c5
--- /dev/null
+++ b/tests/test_scripts/test_pdistreport.py
@@ -0,0 +1,73 @@
+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..75d5cc198
--- /dev/null
+++ b/tests/test_scripts/test_prequest.py
@@ -0,0 +1,214 @@
+import unittest
+from pyramid.tests.test_scripts 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..fab5e163e
--- /dev/null
+++ b/tests/test_scripts/test_proutes.py
@@ -0,0 +1,792 @@
+import os
+import unittest
+from pyramid.tests.test_scripts 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():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():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_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():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',
+             'pyramid.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',
+            'pyramid.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():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, 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(): 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 = 'pyramid.tests.test_scripts.dummy'
+        view_str = '<pyramid.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): 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',
+            'pyramid.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): 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',
+            'pyramid.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): 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',
+            'pyramid.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): 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',
+            'pyramid.tests.test_scripts.test_proutes.view1',
+            '<route', 'mismatch>'
+        ]
+        self.assertEqual(compare_to, expected)
+
+    def test_route_static_views(self):
+        from pyramid.renderers import null_renderer as nr
+        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',
+             'pyramid.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):
+        from pyramid.renderers import null_renderer as nr
+        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): 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): 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',
+            'pyramid.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): 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',
+            'pyramid.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): return 'view1'
+        def view2(context, request): 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',
+            'pyramid.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): 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): 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): 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): 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): 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):
+        from pyramid.renderers import null_renderer as nr
+
+        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..485cf38cb
--- /dev/null
+++ b/tests/test_scripts/test_pserve.py
@@ -0,0 +1,131 @@
+import os
+import unittest
+from pyramid.tests.test_scripts 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\npyramid.tests.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..df664bea9
--- /dev/null
+++ b/tests/test_scripts/test_pshell.py
@@ -0,0 +1,398 @@
+import os
+import unittest
+from pyramid.tests.test_scripts 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..6907b858d
--- /dev/null
+++ b/tests/test_scripts/test_ptweens.py
@@ -0,0 +1,62 @@
+import unittest
+from pyramid.tests.test_scripts 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..6ec9defbd
--- /dev/null
+++ b/tests/test_scripts/test_pviews.py
@@ -0,0 +1,501 @@
+import unittest
+from pyramid.tests.test_scripts 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(): 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():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():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)
+        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():pass
+        def view2():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): 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): 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): 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],
+                         '    pyramid.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(): 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],
+                         '    pyramid.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],
+                         '    pyramid.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(): 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],
+                         '    pyramid.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],
+                   '        pyramid.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],
+                  '    pyramid.tests.test_scripts.dummy.DummyMultiView')
+        self.assertEqual(L[12],
+                  '        pyramid.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(): 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],
+               '        pyramid.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],
+                     '    pyramid.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],
+                       '    pyramid.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(): 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],
+                         '    pyramid.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)