Renamed package itself

33 files changed, 1181 insertions, 0 deletions

diff --git a/paste/tests/__init__.py b/paste/tests/__init__.py
new file mode 100644
index 0000000..792d600
--- /dev/null
+++ b/paste/tests/__init__.py
@@ -0,0 +1 @@
+#
diff --git a/paste/tests/doctest_webapp.py b/paste/tests/doctest_webapp.py
new file mode 100755
index 0000000..b0b786c
--- /dev/null
+++ b/paste/tests/doctest_webapp.py
@@ -0,0 +1,403 @@
+#!/usr/bin/env python2.4
+"""
+These are functions for use when doctest-testing a document.
+"""
+
+import subprocess
+import doctest
+import os
+import sys
+import shutil
+import re
+import cgi
+import rfc822
+from cStringIO import StringIO
+from paste import server
+from paste import wsgilib
+from paste.util.thirdparty import add_package
+add_package('PySourceColor')
+import PySourceColor
+
+
+here = os.path.abspath(__file__)
+paste_parent = os.path.dirname(
+    os.path.dirname(os.path.dirname(here)))
+
+def run(command):
+    """
+    Runs the string command, prints any output.
+    """
+    proc = subprocess.Popen(command, shell=True,
+                            stderr=subprocess.STDOUT,
+                            stdout=subprocess.PIPE, env=_make_env())
+    data = proc.stdout.read()
+    proc.wait()
+    while data.endswith('\n') or data.endswith('\r'):
+        data = data[:-1]
+    if data:
+        data = '\n'.join(
+            [l for l in data.splitlines() if l])
+        print data
+
+def _make_env():
+    env = os.environ.copy()
+    env['PATH'] = (env.get('PATH', '')
+                   + ':'
+                   + os.path.join(paste_parent, 'scripts')
+                   + ':'
+                   + os.path.join(paste_parent, 'paste', '3rd-party',
+                                  'sqlobject-files', 'scripts'))
+    env['PYTHONPATH'] = (env.get('PYTHONPATH', '')
+                         + ':'
+                         + paste_parent)
+    return env
+
+def clear_dir(dir):
+    """
+    Clears (deletes) the given directory
+    """
+    shutil.rmtree(dir, True)
+
+def ls(dir=None, recurse=False, indent=0):
+    """
+    Show a directory listing
+    """
+    dir = dir or os.getcwd()
+    fns = os.listdir(dir)
+    fns.sort()
+    for fn in fns:
+        full = os.path.join(dir, fn)
+        if os.path.isdir(full):
+            fn = fn + '/'
+        print ' '*indent + fn
+        if os.path.isdir(full) and recurse:
+            ls(dir=full, recurse=True, indent=indent+2)
+
+def make_app(dir):
+    os.chdir(dir)
+    sys.path.append(os.path.dirname(dir))
+    conf, app = server.load_commandline((), allow_reload=False)
+    assert conf is not None, (
+        "server.load_commandline requested exit with code %r"
+        % app)
+    return app
+
+default_app = None
+default_url = None
+
+def set_default_app(app, url):
+    global default_app
+    global default_url
+    default_app = app
+    default_url = url
+
+def resource_filename(fn):
+    """
+    Returns the filename of the resource -- generally in the directory
+    resources/DocumentName/fn
+    """
+    return os.path.join(
+        os.path.dirname(sys.testing_document_filename),
+        'resources',
+        os.path.splitext(os.path.basename(sys.testing_document_filename))[0],
+        fn)
+
+def show(path_info, example_name):
+    fn = resource_filename(example_name + '.html')
+    out = StringIO()
+    assert default_app is not None, (
+        "No default_app set")
+    url = default_url + path_info
+    out.write('<span class="doctest-url"><a href="%s">%s</a></span><br>\n'
+              % (url, url))
+    out.write('<div class="doctest-example">\n')
+    proc = subprocess.Popen(
+        ['wsgi-server', '--server=console', '--no-verbose',
+         '--url=' + path_info],
+        stderr=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        env=_make_env())
+    stdout, errors = proc.communicate()
+    stdout = StringIO(stdout)
+    headers = rfc822.Message(stdout)
+    content = stdout.read()
+    for header, value in headers.items():
+        if header.lower() == 'status' and int(value.split()[0]) == 200:
+            continue
+        if header.lower() in ('content-type', 'content-length'):
+            continue
+        if (header.lower() == 'set-cookie'
+            and value.startswith('_SID_')):
+            continue
+        out.write('<span class="doctest-header">%s: %s</span><br>\n'
+                  % (header, value))
+    lines = [l for l in content.splitlines() if l.strip()]
+    for line in lines:
+        out.write(line + '\n')
+    if errors:
+        out.write('<pre class="doctest-errors">%s</pre>'
+                  % errors)
+    out.write('</div>\n')
+    result = out.getvalue()
+    if not os.path.exists(fn):
+        f = open(fn, 'wb')
+        f.write(result)
+        f.close()
+    else:
+        f = open(fn, 'rb')
+        expected = f.read()
+        f.close()
+        if not html_matches(expected, result):
+            print 'Pages did not match.  Expected from %s:' % fn
+            print '-'*60
+            print expected
+            print '='*60
+            print 'Actual output:'
+            print '-'*60
+            print result
+
+def html_matches(pattern, text):
+    return True
+    regex = re.escape(pattern)
+    regex = regex.replace(r'\.\.\.', '.*')
+    regex = re.sub(r'0x[0-9a-f]+', '.*', regex)
+    regex = '^%s$' % regex
+    return re.search(regex, text)
+
+def create_file(path, version, data):
+    if data.startswith('\n'):
+        data = data[1:]
+    lines = data.splitlines()
+    new_lines = []
+    for line in lines:
+        if line.rstrip() == '.':
+            new_lines.append('')
+        else:
+            new_lines.append(line)
+    data = '\n'.join(new_lines) + '\n'
+    write_data(path, data)
+    show_file(path, version)
+
+def show_file(path, version):
+    ext = os.path.splitext(path)[1]
+    f = open(path, 'rb')
+    data = f.read()
+    f.close()
+    if ext == '.py':
+        html = ('<div class="source-code">%s</div>' 
+                % PySourceColor.str2html(data, PySourceColor.dark))
+    else:
+        html = '<pre class="source-code">%s</pre>' % cgi.escape(data, 1)
+    html = '<span class="source-filename">%s</span><br>%s' % (
+        path, html)
+    write_data(resource_filename('%s.%s.gen.html' % (path, version)),
+               html)
+
+def call_source_highlight(input, format):
+    proc = subprocess.Popen(['source-highlight', '--out-format=html',
+                             '--no-doc', '--css=none',
+                             '--src-lang=%s' % format], shell=False,
+                            stdout=subprocess.PIPE)
+    stdout, stderr = proc.communicate(input)
+    result = stdout
+    proc.wait()
+    return result
+
+
+def write_data(path, data):
+    dir = os.path.dirname(os.path.abspath(path))
+    if not os.path.exists(dir):
+        os.makedirs(dir)
+    f = open(path, 'wb')
+    f.write(data)
+    f.close()
+    
+
+def change_file(path, changes):
+    f = open(path, 'rb')
+    lines = f.readlines()
+    f.close()
+    for change_type, line, text in changes:
+        if change_type == 'insert':
+            lines[line:line] = [text]
+        elif change_type == 'delete':
+            lines[line:text] = []
+        else:
+            assert 0, (
+                "Unknown change_type: %r" % change_type)
+    f = open(path, 'wb')
+    f.write(''.join(lines))
+    f.close()
+
+class LongFormDocTestParser(doctest.DocTestParser):
+
+    """
+    This parser recognizes some reST comments as commands, without
+    prompts or expected output, like:
+
+    .. run:
+
+        do_this(...
+        ...)
+    """
+
+    _EXAMPLE_RE = re.compile(r"""
+        # Source consists of a PS1 line followed by zero or more PS2 lines.
+        (?: (?P<source>
+                (?:^(?P<indent> [ ]*) >>>    .*)    # PS1 line
+                (?:\n           [ ]*  \.\.\. .*)*)  # PS2 lines
+            \n?
+            # Want consists of any non-blank lines that do not start with PS1.
+            (?P<want> (?:(?![ ]*$)    # Not a blank line
+                         (?![ ]*>>>)  # Not a line starting with PS1
+                         .*$\n?       # But any other line
+                      )*))
+        | 
+        (?: # This is for longer commands that are prefixed with a reST
+            # comment like '.. run:' (two colons makes that a directive).
+            # These commands cannot have any output.
+
+            (?:^\.\.[ ]*(?P<run>run):[ ]*\n) # Leading command/command
+            (?:[ ]*\n)?         # Blank line following
+            (?P<runsource>
+                (?:(?P<runindent> [ ]+)[^ ].*$)
+                (?:\n [ ]+ .*)*)
+            )
+        |
+        (?: # This is for shell commands
+
+            (?P<shellsource>
+                (?:^(P<shellindent> [ ]*) [$] .*)   # Shell line
+                (?:\n               [ ]*  [>] .*)*) # Continuation
+            \n?
+            # Want consists of any non-blank lines that do not start with $
+            (?P<shellwant> (?:(?![ ]*$)
+                              (?![ ]*[$]$)
+                              .*$\n?
+                           )*))
+        """, re.MULTILINE | re.VERBOSE)
+
+    def _parse_example(self, m, name, lineno):
+        r"""
+        Given a regular expression match from `_EXAMPLE_RE` (`m`),
+        return a pair `(source, want)`, where `source` is the matched
+        example's source code (with prompts and indentation stripped);
+        and `want` is the example's expected output (with indentation
+        stripped).
+
+        `name` is the string's name, and `lineno` is the line number
+        where the example starts; both are used for error messages.
+
+        >>> def parseit(s):
+        ...     p = LongFormDocTestParser()
+        ...     return p._parse_example(p._EXAMPLE_RE.search(s), '<string>', 1)
+        >>> parseit('>>> 1\n1')
+        ('1', {}, '1', None)
+        >>> parseit('>>> (1\n... +1)\n2')
+        ('(1\n+1)', {}, '2', None)
+        >>> parseit('.. run:\n\n    test1\n    test2\n')
+        ('test1\ntest2', {}, '', None)
+        """
+        # Get the example's indentation level.
+        runner = m.group('run') or ''
+        indent = len(m.group('%sindent' % runner))
+        
+        # Divide source into lines; check that they're properly
+        # indented; and then strip their indentation & prompts.
+        source_lines = m.group('%ssource' % runner).split('\n')
+        if runner:
+            self._check_prefix(source_lines[1:], ' '*indent, name, lineno)
+        else:
+            self._check_prompt_blank(source_lines, indent, name, lineno)
+            self._check_prefix(source_lines[2:], ' '*indent + '.', name, lineno)
+        if runner:
+            source = '\n'.join([sl[indent:] for sl in source_lines])
+        else:
+            source = '\n'.join([sl[indent+4:] for sl in source_lines])
+
+        if runner:
+            want = ''
+            exc_msg = None
+        else:
+            # Divide want into lines; check that it's properly indented; and
+            # then strip the indentation.  Spaces before the last newline should
+            # be preserved, so plain rstrip() isn't good enough.
+            want = m.group('want')
+            want_lines = want.split('\n')
+            if len(want_lines) > 1 and re.match(r' *$', want_lines[-1]):
+                del want_lines[-1]  # forget final newline & spaces after it
+            self._check_prefix(want_lines, ' '*indent, name,
+                               lineno + len(source_lines))
+            want = '\n'.join([wl[indent:] for wl in want_lines])
+
+            # If `want` contains a traceback message, then extract it.
+            m = self._EXCEPTION_RE.match(want)
+            if m:
+                exc_msg = m.group('msg')
+            else:
+                exc_msg = None
+
+        # Extract options from the source.
+        options = self._find_options(source, name, lineno)
+
+        return source, options, want, exc_msg
+
+
+    def parse(self, string, name='<string>'):
+        """
+        Divide the given string into examples and intervening text,
+        and return them as a list of alternating Examples and strings.
+        Line numbers for the Examples are 0-based.  The optional
+        argument `name` is a name identifying this string, and is only
+        used for error messages.
+        """
+        string = string.expandtabs()
+        # If all lines begin with the same indentation, then strip it.
+        min_indent = self._min_indent(string)
+        if min_indent > 0:
+            string = '\n'.join([l[min_indent:] for l in string.split('\n')])
+
+        output = []
+        charno, lineno = 0, 0
+        # Find all doctest examples in the string:
+        for m in self._EXAMPLE_RE.finditer(string):
+            # Add the pre-example text to `output`.
+            output.append(string[charno:m.start()])
+            # Update lineno (lines before this example)
+            lineno += string.count('\n', charno, m.start())
+            # Extract info from the regexp match.
+            (source, options, want, exc_msg) = \
+                     self._parse_example(m, name, lineno)
+            # Create an Example, and add it to the list.
+            if not self._IS_BLANK_OR_COMMENT(source):
+                # @@: Erg, this is the only line I need to change...
+                output.append( doctest.Example(source, want, exc_msg,
+                                    lineno=lineno,
+                                    indent=min_indent+len(m.group('indent') or m.group('runindent')),
+                                    options=options) )
+            # Update lineno (lines inside this example)
+            lineno += string.count('\n', m.start(), m.end())
+            # Update charno.
+            charno = m.end()
+        # Add any remaining post-example text to `output`.
+        output.append(string[charno:])
+        return output
+
+
+
+if __name__ == '__main__':
+    import sys
+    if sys.argv[1:] and sys.argv[1] == 'doctest':
+        doctest.testmod()
+        sys.exit()
+    if not paste_parent in sys.path:
+        sys.path.append(paste_parent)
+    for fn in sys.argv[1:]:
+        fn = os.path.abspath(fn)
+        # @@: OK, ick; but this module gets loaded twice
+        sys.testing_document_filename = fn
+        doctest.testfile(fn, module_relative=False,
+                         parser=LongFormDocTestParser())
+        new = os.path.splitext(fn)[0] + '.html'
+        assert new != fn
+        os.system('rest2html %s > %s' % (fn, new))
diff --git a/paste/tests/echotest.py b/paste/tests/echotest.py
new file mode 100755
index 0000000..885d571
--- /dev/null
+++ b/paste/tests/echotest.py
@@ -0,0 +1,109 @@
+"""
+Tests a WSGI stack, using urllib.  Queries the echo application.
+"""
+
+import unittest
+import urlparse
+import urllib
+import os
+import sys
+
+class EchoTest(unittest.TestCase):
+
+    def url(self):
+        if not os.environ.get('ECHO_URL'):
+            print 'You must set $ECHO_URL'
+            sys.exit(1)
+        url = URL(os.environ['ECHO_URL'])
+        return url
+
+class TestEnviron(EchoTest):
+
+    def setUp(self):
+        self.page = self.url().fetch(environ='true')
+        self.environ = parse_environ(self.page)
+
+    def testRequiredKeys(self):
+        environ = self.environ
+        url = self.url()
+        required_keys = 'REQUEST_METHOD SCRIPT_NAME PATH_INFO QUERY_STRING SERVER_NAME SERVER_PORT wsgi.errors wsgi.input wsgi.multiprocess wsgi.multithread wsgi.version'
+        for key in required_keys.split():
+            assert environ.has_key(key), "Key %r missing from %r" % (key, environ)
+        self.assertEqual(environ['PATH_INFO'], '')
+        self.assertEqual(environ['SCRIPT_NAME'], url.path)
+        self.assertEqual(environ['REQUEST_METHOD'], 'GET')
+        self.assertEqual(environ['QUERY_STRING'], 'environ=true')
+        self.assertEqual(environ['SERVER_PORT'], str(url.port))
+        self.assertEqual(environ['SERVER_NAME'], url.host)
+        self.assertEqual(environ['HTTP_HOST'], url.location)
+        assert environ['HTTP_USER_AGENT'].startswith('Python-urllib/'), \
+                         "HTTP_USER_AGENT should start with 'Python-urllib/': %r" % environ['HTTP_USER_AGENT']
+
+    def testPathInfo(self):
+        sub = self.url() / ''
+        environ = parse_environ(sub.fetch(environ='true'))
+        self.assertEqual(environ['PATH_INFO'], '/')
+        self.assertEqual(environ['SCRIPT_NAME'], self.url().path)
+        sub = self.url() / 'test'
+        environ = parse_environ(sub.fetch(environ='true'))
+        self.assertEqual(environ['PATH_INFO'], '/test')
+        self.assertEqual(environ['SCRIPT_NAME'], self.url().path)
+
+    def test_message(self):
+        data = self.url().fetch(message='test')
+        self.assertEqual(data, 'test')
+        data = self.url().fetch(message='')
+        self.assertEqual(data, '')
+
+############################################################
+## Utility functions
+############################################################
+
+def parse_environ(page):
+    """
+    Parses the environment that echo prints (not perfect, but good
+    enough).
+    """
+    environ = {}
+    for line in page.splitlines():
+        if '=' not in line:
+            # ignore second line of long lines
+            continue
+        name, value = line.split('=', 1)
+        environ[name] = value
+    return environ
+
+class URL:
+
+    def __init__(self, url_string):
+        self.url_string = url_string
+        (self.scheme, self.location, self.path, self.query,
+         self.fragment) = urlparse.urlsplit(url_string)
+        if ':' in self.location:
+            self.host, self.port = location.split(':', 1)
+        else:
+            self.host = self.location
+            if self.scheme == 'http':
+                self.port = '80'
+            elif self.scheme == 'https':
+                self.port = '443'
+            else:
+                assert 0, "Unknown scheme: %r" % scheme
+        self.port = int(self.port)
+        
+    def fetch(self, **kw):
+        query = '&'.join(['%s=%s' % (urllib.quote(k), urllib.quote(v))
+                          for k, v in kw.items()])
+        url = self.url_string
+        if query:
+            url += '?' + query
+        f = urllib.urlopen(url)
+        page = f.read()
+        f.close()
+        return page
+
+    def __div__(self, path_part):
+        return self.__class__(self.url_string + '/' + path_part)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/paste/tests/fixture.py b/paste/tests/fixture.py
new file mode 100644
index 0000000..b69c88c
--- /dev/null
+++ b/paste/tests/fixture.py
@@ -0,0 +1,307 @@
+import sys
+try:
+    from cStringIO import StringIO
+except ImportError:
+    from StringIO import StringIO
+import types
+import re
+from py.test.collect import Module, PyCollector
+from paste.util import thirdparty
+doctest = thirdparty.load_new_module('doctest', (2, 4))
+from paste import wsgilib
+from paste import lint
+
+class NoDefault:
+    pass
+
+class Dummy(object):
+
+    def __init__(self, **kw):
+        for name, value in kw.items():
+            if name.startswith('method_'):
+                name = name[len('method_'):]
+                value = DummyMethod(value)
+            setattr(self, name, value)
+
+class DummyMethod(object):
+
+    def __init__(self, return_value):
+        self.return_value = return_value
+
+    def __call__(self, *args, **kw):
+        return self.return_value
+
+class ParamCollector(PyCollector):
+
+    def collect_function(self, extpy):
+        if not extpy.check(func=1, basestarts='test_'):
+            return
+        func = extpy.resolve()
+        if hasattr(func, 'params'):
+            params = func.params
+            for i, param in enumerate(params):
+                item = self.Item(extpy, *param)
+                item.name = item.name + '.%i' % i
+                yield item
+        else:
+            yield self.Item(extpy)
+    
+class DoctestCollector(PyCollector):
+
+    def __init__(self, extpy_or_module):
+        if isinstance(extpy_or_module, types.ModuleType):
+            self.module = extpy_or_module
+            self.extpy = None
+        else:
+            self.extpy = extpy_or_module
+            self.module = self.extpy.getpymodule()
+
+    def __call__(self, extpy):
+        # we throw it away, because this has been set up to explicitly
+        # check another module; maybe this isn't clean
+        if self.extpy is None:
+            self.extpy = extpy
+        return self
+
+    def __iter__(self):
+        finder = doctest.DocTestFinder()
+        tests = finder.find(self.module)
+        for t in tests:
+            yield DoctestItem(self.extpy, t)
+
+class DoctestItem(DoctestCollector.Item):
+
+    def __init__(self, extpy, doctestitem, *args):
+        self.extpy = extpy
+        self.doctestitem = doctestitem
+        self.name = extpy.basename
+        self.args = args
+
+    def execute(self, driver):
+        runner = doctest.DocTestRunner()
+        driver.setup_path(self.extpy)
+        target, teardown = driver.setup_method(self.extpy)
+        try:
+            (failed, tried), run_output = capture_stdout(runner.run, self.doctestitem)
+            if failed:
+                raise self.Failed(msg=run_output, tbindex=-2)
+                
+        finally:
+            if teardown:
+                teardown(target)
+                
+def capture_stdout(func, *args, **kw):
+    newstdout = StringIO()
+    oldstdout = sys.stdout
+    sys.stdout = newstdout
+    try:
+        result = func(*args, **kw)
+    finally:
+        sys.stdout = oldstdout
+    return result, newstdout.getvalue()
+
+def assert_error(func, *args, **kw):
+    kw.setdefault('error', Exception)
+    kw.setdefault('text_re', None)
+    error = kw.pop('error')
+    text_re = kw.pop('text_re')
+    if text_re and isinstance(text_re, str):
+        real_text_re = re.compile(text_re, re.S)
+    else:
+        real_text_re = text_re
+    try:
+        value = func(*args, **kw)
+    except error, e:
+        if real_text_re and not real_text_re.search(str(e)):
+            assert False, (
+                "Exception did not match pattern; exception:\n  %r;\n"
+                "pattern:\n  %r"
+                % (str(e), text_re))
+    except Exception, e:
+        assert False, (
+            "Exception type %s should have been raised; got %s instead (%s)"
+            % (error, e.__class__, e))
+    else:
+        assert False, (
+            "Exception was expected, instead successfully returned %r"
+            % (value))
+
+def sorted(l):
+    l = list(l)
+    l.sort()
+    return l
+
+
+def fake_request(application, path_info='', use_lint=True, **environ):
+    """
+    Runs the application in a fake environment, returning a response object
+    """
+    if use_lint:
+        application = lint.middleware(application)
+    status, headers, body, errors = wsgilib.raw_interactive(
+        application, path_info, **environ)
+    res = FakeResponse(status, headers, body, errors)
+    if res.errors:
+        print 'Errors:'
+        print res.errors
+    return res
+
+class FakeResponse(object):
+
+    def __init__(self, status, headers, body, errors):
+        self.status = status
+        self.headers = headers
+        self.body = body
+        self.errors = errors
+
+    def status_int__get(self):
+        return int(self.status.split()[0])
+    status_int = property(status_int__get)
+
+    def all_ok(self):
+        """
+        Asserts that there were no errors and the status was 200 OK
+        """
+        assert not self.errors, (
+            "Response had errors: %s" % self.errors)
+        assert self.status_int == 200, (
+            "Response did not return 200 OK: %r" % self.status)
+
+    def header(self, name, default=NoDefault):
+        """
+        Returns the named header; an error if there is not exactly one
+        matching header (unless you give a default -- always an error if
+        there is more than one header)
+        """
+        found = None
+        for cur_name, value in self.headers:
+            if cur_name.lower() == name.lower():
+                assert not found, (
+                    "Ambiguous header: %s matches %r and %r"
+                    % (name, found, value))
+                found = value
+        if found is None:
+            if default is NoDefault:
+                raise KeyError(
+                    "No header found: %r (from %s)"
+                    % (name, ', '.join([n for n, v in self.headers])))
+            else:
+                return default
+        return found
+
+    def all_headers(self, name):
+        """
+        Gets all headers, returns as a list
+        """
+        found = []
+        for cur_name, value in self.headers:
+            if cur_name.lower() == name.lower():
+                found.append(value)
+        return found
+
+    def __contains__(self, s):
+        return self.body.find(s) != -1
+    
+    def __repr__(self):
+        return '<Response %s %r>' % (self.status, self.body[:20])
+
+    def __str__(self):
+        return 'Response: %s\n%s\n%s' % (
+            self.status,
+            '\n'.join(['%s: %s' % (n, v) for n, v in self.headers]),
+            self.body)
+
+class Dummy_smtplib(object):
+
+    existing = None
+
+    def __init__(self, server):
+        assert not self.existing, (
+            "smtplib.SMTP() called again before Dummy_smtplib.existing.reset() "
+            "called.")
+        self.server = server
+        self.open = True
+        self.__class__.existing = self
+
+    def quit(self):
+        assert self.open, (
+            "Called %s.quit() twice" % self)
+        self.open = False
+
+    def sendmail(self, from_address, to_addresses, msg):
+        self.from_address = from_address
+        self.to_addresses = to_addresses
+        self.message = msg
+
+    def install(cls):
+        smtplib.SMTP = cls
+
+    install = classmethod(install)
+
+    def reset(self):
+        assert not self.open, (
+            "SMTP connection not quit")
+        self.__class__.existing = None
+        
+class FakeFilesystem(object):
+
+    def __init__(self):
+        self.files = {}
+
+    def make_file(self, filename, content):
+        self.files[filename] = content
+
+    def open(self, filename, mode='r'):
+        if not self.files.has_key(filename):
+            raise IOError("[FakeFS] No such file or directory: %r" % filename)
+
+
+class FakeFile(object):
+
+    def __init__(self, filename, content=None):
+        self.filename = filename
+        self.content = content
+
+    def open(self, mode):
+        if mode == 'r' or mode == 'rb':
+            if self.content is None:
+                raise IOError("[FakeFS] No such file or directory: %r" % filename)
+            return ReaderFile(self)
+        elif mode == 'w' or mode == 'wb':
+            return WriterFile(self)
+        else:
+            assert 0, "Mode %r not yet implemented" % mode
+
+class ReaderFile(object):
+
+    def __init__(self, file):
+        self.file = file
+        self.stream = StringIO(self.file.content)
+        self.open = True
+
+    def read(self, *args):
+        return self.stream.read(*args)
+
+    def close(self):
+        assert self.open, (
+            "Closing open file")
+        self.open = False
+
+class WriterFile(object):
+
+    def __init__(self, file):
+        self.file = file
+        self.stream = StringIO()
+        self.open = True
+
+    def write(self, arg):
+        self.stream.write(arg)
+
+    def close(self):
+        assert self.open, (
+            "Closing an open file")
+        self.open = False
+        
+        
+    
+
diff --git a/paste/tests/pyconfig_data/context.py b/paste/tests/pyconfig_data/context.py
new file mode 100644
index 0000000..73fa626
--- /dev/null
+++ b/paste/tests/pyconfig_data/context.py
@@ -0,0 +1,8 @@
+def simplehook():
+    return 'calc'
+simplehook.config_hook = True
+
+def complexhook(context):
+    return context
+complexhook.config_hook = True
+
diff --git a/paste/tests/pyconfig_data/deriv.conf b/paste/tests/pyconfig_data/deriv.conf
new file mode 100644
index 0000000..c7cdf3c
--- /dev/null
+++ b/paste/tests/pyconfig_data/deriv.conf
@@ -0,0 +1,3 @@
+import os
+
+test1 = test1 + '+another'
diff --git a/paste/tests/pyconfig_data/nest1.conf b/paste/tests/pyconfig_data/nest1.conf
new file mode 100644
index 0000000..4eb06c6
--- /dev/null
+++ b/paste/tests/pyconfig_data/nest1.conf
@@ -0,0 +1,3 @@
+a = 1
+b = 'shadow'
+
diff --git a/paste/tests/pyconfig_data/nest2.conf b/paste/tests/pyconfig_data/nest2.conf
new file mode 100644
index 0000000..c70b217
--- /dev/null
+++ b/paste/tests/pyconfig_data/nest2.conf
@@ -0,0 +1,2 @@
+b = 2
+c = 3
diff --git a/paste/tests/pyconfig_data/one.py b/paste/tests/pyconfig_data/one.py
new file mode 100644
index 0000000..e03cf8b
--- /dev/null
+++ b/paste/tests/pyconfig_data/one.py
@@ -0,0 +1,2 @@
+name1 = 'n1'
+name2 = 'n2'
diff --git a/paste/tests/test_authentication.py b/paste/tests/test_authentication.py
new file mode 100644
index 0000000..f26e5a4
--- /dev/null
+++ b/paste/tests/test_authentication.py
@@ -0,0 +1,76 @@
+from paste import wsgilib
+from paste import login
+from fixture import *
+
+from_cmdline = 0
+
+def application(environ, start_response):
+    if environ.has_key('REMOTE_USER'):
+	start_response('200 OK', [('Content-type', 'text/plain')])
+	return ['Logged in: ' + environ['REMOTE_USER']]
+    else:
+	start_response('401 Unauthorized',
+                       [('Content-type', 'text/plain')])
+	return ['Not logged in.']
+
+class AuthTest(login.Authenticator):
+    def check_auth(self, username, password):
+        return username == password
+
+def report(res):
+    if from_cmdline:
+        print res
+        
+# @@ this should be part of a test fixture, I think
+def mk_basic_auth_app(**kw):
+    kw['http_login'] = True
+    kw['authenticator'] =  AuthTest
+    app = login.middleware(application, **kw)
+    return app
+    
+def test_basicauth_noauth():
+    res = fake_request(mk_basic_auth_app(), '/')
+    assert res.status_int == 401
+    report(res)
+
+def run_userpass(user, password):
+    userpass = user + ':' + password
+    env = {'HTTP_AUTHORIZATION' : 'Basic ' + userpass.encode('base64')}
+    return fake_request(mk_basic_auth_app(), '/', **env)
+
+def test_basicauth_okuser():
+    res = run_userpass('test', 'test') # should succeed
+    assert res.status_int == 200
+    report(res)
+
+def test_basicauth_baduser():
+    res = run_userpass('test', 'badpass') # should succeed
+    assert res.status_int == 401
+    report(res)
+
+def test_basicauth_cookie():
+    res = run_userpass('test', 'test') # should succeed
+    assert res.status_int == 200
+    report(res)
+    cookie_val = res.header('SET-COOKIE')
+    print "cookie value", cookie_val
+    app = mk_basic_auth_app()
+    env = {'HTTP_COOKIE': cookie_val}
+    res = fake_request(mk_basic_auth_app(), '/', **env)
+    report(res)
+    assert res.status_int == 200
+    
+    # ensure that secret is actually used
+    res = fake_request(mk_basic_auth_app(secret='bogus'),
+                       '/', **env)
+    report(res)
+    assert res.status_int == 401
+
+if __name__ == '__main__':
+    from_cmdline = 1
+    test_basicauth_noauth()
+    test_basicauth_okuser()
+    test_basicauth_baduser()
+    test_basicauth_cookie()
+    
+
diff --git a/paste/tests/test_error_middleware.py b/paste/tests/test_error_middleware.py
new file mode 100644
index 0000000..f7731ae
--- /dev/null
+++ b/paste/tests/test_error_middleware.py
@@ -0,0 +1,63 @@
+from fixture import *
+from paste.error_middleware import ErrorMiddleware
+from paste import lint
+
+def do_request(app, expect_status=500):
+    res = fake_request(ErrorMiddleware(lint.middleware(app)),
+                       **{'paste.config': {'debug': True}})
+    assert res.status_int == expect_status
+    return res
+
+def bad_app():
+    "No argument list!"
+    return None
+
+def start_response_app(environ, start_response):
+    "raise error before start_response"
+    raise ValueError("hi")
+
+def after_start_response_app(environ, start_response):
+    start_response("200 OK", [('Content-type', 'text/plain')])
+    raise ValueError('error2')
+
+def iter_app(environ, start_response):
+    start_response("200 OK", [('Content-type', 'text/plain')])
+    return yielder(['this', ' is ', ' a', None])
+
+def yielder(args):
+    for arg in args:
+        if arg is None:
+            raise ValueError("None raises error")
+        yield arg
+
+def test_makes_exception():
+    res = do_request(bad_app)
+    print res
+    assert '<html' in res
+    assert 'bad_app() takes no arguments (2 given' in res
+    assert 'iterator = application(environ, start_response_wrapper)' in res
+    assert 'lint.py' in res
+    assert 'error_middleware.py' in res
+
+def test_start_res():
+    res = do_request(start_response_app)
+    print res
+    assert 'ValueError: hi' in res
+    assert 'test_error_middleware.py' in res
+    assert 'line 17 in <tt>start_response_app</tt>' in res
+
+def test_after_start():
+    res = do_request(after_start_response_app, 200)
+    print res
+    assert 'ValueError: error2' in res
+    assert 'line 21' in res
+
+def test_iter_app():
+    res = do_request(iter_app, 200)
+    print res
+    assert 'None raises error' in res
+    assert 'yielder' in res
+    
+                      
+
+    
diff --git a/paste/tests/test_pyconfig.py b/paste/tests/test_pyconfig.py
new file mode 100644
index 0000000..1b93d02
--- /dev/null
+++ b/paste/tests/test_pyconfig.py
@@ -0,0 +1,46 @@
+import os
+from wsgikit import pyconfig
+from py.test import raises
+
+def path(name):
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                        'pyconfig_data', name)
+
+def test_load():
+    conf = pyconfig.load(path('one.py'))
+    assert conf['name1'] == 'n1'
+    assert conf['name2'] == "n2"
+    raises(KeyError, "conf['name3']")
+    
+def test_nest():
+    conf = pyconfig.load(path('nest1.conf'))
+    conf.load(path('nest2.conf'))
+    assert conf['a'] == 1
+    assert conf['b'] == 2
+    assert conf['c'] == 3
+
+def test_derivative():
+    conf = pyconfig.Config()
+    conf.load_dict({'test1': 'a'})
+    assert conf['test1'] == 'a'
+    conf.load(path('deriv.conf'))
+    assert conf['test1'] == 'a+another'
+    conf = pyconfig.Config()
+    conf.load_dict({'test1': 'b'})
+    conf.load(path('deriv.conf'))
+    assert conf['test1'] == 'b+another'
+    assert not conf.has_key('os')
+    
+def test_command():
+    conf = pyconfig.load(path('one.py'))
+    extra = conf.load_commandline(
+        ['-h', '--host', 'localhost', '--port=8080', 'arg1', '-f', 'arg2'],
+        bool_options=['help', 'verbose'],
+        aliases={'f': 'config_file', 'h': 'help', 'v': 'verbose'})
+    assert extra == ['arg1']
+    assert conf['name1'] == 'n1'
+    assert conf['host'] == 'localhost'
+    assert conf['port'] == 8080
+    assert conf['config_file'] == 'arg2'
+    raises(KeyError, "conf['h']")
+    raises(KeyError, "conf['f']")
diff --git a/paste/tests/test_urlparser.py b/paste/tests/test_urlparser.py
new file mode 100644
index 0000000..b41ecfa
--- /dev/null
+++ b/paste/tests/test_urlparser.py
@@ -0,0 +1,83 @@
+from paste.urlparser import *
+from fixture import fake_request
+
+
+def path(name):
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                        'urlparser_data', name)
+
+def make_parser(name):
+    return URLParser(path(name), name, {'index_names': ['index', 'Main']})
+
+def test_find_file():
+    p = make_parser('find_file')
+    res = fake_request(p, '/')
+    assert 'index1' in res
+    assert res.header('content-type') == 'text/plain'
+    res = fake_request(p, '/index')
+    assert 'index1' in res
+    assert res.header('content-type') == 'text/plain'
+    res = fake_request(p, '/index.txt')
+    assert 'index1' in res
+    assert res.header('content-type') == 'text/plain'
+    res = fake_request(p, '/test2.html')
+    assert 'test2' in res
+    assert res.header('content-type') == 'text/html'
+
+def test_deep():
+    p = make_parser('deep')
+    res = fake_request(p, '/')
+    assert 'index2' in res
+    res = fake_request(p, '/sub')
+    assert res.status_int == 301
+    print res
+    assert res.header('location') == 'http://localhost/sub/'
+    assert 'href="http://localhost/sub/"' in res
+    res = fake_request(p, '/sub/')
+    assert 'index3' in res
+    
+def test_python():
+    p = make_parser('python')
+    res = fake_request(p, '/simpleapp')
+    res.all_ok()
+    assert 'test1' in res
+    assert res.header('test-header') == 'TEST!'
+    assert res.header('content-type') == 'text/html'
+    res = fake_request(p, '/stream')
+    res.all_ok()
+    assert 'test2' in res
+    res = fake_request(p, '/sub/simpleapp')
+    res.all_ok()
+    assert 'subsimple' in res
+    
+def test_hook():
+    p = make_parser('hook')
+    res = fake_request(p, '/bob/app')
+    res.all_ok()
+    assert 'user: bob' in res
+    res = fake_request(p, '/tim/')
+    res.all_ok()
+    assert 'index: tim' in res
+    
+def test_not_found_hook():
+    p = make_parser('not_found')
+    res = fake_request(p, '/simple/notfound')
+    assert res.status_int == 200
+    assert 'not found' in res
+    res = fake_request(p, '/simple/found')
+    res.all_ok()
+    assert 'is found' in res
+    res = fake_request(p, '/recur/__notfound')
+    assert res.status_int == 404
+    # @@: It's unfortunate that the original path doesn't actually show up
+    assert '/recur/notfound' in res
+    res = fake_request(p, '/recur/__isfound')
+    assert res.status_int == 200
+    assert 'is found' in res
+    res = fake_request(p, '/user/list')
+    res.all_ok()
+    assert 'user: None' in res
+    res = fake_request(p, '/user/bob/list')
+    assert res.status_int == 200
+    assert 'user: bob' in res
+    
diff --git a/paste/tests/urlparser_data/__init__.py b/paste/tests/urlparser_data/__init__.py
new file mode 100644
index 0000000..792d600
--- /dev/null
+++ b/paste/tests/urlparser_data/__init__.py
@@ -0,0 +1 @@
+#
diff --git a/paste/tests/urlparser_data/deep/index.html b/paste/tests/urlparser_data/deep/index.html
new file mode 100644
index 0000000..8913442
--- /dev/null
+++ b/paste/tests/urlparser_data/deep/index.html
@@ -0,0 +1 @@
+index2
diff --git a/paste/tests/urlparser_data/deep/sub/Main.txt b/paste/tests/urlparser_data/deep/sub/Main.txt
new file mode 100644
index 0000000..ec42756
--- /dev/null
+++ b/paste/tests/urlparser_data/deep/sub/Main.txt
@@ -0,0 +1 @@
+index3
diff --git a/paste/tests/urlparser_data/find_file/index.txt b/paste/tests/urlparser_data/find_file/index.txt
new file mode 100644
index 0000000..6be29bc
--- /dev/null
+++ b/paste/tests/urlparser_data/find_file/index.txt
@@ -0,0 +1 @@
+index1
diff --git a/paste/tests/urlparser_data/find_file/test2.html b/paste/tests/urlparser_data/find_file/test2.html
new file mode 100644
index 0000000..180cf83
--- /dev/null
+++ b/paste/tests/urlparser_data/find_file/test2.html
@@ -0,0 +1 @@
+test2
diff --git a/paste/tests/urlparser_data/hook/__init__.py b/paste/tests/urlparser_data/hook/__init__.py
new file mode 100644
index 0000000..9b1055c
--- /dev/null
+++ b/paste/tests/urlparser_data/hook/__init__.py
@@ -0,0 +1,10 @@
+from paste import wsgilib
+
+def urlparser_hook(environ):
+    first, rest = wsgilib.path_info_split(environ.get('PATH_INFO', ''))
+    if not first:
+        # No username
+        return
+    environ['app.user'] = first
+    environ['SCRIPT_NAME'] += '/' + first
+    environ['PATH_INFO'] = rest
diff --git a/paste/tests/urlparser_data/hook/app.py b/paste/tests/urlparser_data/hook/app.py
new file mode 100644
index 0000000..d2714e5
--- /dev/null
+++ b/paste/tests/urlparser_data/hook/app.py
@@ -0,0 +1,5 @@
+def application(environ, start_response):
+    start_response('200 OK', [('Content-type', 'text/html')])
+    return ['user: %s' % environ['app.user']]
+
+                   
diff --git a/paste/tests/urlparser_data/hook/index.py b/paste/tests/urlparser_data/hook/index.py
new file mode 100644
index 0000000..49e89f0
--- /dev/null
+++ b/paste/tests/urlparser_data/hook/index.py
@@ -0,0 +1,4 @@
+def application(environ, start_response):
+    start_response('200 OK', [('Content-type', 'text/html')])
+    return ['index: %s' % environ['app.user']]
+
diff --git a/paste/tests/urlparser_data/not_found/__init__.py b/paste/tests/urlparser_data/not_found/__init__.py
new file mode 100644
index 0000000..792d600
--- /dev/null
+++ b/paste/tests/urlparser_data/not_found/__init__.py
@@ -0,0 +1 @@
+#
diff --git a/paste/tests/urlparser_data/not_found/recur/__init__.py b/paste/tests/urlparser_data/not_found/recur/__init__.py
new file mode 100644
index 0000000..48205a5
--- /dev/null
+++ b/paste/tests/urlparser_data/not_found/recur/__init__.py
@@ -0,0 +1,9 @@
+def not_found_hook(environ, start_response):
+    urlparser = environ['paste.urlparser.not_found_parser']
+    path = environ.get('PATH_INFO', '')
+    if not path:
+        return urlparser.not_found(environ, start_response)
+    # Strip off leading _'s
+    path = '/' + path.lstrip('/').lstrip('_')
+    environ['PATH_INFO'] = path
+    return urlparser(environ, start_response)
diff --git a/paste/tests/urlparser_data/not_found/recur/isfound.txt b/paste/tests/urlparser_data/not_found/recur/isfound.txt
new file mode 100644
index 0000000..c8b8fab
--- /dev/null
+++ b/paste/tests/urlparser_data/not_found/recur/isfound.txt
@@ -0,0 +1 @@
+is found
diff --git a/paste/tests/urlparser_data/not_found/simple/__init__.py b/paste/tests/urlparser_data/not_found/simple/__init__.py
new file mode 100644
index 0000000..f1e7faa
--- /dev/null
+++ b/paste/tests/urlparser_data/not_found/simple/__init__.py
@@ -0,0 +1,3 @@
+def not_found_hook(environ, start_response):
+    start_response('200 OK', [('Content-type', 'text/plain')])
+    return ['not found']
diff --git a/paste/tests/urlparser_data/not_found/simple/found.txt b/paste/tests/urlparser_data/not_found/simple/found.txt
new file mode 100644
index 0000000..c8b8fab
--- /dev/null
+++ b/paste/tests/urlparser_data/not_found/simple/found.txt
@@ -0,0 +1 @@
+is found
diff --git a/paste/tests/urlparser_data/not_found/user/__init__.py b/paste/tests/urlparser_data/not_found/user/__init__.py
new file mode 100644
index 0000000..c47f88e
--- /dev/null
+++ b/paste/tests/urlparser_data/not_found/user/__init__.py
@@ -0,0 +1,12 @@
+from paste import wsgilib
+
+def not_found_hook(environ, start_response):
+    urlparser = environ['paste.urlparser.not_found_parser']
+    first, rest = wsgilib.path_info_split(environ.get('PATH_INFO', ''))
+    if not first:
+        # No username
+        return
+    environ['app.user'] = first
+    environ['SCRIPT_NAME'] += '/' + first
+    environ['PATH_INFO'] = rest
+    return urlparser(environ, start_response)
diff --git a/paste/tests/urlparser_data/not_found/user/list.py b/paste/tests/urlparser_data/not_found/user/list.py
new file mode 100644
index 0000000..f6228f0
--- /dev/null
+++ b/paste/tests/urlparser_data/not_found/user/list.py
@@ -0,0 +1,3 @@
+def application(environ, start_response):
+    start_response('200 OK', [('Content-type', 'text/plain')])
+    return ['user: %s' % environ.get('app.user')]
diff --git a/paste/tests/urlparser_data/python/__init__.py b/paste/tests/urlparser_data/python/__init__.py
new file mode 100644
index 0000000..792d600
--- /dev/null
+++ b/paste/tests/urlparser_data/python/__init__.py
@@ -0,0 +1 @@
+#
diff --git a/paste/tests/urlparser_data/python/simpleapp.py b/paste/tests/urlparser_data/python/simpleapp.py
new file mode 100644
index 0000000..cbef9f1
--- /dev/null
+++ b/paste/tests/urlparser_data/python/simpleapp.py
@@ -0,0 +1,6 @@
+def application(environ, start_response):
+    start_response('200 OK', [('Content-type', 'text/html'),
+                              ('test-header', 'TEST!')])
+    return ['test1']
+
+                   
diff --git a/paste/tests/urlparser_data/python/stream.py b/paste/tests/urlparser_data/python/stream.py
new file mode 100644
index 0000000..121b4d1
--- /dev/null
+++ b/paste/tests/urlparser_data/python/stream.py
@@ -0,0 +1,7 @@
+def stream():
+    def app(environ, start_response):
+        writer = start_response('200 OK', [('Content-type', 'text/html')])
+        writer('te')
+        writer('st')
+        return ['2']
+    return app
diff --git a/paste/tests/urlparser_data/python/sub/__init__.py b/paste/tests/urlparser_data/python/sub/__init__.py
new file mode 100644
index 0000000..792d600
--- /dev/null
+++ b/paste/tests/urlparser_data/python/sub/__init__.py
@@ -0,0 +1 @@
+#
diff --git a/paste/tests/urlparser_data/python/sub/simpleapp.py b/paste/tests/urlparser_data/python/sub/simpleapp.py
new file mode 100644
index 0000000..fd90966
--- /dev/null
+++ b/paste/tests/urlparser_data/python/sub/simpleapp.py
@@ -0,0 +1,6 @@
+def application(environ, start_response):
+    start_response('200 OK', [('Content-type', 'text/html'),
+                              ('test-header', 'TEST!')])
+    return ['subsimple']
+
+