# -*- coding: utf-8 -*-
from unittest import TestCase
import mimetypes
import poster.encode
import StringIO
import sys

def unix2dos(s):
    return s.replace("\n", "\r\n")

class TestEncode_String(TestCase):
    def test_simple(self):
        expected = unix2dos("""--XXXXXXXXX
Content-Disposition: form-data; name="foo"
Content-Type: text/plain; charset=utf-8

bar
""")
        self.assertEqual(expected,
                poster.encode.encode_string("XXXXXXXXX", "foo", "bar"))

    def test_quote_name_space(self):
        expected = unix2dos("""--XXXXXXXXX
Content-Disposition: form-data; name="foo baz"
Content-Type: text/plain; charset=utf-8

bar
""")
        self.assertEqual(expected,
                poster.encode.encode_string("XXXXXXXXX", "foo baz", "bar"))

    def test_quote_name_phparray(self):
        expected = unix2dos("""--XXXXXXXXX
Content-Disposition: form-data; name="files[]"
Content-Type: text/plain; charset=utf-8

bar
""")
        self.assertEqual(expected,
                poster.encode.encode_string("XXXXXXXXX", "files[]", "bar"))

    def test_quote_unicode_name(self):
        expected = unix2dos("""--XXXXXXXXX
Content-Disposition: form-data; name="=?utf-8?b?4piD?="
Content-Type: text/plain; charset=utf-8

bar
""")
        self.assertEqual(expected,
                poster.encode.encode_string("XXXXXXXXX", u"\N{SNOWMAN}", "bar"))

    def test_quote_value(self):
        expected = unix2dos("""--XXXXXXXXX
Content-Disposition: form-data; name="foo"
Content-Type: text/plain; charset=utf-8

bar baz@bat
""")
        self.assertEqual(expected,
                poster.encode.encode_string("XXXXXXXXX", "foo", "bar baz@bat"))

    def test_boundary(self):
        expected = unix2dos("""--ABC+DEF
Content-Disposition: form-data; name="foo"
Content-Type: text/plain; charset=utf-8

bar
""")
        self.assertEqual(expected,
                poster.encode.encode_string("ABC DEF", "foo", "bar"))

    def test_unicode(self):
        expected = unix2dos("""--XXXXXXXXX
Content-Disposition: form-data; name="foo"
Content-Type: text/plain; charset=utf-8

b\xc3\xa1r
""")
        self.assertEqual(expected,
                poster.encode.encode_string("XXXXXXXXX", "foo", u"bár"))


class TestEncode_File(TestCase):
    def test_simple(self):
        expected = unix2dos("""--XXXXXXXXX
Content-Disposition: form-data; name="foo"
Content-Type: text/plain; charset=utf-8

""")
        self.assertEqual(expected,
                poster.encode.encode_file_header("XXXXXXXXX", "foo", 42))

    def test_content_type(self):
        expected = unix2dos("""--XXXXXXXXX
Content-Disposition: form-data; name="foo"
Content-Type: text/html

""")
        self.assertEqual(expected,
                poster.encode.encode_file_header("XXXXXXXXX", "foo", 42, filetype="text/html"))

    def test_filename_simple(self):
        expected = unix2dos("""--XXXXXXXXX
Content-Disposition: form-data; name="foo"; filename="test.txt"
Content-Type: text/plain; charset=utf-8

""")
        self.assertEqual(expected,
                poster.encode.encode_file_header("XXXXXXXXX", "foo", 42,
                    "test.txt"))

    def test_quote_filename(self):
        expected = unix2dos("""--XXXXXXXXX
Content-Disposition: form-data; name="foo"; filename="test file.txt"
Content-Type: text/plain; charset=utf-8

""")
        self.assertEqual(expected,
                poster.encode.encode_file_header("XXXXXXXXX", "foo", 42,
                    "test file.txt"))

        expected = unix2dos("""--XXXXXXXXX
Content-Disposition: form-data; name="foo"; filename="test\\"file.txt"
Content-Type: text/plain; charset=utf-8

""")
        self.assertEqual(expected,
                poster.encode.encode_file_header("XXXXXXXXX", "foo", 42,
                    "test\"file.txt"))

    def test_unicode_filename(self):
        expected = unix2dos("""--XXXXXXXXX
Content-Disposition: form-data; name="foo"; filename="☃.txt"
Content-Type: text/plain; charset=utf-8

""")
        self.assertEqual(expected,
                poster.encode.encode_file_header("XXXXXXXXX", "foo", 42,
                    u"\N{SNOWMAN}.txt"))

class TestEncodeAndQuote(TestCase):
    def test(self):
        self.assertEqual("foo+bar", poster.encode.encode_and_quote("foo bar"))
        self.assertEqual("foo%40bar", poster.encode.encode_and_quote("foo@bar"))
        self.assertEqual("%28%C2%A9%29+2008",
                poster.encode.encode_and_quote(u"(©) 2008"))

class TestMultiparam(TestCase):
    def test_from_params(self):
        fp = open("tests/test_encode.py")
        expected = [poster.encode.MultipartParam("foo", "bar"),
                    poster.encode.MultipartParam("baz", fileobj=fp,
                        filename=fp.name,
                        filetype=mimetypes.guess_type(fp.name)[0])]

        self.assertEqual(poster.encode.MultipartParam.from_params(
            [("foo", "bar"), ("baz", fp)]), expected)

        self.assertEqual(poster.encode.MultipartParam.from_params(
            (("foo", "bar"), ("baz", fp))), expected)

        self.assertEqual(poster.encode.MultipartParam.from_params(
            {"foo": "bar", "baz": fp}), expected)

        self.assertEqual(poster.encode.MultipartParam.from_params(
            [expected[0], expected[1]]), expected)

    def test_from_params_dict(self):

        p = poster.encode.MultipartParam('file', fileobj=open("tests/test_encode.py"))
        params = {"foo": "bar", "file": p}

        expected = [poster.encode.MultipartParam("foo", "bar"), p]
        retval = poster.encode.MultipartParam.from_params(params)

        expected.sort()
        retval.sort()

        self.assertEqual(retval, expected)

    def test_from_params_assertion(self):
        p = poster.encode.MultipartParam('file', fileobj=open("tests/test_encode.py"))
        params = {"foo": "bar", "baz": p}

        self.assertRaises(AssertionError, poster.encode.MultipartParam.from_params,
                params)

    def test_simple(self):
        p = poster.encode.MultipartParam("foo", "bar")
        boundary = "XYZXYZXYZ"
        expected = unix2dos("""--XYZXYZXYZ
Content-Disposition: form-data; name="foo"
Content-Type: text/plain; charset=utf-8

bar
--XYZXYZXYZ--
""")
        self.assertEqual(p.encode(boundary), expected[:-len(boundary)-6])
        self.assertEqual(p.get_size(boundary), len(expected)-len(boundary)-6)
        self.assertEqual(poster.encode.get_body_size([p], boundary),
                len(expected))
        self.assertEqual(poster.encode.get_headers([p], boundary),
                {'Content-Length': str(len(expected)),
                 'Content-Type': 'multipart/form-data; boundary=%s' % boundary})

        datagen, headers = poster.encode.multipart_encode([p], boundary)
        self.assertEqual(headers, {'Content-Length': str(len(expected)),
                 'Content-Type': 'multipart/form-data; boundary=%s' % boundary})
        self.assertEqual("".join(datagen), expected)

    def test_multiple_keys(self):
        params = poster.encode.MultipartParam.from_params(
                [("key", "value1"), ("key", "value2")])
        boundary = "XYZXYZXYZ"
        datagen, headers = poster.encode.multipart_encode(params, boundary)
        encoded = "".join(datagen)

        expected = unix2dos("""--XYZXYZXYZ
Content-Disposition: form-data; name="key"
Content-Type: text/plain; charset=utf-8

value1
--XYZXYZXYZ
Content-Disposition: form-data; name="key"
Content-Type: text/plain; charset=utf-8

value2
--XYZXYZXYZ--
""")
        self.assertEqual(encoded, expected)


    def test_stringio(self):
        fp = StringIO.StringIO("file data")
        params = poster.encode.MultipartParam.from_params( [("foo", fp)] )
        boundary = "XYZXYZXYZ"
        datagen, headers = poster.encode.multipart_encode(params, boundary)
        encoded = "".join(datagen)

        expected = unix2dos("""--XYZXYZXYZ
Content-Disposition: form-data; name="foo"
Content-Type: text/plain; charset=utf-8

file data
--XYZXYZXYZ--
""")
        self.assertEqual(encoded, expected)

    def test_reset_string(self):
        p = poster.encode.MultipartParam("foo", "bar")
        boundary = "XYZXYZXYZ"

        datagen, headers = poster.encode.multipart_encode([p], boundary)

        expected = unix2dos("""--XYZXYZXYZ
Content-Disposition: form-data; name="foo"
Content-Type: text/plain; charset=utf-8

bar
--XYZXYZXYZ--
""")

        self.assertEquals("".join(datagen), expected)
        datagen.reset()
        self.assertEquals("".join(datagen), expected)

    def test_reset_multiple_keys(self):
        params = poster.encode.MultipartParam.from_params(
                [("key", "value1"), ("key", "value2")])
        boundary = "XYZXYZXYZ"
        datagen, headers = poster.encode.multipart_encode(params, boundary)
        expected = unix2dos("""--XYZXYZXYZ
Content-Disposition: form-data; name="key"
Content-Type: text/plain; charset=utf-8

value1
--XYZXYZXYZ
Content-Disposition: form-data; name="key"
Content-Type: text/plain; charset=utf-8

value2
--XYZXYZXYZ--
""")

        encoded = "".join(datagen)
        self.assertEqual(encoded, expected)
        datagen.reset()
        encoded = "".join(datagen)
        self.assertEqual(encoded, expected)

    def test_reset_file(self):
        fp = StringIO.StringIO("file data")
        params = poster.encode.MultipartParam.from_params( [("foo", fp)] )
        boundary = "XYZXYZXYZ"
        datagen, headers = poster.encode.multipart_encode(params, boundary)

        expected = unix2dos("""--XYZXYZXYZ
Content-Disposition: form-data; name="foo"
Content-Type: text/plain; charset=utf-8

file data
--XYZXYZXYZ--
""")
        encoded = "".join(datagen)
        self.assertEqual(encoded, expected)
        datagen.reset()
        encoded = "".join(datagen)
        self.assertEqual(encoded, expected)

    def test_MultipartParam_cb(self):
        log = []
        def cb(p, current, total):
            log.append( (p, current, total) )
        p = poster.encode.MultipartParam("foo", "bar", cb=cb)
        boundary = "XYZXYZXYZ"

        datagen, headers = poster.encode.multipart_encode([p], boundary)

        "".join(datagen)

        l = p.get_size(boundary)
        self.assertEquals(log[-1], (p, l, l))

    def test_MultipartParam_file_cb(self):
        log = []
        def cb(p, current, total):
            log.append( (p, current, total) )
        p = poster.encode.MultipartParam("foo", fileobj=open("tests/test_encode.py"),
                cb=cb)
        boundary = poster.encode.gen_boundary()

        list(p.iter_encode(boundary))

        l = p.get_size(boundary)
        self.assertEquals(log[-1], (p, l, l))

    def test_multipart_encode_cb(self):
        log = []
        def cb(p, current, total):
            log.append( (p, current, total) )
        p = poster.encode.MultipartParam("foo", "bar")
        boundary = "XYZXYZXYZ"

        datagen, headers = poster.encode.multipart_encode([p], boundary, cb=cb)

        "".join(datagen)

        l = int(headers['Content-Length'])
        self.assertEquals(log[-1], (None, l, l))

class TestGenBoundary(TestCase):
    def testGenBoundary(self):
        boundary1 = poster.encode.gen_boundary()
        boundary2 = poster.encode.gen_boundary()

        self.assertNotEqual(boundary1, boundary2)
        self.assert_(len(boundary1) > 0)

class TestBackupGenBoundary(TestGenBoundary):
    _orig_import = __import__
    def setUp(self):
        # Make import uuid fail
        def my_import(name, *args, **kwargs):
            if name == 'uuid':
                raise ImportError("Disabled for testing")
            return self._orig_import(name, *args, **kwargs)
        __builtins__['__import__'] = my_import
        reload(poster.encode)

    def tearDown(self):
        __builtins__['__import__'] = self._orig_import
        reload(poster.encode)