def __call__(self, environ, start_response):
        request = Request(environ)
        lang = request.values.get('_lang')
        if lang is None:
            lang = (request.accept_languages.best or 'en').split('-')[0].lower()
        if not has_language(lang):
            lang = 'en'
        request.translations = load_core_translations(lang)
        request.translations.language = lang
        response = None

        if request.path == '/':
            view = request.values.get('_current', 'start')
            if request.values.get('_startsetup'):
                response = self.start_setup(request)
            elif view in self.views:
                handler = self.views[view]
                if handler is not None and \
                   request.values.get('_next'):
                    ctx = handler(request)
                    if ctx is not None:
                        response = self.handle_view(request, view, ctx)

                if response is None:
                    if request.values.get('_next'):
                        view = self.next[view]
                    elif request.values.get('_prev'):
                        view = self.prev[view]
                    response = self.handle_view(request, view)

        if response is None:
            response = redirect('')
        return response(environ, start_response)

 def __init__(self, environ, populate_request=True, shallow=False):
     ResponseBase.__init__(self)
     RequestBase.__init__(self, environ, populate_request, shallow)
     self.href = Href(self.script_root or "/", self.charset)
     self.abs_href = Href(self.url_root, self.charset)
     self.headers = Headers([("Content-Type", "text/html")])
     self.response = []
     self.status_code = 200

 def __init__(self, *args, **kwargs):
     self.context = {}
     Request.__init__(self, *args, **kwargs)
     # self.stream, self.form, self.files = parse_form_data(self.environ)
     
     self.context.update(self.args.to_dict())
     self.context.update(self.form.to_dict())
     self.context.update(self.cookies)
     self.context['request'] = self

 def __init__(self, environ):
     RequestBase.__init__(self, environ)
     before_request_init.emit()
     self.url_adapter = url_map.bind_to_environ(self.environ)
     self.match_exception = None
     try:
         self.endpoint, self.view_arguments = self.url_adapter.match()
     except HTTPException, e:
         self.endpoint = self.view_arguments = None
         self.match_exception = e

    def wsgi_app(self, environ, start_response):
        adapter = self.routes.bind_to_environ(environ)

        try:
            endpoint, args = adapter.match()
        except HTTPException as e:
            rv = e
        else:
            req = Request(environ)
            req.view_args = args
            rv = self.make_response(self.views[endpoint](req))

        return rv(environ, start_response)

def _send_with_auth(values, secret_key, url):
  """Send dictionary of JSON serializable `values` as a POST body to `url`
     along with `auth_token` that's generated from `secret_key` and `values`

  scheduler.auth.create_token expects a JSON serializable payload, so we send
  a dictionary. On the receiving end of the POST request, the Flask view will
  have access to a werkzeug.datastructures.ImmutableMultiDict. The easiest
  and most surefire way to ensure that the payload sent to create_token will
  be consistent on both ends is to generate an ImmutableMultiDict using the
  werkzeug.Request.
  """

  data = urllib.urlencode(values)

  # Simulate a Flask request because that is what will be unpacked when the
  # request is received on the other side
  request = Request.from_values(
    content_length=len(data),
    input_stream=StringIO(data),
    content_type='application/x-www-form-urlencoded',
    method='POST')

  # Add the auth_token, re-encode, and send
  values['auth_token'] = create_token(secret_key, dict(request.form))
  data = urllib.urlencode(values)
  req = urllib2.Request(url, data)
  response = urllib2.urlopen(req)
  return json.loads(response.read())

def test_wrapper_support():
    """Securecookie wrapper integration"""
    req = Request.from_values()
    resp = Response()
    c = SecureCookie.load_cookie(req, secret_key='foo')
    assert c.new
    c['foo'] = 42
    assert c.secret_key == 'foo'
    c.save_cookie(resp)

    req = Request.from_values(headers={
        'Cookie':  'session="%s"' % parse_cookie(resp.headers['set-cookie'])['session']
    })
    c2 = SecureCookie.load_cookie(req, secret_key='foo')
    assert not c2.new
    assert c2 == c

def test_large_file():
    """Test a largish file."""
    data = "x" * (1024 * 600)
    req = Request.from_values(data={"foo": (StringIO(data), "test.txt")}, method="POST")
    # make sure we have a real file here, because we expect to be
    # on the disk.  > 1024 * 500
    assert isinstance(req.files["foo"].stream, file)

def test_nonstandard_line_endings():
    """Test nonstandard line endings of multipart form data"""
    for nl in "\n", "\r", "\r\n":
        data = nl.join(
            (
                "--foo",
                "Content-Disposition: form-data; name=foo",
                "",
                "this is just bar",
                "--foo",
                "Content-Disposition: form-data; name=bar",
                "",
                "blafasel",
                "--foo--",
            )
        )
        req = Request.from_values(
            input_stream=StringIO(data),
            content_length=len(data),
            content_type="multipart/form-data; " "boundary=foo",
            method="POST",
        )
        print req.form
        assert req.form["foo"] == "this is just bar"
        assert req.form["bar"] == "blafasel"

def test_large_file():
    """Test a largish file."""
    data = 'x' * (1024 * 600)
    req = Request.from_values(data={'foo': (StringIO(data), 'test.txt')},
                              method='POST')
    # make sure we have a real file here, because we expect to be
    # on the disk.  > 1024 * 500
    assert isinstance(req.files['foo'].stream, file)

    def dispatch(self, environ, start_response):
        local.application = self
        request = Request(environ)
        local.url_adapter = adapter = url_map.bind_to_environ(environ)

        request.debug = self.debug
        
        request.session = SecureCookie.load_cookie(request, 
                                                   key='com.kinaj.session', 
                                                   secret_key='kinaj')
        
        try:
            endpoint, values = adapter.match()
            handler = getattr(views, endpoint)
            response = handler(request, **values)
            
        except NotFound, e:
            response = views.not_found(request)
            response.status_code = 404

 def __init__(self, environ):
     RequestBase.__init__(self, environ)
     before_request_init.emit()
     self.url_adapter = url_map.bind_to_environ(self.environ)
     self.view_lang = self.match_exception = None
     try:
         self.endpoint, self.view_arguments = self.url_adapter.match()
         view_lang = self.view_arguments.pop('lang_code', None)
         if view_lang is not None:
             try:
                 self.view_lang = Locale.parse(view_lang)
                 if not has_section(self.view_lang):
                     raise UnknownLocaleError(str(self.view_lang))
             except UnknownLocaleError:
                 self.view_lang = None
                 self.match_exception = NotFound()
     except HTTPException, e:
         self.endpoint = self.view_arguments = None
         self.match_exception = e

	def dispatch(self, environ, start_response):
		local.application = self
		request = Request(environ)

		## this is where we load the cookie if any, or create a new one
		sid = request.cookies.get('kif415-helfer-login')
		if sid is None:
			request.session = session_store.new()
		else:
			request.session = session_store.get(sid)
			if not validate_session(request.session):
				session_store.delete(request.session)
				request.session = session_store.new()
				request.session['logout'] = True

		local.url_adapter = adapter = url_map.bind_to_environ(environ)
		try:
			endpoint, values = adapter.match()
			handler = getattr(views, endpoint)
			response = handler(request, **values)
		except HTTPException, e:
			response = e # XXX hrm? this breaks when setting cookies!

def test_multipart_file_no_content_type():
    """Chrome does not always provide a content type."""
    data = (
        '--foo\r\n'
        'Content-Disposition: form-data; name="test"; filename="test.txt"\r\n\r\n'
        'file contents\r\n--foo--'
    )
    data = Request.from_values(input_stream=StringIO(data),
                               content_length=len(data),
                               content_type='multipart/form-data; boundary=foo',
                               method='POST')
    assert data.files['test'].filename == 'test.txt'
    assert data.files['test'].read() == 'file contents'

def test_extra_newline_multipart():
    """Test for multipart uploads with extra newlines"""
    # this test looks innocent but it was actually timeing out in
    # the Werkzeug 0.5 release version (#394)
    data = "\r\n\r\n--foo\r\n" 'Content-Disposition: form-data; name="foo"\r\n\r\n' "a string\r\n" "--foo--"
    data = Request.from_values(
        input_stream=StringIO(data),
        content_length=len(data),
        content_type="multipart/form-data; boundary=foo",
        method="POST",
    )
    assert not data.files
    assert data.form["foo"] == "a string"

def test_multipart_file_no_content_type():
    """Chrome does not always provide a content type."""
    data = (
        "--foo\r\n"
        'Content-Disposition: form-data; name="test"; filename="test.txt"\r\n\r\n'
        "file contents\r\n--foo--"
    )
    data = Request.from_values(
        input_stream=StringIO(data),
        content_length=len(data),
        content_type="multipart/form-data; boundary=foo",
        method="POST",
    )
    assert data.files["test"].filename == "test.txt"
    assert data.files["test"].read() == "file contents"

def test_multipart_headers():
    """Test access to multipart headers"""
    data = ('--foo\r\n'
            'Content-Disposition: form-data; name="foo"; filename="foo.txt"\r\n'
            'X-Custom-Header: blah\r\n'
            'Content-Type: text/plain; charset=utf-8\r\n\r\n'
            'file contents, just the contents\r\n'
            '--foo--')
    req = Request.from_values(input_stream=StringIO(data),
                              content_length=len(data),
                              content_type='multipart/form-data; boundary=foo',
                              method='POST')
    foo = req.files['foo']
    assert foo.content_type == 'text/plain'
    assert foo.headers['content-type'] == 'text/plain; charset=utf-8'
    assert foo.headers['x-custom-header'] == 'blah'

def test_end_of_file_multipart():
    """Test for multipart files ending unexpectedly"""
    # This test looks innocent but it was actually timeing out in
    # the Werkzeug 0.5 release version (#394)
    data = (
        '--foo\r\n'
        'Content-Disposition: form-data; name="test"; filename="test.txt"\r\n'
        'Content-Type: text/plain\r\n\r\n'
        'file contents and no end'
    )
    data = Request.from_values(input_stream=StringIO(data),
                               content_length=len(data),
                               content_type='multipart/form-data; boundary=foo',
                               method='POST')
    assert not data.files
    assert not data.form

 def serve(self, interface='0.0.0.0', port=3080,
     max_size=DEFAULT_MAX_CONC_REQUESTS):
     
     self.log.info('ZenQueue HTTP Server v%s', zenqueue.__version__)
     if interface == '0.0.0.0':
         self.log.info('Serving on %s:%d (all interfaces)', interface, port)
     else:
         self.log.info('Serving on %s:%d', interface, port)
     
     self.sock = api.tcp_listener((interface, port))
     
     try:
         # Wrap `self` with `Request.application` so that we get a request as
         # an argument instead of the usual `environ, start_response`.
         wsgi.server(self.sock, Request.application(self), max_size=max_size)
     finally:
         self.sock = None

def test_multipart_headers():
    """Test access to multipart headers"""
    data = (
        "--foo\r\n"
        'Content-Disposition: form-data; name="foo"; filename="foo.txt"\r\n'
        "X-Custom-Header: blah\r\n"
        "Content-Type: text/plain; charset=utf-8\r\n\r\n"
        "file contents, just the contents\r\n"
        "--foo--"
    )
    req = Request.from_values(
        input_stream=StringIO(data),
        content_length=len(data),
        content_type="multipart/form-data; boundary=foo",
        method="POST",
    )
    foo = req.files["foo"]
    assert foo.content_type == "text/plain"
    assert foo.headers["content-type"] == "text/plain; charset=utf-8"
    assert foo.headers["x-custom-header"] == "blah"