def test_group_inexact_pattern(self):
        r = route("news",
                route("{id:int}",
                    route("comments", "view")))
        req = Request.blank("/news/42/comments")
        tr = r(req)
        self.assertEqual(
                (tr.args, tr.kwargs, tr.endpoint.target),
                ((42,), {}, "view"))

        r = route("news/{id:int}",
                route("comments", "view"))
        req = Request.blank("/news/42/comments")
        tr = r(req)
        self.assertEqual(
                (tr.args, tr.kwargs, tr.endpoint.target),
                ((42,), {}, "view"))

        r = route("news",
                route("{id:int}/comments", "view"))
        req = Request.blank("/news/42/comments")
        tr = r(req)
        self.assertEqual(
                (tr.args, tr.kwargs, tr.endpoint.target),
                ((42,), {}, "view"))

def make_pre_authed_request(env, method, path, body=None, headers=None, agent="Swift"):
    """
    Makes a new webob.Request based on the current env but with the
    parameters specified. Note that this request will be preauthorized.

    :param env: Current WSGI environment dictionary
    :param method: HTTP method of new request
    :param path: HTTP path of new request
    :param body: HTTP body of new request; None by default
    :param headers: Extra HTTP headers of new request; None by default

    :returns: webob.Request object

    (Stolen from Swauth: https://github.com/gholt/swauth)
    """
    newenv = {"REQUEST_METHOD": method, "HTTP_USER_AGENT": agent}
    for name in ("swift.cache", "swift.trans_id"):
        if name in env:
            newenv[name] = env[name]
    newenv["swift.authorize"] = lambda req: None
    if not headers:
        headers = {}
    if body:
        return Request.blank(path, environ=newenv, body=body, headers=headers)
    else:
        return Request.blank(path, environ=newenv, headers=headers)

 def test_GET_empty_account_plain(self):
     req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'PUT',
         'HTTP_X_TIMESTAMP': '0'})
     self.controller.PUT(req)
     req = Request.blank('/sda1/p/a', environ={'REQUEST_METHOD': 'GET'})
     resp = self.controller.GET(req)
     self.assertEquals(resp.status_int, 204)

    def test_origin_db_valid_setup(self):
        fake_conf = FakeConf(data=['[sos]',
            'origin_cdn_host_suffixes = origin_cdn.com'])
        test_origin = origin.filter_factory(
            {'sos_conf': fake_conf})(FakeApp())
        resp = Request.blank('http://origin_db.com:8080/v1/acc/cont',
            environ={'REQUEST_METHOD': 'POST'}).get_response(test_origin)
        self.assertEquals(resp.status_int, 404)

        fake_conf = FakeConf(data='''[sos]
origin_admin_key = unittest
origin_cdn_host_suffixes = origin_cdn.com
origin_db_hosts = origin_db.com
origin_account = .origin
max_cdn_file_size = 0
'''.split('\n'))
        test_origin = origin.filter_factory(
            {'sos_conf': fake_conf})(FakeApp())
        resp = Request.blank('http://origin_db.com:8080/v1/acc/cont',
            environ={'REQUEST_METHOD': 'POST'}).get_response(test_origin)
        self.assertEquals(resp.status_int, 500)

        fake_conf = FakeConf(data='''[sos]
origin_admin_key = unittest
origin_db_hosts = origin_db.com
origin_account = .origin
max_cdn_file_size = 0
'''.split('\n'))
        factory = origin.filter_factory(
            {'sos_conf': fake_conf})
        self.assertRaises(origin.InvalidConfiguration, factory, FakeApp())

    def test_cdn_get_no_content(self):
        prev_data = json.dumps({'account': 'acc', 'container': 'cont',
                'ttl': 1234, 'logs_enabled': True, 'cdn_enabled': True})
        self.test_origin.app = FakeApp(iter([
            ('204 No Content', {}, prev_data), # call to _get_cdn_data
            ('304 No Content', {}, '')])) #call to get obj
        req = Request.blank('http://1234.r34.origin_cdn.com:8080/obj1.jpg',
            environ={'REQUEST_METHOD': 'HEAD',
                     'swift.cdn_hash': 'abcd',
                     'swift.cdn_object_name': 'obj1.jpg'})
        resp = req.get_response(self.test_origin)
        self.assertEquals(resp.status_int, 304)

        self.test_origin.app = FakeApp(iter([
            ('204 No Content', {}, prev_data), # call to _get_cdn_data
            ('404 No Content', {}, '')])) #call to get obj
        req = Request.blank('http://1234.r34.origin_cdn.com:8080/obj1.jpg',
            environ={'REQUEST_METHOD': 'HEAD',
                     'swift.cdn_hash': 'abcd',
                     'swift.cdn_object_name': 'obj1.jpg'})
        resp = req.get_response(self.test_origin)
        self.assertEquals(resp.status_int, 404)

        self.test_origin.app = FakeApp(iter([
            ('204 No Content', {}, prev_data), # call to _get_cdn_data
            ('416 No Content', {}, '')])) #call to get obj
        req = Request.blank('http://1234.r34.origin_cdn.com:8080/obj1.jpg',
            environ={'REQUEST_METHOD': 'HEAD',
                     'swift.cdn_hash': 'abcd',
                     'swift.cdn_object_name': 'obj1.jpg'})
        resp = req.get_response(self.test_origin)
        self.assertEquals(resp.status_int, 416)

    def DELETE(self, env, start_response):
        """
        Handle DELETE both container and data object removal.
        """

        path = "/v1/" + self.account_name + "/" + self.container_name
        query_string = "delimiter=/"
        if self.object_name:
            query_string += "&prefix=" + concat_parts(self.parent_name, self.object_name) + "/"
        exists, dummy, body = check_resource(env, "GET", path, self.logger, True, query_string)
        # Not even the top container exist, so there is no such resource.
        if not exists:
            return get_err_response("NoSuchKey")
        # Top container exists, check if there is anything under.
        else:
            try:
                children = json.loads(body)
                # there are some children under
                if len(children) > 0:
                    return get_err_response("ContainerNotEmpty")
            except ValueError:
                return get_err_response("InconsistantState")

        # Create a new WebOb Request object according to the current request
        req = Request(env)
        # Now send the request over.
        return req.get_response(self.app)

    def test_bucket_GET_max_keys(self):
        class FakeApp(object):
            def __call__(self, env, start_response):
                self.query_string = env['QUERY_STRING']
                start_response('200 OK', [])
                return '[]'
        fake_app = FakeApp()
        local_app = swift3.filter_factory({})(fake_app)
        bucket_name = 'junk'

        req = Request.blank('/%s' % bucket_name,
                environ={'REQUEST_METHOD': 'GET',
                         'QUERY_STRING': 'max-keys=5'},
                headers={'Authorization': 'AWS test:tester:hmac'})
        resp = local_app(req.environ, lambda *args: None)
        dom = xml.dom.minidom.parseString("".join(resp))
        self.assertEquals(dom.getElementsByTagName('MaxKeys')[0].
                childNodes[0].nodeValue, '5')
        args = dict(cgi.parse_qsl(fake_app.query_string))
        self.assert_(args['limit'] == '6')

        req = Request.blank('/%s' % bucket_name,
                environ={'REQUEST_METHOD': 'GET',
                         'QUERY_STRING': 'max-keys=5000'},
                headers={'Authorization': 'AWS test:tester:hmac'})
        resp = local_app(req.environ, lambda *args: None)
        dom = xml.dom.minidom.parseString("".join(resp))
        self.assertEquals(dom.getElementsByTagName('MaxKeys')[0].
                childNodes[0].nodeValue, '1000')
        args = dict(cgi.parse_qsl(fake_app.query_string))
        self.assertEquals(args['limit'], '1001')

    def __call__(self,environ,start_response):
        req = Request(environ)

        session = environ.get('pybald.session', None)
        if session and session.user and session.user.can_login:
            environ['REMOTE_USER'] = session.user
        else:
            environ['REMOTE_USER'] = None

        if environ['REMOTE_USER']:
            # Continuously validate user sessions
            # TODO: Clean up our app-level login code a lot...

            # Look for a "valid" method on User
            try:
                valid = getattr(environ['REMOTE_USER'], "valid")
            except AttributeError:
                # (If this method isn't defined, do nothing.)
                pass
            else:
                # If available, call it, and expect a Boolean:
                # If False, end the session right now.
                if not valid():
                    environ['REMOTE_USER'] = None
                # Otherwise, do nothing

        # update or create the pybald.extension to populate controller instances
        environ['pybald.extension'] = environ.get('pybald.extension', {})
        environ['pybald.extension']['user'] = environ['REMOTE_USER']

        # call the next part of the pipeline
        resp = req.get_response(self.application)
        return resp(environ,start_response)

    def __call__(self, env, start_response):
        req = Request(env)

        if 'AWSAccessKeyId' in req.GET:
            try:
                req.headers['Date'] = req.GET['Expires']
                req.headers['Authorization'] = \
                    'AWS %(AWSAccessKeyId)s:%(Signature)s' % req.GET
            except KeyError:
                return get_err_response('InvalidArgument')(env, start_response)

        if not 'Authorization' in req.headers:
            return self.app(env, start_response)

        try:
            account, signature = \
                req.headers['Authorization'].split(' ')[-1].rsplit(':', 1)
        except Exception:
            return get_err_response('InvalidArgument')(env, start_response)

        try:
            controller, path_parts = self.get_controller(req.path)
        except ValueError:
            return get_err_response('InvalidURI')(env, start_response)

        token = base64.urlsafe_b64encode(canonical_string(req))

        controller = controller(env, self.app, account, token, **path_parts)

        if hasattr(controller, req.method):
            res = getattr(controller, req.method)(env, start_response)
        else:
            return get_err_response('InvalidURI')(env, start_response)

        return res(env, start_response)

 def test_domain_remap_account(self):
     req = Request.blank("/", environ={"REQUEST_METHOD": "GET"}, headers={"Host": "AUTH_a.example.com"})
     resp = self.app(req.environ, start_response)
     self.assertEquals(resp, "/v1/AUTH_a")
     req = Request.blank("/", environ={"REQUEST_METHOD": "GET"}, headers={"Host": "AUTH-uuid.example.com"})
     resp = self.app(req.environ, start_response)
     self.assertEquals(resp, "/v1/AUTH_uuid")

    def test_method_inner(self):
        r = route(
            route('news', 'news'),
            route(GET, 'comments', 'comments_get'),
            route(POST, 'comments', 'comments_post'))

        req = Request.blank('/news', {'REQUEST_METHOD': 'GET'})
        tr = r(req)
        self.assertEqual(
            (tr.args, tr.kwargs, tr.target),
            ((), {}, 'news'))

        req = Request.blank('/news', {'REQUEST_METHOD': 'POST'})
        self.assertRaises(
            RouteGuarded,
            r, req)

        req = Request.blank('/comments', {'REQUEST_METHOD': 'POST'})
        tr = r(req)
        self.assertEqual(
            (tr.args, tr.kwargs, tr.target),
            ((), {}, 'comments_post'))

        req = Request.blank('/comments', {'REQUEST_METHOD': 'DELETE'})
        self.assertRaises(
            RouteGuarded,
            r, req)

        self.assertNoMatch(r, '/newsweeek')
        self.assertNoMatch(r, '/ne')

 def test_domain_remap_passthrough(self):
     req = Request.blank("/", environ={"REQUEST_METHOD": "GET"}, headers={"Host": "example.com"})
     resp = self.app(req.environ, start_response)
     self.assertEquals(resp, "/")
     req = Request.blank("/", environ={"REQUEST_METHOD": "GET"}, headers={"Host": "example.com:8080"})
     resp = self.app(req.environ, start_response)
     self.assertEquals(resp, "/")

    def __call__(self, environ, start_response):
        req = Request(environ)
        if self._no_redirect_re.match(environ['PATH_INFO']):
            return req.get_response(self.app)(environ, start_response)
        resp = None
        try:
            request_uri = req.url
            request_uri.decode('ascii')
        except UnicodeError:
            resp = exc.HTTPNotFound()
        secure = req.url.startswith('https://')
        srv_path = req.url.split('://', 1)[-1]
        # This SFUSER check is SourceForge-specific (to require all logged-in users to use https)
        # BUT has the additional affect of not forcing SSL for regular Allura instances
        # This is important for local development, at least.  When we remove SFUSER (perhaps by requiring SSL everywhere),
        # we can use `no_redirect.pattern = .` for local development to work without SSL
        force_ssl = req.cookies.get('SFUSER') or self._force_ssl_re.match(environ['PATH_INFO'])
        if not secure and force_ssl:
            resp = exc.HTTPFound(location='https://' + srv_path)
        elif secure and not force_ssl:
            resp = exc.HTTPFound(location='http://' + srv_path)

        if not resp:
            resp = self.app
        return resp(environ, start_response)

    def test_xml_transcript(self):
        """
        Set data_dir and remove runtime modulestore to simulate an XMLModuelStore course.
        Then run the same tests as static_asset_path run.
        """
        # Simulate XMLModuleStore xmodule
        self.item_descriptor.data_dir = 'dummy/static'
        del self.item_descriptor.runtime.modulestore

        self.assertFalse(self.course.static_asset_path)

        # Test youtube style en
        request = Request.blank('/translation/en?videoId=12345')
        response = self.item.transcript(request=request, dispatch='translation/en')
        self.assertEqual(response.status, '307 Temporary Redirect')
        self.assertIn(
            ('Location', '/static/dummy/static/subs_12345.srt.sjson'),
            response.headerlist
        )

        # Test HTML5 video style
        self.item.sub = 'OEoXaMPEzfM'
        request = Request.blank('/translation/en')
        response = self.item.transcript(request=request, dispatch='translation/en')
        self.assertEqual(response.status, '307 Temporary Redirect')
        self.assertIn(
            ('Location', '/static/dummy/static/subs_OEoXaMPEzfM.srt.sjson'),
            response.headerlist
        )

        # Test different language to ensure we are just ignoring it since we can't
        # translate with static fallback
        request = Request.blank('/translation/uk')
        response = self.item.transcript(request=request, dispatch='translation/uk')
        self.assertEqual(response.status, '404 Not Found')

 def test_container4unknown_memcache(self):
     fake_memcache = FakeMemcache()
     self.assertEquals(fake_memcache.store, {})
     resp = Request.blank("/v1/a/c4", environ={"swift.cache": fake_memcache}).get_response(self.test_staticweb)
     self.assertEquals(resp.status_int, 301)
     self.assertEquals(fake_memcache.store, {"/staticweb/v1/a/c4": ("index.html", "error.html", "t", "listing.css")})
     self.assert_(self.test_staticweb.app.get_c4_called)
     self.test_staticweb.app.get_c4_called = False
     resp = Request.blank("/v1/a/c4", environ={"swift.cache": fake_memcache}).get_response(self.test_staticweb)
     self.assertEquals(resp.status_int, 301)
     self.assert_(not self.test_staticweb.app.get_c4_called)
     self.assertEquals(fake_memcache.store, {"/staticweb/v1/a/c4": ("index.html", "error.html", "t", "listing.css")})
     resp = Request.blank("/v1/a/c4", environ={"swift.cache": fake_memcache, "REQUEST_METHOD": "PUT"}).get_response(
         self.test_staticweb
     )
     self.assertEquals(resp.status_int, 200)
     self.assertEquals(fake_memcache.store, {})
     resp = Request.blank("/v1/a/c4", environ={"swift.cache": fake_memcache}).get_response(self.test_staticweb)
     self.assertEquals(resp.status_int, 301)
     self.assertEquals(fake_memcache.store, {"/staticweb/v1/a/c4": ("index.html", "error.html", "t", "listing.css")})
     resp = Request.blank("/v1/a/c4", environ={"swift.cache": fake_memcache, "REQUEST_METHOD": "POST"}).get_response(
         self.test_staticweb
     )
     self.assertEquals(resp.status_int, 200)
     self.assertEquals(fake_memcache.store, {})

    def test_translation_fails(self):
        # No language
        request = Request.blank('')
        response = self.item_descriptor.studio_transcript(request=request, dispatch='translation')
        self.assertEqual(response.status, '400 Bad Request')

        # No filename in request.GET
        request = Request.blank('')
        response = self.item_descriptor.studio_transcript(request=request, dispatch='translation/uk')
        self.assertEqual(response.status, '400 Bad Request')

        # Correct case:
        filename = os.path.split(self.non_en_file.name)[1]
        _upload_file(self.non_en_file, self.item_descriptor.location, filename)
        self.non_en_file.seek(0)
        request = Request.blank(u'translation/uk?filename={}'.format(filename))
        response = self.item_descriptor.studio_transcript(request=request, dispatch='translation/uk')
        self.assertEqual(response.body, self.non_en_file.read())
        self.assertEqual(response.headers['Content-Type'], 'application/x-subrip; charset=utf-8')
        self.assertEqual(
            response.headers['Content-Disposition'],
            'attachment; filename="{}"'.format(filename)
        )
        self.assertEqual(response.headers['Content-Language'], 'uk')

        # Non ascii file name download:
        self.non_en_file.seek(0)
        _upload_file(self.non_en_file, self.item_descriptor.location, u'塞.srt')
        self.non_en_file.seek(0)
        request = Request.blank('translation/zh?filename={}'.format(u'塞.srt'.encode('utf8')))
        response = self.item_descriptor.studio_transcript(request=request, dispatch='translation/zh')
        self.assertEqual(response.body, self.non_en_file.read())
        self.assertEqual(response.headers['Content-Type'], 'application/x-subrip; charset=utf-8')
        self.assertEqual(response.headers['Content-Disposition'], 'attachment; filename="塞.srt"')
        self.assertEqual(response.headers['Content-Language'], 'zh')

 def __call__(self, environ, start_response):
     req = Request(environ)
     req.remove_conditional_headers()
     resp = req.get_response(self.app)
     if resp.content_type == 'text/html':
         resp.body = jumble_words(resp.body)
     return resp(environ, start_response)

    def dispatch_wsgi(self, environ, start_response):
        """
        Dispatches a WSGI request.

        :param environ: WSGI request environment.
        :param start_response: WSGI response callback
        :returns: A valid WSGI response content.
        """
        req = Request(environ)
        req.response = Response()

        try:
            resp = self.dispatch_request(req)
        except HTTPException as e:
            resp = e

        if inspect.isgenerator(resp):
            resp = Response(app_iter=resp)
        elif resp is None:
            resp = req.response
        if isinstance(resp, text_type):
            resp = bytes_(resp, req.charset)
        if isinstance(resp, bytes):
            body = resp
            resp = req.response
            resp.write(body)
        if resp is not req.response:
            resp = req.response.merge_cookies(resp)
        return resp(environ, start_response)

    def _do_proxy_call(self, environ, orig_response, url, prefix):
        # TODO: wrap it all into try/except and display main app page with
        # traceback in it
        log.debug('SSI proxy call to "%s"'%url)
        proxy = WSGIProxyApp(url)
        o = urlparse(url)
        middleware = WSGIProxyMiddleware(proxy, 
            scheme=o.scheme, domain=o.hostname, port=(o.port or '80'))

        # after parse includes process reads input restore file pointer so proxy
        # can still read all post data
        # environ['wsgi.input'].seek(0)

        reqenv = environ.copy()
        if reqenv['PATH_INFO'].startswith(prefix):
            reqenv['PATH_INFO'] = reqenv['PATH_INFO'][len(prefix):]
            reqenv['RAW_URI'] = reqenv['RAW_URI'][len(prefix):]

        proxy_req = Request(reqenv)

        # tweak proxy request headers a bit
        self._copy_user_headers(orig_response, proxy_req)
        self._purge_cache_headers(proxy_req)

        proxy_resp = proxy_req.get_response(middleware)

        # ignore redirects
        # TODO: redirect only when location is within proxy_url
        proxy_resp.location = None
        return proxy_resp

    def test_admin_setup(self):
        # PUTs for account and 16 .hash's
        self.test_origin.app = FakeApp(iter(
           [('204 No Content', {}, '') for i in xrange(102)]))
        resp = Request.blank('/origin/.prep',
            environ={'REQUEST_METHOD': 'PUT'},
            headers={'X-Origin-Admin-User': '.origin_admin',
                     'X-Origin-Admin-Key': 'unittest'}).get_response(
                     self.test_origin)
        self.assertEquals(resp.status_int, 204)
        self.assertEquals(self.test_origin.app.calls, 101)

        self.test_origin.app = FakeApp(iter(
           [('404 Not Found', {}, '')]))
        req = Request.blank('/origin/.prep',
            environ={'REQUEST_METHOD': 'PUT'},
            headers={'X-Origin-Admin-User': '.origin_admin',
                     'X-Origin-Admin-Key': 'unittest'})
        self.assertRaises(Exception, req.get_response, self.test_origin)

        self.test_origin.app = FakeApp(iter(
           [('204 No Content', {}, ''), ('404 Not Found', {}, '')]))
        req = Request.blank('/origin/.prep',
            environ={'REQUEST_METHOD': 'PUT'},
            headers={'X-Origin-Admin-User': '.origin_admin',
                     'X-Origin-Admin-Key': 'unittest'})
        self.assertRaises(Exception, req.get_response, self.test_origin)