def test_render_parts(self):
     field = RequestField('somename', 'data')
     parts = field._render_parts({'name': 'value', 'filename': 'value'})
     assert 'name="value"' in parts
     assert 'filename="value"' in parts
     parts = field._render_parts([('name', 'value'), ('filename', 'value')])
     assert parts == 'name="value"; filename="value"'

 def test_render_parts(self):
     field = RequestField("somename", "data")
     parts = field._render_parts({"name": "value", "filename": "value"})
     self.assertTrue('name="value"' in parts)
     self.assertTrue('filename="value"' in parts)
     parts = field._render_parts([("name", "value"), ("filename", "value")])
     self.assertEqual(parts, 'name="value"; filename="value"')

 def test_make_multipart_empty_filename(self):
     field = RequestField('somename', 'data', '')
     field.make_multipart(content_type='application/octet-stream')
     assert (
         field.render_headers() ==
         'Content-Disposition: form-data; name="somename"; filename=""\r\n'
         'Content-Type: application/octet-stream\r\n'
         '\r\n')

 def test_make_multipart(self):
   field = RequestField('somename', 'data')
   field.make_multipart(content_type='image/jpg', content_location='/test')
   self.assertEqual(field.render_headers(),
       'Content-Disposition: form-data; name="somename"\r\n'
       'Content-Type: image/jpg\r\n'
       'Content-Location: /test\r\n'
       '\r\n')

    def _encode_files(files, data):
        """Build the body for a multipart/form-data request.

        Will successfully encode files when passed as a dict or a list of
        2-tuples. Order is retained if data is a list of 2-tuples but arbitrary
        if parameters are supplied as a dict.

        """
        if (not files):
            raise ValueError("Files must be provided.")
        elif isinstance(data, basestring):
            raise ValueError("Data must not be a string.")

        new_fields = []
        fields = to_key_val_list(data or {})
        files = to_key_val_list(files or {})

        for field, val in fields:
            if isinstance(val, basestring) or not hasattr(val, '__iter__'):
                val = [val]
            for v in val:
                if v is not None:
                    # Don't call str() on bytestrings: in Py3 it all goes wrong.
                    if not isinstance(v, bytes):
                        v = str(v)

                    new_fields.append(
                        (field.decode('utf-8') if isinstance(field, bytes) else field,
                         v.encode('utf-8') if isinstance(v, str) else v))

        for (k, v) in files:
            # support for explicit filename
            ft = None
            fh = None
            if isinstance(v, (tuple, list)):
                if len(v) == 2:
                    fn, fp = v
                elif len(v) == 3:
                    fn, fp, ft = v
                else:
                    fn, fp, ft, fh = v
            else:
                fn = guess_filename(v) or k
                fp = v

            if isinstance(fp, (str, bytes, bytearray)):
                fdata = fp
            else:
                fdata = fp.read()

            rf = RequestField(name=k, data=fdata,
                              filename=fn, headers=fh)
            rf.make_multipart(content_type=ft)
            new_fields.append(rf)

        body, content_type = encode_multipart_formdata(new_fields)

        return body, content_type

 def test_render_part_rfc2231(self):
     field = RequestField('somename', 'data')
     field.style = 'RFC2231'
     param = field._render_part('filename', u('name'))
     self.assertEqual(param, 'filename="name"')
     param = field._render_part('filename', u('n\u00e4me'))
     self.assertEqual(param, "filename*=utf-8''n%C3%A4me")
     param = field._render_part('filename', 'some"really\nbad\\name')
     self.assertEqual(param, u("filename*=utf-8''some%22really%0Abad%5Cname"))

 def test_render_part_html5(self):
     field = RequestField('somename', 'data')
     field.style = 'HTML5'
     param = field._render_part('filename', u('name'))
     self.assertEqual(param, 'filename="name"')
     param = field._render_part('filename', u('n\u00e4me'))
     self.assertEqual(param, u('filename="n\u00e4me"'))
     param = field._render_part('filename', 'some"really\nbad\\name')
     self.assertEqual(param, 'filename="some\\"really bad\\\\name"')

 def test_make_multipart(self):
     field = RequestField("somename", "data")
     field.make_multipart(content_type="image/jpg", content_location="/test")
     self.assertEqual(
         field.render_headers(),
         'Content-Disposition: form-data; name="somename"\r\n'
         "Content-Type: image/jpg\r\n"
         "Content-Location: /test\r\n"
         "\r\n",
     )

    def encode_body(self):
        new_fields = []
        for field, val in self.form_fields:
            if isinstance(val, basestring) or not hasattr(val, '__iter__'):
                val = [val]
            for v in val:
                if v is not None:
                    # Don't call str() on bytestrings: in Py3 it all goes wrong.
                    if not isinstance(v, bytes):
                        v = str(v)

                    new_fields.append(
                        (field.decode('utf-8') if isinstance(field, bytes) else field,
                         v.encode('utf-8') if isinstance(v, str) else v))
        if not self.files:
            self.files = {}
        for k, v in self.files.items():
            # support for explicit filename
            ft = None
            fh = None
            if isinstance(v, (tuple, list)):
                if len(v) == 2:
                    fn, fp = v
                elif len(v) == 3:
                    fn, fp, ft = v
                else:
                    fn, fp, ft, fh = v
            else:
                fn = guess_filename(v) or k
                fp = v

            if isinstance(fp, (str, bytes, bytearray)):
                fdata = fp
            else:
                fdata = fp.read()

            rf = RequestField(name=k, data=fdata,
                              filename=fn, headers=fh)
            rf.make_multipart(content_type=ft)
            new_fields.append(rf)

        body, content_type = encode_multipart_formdata(new_fields)
        return body,content_type

 def test_create(self):
     simple_field = RequestField("somename", "data")
     self.assertEqual(simple_field.render_headers(), "\r\n")
     filename_field = RequestField("somename", "data", filename="somefile.txt")
     self.assertEqual(filename_field.render_headers(), "\r\n")
     headers_field = RequestField("somename", "data", headers={"Content-Length": 4})
     self.assertEqual(headers_field.render_headers(), "Content-Length: 4\r\n\r\n")

 def test_create(self):
   simple_field = RequestField('somename', 'data')
   self.assertEqual(simple_field.render_headers(), '\r\n')
   filename_field = RequestField('somename', 'data', filename='somefile.txt')
   self.assertEqual(filename_field.render_headers(), '\r\n')
   headers_field = RequestField('somename', 'data', headers={'Content-Length': 4})
   self.assertEqual(headers_field.render_headers(),
       'Content-Length: 4\r\n'
       '\r\n')

 def test_create(self):
     simple_field = RequestField('somename', 'data')
     assert simple_field.render_headers() == '\r\n'
     filename_field = RequestField('somename', 'data',
                                   filename='somefile.txt')
     assert filename_field.render_headers() == '\r\n'
     headers_field = RequestField('somename', 'data',
                                  headers={'Content-Length': 4})
     assert headers_field.render_headers() == 'Content-Length: 4\r\n\r\n'

 def test_create(self):
     simple_field = RequestField('somename', 'data')
     self.assertEqual(simple_field.render_headers(),
         'Content-Disposition: form-data; name="somename"\r\n\r\n')
     filename_field = RequestField('somename', 'data',
                                   filename='somefile.txt')
     self.assertEqual(filename_field.render_headers(),
         'Content-Disposition: form-data; name="somename"; filename="somefile.txt"\r\n'
         'Content-Type: text/plain\r\n'
         '\r\n')
     headers_field = RequestField('somename', 'data',
                                  headers={'Content-Length': 4})
     self.assertEqual(headers_field.render_headers(),
         'Content-Disposition: form-data; name="somename"\r\n'
         'Content-Length: 4\r\n\r\n')

def process_upload_items(items):
    result = []
    for key, val in items:
        if isinstance(val, UploadContent):
            headers = {"Content-Type": val.content_type}
            field = RequestField(name=key, data=val.content, filename=val.filename, headers=headers)
            field.make_multipart(content_type=val.content_type)
            result.append(field)
        elif isinstance(val, UploadFile):
            data = open(val.path, "rb").read()
            headers = {"Content-Type": val.content_type}
            field = RequestField(name=key, data=data, filename=val.filename, headers=headers)
            field.make_multipart(content_type=val.content_type)
            result.append(field)
        else:
            result.append((key, val))
    return result

 def test_render_part(self):
     field = RequestField('somename', 'data')
     param = field._render_part('filename', u('n\u00e4me'))
     self.assertEqual(param, "filename*=utf-8''n%C3%A4me")

 def test_render_unicode_bytes_py2(self):
     field = RequestField('somename', 'data')
     param = field._render_part('filename', 'n\xc3\xa4me')
     self.assertEqual(param, "filename*=utf-8''n%C3%A4me")

 def test_render_part_html5(self):
     field = RequestField('somename', 'data')
     param = field._render_part('filename', u('n\u00e4me'))
     self.assertEqual(param, u('filename="n\u00e4me"'))

 def test_from_tuples_html5(self):
     field = RequestField.from_tuples(u('fieldname'), (u('filen\u00e4me'), 'data'))
     cd = field.headers['Content-Disposition']
     self.assertEqual(cd, u('form-data; name="fieldname"; filename="filen\u00e4me"'))

    def encode_params(self, data=None, files=None, **kwargs):
        """
        Build the body for a multipart/form-data request.
        Will successfully encode files when passed as a dict or a list of
        tuples. Order is retained if data is a list of tuples but arbitrary
        if parameters are supplied as a dict.
        The tuples may be string (filepath), 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype)
        or 4-tuples (filename, fileobj, contentype, custom_headers).
        """
        if isinstance(data, basestring):
            raise ValueError("Data must not be a string.")

        # optional args
        boundary = kwargs.get("boundary", None)
        output_str = kwargs.get("output_str", self.output_str)

        new_fields = []
        fields = to_key_val_list(data or {})
        files = to_key_val_list(files or {})

        for field, value in fields:
            ctype = None
            if isinstance(value, (tuple, list)) and len(value) == 2:
                val, ctype = value
            else:
                val = value

            if isinstance(val, basestring) or not hasattr(val, '__iter__'):
                val = [val]
            for v in val:
                # Don't call str() on bytestrings: in Py3 it all goes wrong.
                if not isinstance(v, bytes):
                    v = to_string(v, lang=output_str)

                field = field.decode('utf-8') if isinstance(field, bytes) else field
                v = v.encode('utf-8') if isinstance(v, str) else v

                rf = RequestField(name=field, data=v)
                rf.make_multipart(content_type=ctype)
                new_fields.append(rf)

        for (k, v) in files:
            # support for explicit filename
            ft = None
            fh = None
            if isinstance(v, (tuple, list)):
                if len(v) == 2:
                    fn, fp = v
                elif len(v) == 3:
                    fn, fp, ft = v
                else:
                    fn, fp, ft, fh = v
            else:
                fn, fp = guess_filename_stream(v)
                ft = guess_content_type(fn)

            if isinstance(fp, (str, bytes, bytearray)):
                fdata = fp
            else:
                fdata = fp.read()

            rf = RequestField(name=k, data=fdata, filename=fn, headers=fh)
            rf.make_multipart(content_type=ft)
            new_fields.append(rf)

        if boundary is None:
            boundary = self.boundary
        body, content_type = encode_multipart_formdata(new_fields, boundary=boundary)

        return body, content_type

 def test_render_part_invalid_style(self):
     field = RequestField('somename', 'data')
     field.style = 'ThereIsNoSuchStyle'
     self.assertRaises(NotImplementedError,
         field._render_part, 'filename', u('name'))