# -*- coding: utf-8 -*-
import StringIO

import webapp2

import test_base


def _norm_req(s):
    return '\r\n'.join(s.strip().replace('\r','').split('\n'))

_test_req = """
POST /webob/ HTTP/1.0
Accept: */*
Cache-Control: max-age=0
Content-Type: multipart/form-data; boundary=----------------------------deb95b63e42a
Host: pythonpaste.org
User-Agent: UserAgent/1.0 (identifier-version) library/7.0 otherlibrary/0.8

------------------------------deb95b63e42a
Content-Disposition: form-data; name="foo"

foo
------------------------------deb95b63e42a
Content-Disposition: form-data; name="bar"; filename="bar.txt"
Content-type: application/octet-stream

these are the contents of the file 'bar.txt'

------------------------------deb95b63e42a--
"""

_test_req2 = """
POST / HTTP/1.0
Content-Length: 0

"""

_test_req = _norm_req(_test_req)
_test_req2 = _norm_req(_test_req2) + '\r\n'


class TestRequest(test_base.BaseTestCase):
    def test_charset(self):
        req = webapp2.Request.blank('/', environ={
            'CONTENT_TYPE': 'text/html; charset=ISO-8859-4',
        })
        self.assertEqual(req.content_type, 'text/html')
        self.assertEqual(req.charset, 'iso-8859-4')

        req = webapp2.Request.blank('/', environ={
            'CONTENT_TYPE': 'application/json; charset="ISO-8859-1"',
        })
        self.assertEqual(req.content_type, 'application/json')
        self.assertEqual(req.charset, 'iso-8859-1')

        req = webapp2.Request.blank('/', environ={
            'CONTENT_TYPE': 'application/json',
        })
        self.assertEqual(req.content_type, 'application/json')
        self.assertEqual(req.charset.lower(), 'utf-8')

        match = webapp2._charset_re.search('text/html')
        if match:
            charset = match.group(1).lower().strip().strip('"').strip()
        else:
            charset = 'utf-8'
        self.assertEqual(charset, 'utf-8')

        match = webapp2._charset_re.search('text/html; charset=ISO-8859-4')
        if match:
            charset = match.group(1).lower().strip().strip('"').strip()
        else:
            charset = 'utf-8'
        self.assertEqual(charset, 'iso-8859-4')

        match = webapp2._charset_re.search('text/html; charset="ISO-8859-4"')
        if match:
            charset = match.group(1).lower().strip().strip('"').strip()
        else:
            charset = 'utf-8'
        self.assertEqual(charset, 'iso-8859-4')

        match = webapp2._charset_re.search('text/html; charset=  "  ISO-8859-4  "  ')
        if match:
            charset = match.group(1).lower().strip().strip('"').strip()
        else:
            charset = 'utf-8'
        self.assertEqual(charset, 'iso-8859-4')

    def test_unicode(self):
        req = webapp2.Request.blank('/?1=2', POST='3=4')

        res = req.GET.get('1')
        self.assertEqual(res, '2')
        self.assertTrue(isinstance(res, unicode))

        res = req.str_GET.get('1')
        self.assertEqual(res, '2')
        self.assertTrue(isinstance(res, str))

        res = req.POST.get('3')
        self.assertEqual(res, '4')
        self.assertTrue(isinstance(res, unicode))

        res = req.str_POST.get('3')
        self.assertEqual(res, '4')
        self.assertTrue(isinstance(res, str))

    def test_cookie_unicode(self):
        import urllib
        import base64

        # With base64 ---------------------------------------------------------

        value = base64.b64encode(u'á'.encode('utf-8'))
        rsp = webapp2.Response()
        rsp.set_cookie('foo', value)

        cookie = rsp.headers.get('Set-Cookie')
        req = webapp2.Request.blank('/', headers=[('Cookie', cookie)])

        self.assertEqual(req.cookies.get('foo'), value)
        self.assertEqual(base64.b64decode(req.cookies.get('foo')).decode('utf-8'), u'á')

        # Without quote -------------------------------------------------------

        # Most recent WebOb versions take care of quoting.
        # (not the version available on App Engine though)

        value = u'föö=bär; föo, bär, bäz=dïng;'
        rsp = webapp2.Response()
        rsp.set_cookie('foo', value)

        cookie = rsp.headers.get('Set-Cookie')
        req = webapp2.Request.blank('/', headers=[('Cookie', cookie)])

        self.assertEqual(req.cookies.get('foo'), value)

        # With quote, hard way ------------------------------------------------

        # Here is our test value.
        x = u'föö'
        # We must store cookies quoted. To quote unicode, we need to encode it.
        y = urllib.quote(x.encode('utf8'))
        # The encoded, quoted string looks ugly.
        self.assertEqual(y, 'f%C3%B6%C3%B6')
        # But it is easy to get it back to our initial value.
        z = urllib.unquote(y).decode('utf8')
        # And it is indeed the same value.
        self.assertEqual(z, x)

        # Set a cookie using the encoded/quoted value.
        rsp = webapp2.Response()
        rsp.set_cookie('foo', y)
        cookie = rsp.headers.get('Set-Cookie')
        self.assertEqual(cookie, 'foo=f%C3%B6%C3%B6; Path=/')

        # Get the cookie back.
        req = webapp2.Request.blank('/', headers=[('Cookie', cookie)])
        self.assertEqual(req.cookies.get('foo'), y)
        # Here is our original value, again. Problem: the value is decoded
        # before we had a chance to unquote it.
        w = urllib.unquote(req.cookies.get('foo').encode('utf8')).decode('utf8')
        # And it is indeed the same value.
        self.assertEqual(w, x)

        # With quote, easy way ------------------------------------------------

        value = u'föö=bär; föo, bär, bäz=dïng;'
        quoted_value = urllib.quote(value.encode('utf8'))
        rsp = webapp2.Response()
        rsp.set_cookie('foo', quoted_value)

        cookie = rsp.headers.get('Set-Cookie')
        req = webapp2.Request.blank('/', headers=[('Cookie', cookie)])

        cookie_value = req.str_cookies.get('foo')
        unquoted_cookie_value = urllib.unquote(cookie_value).decode('utf-8')
        self.assertEqual(cookie_value, quoted_value)
        self.assertEqual(unquoted_cookie_value, value)

    def test_get(self):
        req = webapp2.Request.blank('/?1=2&1=3&3=4', POST='5=6&7=8')

        res = req.get('1')
        self.assertEqual(res, '2')

        res = req.get('1', allow_multiple=True)
        self.assertEqual(res, ['2', '3'])

        res = req.get('8')
        self.assertEqual(res, '')

        res = req.get('8', allow_multiple=True)
        self.assertEqual(res, [])

        res = req.get('8', default_value='9')
        self.assertEqual(res, '9')

    def test_get_with_POST(self):
        req = webapp2.Request.blank('/?1=2&1=3&3=4', POST={5: 6, 7: 8},
                                    unicode_errors='ignore')

        res = req.get('1')
        self.assertEqual(res, '2')

        res = req.get('1', allow_multiple=True)
        self.assertEqual(res, ['2', '3'])

        res = req.get('8')
        self.assertEqual(res, '')

        res = req.get('8', allow_multiple=True)
        self.assertEqual(res, [])

        res = req.get('8', default_value='9')
        self.assertEqual(res, '9')

    def test_arguments(self):
        req = webapp2.Request.blank('/?1=2&3=4', POST='5=6&7=8')

        res = req.arguments()
        self.assertEqual(res, ['1', '3', '5', '7'])

    def test_get_range(self):
        req = webapp2.Request.blank('/')
        res = req.get_range('1', min_value=None, max_value=None, default=None)
        self.assertEqual(res, None)

        req = webapp2.Request.blank('/?1=2')
        res = req.get_range('1', min_value=None, max_value=None, default=0)
        self.assertEqual(res, 2)

        req = webapp2.Request.blank('/?1=foo')
        res = req.get_range('1', min_value=1, max_value=99, default=100)
        self.assertEqual(res, 99)

    def test_issue_3426(self):
        """When the content-type is 'application/x-www-form-urlencoded' and
        POST data is empty the content-type is dropped by Google appengine.
        """
        req = webapp2.Request.blank('/', environ={
            'REQUEST_METHOD': 'GET',
            'CONTENT_TYPE': 'application/x-www-form-urlencoded',
        })
        self.assertEqual(req.method, 'GET')
        self.assertEqual(req.content_type, 'application/x-www-form-urlencoded')

    # XXX: These tests fail when request charset is set to utf-8 by default.
    # Otherwise they pass.
    '''
    def test_get_with_FieldStorage(self):
        if not test_base.check_webob_version(1.0):
            return
        # A valid request without a Content-Length header should still read
        # the full body.
        # Also test parity between as_string and from_string / from_file.
        import cgi
        req = webapp2.Request.from_string(_test_req)
        self.assertTrue(isinstance(req, webapp2.Request))
        self.assertTrue(not repr(req).endswith('(invalid WSGI environ)>'))
        self.assertTrue('\n' not in req.http_version or '\r' in req.http_version)
        self.assertTrue(',' not in req.host)
        self.assertTrue(req.content_length is not None)
        self.assertEqual(req.content_length, 337)
        self.assertTrue('foo' in req.body)
        bar_contents = "these are the contents of the file 'bar.txt'\r\n"
        self.assertTrue(bar_contents in req.body)
        self.assertEqual(req.params['foo'], 'foo')
        bar = req.params['bar']
        self.assertTrue(isinstance(bar, cgi.FieldStorage))
        self.assertEqual(bar.type, 'application/octet-stream')
        bar.file.seek(0)
        self.assertEqual(bar.file.read(), bar_contents)

        bar = req.get_all('bar')
        self.assertEqual(bar[0], bar_contents)

        # out should equal contents, except for the Content-Length header,
        # so insert that.
        _test_req_copy = _test_req.replace('Content-Type',
                            'Content-Length: 337\r\nContent-Type')
        self.assertEqual(str(req), _test_req_copy)

        req2 = webapp2.Request.from_string(_test_req2)
        self.assertTrue('host' not in req2.headers)
        self.assertEqual(str(req2), _test_req2.rstrip())
        self.assertRaises(ValueError,
                          webapp2.Request.from_string, _test_req2 + 'xx')

    def test_issue_5118(self):
        """Unable to read POST variables ONCE self.request.body is read."""
        if not test_base.check_webob_version(1.0):
            return
        import cgi
        req = webapp2.Request.from_string(_test_req)
        fieldStorage = req.POST.get('bar')
        self.assertTrue(isinstance(fieldStorage, cgi.FieldStorage))
        self.assertEqual(fieldStorage.type, 'application/octet-stream')
        # Double read.
        fieldStorage = req.POST.get('bar')
        self.assertTrue(isinstance(fieldStorage, cgi.FieldStorage))
        self.assertEqual(fieldStorage.type, 'application/octet-stream')
        # Now read the body.
        x = req.body
        fieldStorage = req.POST.get('bar')
        self.assertTrue(isinstance(fieldStorage, cgi.FieldStorage))
        self.assertEqual(fieldStorage.type, 'application/octet-stream')
    '''

if __name__ == '__main__':
    test_base.main()