mirror of
https://github.com/django/django.git
synced 2025-11-02 21:03:53 +00:00
Marked bytestrings with b prefix. Refs #18269
This is a preparation for unicode literals general usage in Django (Python 3 compatibility).
This commit is contained in:
Claude Paroz
parent
822d6d6dab
commit
38408f8007
44 changed files with 296 additions and 295 deletions
|
|
@ -170,7 +170,7 @@ class UtilTests(unittest.TestCase):
|
|||
)
|
||||
self.assertEqual(
|
||||
label_for_field("__str__", Article),
|
||||
"article"
|
||||
b"article"
|
||||
)
|
||||
|
||||
self.assertRaises(
|
||||
|
|
|
|||
|
|
@ -280,7 +280,7 @@ class AdminFileWidgetTest(DjangoTestCase):
|
|||
)
|
||||
|
||||
self.assertHTMLEqual(
|
||||
conditional_escape(w.render('test', SimpleUploadedFile('test', 'content'))),
|
||||
conditional_escape(w.render('test', SimpleUploadedFile('test', b'content'))),
|
||||
'<input type="file" name="test" />',
|
||||
)
|
||||
|
||||
|
|
|
|||
2
tests/regressiontests/cache/tests.py
vendored
2
tests/regressiontests/cache/tests.py
vendored
|
|
@ -822,7 +822,7 @@ class DBCacheTests(BaseCacheTests, TransactionTestCase):
|
|||
def test_second_call_doesnt_crash(self):
|
||||
err = StringIO.StringIO()
|
||||
management.call_command('createcachetable', self._table_name, verbosity=0, interactive=False, stderr=err)
|
||||
self.assertTrue("Cache table 'test cache table' could not be created" in err.getvalue())
|
||||
self.assertTrue(b"Cache table 'test cache table' could not be created" in err.getvalue())
|
||||
|
||||
|
||||
@override_settings(USE_TZ=True)
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ class TestingHttpRequest(HttpRequest):
|
|||
class CsrfViewMiddlewareTest(TestCase):
|
||||
# The csrf token is potentially from an untrusted source, so could have
|
||||
# characters that need dealing with.
|
||||
_csrf_id_cookie = "<1>\xc2\xa1"
|
||||
_csrf_id_cookie = b"<1>\xc2\xa1"
|
||||
_csrf_id = "1"
|
||||
|
||||
def _get_GET_no_csrf_cookie_request(self):
|
||||
|
|
|
|||
|
|
@ -127,7 +127,7 @@ class FileStorageTests(unittest.TestCase):
|
|||
"""
|
||||
self.assertFalse(self.storage.exists('test.file'))
|
||||
|
||||
f = ContentFile('custom contents')
|
||||
f = ContentFile(b'custom contents')
|
||||
f_name = self.storage.save('test.file', f)
|
||||
atime = self.storage.accessed_time(f_name)
|
||||
|
||||
|
|
@ -143,7 +143,7 @@ class FileStorageTests(unittest.TestCase):
|
|||
"""
|
||||
self.assertFalse(self.storage.exists('test.file'))
|
||||
|
||||
f = ContentFile('custom contents')
|
||||
f = ContentFile(b'custom contents')
|
||||
f_name = self.storage.save('test.file', f)
|
||||
ctime = self.storage.created_time(f_name)
|
||||
|
||||
|
|
@ -160,7 +160,7 @@ class FileStorageTests(unittest.TestCase):
|
|||
"""
|
||||
self.assertFalse(self.storage.exists('test.file'))
|
||||
|
||||
f = ContentFile('custom contents')
|
||||
f = ContentFile(b'custom contents')
|
||||
f_name = self.storage.save('test.file', f)
|
||||
mtime = self.storage.modified_time(f_name)
|
||||
|
||||
|
|
@ -177,7 +177,7 @@ class FileStorageTests(unittest.TestCase):
|
|||
"""
|
||||
self.assertFalse(self.storage.exists('test.file'))
|
||||
|
||||
f = ContentFile('custom contents')
|
||||
f = ContentFile(b'custom contents')
|
||||
f.name = 'test.file'
|
||||
|
||||
storage_f_name = self.storage.save(None, f)
|
||||
|
|
@ -194,11 +194,11 @@ class FileStorageTests(unittest.TestCase):
|
|||
"""
|
||||
self.assertFalse(self.storage.exists('path/to'))
|
||||
self.storage.save('path/to/test.file',
|
||||
ContentFile('file saved with path'))
|
||||
ContentFile(b'file saved with path'))
|
||||
|
||||
self.assertTrue(self.storage.exists('path/to'))
|
||||
self.assertEqual(self.storage.open('path/to/test.file').read(),
|
||||
'file saved with path')
|
||||
b'file saved with path')
|
||||
|
||||
self.assertTrue(os.path.exists(
|
||||
os.path.join(self.temp_dir, 'path', 'to', 'test.file')))
|
||||
|
|
@ -211,7 +211,7 @@ class FileStorageTests(unittest.TestCase):
|
|||
"""
|
||||
self.assertFalse(self.storage.exists('test.file'))
|
||||
|
||||
f = ContentFile('custom contents')
|
||||
f = ContentFile(b'custom contents')
|
||||
f_name = self.storage.save('test.file', f)
|
||||
|
||||
self.assertEqual(self.storage.path(f_name),
|
||||
|
|
@ -246,8 +246,8 @@ class FileStorageTests(unittest.TestCase):
|
|||
self.assertFalse(self.storage.exists('storage_test_2'))
|
||||
self.assertFalse(self.storage.exists('storage_dir_1'))
|
||||
|
||||
f = self.storage.save('storage_test_1', ContentFile('custom content'))
|
||||
f = self.storage.save('storage_test_2', ContentFile('custom content'))
|
||||
f = self.storage.save('storage_test_1', ContentFile(b'custom content'))
|
||||
f = self.storage.save('storage_test_2', ContentFile(b'custom content'))
|
||||
os.mkdir(os.path.join(self.temp_dir, 'storage_dir_1'))
|
||||
|
||||
dirs, files = self.storage.listdir('')
|
||||
|
|
@ -304,18 +304,18 @@ class FileStorageTests(unittest.TestCase):
|
|||
os.makedirs = fake_makedirs
|
||||
|
||||
self.storage.save('normal/test.file',
|
||||
ContentFile('saved normally'))
|
||||
ContentFile(b'saved normally'))
|
||||
self.assertEqual(self.storage.open('normal/test.file').read(),
|
||||
'saved normally')
|
||||
b'saved normally')
|
||||
|
||||
self.storage.save('raced/test.file',
|
||||
ContentFile('saved with race'))
|
||||
ContentFile(b'saved with race'))
|
||||
self.assertEqual(self.storage.open('raced/test.file').read(),
|
||||
'saved with race')
|
||||
b'saved with race')
|
||||
|
||||
# Check that OSErrors aside from EEXIST are still raised.
|
||||
self.assertRaises(OSError,
|
||||
self.storage.save, 'error/test.file', ContentFile('not saved'))
|
||||
self.storage.save, 'error/test.file', ContentFile(b'not saved'))
|
||||
finally:
|
||||
os.makedirs = real_makedirs
|
||||
|
||||
|
|
@ -341,16 +341,16 @@ class FileStorageTests(unittest.TestCase):
|
|||
try:
|
||||
os.remove = fake_remove
|
||||
|
||||
self.storage.save('normal.file', ContentFile('delete normally'))
|
||||
self.storage.save('normal.file', ContentFile(b'delete normally'))
|
||||
self.storage.delete('normal.file')
|
||||
self.assertFalse(self.storage.exists('normal.file'))
|
||||
|
||||
self.storage.save('raced.file', ContentFile('delete with race'))
|
||||
self.storage.save('raced.file', ContentFile(b'delete with race'))
|
||||
self.storage.delete('raced.file')
|
||||
self.assertFalse(self.storage.exists('normal.file'))
|
||||
|
||||
# Check that OSErrors aside from ENOENT are still raised.
|
||||
self.storage.save('error.file', ContentFile('delete with error'))
|
||||
self.storage.save('error.file', ContentFile(b'delete with error'))
|
||||
self.assertRaises(OSError, self.storage.delete, 'error.file')
|
||||
finally:
|
||||
os.remove = real_remove
|
||||
|
|
@ -374,9 +374,9 @@ class CustomStorageTests(FileStorageTests):
|
|||
storage_class = CustomStorage
|
||||
|
||||
def test_custom_get_available_name(self):
|
||||
first = self.storage.save('custom_storage', ContentFile('custom contents'))
|
||||
first = self.storage.save('custom_storage', ContentFile(b'custom contents'))
|
||||
self.assertEqual(first, 'custom_storage')
|
||||
second = self.storage.save('custom_storage', ContentFile('more contents'))
|
||||
second = self.storage.save('custom_storage', ContentFile(b'more contents'))
|
||||
self.assertEqual(second, 'custom_storage.2')
|
||||
self.storage.delete(first)
|
||||
self.storage.delete(second)
|
||||
|
|
@ -410,7 +410,7 @@ class FileSaveRaceConditionTest(unittest.TestCase):
|
|||
shutil.rmtree(self.storage_dir)
|
||||
|
||||
def save_file(self, name):
|
||||
name = self.storage.save(name, SlowFile("Data"))
|
||||
name = self.storage.save(name, SlowFile(b"Data"))
|
||||
|
||||
def test_race_condition(self):
|
||||
self.thread.start()
|
||||
|
|
@ -433,7 +433,7 @@ class FileStoragePermissions(unittest.TestCase):
|
|||
shutil.rmtree(self.storage_dir)
|
||||
|
||||
def test_file_upload_permissions(self):
|
||||
name = self.storage.save("the_file", ContentFile("data"))
|
||||
name = self.storage.save("the_file", ContentFile(b"data"))
|
||||
actual_mode = os.stat(self.storage.path(name))[0] & 0777
|
||||
self.assertEqual(actual_mode, 0666)
|
||||
|
||||
|
|
@ -453,8 +453,8 @@ class FileStoragePathParsing(unittest.TestCase):
|
|||
sure we still mangle the file name instead of the directory name.
|
||||
"""
|
||||
|
||||
self.storage.save('dotted.path/test', ContentFile("1"))
|
||||
self.storage.save('dotted.path/test', ContentFile("2"))
|
||||
self.storage.save('dotted.path/test', ContentFile(b"1"))
|
||||
self.storage.save('dotted.path/test', ContentFile(b"2"))
|
||||
|
||||
self.assertFalse(os.path.exists(os.path.join(self.storage_dir, 'dotted_.path')))
|
||||
self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/test')))
|
||||
|
|
@ -465,8 +465,8 @@ class FileStoragePathParsing(unittest.TestCase):
|
|||
File names with a dot as their first character don't have an extension,
|
||||
and the underscore should get added to the end.
|
||||
"""
|
||||
self.storage.save('dotted.path/.test', ContentFile("1"))
|
||||
self.storage.save('dotted.path/.test', ContentFile("2"))
|
||||
self.storage.save('dotted.path/.test', ContentFile(b"1"))
|
||||
self.storage.save('dotted.path/.test', ContentFile(b"2"))
|
||||
|
||||
self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/.test')))
|
||||
self.assertTrue(os.path.exists(os.path.join(self.storage_dir, 'dotted.path/.test_1')))
|
||||
|
|
@ -542,11 +542,11 @@ class ContentFileTestCase(unittest.TestCase):
|
|||
Test that the constructor of ContentFile accepts 'name' (#16590).
|
||||
"""
|
||||
def test_content_file_default_name(self):
|
||||
self.assertEqual(ContentFile("content").name, None)
|
||||
self.assertEqual(ContentFile(b"content").name, None)
|
||||
|
||||
def test_content_file_custom_name(self):
|
||||
name = "I can have a name too!"
|
||||
self.assertEqual(ContentFile("content", name=name).name, name)
|
||||
self.assertEqual(ContentFile(b"content", name=name).name, name)
|
||||
|
||||
class NoNameFileTestCase(unittest.TestCase):
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ UNICODE_FILENAME = u'test-0123456789_中文_Orléans.jpg'
|
|||
|
||||
class FileUploadTests(TestCase):
|
||||
def test_simple_upload(self):
|
||||
with open(__file__) as fp:
|
||||
with open(__file__, 'rb') as fp:
|
||||
post_data = {
|
||||
'name': 'Ringo',
|
||||
'file_field': fp,
|
||||
|
|
@ -36,11 +36,11 @@ class FileUploadTests(TestCase):
|
|||
tdir = tempfile.gettempdir()
|
||||
|
||||
file1 = tempfile.NamedTemporaryFile(suffix=".file1", dir=tdir)
|
||||
file1.write('a' * (2 ** 21))
|
||||
file1.write(b'a' * (2 ** 21))
|
||||
file1.seek(0)
|
||||
|
||||
file2 = tempfile.NamedTemporaryFile(suffix=".file2", dir=tdir)
|
||||
file2.write('a' * (10 * 2 ** 20))
|
||||
file2.write(b'a' * (10 * 2 ** 20))
|
||||
file2.seek(0)
|
||||
|
||||
post_data = {
|
||||
|
|
@ -89,7 +89,7 @@ class FileUploadTests(TestCase):
|
|||
|
||||
# This file contains chinese symbols and an accented char in the name.
|
||||
with open(os.path.join(tdir, UNICODE_FILENAME.encode('utf-8')), 'w+b') as file1:
|
||||
file1.write('b' * (2 ** 10))
|
||||
file1.write(b'b' * (2 ** 10))
|
||||
file1.seek(0)
|
||||
|
||||
post_data = {
|
||||
|
|
@ -214,7 +214,7 @@ class FileUploadTests(TestCase):
|
|||
'CONTENT_TYPE': client.MULTIPART_CONTENT,
|
||||
'PATH_INFO': '/file_uploads/echo/',
|
||||
'REQUEST_METHOD': 'POST',
|
||||
'wsgi.input': client.FakePayload(''),
|
||||
'wsgi.input': client.FakePayload(b''),
|
||||
}
|
||||
got = json.loads(self.client.request(**r).content)
|
||||
self.assertEqual(got, {})
|
||||
|
|
@ -222,12 +222,12 @@ class FileUploadTests(TestCase):
|
|||
def test_custom_upload_handler(self):
|
||||
# A small file (under the 5M quota)
|
||||
smallfile = tempfile.NamedTemporaryFile()
|
||||
smallfile.write('a' * (2 ** 21))
|
||||
smallfile.write(b'a' * (2 ** 21))
|
||||
smallfile.seek(0)
|
||||
|
||||
# A big file (over the quota)
|
||||
bigfile = tempfile.NamedTemporaryFile()
|
||||
bigfile.write('a' * (10 * 2 ** 20))
|
||||
bigfile.write(b'a' * (10 * 2 ** 20))
|
||||
bigfile.seek(0)
|
||||
|
||||
# Small file posting should work.
|
||||
|
|
@ -242,7 +242,7 @@ class FileUploadTests(TestCase):
|
|||
|
||||
def test_broken_custom_upload_handler(self):
|
||||
f = tempfile.NamedTemporaryFile()
|
||||
f.write('a' * (2 ** 21))
|
||||
f.write(b'a' * (2 ** 21))
|
||||
f.seek(0)
|
||||
|
||||
# AttributeError: You cannot alter upload handlers after the upload has been processed.
|
||||
|
|
@ -255,15 +255,15 @@ class FileUploadTests(TestCase):
|
|||
|
||||
def test_fileupload_getlist(self):
|
||||
file1 = tempfile.NamedTemporaryFile()
|
||||
file1.write('a' * (2 ** 23))
|
||||
file1.write(b'a' * (2 ** 23))
|
||||
file1.seek(0)
|
||||
|
||||
file2 = tempfile.NamedTemporaryFile()
|
||||
file2.write('a' * (2 * 2 ** 18))
|
||||
file2.write(b'a' * (2 * 2 ** 18))
|
||||
file2.seek(0)
|
||||
|
||||
file2a = tempfile.NamedTemporaryFile()
|
||||
file2a.write('a' * (5 * 2 ** 20))
|
||||
file2a.write(b'a' * (5 * 2 ** 20))
|
||||
file2a.seek(0)
|
||||
|
||||
response = self.client.post('/file_uploads/getlist_count/', {
|
||||
|
|
@ -299,14 +299,14 @@ class FileUploadTests(TestCase):
|
|||
# this test would fail. So we need to know exactly what kind of error
|
||||
# it raises when there is an attempt to read more than the available bytes:
|
||||
try:
|
||||
client.FakePayload('a').read(2)
|
||||
client.FakePayload(b'a').read(2)
|
||||
except Exception as reference_error:
|
||||
pass
|
||||
|
||||
# install the custom handler that tries to access request.POST
|
||||
self.client.handler = POSTAccessingHandler()
|
||||
|
||||
with open(__file__) as fp:
|
||||
with open(__file__, 'rb') as fp:
|
||||
post_data = {
|
||||
'name': 'Ringo',
|
||||
'file_field': fp,
|
||||
|
|
@ -374,7 +374,7 @@ class DirectoryCreationTests(unittest.TestCase):
|
|||
"""Permission errors are not swallowed"""
|
||||
os.chmod(temp_storage.location, 0500)
|
||||
try:
|
||||
self.obj.testfile.save('foo.txt', SimpleUploadedFile('foo.txt', 'x'))
|
||||
self.obj.testfile.save('foo.txt', SimpleUploadedFile('foo.txt', b'x'))
|
||||
except OSError as err:
|
||||
self.assertEqual(err.errno, errno.EACCES)
|
||||
except Exception:
|
||||
|
|
@ -383,9 +383,9 @@ class DirectoryCreationTests(unittest.TestCase):
|
|||
def test_not_a_directory(self):
|
||||
"""The correct IOError is raised when the upload directory name exists but isn't a directory"""
|
||||
# Create a file with the upload directory name
|
||||
open(UPLOAD_TO, 'w').close()
|
||||
open(UPLOAD_TO, 'wb').close()
|
||||
try:
|
||||
self.obj.testfile.save('foo.txt', SimpleUploadedFile('foo.txt', 'x'))
|
||||
self.obj.testfile.save('foo.txt', SimpleUploadedFile('foo.txt', b'x'))
|
||||
except IOError as err:
|
||||
# The test needs to be done on a specific string as IOError
|
||||
# is raised even without the patch (just not early enough)
|
||||
|
|
|
|||
|
|
@ -540,27 +540,27 @@ class FieldsTests(SimpleTestCase):
|
|||
self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None)
|
||||
self.assertRaisesMessage(ValidationError, "[u'This field is required.']", f.clean, None, '')
|
||||
self.assertEqual('files/test2.pdf', f.clean(None, 'files/test2.pdf'))
|
||||
self.assertRaisesMessage(ValidationError, "[u'No file was submitted. Check the encoding type on the form.']", f.clean, SimpleUploadedFile('', ''))
|
||||
self.assertRaisesMessage(ValidationError, "[u'No file was submitted. Check the encoding type on the form.']", f.clean, SimpleUploadedFile('', ''), '')
|
||||
self.assertRaisesMessage(ValidationError, "[u'No file was submitted. Check the encoding type on the form.']", f.clean, SimpleUploadedFile('', b''))
|
||||
self.assertRaisesMessage(ValidationError, "[u'No file was submitted. Check the encoding type on the form.']", f.clean, SimpleUploadedFile('', b''), '')
|
||||
self.assertEqual('files/test3.pdf', f.clean(None, 'files/test3.pdf'))
|
||||
self.assertRaisesMessage(ValidationError, "[u'No file was submitted. Check the encoding type on the form.']", f.clean, 'some content that is not a file')
|
||||
self.assertRaisesMessage(ValidationError, "[u'The submitted file is empty.']", f.clean, SimpleUploadedFile('name', None))
|
||||
self.assertRaisesMessage(ValidationError, "[u'The submitted file is empty.']", f.clean, SimpleUploadedFile('name', ''))
|
||||
self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', 'Some File Content'))))
|
||||
self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', 'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह'))))
|
||||
self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', 'Some File Content'), 'files/test4.pdf')))
|
||||
self.assertRaisesMessage(ValidationError, "[u'The submitted file is empty.']", f.clean, SimpleUploadedFile('name', b''))
|
||||
self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', b'Some File Content'))))
|
||||
self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', u'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह'.encode('utf-8')))))
|
||||
self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', b'Some File Content'), 'files/test4.pdf')))
|
||||
|
||||
def test_filefield_2(self):
|
||||
f = FileField(max_length = 5)
|
||||
self.assertRaisesMessage(ValidationError, "[u'Ensure this filename has at most 5 characters (it has 18).']", f.clean, SimpleUploadedFile('test_maxlength.txt', 'hello world'))
|
||||
self.assertRaisesMessage(ValidationError, "[u'Ensure this filename has at most 5 characters (it has 18).']", f.clean, SimpleUploadedFile('test_maxlength.txt', b'hello world'))
|
||||
self.assertEqual('files/test1.pdf', f.clean('', 'files/test1.pdf'))
|
||||
self.assertEqual('files/test2.pdf', f.clean(None, 'files/test2.pdf'))
|
||||
self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', 'Some File Content'))))
|
||||
self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', b'Some File Content'))))
|
||||
|
||||
def test_filefield_3(self):
|
||||
f = FileField(allow_empty_file=True)
|
||||
self.assertEqual(SimpleUploadedFile,
|
||||
type(f.clean(SimpleUploadedFile('name', ''))))
|
||||
type(f.clean(SimpleUploadedFile('name', b''))))
|
||||
|
||||
# URLField ##################################################################
|
||||
|
||||
|
|
|
|||
|
|
@ -1463,17 +1463,17 @@ class FormsTestCase(TestCase):
|
|||
f = FileForm(data={}, files={}, auto_id=False)
|
||||
self.assertHTMLEqual(f.as_table(), '<tr><th>File1:</th><td><ul class="errorlist"><li>This field is required.</li></ul><input type="file" name="file1" /></td></tr>')
|
||||
|
||||
f = FileForm(data={}, files={'file1': SimpleUploadedFile('name', '')}, auto_id=False)
|
||||
f = FileForm(data={}, files={'file1': SimpleUploadedFile('name', b'')}, auto_id=False)
|
||||
self.assertHTMLEqual(f.as_table(), '<tr><th>File1:</th><td><ul class="errorlist"><li>The submitted file is empty.</li></ul><input type="file" name="file1" /></td></tr>')
|
||||
|
||||
f = FileForm(data={}, files={'file1': 'something that is not a file'}, auto_id=False)
|
||||
self.assertHTMLEqual(f.as_table(), '<tr><th>File1:</th><td><ul class="errorlist"><li>No file was submitted. Check the encoding type on the form.</li></ul><input type="file" name="file1" /></td></tr>')
|
||||
|
||||
f = FileForm(data={}, files={'file1': SimpleUploadedFile('name', 'some content')}, auto_id=False)
|
||||
f = FileForm(data={}, files={'file1': SimpleUploadedFile('name', b'some content')}, auto_id=False)
|
||||
self.assertHTMLEqual(f.as_table(), '<tr><th>File1:</th><td><input type="file" name="file1" /></td></tr>')
|
||||
self.assertTrue(f.is_valid())
|
||||
|
||||
f = FileForm(data={}, files={'file1': SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', 'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह')}, auto_id=False)
|
||||
f = FileForm(data={}, files={'file1': SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', u'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह'.encode('utf-8'))}, auto_id=False)
|
||||
self.assertHTMLEqual(f.as_table(), '<tr><th>File1:</th><td><input type="file" name="file1" /></td></tr>')
|
||||
|
||||
def test_basic_processing_in_view(self):
|
||||
|
|
|
|||
|
|
@ -106,7 +106,7 @@ class ModelFormCallableModelDefault(TestCase):
|
|||
class FormsModelTestCase(TestCase):
|
||||
def test_unicode_filename(self):
|
||||
# FileModel with unicode filename and data #########################
|
||||
f = FileForm(data={}, files={'file1': SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', 'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह')}, auto_id=False)
|
||||
f = FileForm(data={}, files={'file1': SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', u'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह'.encode('utf-8'))}, auto_id=False)
|
||||
self.assertTrue(f.is_valid())
|
||||
self.assertTrue('file1' in f.cleaned_data)
|
||||
m = FileModel.objects.create(file=f.cleaned_data['file1'])
|
||||
|
|
@ -177,7 +177,7 @@ class RelatedModelFormTests(TestCase):
|
|||
class Meta:
|
||||
model=A
|
||||
|
||||
self.assertRaises(ValueError, ModelFormMetaclass, 'Form', (ModelForm,), {'Meta': Meta})
|
||||
self.assertRaises(ValueError, ModelFormMetaclass, b'Form', (ModelForm,), {'Meta': Meta})
|
||||
|
||||
class B(models.Model):
|
||||
pass
|
||||
|
|
@ -195,4 +195,4 @@ class RelatedModelFormTests(TestCase):
|
|||
class Meta:
|
||||
model=A
|
||||
|
||||
self.assertTrue(issubclass(ModelFormMetaclass('Form', (ModelForm,), {'Meta': Meta}), ModelForm))
|
||||
self.assertTrue(issubclass(ModelFormMetaclass(b'Form', (ModelForm,), {'Meta': Meta}), ModelForm))
|
||||
|
|
|
|||
|
|
@ -54,10 +54,11 @@ class FormsRegressionsTestCase(TestCase):
|
|||
|
||||
# Testing choice validation with UTF-8 bytestrings as input (these are the
|
||||
# Russian abbreviations "мес." and "шт.".
|
||||
UNITS = (('\xd0\xbc\xd0\xb5\xd1\x81.', '\xd0\xbc\xd0\xb5\xd1\x81.'), ('\xd1\x88\xd1\x82.', '\xd1\x88\xd1\x82.'))
|
||||
UNITS = ((b'\xd0\xbc\xd0\xb5\xd1\x81.', b'\xd0\xbc\xd0\xb5\xd1\x81.'),
|
||||
(b'\xd1\x88\xd1\x82.', b'\xd1\x88\xd1\x82.'))
|
||||
f = ChoiceField(choices=UNITS)
|
||||
self.assertEqual(f.clean(u'\u0448\u0442.'), u'\u0448\u0442.')
|
||||
self.assertEqual(f.clean('\xd1\x88\xd1\x82.'), u'\u0448\u0442.')
|
||||
self.assertEqual(f.clean(b'\xd1\x88\xd1\x82.'), u'\u0448\u0442.')
|
||||
|
||||
# Translated error messages used to be buggy.
|
||||
with override('ru'):
|
||||
|
|
|
|||
|
|
@ -1182,7 +1182,7 @@ class ClearableFileInputTests(TestCase):
|
|||
"""
|
||||
widget = ClearableFileInput()
|
||||
widget.is_required = True
|
||||
f = SimpleUploadedFile('something.txt', 'content')
|
||||
f = SimpleUploadedFile('something.txt', b'content')
|
||||
self.assertEqual(widget.value_from_datadict(
|
||||
data={'myfile-clear': True},
|
||||
files={'myfile': f},
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ class HandlerTests(unittest.TestCase):
|
|||
def test_bad_path_info(self):
|
||||
"""Tests for bug #15672 ('request' referenced before assignment)"""
|
||||
environ = RequestFactory().get('/').environ
|
||||
environ['PATH_INFO'] = '\xed'
|
||||
environ['PATH_INFO'] = b'\xed'
|
||||
handler = WSGIHandler()
|
||||
response = handler(environ, lambda *a, **k: None)
|
||||
self.assertEqual(response.status_code, 400)
|
||||
|
|
|
|||
|
|
@ -174,7 +174,7 @@ class QueryDictTests(unittest.TestCase):
|
|||
QueryDicts must be able to handle invalid input encoding (in this
|
||||
case, bad UTF-8 encoding).
|
||||
"""
|
||||
q = QueryDict('foo=bar&foo=\xff')
|
||||
q = QueryDict(b'foo=bar&foo=\xff')
|
||||
self.assertEqual(q['foo'], u'\ufffd')
|
||||
self.assertEqual(q.getlist('foo'), [u'bar', u'\ufffd'])
|
||||
|
||||
|
|
@ -198,7 +198,7 @@ class QueryDictTests(unittest.TestCase):
|
|||
|
||||
def test_non_default_encoding(self):
|
||||
"""#13572 - QueryDict with a non-default encoding"""
|
||||
q = QueryDict('sbb=one', encoding='rot_13')
|
||||
q = QueryDict(b'sbb=one', encoding='rot_13')
|
||||
self.assertEqual(q.encoding , 'rot_13' )
|
||||
self.assertEqual(q.items() , [(u'foo', u'bar')] )
|
||||
self.assertEqual(q.urlencode() , 'sbb=one' )
|
||||
|
|
@ -285,8 +285,8 @@ class HttpResponseTests(unittest.TestCase):
|
|||
except StopIteration:
|
||||
break
|
||||
#'\xde\x9e' == unichr(1950).encode('utf-8')
|
||||
self.assertEqual(result, ['1', '2', '3', '\xde\x9e'])
|
||||
self.assertEqual(r.content, '123\xde\x9e')
|
||||
self.assertEqual(result, ['1', '2', '3', b'\xde\x9e'])
|
||||
self.assertEqual(r.content, b'123\xde\x9e')
|
||||
|
||||
#with Content-Encoding header
|
||||
r = HttpResponse([1,1,2,4,8])
|
||||
|
|
@ -321,7 +321,7 @@ class CookieTests(unittest.TestCase):
|
|||
Test that we haven't broken normal encoding
|
||||
"""
|
||||
c = SimpleCookie()
|
||||
c['test'] = "\xf0"
|
||||
c['test'] = b"\xf0"
|
||||
c2 = SimpleCookie()
|
||||
c2.load(c.output())
|
||||
self.assertEqual(c['test'].value, c2['test'].value)
|
||||
|
|
|
|||
|
|
@ -230,7 +230,7 @@ class TranslationTests(TestCase):
|
|||
"""
|
||||
Translating a string requiring no auto-escaping shouldn't change the "safe" status.
|
||||
"""
|
||||
s = mark_safe('Password')
|
||||
s = mark_safe(b'Password')
|
||||
self.assertEqual(SafeString, type(s))
|
||||
with translation.override('de', deactivate=True):
|
||||
self.assertEqual(SafeUnicode, type(ugettext(s)))
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ class MKLocalFlavorTests(SimpleTestCase):
|
|||
"""
|
||||
Test that the empty option is there.
|
||||
"""
|
||||
municipality_select_html = """\
|
||||
municipality_select_html = b"""\
|
||||
<select name="municipality" id="id_municipality">
|
||||
<option value="">---------</option>
|
||||
<option value="AD">Aerodrom</option>
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ class MailTests(TestCase):
|
|||
"""
|
||||
headers = {"date": "Fri, 09 Nov 2001 01:08:47 -0000", "Message-ID": "foo"}
|
||||
email = EmailMessage('subject', 'content', 'from@example.com', ['to@example.com'], headers=headers)
|
||||
self.assertEqual(email.message().as_string(), 'Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: 7bit\nSubject: subject\nFrom: from@example.com\nTo: to@example.com\ndate: Fri, 09 Nov 2001 01:08:47 -0000\nMessage-ID: foo\n\ncontent')
|
||||
self.assertEqual(email.message().as_string(), b'Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: 7bit\nSubject: subject\nFrom: from@example.com\nTo: to@example.com\ndate: Fri, 09 Nov 2001 01:08:47 -0000\nMessage-ID: foo\n\ncontent')
|
||||
|
||||
def test_from_header(self):
|
||||
"""
|
||||
|
|
@ -168,7 +168,7 @@ class MailTests(TestCase):
|
|||
email = EmailMessage('Subject', 'Firstname Sürname is a great guy.', 'from@example.com', ['other@example.com'])
|
||||
email.encoding = 'iso-8859-1'
|
||||
message = email.message()
|
||||
self.assertTrue(message.as_string().startswith('Content-Type: text/plain; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: Subject\nFrom: from@example.com\nTo: other@example.com'))
|
||||
self.assertTrue(message.as_string().startswith(b'Content-Type: text/plain; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\nSubject: Subject\nFrom: from@example.com\nTo: other@example.com'))
|
||||
self.assertEqual(message.get_payload(), 'Firstname S=FCrname is a great guy.')
|
||||
|
||||
# Make sure MIME attachments also works correctly with other encodings than utf-8
|
||||
|
|
@ -177,8 +177,8 @@ class MailTests(TestCase):
|
|||
msg = EmailMultiAlternatives('Subject', text_content, 'from@example.com', ['to@example.com'])
|
||||
msg.encoding = 'iso-8859-1'
|
||||
msg.attach_alternative(html_content, "text/html")
|
||||
self.assertEqual(msg.message().get_payload(0).as_string(), 'Content-Type: text/plain; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\n\nFirstname S=FCrname is a great guy.')
|
||||
self.assertEqual(msg.message().get_payload(1).as_string(), 'Content-Type: text/html; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\n\n<p>Firstname S=FCrname is a <strong>great</strong> guy.</p>')
|
||||
self.assertEqual(msg.message().get_payload(0).as_string(), b'Content-Type: text/plain; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\n\nFirstname S=FCrname is a great guy.')
|
||||
self.assertEqual(msg.message().get_payload(1).as_string(), b'Content-Type: text/html; charset="iso-8859-1"\nMIME-Version: 1.0\nContent-Transfer-Encoding: quoted-printable\n\n<p>Firstname S=FCrname is a <strong>great</strong> guy.</p>')
|
||||
|
||||
def test_attachments(self):
|
||||
"""Regression test for #9367"""
|
||||
|
|
@ -188,7 +188,7 @@ class MailTests(TestCase):
|
|||
html_content = '<p>This is an <strong>important</strong> message.</p>'
|
||||
msg = EmailMultiAlternatives(subject, text_content, from_email, [to], headers=headers)
|
||||
msg.attach_alternative(html_content, "text/html")
|
||||
msg.attach("an attachment.pdf", "%PDF-1.4.%...", mimetype="application/pdf")
|
||||
msg.attach("an attachment.pdf", b"%PDF-1.4.%...", mimetype="application/pdf")
|
||||
msg_str = msg.message().as_string()
|
||||
message = email.message_from_string(msg_str)
|
||||
self.assertTrue(message.is_multipart())
|
||||
|
|
@ -205,7 +205,7 @@ class MailTests(TestCase):
|
|||
content = 'This is the message.'
|
||||
msg = EmailMessage(subject, content, from_email, [to], headers=headers)
|
||||
# Unicode in file name
|
||||
msg.attach(u"une pièce jointe.pdf", "%PDF-1.4.%...", mimetype="application/pdf")
|
||||
msg.attach(u"une pièce jointe.pdf", b"%PDF-1.4.%...", mimetype="application/pdf")
|
||||
msg_str = msg.message().as_string()
|
||||
message = email.message_from_string(msg_str)
|
||||
payload = message.get_payload()
|
||||
|
|
@ -289,31 +289,31 @@ class MailTests(TestCase):
|
|||
# Regression for #13433 - Make sure that EmailMessage doesn't mangle
|
||||
# 'From ' in message body.
|
||||
email = EmailMessage('Subject', 'From the future', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
|
||||
self.assertFalse('>From the future' in email.message().as_string())
|
||||
self.assertFalse(b'>From the future' in email.message().as_string())
|
||||
|
||||
def test_dont_base64_encode(self):
|
||||
# Ticket #3472
|
||||
# Shouldn't use Base64 encoding at all
|
||||
msg = EmailMessage('Subject', 'UTF-8 encoded body', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
|
||||
self.assertFalse('Content-Transfer-Encoding: base64' in msg.message().as_string())
|
||||
self.assertFalse(b'Content-Transfer-Encoding: base64' in msg.message().as_string())
|
||||
|
||||
# Ticket #11212
|
||||
# Shouldn't use quoted printable, should detect it can represent content with 7 bit data
|
||||
msg = EmailMessage('Subject', 'Body with only ASCII characters.', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
|
||||
s = msg.message().as_string()
|
||||
self.assertFalse('Content-Transfer-Encoding: quoted-printable' in s)
|
||||
self.assertTrue('Content-Transfer-Encoding: 7bit' in s)
|
||||
self.assertFalse(b'Content-Transfer-Encoding: quoted-printable' in s)
|
||||
self.assertTrue(b'Content-Transfer-Encoding: 7bit' in s)
|
||||
|
||||
# Shouldn't use quoted printable, should detect it can represent content with 8 bit data
|
||||
msg = EmailMessage('Subject', 'Body with latin characters: àáä.', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
|
||||
s = msg.message().as_string()
|
||||
self.assertFalse('Content-Transfer-Encoding: quoted-printable' in s)
|
||||
self.assertTrue('Content-Transfer-Encoding: 8bit' in s)
|
||||
self.assertFalse(b'Content-Transfer-Encoding: quoted-printable' in s)
|
||||
self.assertTrue(b'Content-Transfer-Encoding: 8bit' in s)
|
||||
|
||||
msg = EmailMessage('Subject', u'Body with non latin characters: А Б В Г Д Е Ж Ѕ З И І К Л М Н О П.', 'bounce@example.com', ['to@example.com'], headers={'From': 'from@example.com'})
|
||||
s = msg.message().as_string()
|
||||
self.assertFalse('Content-Transfer-Encoding: quoted-printable' in s)
|
||||
self.assertTrue('Content-Transfer-Encoding: 8bit' in s)
|
||||
self.assertFalse(b'Content-Transfer-Encoding: quoted-printable' in s)
|
||||
self.assertTrue(b'Content-Transfer-Encoding: 8bit' in s)
|
||||
|
||||
|
||||
class BaseEmailBackendTests(object):
|
||||
|
|
@ -438,7 +438,7 @@ class BaseEmailBackendTests(object):
|
|||
email = EmailMessage('Subject', 'Content', 'from@example.com', ['to@example.com'], cc=['cc@example.com'])
|
||||
mail.get_connection().send_messages([email])
|
||||
message = self.get_the_message()
|
||||
self.assertStartsWith(message.as_string(), 'Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: 7bit\nSubject: Subject\nFrom: from@example.com\nTo: to@example.com\nCc: cc@example.com\nDate: ')
|
||||
self.assertStartsWith(message.as_string(), b'Content-Type: text/plain; charset="utf-8"\nMIME-Version: 1.0\nContent-Transfer-Encoding: 7bit\nSubject: Subject\nFrom: from@example.com\nTo: to@example.com\nCc: cc@example.com\nDate: ')
|
||||
|
||||
def test_idn_send(self):
|
||||
"""
|
||||
|
|
@ -517,8 +517,8 @@ class FileBackendTests(BaseEmailBackendTests, TestCase):
|
|||
def get_mailbox_content(self):
|
||||
messages = []
|
||||
for filename in os.listdir(self.tmp_dir):
|
||||
with open(os.path.join(self.tmp_dir, filename)) as fp:
|
||||
session = fp.read().split('\n' + ('-' * 79) + '\n')
|
||||
with open(os.path.join(self.tmp_dir, filename), 'rb') as fp:
|
||||
session = fp.read().split(b'\n' + (b'-' * 79) + b'\n')
|
||||
messages.extend(email.message_from_string(m) for m in session if m)
|
||||
return messages
|
||||
|
||||
|
|
@ -569,7 +569,7 @@ class ConsoleBackendTests(BaseEmailBackendTests, TestCase):
|
|||
self.stream = sys.stdout = StringIO()
|
||||
|
||||
def get_mailbox_content(self):
|
||||
messages = self.stream.getvalue().split('\n' + ('-' * 79) + '\n')
|
||||
messages = self.stream.getvalue().split(b'\n' + (b'-' * 79) + b'\n')
|
||||
return [email.message_from_string(m) for m in messages if m]
|
||||
|
||||
def test_console_stream_kwarg(self):
|
||||
|
|
|
|||
|
|
@ -394,7 +394,7 @@ class FileFieldTests(unittest.TestCase):
|
|||
form = DocumentForm()
|
||||
self.assertTrue('name="myfile"' in unicode(form))
|
||||
self.assertTrue('myfile-clear' not in unicode(form))
|
||||
form = DocumentForm(files={'myfile': SimpleUploadedFile('something.txt', 'content')})
|
||||
form = DocumentForm(files={'myfile': SimpleUploadedFile('something.txt', b'content')})
|
||||
self.assertTrue(form.is_valid())
|
||||
doc = form.save(commit=False)
|
||||
self.assertEqual(doc.myfile.name, 'something.txt')
|
||||
|
|
@ -411,11 +411,11 @@ class FileFieldTests(unittest.TestCase):
|
|||
includes the current file and the clear checkbox.
|
||||
|
||||
"""
|
||||
form = DocumentForm(files={'myfile': SimpleUploadedFile('something.txt', 'content')})
|
||||
form = DocumentForm(files={'myfile': SimpleUploadedFile('something.txt', b'content')})
|
||||
self.assertTrue(form.is_valid())
|
||||
doc = form.save(commit=False)
|
||||
form = DocumentForm(instance=doc,
|
||||
files={'myfile': SimpleUploadedFile('something.txt', 'content')},
|
||||
files={'myfile': SimpleUploadedFile('something.txt', b'content')},
|
||||
data={'myfile-clear': 'true'})
|
||||
self.assertTrue(not form.is_valid())
|
||||
self.assertEqual(form.errors['myfile'],
|
||||
|
|
|
|||
|
|
@ -204,91 +204,91 @@ class RequestsTests(unittest.TestCase):
|
|||
|
||||
def test_limited_stream(self):
|
||||
# Read all of a limited stream
|
||||
stream = LimitedStream(StringIO('test'), 2)
|
||||
self.assertEqual(stream.read(), 'te')
|
||||
stream = LimitedStream(StringIO(b'test'), 2)
|
||||
self.assertEqual(stream.read(), b'te')
|
||||
# Reading again returns nothing.
|
||||
self.assertEqual(stream.read(), '')
|
||||
self.assertEqual(stream.read(), b'')
|
||||
|
||||
# Read a number of characters greater than the stream has to offer
|
||||
stream = LimitedStream(StringIO('test'), 2)
|
||||
self.assertEqual(stream.read(5), 'te')
|
||||
stream = LimitedStream(StringIO(b'test'), 2)
|
||||
self.assertEqual(stream.read(5), b'te')
|
||||
# Reading again returns nothing.
|
||||
self.assertEqual(stream.readline(5), '')
|
||||
self.assertEqual(stream.readline(5), b'')
|
||||
|
||||
# Read sequentially from a stream
|
||||
stream = LimitedStream(StringIO('12345678'), 8)
|
||||
self.assertEqual(stream.read(5), '12345')
|
||||
self.assertEqual(stream.read(5), '678')
|
||||
stream = LimitedStream(StringIO(b'12345678'), 8)
|
||||
self.assertEqual(stream.read(5), b'12345')
|
||||
self.assertEqual(stream.read(5), b'678')
|
||||
# Reading again returns nothing.
|
||||
self.assertEqual(stream.readline(5), '')
|
||||
self.assertEqual(stream.readline(5), b'')
|
||||
|
||||
# Read lines from a stream
|
||||
stream = LimitedStream(StringIO('1234\n5678\nabcd\nefgh\nijkl'), 24)
|
||||
stream = LimitedStream(StringIO(b'1234\n5678\nabcd\nefgh\nijkl'), 24)
|
||||
# Read a full line, unconditionally
|
||||
self.assertEqual(stream.readline(), '1234\n')
|
||||
self.assertEqual(stream.readline(), b'1234\n')
|
||||
# Read a number of characters less than a line
|
||||
self.assertEqual(stream.readline(2), '56')
|
||||
self.assertEqual(stream.readline(2), b'56')
|
||||
# Read the rest of the partial line
|
||||
self.assertEqual(stream.readline(), '78\n')
|
||||
self.assertEqual(stream.readline(), b'78\n')
|
||||
# Read a full line, with a character limit greater than the line length
|
||||
self.assertEqual(stream.readline(6), 'abcd\n')
|
||||
self.assertEqual(stream.readline(6), b'abcd\n')
|
||||
# Read the next line, deliberately terminated at the line end
|
||||
self.assertEqual(stream.readline(4), 'efgh')
|
||||
self.assertEqual(stream.readline(4), b'efgh')
|
||||
# Read the next line... just the line end
|
||||
self.assertEqual(stream.readline(), '\n')
|
||||
self.assertEqual(stream.readline(), b'\n')
|
||||
# Read everything else.
|
||||
self.assertEqual(stream.readline(), 'ijkl')
|
||||
self.assertEqual(stream.readline(), b'ijkl')
|
||||
|
||||
# Regression for #15018
|
||||
# If a stream contains a newline, but the provided length
|
||||
# is less than the number of provided characters, the newline
|
||||
# doesn't reset the available character count
|
||||
stream = LimitedStream(StringIO('1234\nabcdef'), 9)
|
||||
self.assertEqual(stream.readline(10), '1234\n')
|
||||
self.assertEqual(stream.readline(3), 'abc')
|
||||
stream = LimitedStream(StringIO(b'1234\nabcdef'), 9)
|
||||
self.assertEqual(stream.readline(10), b'1234\n')
|
||||
self.assertEqual(stream.readline(3), b'abc')
|
||||
# Now expire the available characters
|
||||
self.assertEqual(stream.readline(3), 'd')
|
||||
self.assertEqual(stream.readline(3), b'd')
|
||||
# Reading again returns nothing.
|
||||
self.assertEqual(stream.readline(2), '')
|
||||
self.assertEqual(stream.readline(2), b'')
|
||||
|
||||
# Same test, but with read, not readline.
|
||||
stream = LimitedStream(StringIO('1234\nabcdef'), 9)
|
||||
self.assertEqual(stream.read(6), '1234\na')
|
||||
self.assertEqual(stream.read(2), 'bc')
|
||||
self.assertEqual(stream.read(2), 'd')
|
||||
self.assertEqual(stream.read(2), '')
|
||||
self.assertEqual(stream.read(), '')
|
||||
stream = LimitedStream(StringIO(b'1234\nabcdef'), 9)
|
||||
self.assertEqual(stream.read(6), b'1234\na')
|
||||
self.assertEqual(stream.read(2), b'bc')
|
||||
self.assertEqual(stream.read(2), b'd')
|
||||
self.assertEqual(stream.read(2), b'')
|
||||
self.assertEqual(stream.read(), b'')
|
||||
|
||||
def test_stream(self):
|
||||
payload = 'name=value'
|
||||
payload = b'name=value'
|
||||
request = WSGIRequest({'REQUEST_METHOD': 'POST',
|
||||
'CONTENT_LENGTH': len(payload),
|
||||
'wsgi.input': StringIO(payload)})
|
||||
self.assertEqual(request.read(), 'name=value')
|
||||
self.assertEqual(request.read(), b'name=value')
|
||||
|
||||
def test_read_after_value(self):
|
||||
"""
|
||||
Reading from request is allowed after accessing request contents as
|
||||
POST or body.
|
||||
"""
|
||||
payload = 'name=value'
|
||||
payload = b'name=value'
|
||||
request = WSGIRequest({'REQUEST_METHOD': 'POST',
|
||||
'CONTENT_LENGTH': len(payload),
|
||||
'wsgi.input': StringIO(payload)})
|
||||
self.assertEqual(request.POST, {u'name': [u'value']})
|
||||
self.assertEqual(request.body, 'name=value')
|
||||
self.assertEqual(request.read(), 'name=value')
|
||||
self.assertEqual(request.body, b'name=value')
|
||||
self.assertEqual(request.read(), b'name=value')
|
||||
|
||||
def test_value_after_read(self):
|
||||
"""
|
||||
Construction of POST or body is not allowed after reading
|
||||
from request.
|
||||
"""
|
||||
payload = 'name=value'
|
||||
payload = b'name=value'
|
||||
request = WSGIRequest({'REQUEST_METHOD': 'POST',
|
||||
'CONTENT_LENGTH': len(payload),
|
||||
'wsgi.input': StringIO(payload)})
|
||||
self.assertEqual(request.read(2), 'na')
|
||||
self.assertEqual(request.read(2), b'na')
|
||||
self.assertRaises(Exception, lambda: request.body)
|
||||
self.assertEqual(request.POST, {})
|
||||
|
||||
|
|
@ -335,17 +335,17 @@ class RequestsTests(unittest.TestCase):
|
|||
self.assertEqual(request.POST, {})
|
||||
|
||||
def test_read_by_lines(self):
|
||||
payload = 'name=value'
|
||||
payload = b'name=value'
|
||||
request = WSGIRequest({'REQUEST_METHOD': 'POST',
|
||||
'CONTENT_LENGTH': len(payload),
|
||||
'wsgi.input': StringIO(payload)})
|
||||
self.assertEqual(list(request), ['name=value'])
|
||||
self.assertEqual(list(request), [b'name=value'])
|
||||
|
||||
def test_POST_after_body_read(self):
|
||||
"""
|
||||
POST should be populated even if body is read first
|
||||
"""
|
||||
payload = 'name=value'
|
||||
payload = b'name=value'
|
||||
request = WSGIRequest({'REQUEST_METHOD': 'POST',
|
||||
'CONTENT_LENGTH': len(payload),
|
||||
'wsgi.input': StringIO(payload)})
|
||||
|
|
@ -357,12 +357,12 @@ class RequestsTests(unittest.TestCase):
|
|||
POST should be populated even if body is read first, and then
|
||||
the stream is read second.
|
||||
"""
|
||||
payload = 'name=value'
|
||||
payload = b'name=value'
|
||||
request = WSGIRequest({'REQUEST_METHOD': 'POST',
|
||||
'CONTENT_LENGTH': len(payload),
|
||||
'wsgi.input': StringIO(payload)})
|
||||
raw_data = request.body
|
||||
self.assertEqual(request.read(1), u'n')
|
||||
self.assertEqual(request.read(1), b'n')
|
||||
self.assertEqual(request.POST, {u'name': [u'value']})
|
||||
|
||||
def test_POST_after_body_read_and_stream_read_multipart(self):
|
||||
|
|
@ -383,14 +383,14 @@ class RequestsTests(unittest.TestCase):
|
|||
'wsgi.input': StringIO(payload)})
|
||||
raw_data = request.body
|
||||
# Consume enough data to mess up the parsing:
|
||||
self.assertEqual(request.read(13), u'--boundary\r\nC')
|
||||
self.assertEqual(request.read(13), b'--boundary\r\nC')
|
||||
self.assertEqual(request.POST, {u'name': [u'value']})
|
||||
|
||||
def test_raw_post_data_returns_body(self):
|
||||
"""
|
||||
HttpRequest.raw_post_body should be the same as HttpRequest.body
|
||||
"""
|
||||
payload = 'Hello There!'
|
||||
payload = b'Hello There!'
|
||||
request = WSGIRequest({
|
||||
'REQUEST_METHOD': 'POST',
|
||||
'CONTENT_LENGTH': len(payload),
|
||||
|
|
@ -409,7 +409,7 @@ class RequestsTests(unittest.TestCase):
|
|||
def read(self, len=0):
|
||||
raise IOError("kaboom!")
|
||||
|
||||
payload = 'name=value'
|
||||
payload = b'name=value'
|
||||
request = WSGIRequest({'REQUEST_METHOD': 'POST',
|
||||
'CONTENT_LENGTH': len(payload),
|
||||
'wsgi.input': ExplodingStringIO(payload)})
|
||||
|
|
|
|||
|
|
@ -12,8 +12,8 @@ class TestSigner(TestCase):
|
|||
signer = signing.Signer('predictable-secret')
|
||||
signer2 = signing.Signer('predictable-secret2')
|
||||
for s in (
|
||||
'hello',
|
||||
'3098247:529:087:',
|
||||
b'hello',
|
||||
b'3098247:529:087:',
|
||||
u'\u2019'.encode('utf-8'),
|
||||
):
|
||||
self.assertEqual(
|
||||
|
|
@ -69,7 +69,7 @@ class TestSigner(TestCase):
|
|||
"dumps and loads be reversible for any JSON serializable object"
|
||||
objects = (
|
||||
['a', 'list'],
|
||||
'a string',
|
||||
b'a string',
|
||||
u'a unicode string \u2019',
|
||||
{'a': 'dictionary'},
|
||||
)
|
||||
|
|
|
|||
|
|
@ -387,8 +387,8 @@ class TestCollectionCachedStorage(BaseCollectionTestCase,
|
|||
self.assertEqual(relpath, "cached/styles.93b1147e8552.css")
|
||||
with storage.staticfiles_storage.open(relpath) as relfile:
|
||||
content = relfile.read()
|
||||
self.assertNotIn("cached/other.css", content)
|
||||
self.assertIn("other.d41d8cd98f00.css", content)
|
||||
self.assertNotIn(b"cached/other.css", content)
|
||||
self.assertIn(b"other.d41d8cd98f00.css", content)
|
||||
|
||||
def test_path_with_querystring(self):
|
||||
relpath = self.cached_file_path("cached/styles.css?spam=eggs")
|
||||
|
|
@ -397,8 +397,8 @@ class TestCollectionCachedStorage(BaseCollectionTestCase,
|
|||
with storage.staticfiles_storage.open(
|
||||
"cached/styles.93b1147e8552.css") as relfile:
|
||||
content = relfile.read()
|
||||
self.assertNotIn("cached/other.css", content)
|
||||
self.assertIn("other.d41d8cd98f00.css", content)
|
||||
self.assertNotIn(b"cached/other.css", content)
|
||||
self.assertIn(b"other.d41d8cd98f00.css", content)
|
||||
|
||||
def test_path_with_fragment(self):
|
||||
relpath = self.cached_file_path("cached/styles.css#eggs")
|
||||
|
|
@ -406,62 +406,62 @@ class TestCollectionCachedStorage(BaseCollectionTestCase,
|
|||
with storage.staticfiles_storage.open(
|
||||
"cached/styles.93b1147e8552.css") as relfile:
|
||||
content = relfile.read()
|
||||
self.assertNotIn("cached/other.css", content)
|
||||
self.assertIn("other.d41d8cd98f00.css", content)
|
||||
self.assertNotIn(b"cached/other.css", content)
|
||||
self.assertIn(b"other.d41d8cd98f00.css", content)
|
||||
|
||||
def test_path_with_querystring_and_fragment(self):
|
||||
relpath = self.cached_file_path("cached/css/fragments.css")
|
||||
self.assertEqual(relpath, "cached/css/fragments.75433540b096.css")
|
||||
with storage.staticfiles_storage.open(relpath) as relfile:
|
||||
content = relfile.read()
|
||||
self.assertIn('fonts/font.a4b0478549d0.eot?#iefix', content)
|
||||
self.assertIn('fonts/font.b8d603e42714.svg#webfontIyfZbseF', content)
|
||||
self.assertIn('data:font/woff;charset=utf-8;base64,d09GRgABAAAAADJoAA0AAAAAR2QAAQAAAAAAAAAAAAA', content)
|
||||
self.assertIn('#default#VML', content)
|
||||
self.assertIn(b'fonts/font.a4b0478549d0.eot?#iefix', content)
|
||||
self.assertIn(b'fonts/font.b8d603e42714.svg#webfontIyfZbseF', content)
|
||||
self.assertIn(b'data:font/woff;charset=utf-8;base64,d09GRgABAAAAADJoAA0AAAAAR2QAAQAAAAAAAAAAAAA', content)
|
||||
self.assertIn(b'#default#VML', content)
|
||||
|
||||
def test_template_tag_absolute(self):
|
||||
relpath = self.cached_file_path("cached/absolute.css")
|
||||
self.assertEqual(relpath, "cached/absolute.23f087ad823a.css")
|
||||
with storage.staticfiles_storage.open(relpath) as relfile:
|
||||
content = relfile.read()
|
||||
self.assertNotIn("/static/cached/styles.css", content)
|
||||
self.assertIn("/static/cached/styles.93b1147e8552.css", content)
|
||||
self.assertIn('/static/cached/img/relative.acae32e4532b.png', content)
|
||||
self.assertNotIn(b"/static/cached/styles.css", content)
|
||||
self.assertIn(b"/static/cached/styles.93b1147e8552.css", content)
|
||||
self.assertIn(b'/static/cached/img/relative.acae32e4532b.png', content)
|
||||
|
||||
def test_template_tag_denorm(self):
|
||||
relpath = self.cached_file_path("cached/denorm.css")
|
||||
self.assertEqual(relpath, "cached/denorm.c5bd139ad821.css")
|
||||
with storage.staticfiles_storage.open(relpath) as relfile:
|
||||
content = relfile.read()
|
||||
self.assertNotIn("..//cached///styles.css", content)
|
||||
self.assertIn("../cached/styles.93b1147e8552.css", content)
|
||||
self.assertNotIn("url(img/relative.png )", content)
|
||||
self.assertIn('url("img/relative.acae32e4532b.png', content)
|
||||
self.assertNotIn(b"..//cached///styles.css", content)
|
||||
self.assertIn(b"../cached/styles.93b1147e8552.css", content)
|
||||
self.assertNotIn(b"url(img/relative.png )", content)
|
||||
self.assertIn(b'url("img/relative.acae32e4532b.png', content)
|
||||
|
||||
def test_template_tag_relative(self):
|
||||
relpath = self.cached_file_path("cached/relative.css")
|
||||
self.assertEqual(relpath, "cached/relative.2217ea7273c2.css")
|
||||
with storage.staticfiles_storage.open(relpath) as relfile:
|
||||
content = relfile.read()
|
||||
self.assertNotIn("../cached/styles.css", content)
|
||||
self.assertNotIn('@import "styles.css"', content)
|
||||
self.assertNotIn('url(img/relative.png)', content)
|
||||
self.assertIn('url("img/relative.acae32e4532b.png")', content)
|
||||
self.assertIn("../cached/styles.93b1147e8552.css", content)
|
||||
self.assertNotIn(b"../cached/styles.css", content)
|
||||
self.assertNotIn(b'@import "styles.css"', content)
|
||||
self.assertNotIn(b'url(img/relative.png)', content)
|
||||
self.assertIn(b'url("img/relative.acae32e4532b.png")', content)
|
||||
self.assertIn(b"../cached/styles.93b1147e8552.css", content)
|
||||
|
||||
def test_template_tag_deep_relative(self):
|
||||
relpath = self.cached_file_path("cached/css/window.css")
|
||||
self.assertEqual(relpath, "cached/css/window.9db38d5169f3.css")
|
||||
with storage.staticfiles_storage.open(relpath) as relfile:
|
||||
content = relfile.read()
|
||||
self.assertNotIn('url(img/window.png)', content)
|
||||
self.assertIn('url("img/window.acae32e4532b.png")', content)
|
||||
self.assertNotIn(b'url(img/window.png)', content)
|
||||
self.assertIn(b'url("img/window.acae32e4532b.png")', content)
|
||||
|
||||
def test_template_tag_url(self):
|
||||
relpath = self.cached_file_path("cached/url.css")
|
||||
self.assertEqual(relpath, "cached/url.615e21601e4b.css")
|
||||
with storage.staticfiles_storage.open(relpath) as relfile:
|
||||
self.assertIn("https://", relfile.read())
|
||||
self.assertIn(b"https://", relfile.read())
|
||||
|
||||
def test_cache_invalidation(self):
|
||||
name = "cached/styles.css"
|
||||
|
|
@ -508,7 +508,7 @@ class TestCollectionCachedStorage(BaseCollectionTestCase,
|
|||
"""
|
||||
Handle cache key creation correctly, see #17861.
|
||||
"""
|
||||
name = "/some crazy/long filename/ with spaces Here and ?#%#$/other/stuff/some crazy/long filename/ with spaces Here and ?#%#$/other/stuff/some crazy/long filename/ with spaces Here and ?#%#$/other/stuff/some crazy/long filename/ with spaces Here and ?#%#$/other/stuff/some crazy/long filename/ with spaces Here and ?#%#$/other/stuff/some crazy/" + chr(22) + chr(180)
|
||||
name = b"/some crazy/long filename/ with spaces Here and ?#%#$/other/stuff/some crazy/long filename/ with spaces Here and ?#%#$/other/stuff/some crazy/long filename/ with spaces Here and ?#%#$/other/stuff/some crazy/long filename/ with spaces Here and ?#%#$/other/stuff/some crazy/long filename/ with spaces Here and ?#%#$/other/stuff/some crazy/" + chr(22) + chr(180)
|
||||
cache_key = storage.staticfiles_storage.cache_key(name)
|
||||
cache_validator = BaseCache({})
|
||||
cache_validator.validate_key(cache_key)
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ class StringLookupTests(TestCase):
|
|||
self.assertEqual(Foo.objects.get(friend__contains=u'\xe7'), fx)
|
||||
|
||||
# We can also do the above query using UTF-8 strings.
|
||||
self.assertEqual(Foo.objects.get(friend__contains='\xc3\xa7'), fx)
|
||||
self.assertEqual(Foo.objects.get(friend__contains=b'\xc3\xa7'), fx)
|
||||
|
||||
def test_queries_on_textfields(self):
|
||||
"""
|
||||
|
|
|
|||
|
|
@ -192,17 +192,17 @@ class Templates(unittest.TestCase):
|
|||
test_template_sources('../dir1blah', template_dirs, [])
|
||||
|
||||
# UTF-8 bytestrings are permitted.
|
||||
test_template_sources('\xc3\x85ngstr\xc3\xb6m', template_dirs,
|
||||
test_template_sources(b'\xc3\x85ngstr\xc3\xb6m', template_dirs,
|
||||
[u'/dir1/Ångström', u'/dir2/Ångström'])
|
||||
# Unicode strings are permitted.
|
||||
test_template_sources(u'Ångström', template_dirs,
|
||||
[u'/dir1/Ångström', u'/dir2/Ångström'])
|
||||
test_template_sources(u'Ångström', ['/Straße'], [u'/Straße/Ångström'])
|
||||
test_template_sources('\xc3\x85ngstr\xc3\xb6m', ['/Straße'],
|
||||
test_template_sources(u'Ångström', [b'/Stra\xc3\x9fe'], [u'/Straße/Ångström'])
|
||||
test_template_sources(b'\xc3\x85ngstr\xc3\xb6m', [b'/Stra\xc3\x9fe'],
|
||||
[u'/Straße/Ångström'])
|
||||
# Invalid UTF-8 encoding in bytestrings is not. Should raise a
|
||||
# semi-useful error message.
|
||||
test_template_sources('\xc3\xc3', template_dirs, UnicodeDecodeError)
|
||||
test_template_sources(b'\xc3\xc3', template_dirs, UnicodeDecodeError)
|
||||
|
||||
# Case insensitive tests (for win32). Not run unless we're on
|
||||
# a case insensitive operating system.
|
||||
|
|
@ -1239,11 +1239,11 @@ class Templates(unittest.TestCase):
|
|||
'i18n02': ('{% load i18n %}{% trans "xxxyyyxxx" %}', {}, "xxxyyyxxx"),
|
||||
|
||||
# simple translation of a variable
|
||||
'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': '\xc3\x85'}, u"Å"),
|
||||
'i18n03': ('{% load i18n %}{% blocktrans %}{{ anton }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, u"Å"),
|
||||
|
||||
# simple translation of a variable and filter
|
||||
'i18n04': ('{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}', {'anton': '\xc3\x85'}, u'å'),
|
||||
'legacyi18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': '\xc3\x85'}, u'å'),
|
||||
'i18n04': ('{% load i18n %}{% blocktrans with berta=anton|lower %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, u'å'),
|
||||
'legacyi18n04': ('{% load i18n %}{% blocktrans with anton|lower as berta %}{{ berta }}{% endblocktrans %}', {'anton': b'\xc3\x85'}, u'å'),
|
||||
|
||||
# simple translation of a string with interpolation
|
||||
'i18n05': ('{% load i18n %}{% blocktrans %}xxx{{ anton }}xxx{% endblocktrans %}', {'anton': 'yyy'}, "xxxyyyxxx"),
|
||||
|
|
|
|||
|
|
@ -10,16 +10,16 @@ class UnicodeTests(TestCase):
|
|||
t1 = Template(u'ŠĐĆŽćžšđ {{ var }}')
|
||||
# Templates can also be created from bytestrings. These are assumed to
|
||||
# be encoded using UTF-8.
|
||||
s = '\xc5\xa0\xc4\x90\xc4\x86\xc5\xbd\xc4\x87\xc5\xbe\xc5\xa1\xc4\x91 {{ var }}'
|
||||
s = b'\xc5\xa0\xc4\x90\xc4\x86\xc5\xbd\xc4\x87\xc5\xbe\xc5\xa1\xc4\x91 {{ var }}'
|
||||
t2 = Template(s)
|
||||
s = '\x80\xc5\xc0'
|
||||
s = b'\x80\xc5\xc0'
|
||||
self.assertRaises(TemplateEncodingError, Template, s)
|
||||
|
||||
# Contexts can be constructed from unicode or UTF-8 bytestrings.
|
||||
c1 = Context({"var": "foo"})
|
||||
c2 = Context({u"var": "foo"})
|
||||
c3 = Context({"var": u"Đđ"})
|
||||
c4 = Context({u"var": "\xc4\x90\xc4\x91"})
|
||||
c1 = Context({b"var": b"foo"})
|
||||
c2 = Context({u"var": b"foo"})
|
||||
c3 = Context({b"var": u"Đđ"})
|
||||
c4 = Context({u"var": b"\xc4\x90\xc4\x91"})
|
||||
|
||||
# Since both templates and all four contexts represent the same thing,
|
||||
# they all render the same (and are returned as unicode objects and
|
||||
|
|
|
|||
|
|
@ -122,14 +122,14 @@ class AssertContainsTests(TestCase):
|
|||
#Regression test for #10183
|
||||
r = self.client.get('/test_client_regress/check_unicode/')
|
||||
self.assertContains(r, u'さかき')
|
||||
self.assertContains(r, '\xe5\xb3\xa0'.decode('utf-8'))
|
||||
self.assertContains(r, b'\xe5\xb3\xa0'.decode('utf-8'))
|
||||
|
||||
def test_unicode_not_contains(self):
|
||||
"Unicode characters can be searched for, and not found in template context"
|
||||
#Regression test for #10183
|
||||
r = self.client.get('/test_client_regress/check_unicode/')
|
||||
self.assertNotContains(r, u'はたけ')
|
||||
self.assertNotContains(r, '\xe3\x81\xaf\xe3\x81\x9f\xe3\x81\x91'.decode('utf-8'))
|
||||
self.assertNotContains(r, b'\xe3\x81\xaf\xe3\x81\x9f\xe3\x81\x91'.decode('utf-8'))
|
||||
|
||||
def test_assert_contains_renders_template_response(self):
|
||||
""" Test that we can pass in an unrendered SimpleTemplateReponse
|
||||
|
|
@ -571,25 +571,25 @@ class URLEscapingTests(TestCase):
|
|||
"Get a view that has a simple string argument"
|
||||
response = self.client.get(reverse('arg_view', args=['Slartibartfast']))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'Howdy, Slartibartfast')
|
||||
self.assertEqual(response.content, b'Howdy, Slartibartfast')
|
||||
|
||||
def test_argument_with_space_get(self):
|
||||
"Get a view that has a string argument that requires escaping"
|
||||
response = self.client.get(reverse('arg_view', args=['Arthur Dent']))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'Hi, Arthur')
|
||||
self.assertEqual(response.content, b'Hi, Arthur')
|
||||
|
||||
def test_simple_argument_post(self):
|
||||
"Post for a view that has a simple string argument"
|
||||
response = self.client.post(reverse('arg_view', args=['Slartibartfast']))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'Howdy, Slartibartfast')
|
||||
self.assertEqual(response.content, b'Howdy, Slartibartfast')
|
||||
|
||||
def test_argument_with_space_post(self):
|
||||
"Post for a view that has a string argument that requires escaping"
|
||||
response = self.client.post(reverse('arg_view', args=['Arthur Dent']))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'Hi, Arthur')
|
||||
self.assertEqual(response.content, b'Hi, Arthur')
|
||||
|
||||
@override_settings(PASSWORD_HASHERS=('django.contrib.auth.hashers.SHA1PasswordHasher',))
|
||||
class ExceptionTests(TestCase):
|
||||
|
|
@ -721,17 +721,17 @@ class SessionTests(TestCase):
|
|||
# The session doesn't exist to start.
|
||||
response = self.client.get('/test_client_regress/check_session/')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'NO')
|
||||
self.assertEqual(response.content, b'NO')
|
||||
|
||||
# This request sets a session variable.
|
||||
response = self.client.get('/test_client_regress/set_session/')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'set_session')
|
||||
self.assertEqual(response.content, b'set_session')
|
||||
|
||||
# Check that the session has been modified
|
||||
response = self.client.get('/test_client_regress/check_session/')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'YES')
|
||||
self.assertEqual(response.content, b'YES')
|
||||
|
||||
# Log in
|
||||
login = self.client.login(username='testclient',password='password')
|
||||
|
|
@ -740,7 +740,7 @@ class SessionTests(TestCase):
|
|||
# Session should still contain the modified value
|
||||
response = self.client.get('/test_client_regress/check_session/')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'YES')
|
||||
self.assertEqual(response.content, b'YES')
|
||||
|
||||
def test_logout(self):
|
||||
"""Logout should work whether the user is logged in or not (#9978)."""
|
||||
|
|
@ -755,39 +755,39 @@ class RequestMethodTests(TestCase):
|
|||
"Request a view via request method GET"
|
||||
response = self.client.get('/test_client_regress/request_methods/')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'request method: GET')
|
||||
self.assertEqual(response.content, b'request method: GET')
|
||||
|
||||
def test_post(self):
|
||||
"Request a view via request method POST"
|
||||
response = self.client.post('/test_client_regress/request_methods/')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'request method: POST')
|
||||
self.assertEqual(response.content, b'request method: POST')
|
||||
|
||||
def test_head(self):
|
||||
"Request a view via request method HEAD"
|
||||
response = self.client.head('/test_client_regress/request_methods/')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
# A HEAD request doesn't return any content.
|
||||
self.assertNotEqual(response.content, 'request method: HEAD')
|
||||
self.assertEqual(response.content, '')
|
||||
self.assertNotEqual(response.content, b'request method: HEAD')
|
||||
self.assertEqual(response.content, b'')
|
||||
|
||||
def test_options(self):
|
||||
"Request a view via request method OPTIONS"
|
||||
response = self.client.options('/test_client_regress/request_methods/')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'request method: OPTIONS')
|
||||
self.assertEqual(response.content, b'request method: OPTIONS')
|
||||
|
||||
def test_put(self):
|
||||
"Request a view via request method PUT"
|
||||
response = self.client.put('/test_client_regress/request_methods/')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'request method: PUT')
|
||||
self.assertEqual(response.content, b'request method: PUT')
|
||||
|
||||
def test_delete(self):
|
||||
"Request a view via request method DELETE"
|
||||
response = self.client.delete('/test_client_regress/request_methods/')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'request method: DELETE')
|
||||
self.assertEqual(response.content, b'request method: DELETE')
|
||||
|
||||
class RequestMethodStringDataTests(TestCase):
|
||||
def test_post(self):
|
||||
|
|
@ -796,7 +796,7 @@ class RequestMethodStringDataTests(TestCase):
|
|||
data = u'{"test": "json"}'
|
||||
response = self.client.post('/test_client_regress/request_methods/', data=data, content_type='application/json')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'request method: POST')
|
||||
self.assertEqual(response.content, b'request method: POST')
|
||||
|
||||
def test_put(self):
|
||||
"Request a view with string data via request method PUT"
|
||||
|
|
@ -804,7 +804,7 @@ class RequestMethodStringDataTests(TestCase):
|
|||
data = u'{"test": "json"}'
|
||||
response = self.client.put('/test_client_regress/request_methods/', data=data, content_type='application/json')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertEqual(response.content, 'request method: PUT')
|
||||
self.assertEqual(response.content, b'request method: PUT')
|
||||
|
||||
class QueryStringTests(TestCase):
|
||||
def test_get_like_requests(self):
|
||||
|
|
@ -913,34 +913,34 @@ class DummyFile(object):
|
|||
class UploadedFileEncodingTest(TestCase):
|
||||
def test_file_encoding(self):
|
||||
encoded_file = encode_file('TEST_BOUNDARY', 'TEST_KEY', DummyFile('test_name.bin'))
|
||||
self.assertEqual('--TEST_BOUNDARY', encoded_file[0])
|
||||
self.assertEqual('Content-Disposition: form-data; name="TEST_KEY"; filename="test_name.bin"', encoded_file[1])
|
||||
self.assertEqual('TEST_FILE_CONTENT', encoded_file[-1])
|
||||
self.assertEqual(b'--TEST_BOUNDARY', encoded_file[0])
|
||||
self.assertEqual(b'Content-Disposition: form-data; name="TEST_KEY"; filename="test_name.bin"', encoded_file[1])
|
||||
self.assertEqual(b'TEST_FILE_CONTENT', encoded_file[-1])
|
||||
|
||||
def test_guesses_content_type_on_file_encoding(self):
|
||||
self.assertEqual('Content-Type: application/octet-stream',
|
||||
self.assertEqual(b'Content-Type: application/octet-stream',
|
||||
encode_file('IGNORE', 'IGNORE', DummyFile("file.bin"))[2])
|
||||
self.assertEqual('Content-Type: text/plain',
|
||||
self.assertEqual(b'Content-Type: text/plain',
|
||||
encode_file('IGNORE', 'IGNORE', DummyFile("file.txt"))[2])
|
||||
self.assertIn(encode_file('IGNORE', 'IGNORE', DummyFile("file.zip"))[2], (
|
||||
'Content-Type: application/x-compress',
|
||||
'Content-Type: application/x-zip',
|
||||
'Content-Type: application/x-zip-compressed',
|
||||
'Content-Type: application/zip',))
|
||||
self.assertEqual('Content-Type: application/octet-stream',
|
||||
b'Content-Type: application/x-compress',
|
||||
b'Content-Type: application/x-zip',
|
||||
b'Content-Type: application/x-zip-compressed',
|
||||
b'Content-Type: application/zip',))
|
||||
self.assertEqual(b'Content-Type: application/octet-stream',
|
||||
encode_file('IGNORE', 'IGNORE', DummyFile("file.unknown"))[2])
|
||||
|
||||
class RequestHeadersTest(TestCase):
|
||||
def test_client_headers(self):
|
||||
"A test client can receive custom headers"
|
||||
response = self.client.get("/test_client_regress/check_headers/", HTTP_X_ARG_CHECK='Testing 123')
|
||||
self.assertEqual(response.content, "HTTP_X_ARG_CHECK: Testing 123")
|
||||
self.assertEqual(response.content, b"HTTP_X_ARG_CHECK: Testing 123")
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_client_headers_redirect(self):
|
||||
"Test client headers are preserved through redirects"
|
||||
response = self.client.get("/test_client_regress/check_headers_redirect/", follow=True, HTTP_X_ARG_CHECK='Testing 123')
|
||||
self.assertEqual(response.content, "HTTP_X_ARG_CHECK: Testing 123")
|
||||
self.assertEqual(response.content, b"HTTP_X_ARG_CHECK: Testing 123")
|
||||
self.assertRedirects(response, '/test_client_regress/check_headers/',
|
||||
status_code=301, target_status_code=200)
|
||||
|
||||
|
|
@ -956,22 +956,22 @@ class ReadLimitedStreamTest(TestCase):
|
|||
def test_body_from_empty_request(self):
|
||||
"""HttpRequest.body on a test client GET request should return
|
||||
the empty string."""
|
||||
self.assertEqual(self.client.get("/test_client_regress/body/").content, '')
|
||||
self.assertEqual(self.client.get("/test_client_regress/body/").content, b'')
|
||||
|
||||
def test_read_from_empty_request(self):
|
||||
"""HttpRequest.read() on a test client GET request should return the
|
||||
empty string."""
|
||||
self.assertEqual(self.client.get("/test_client_regress/read_all/").content, '')
|
||||
self.assertEqual(self.client.get("/test_client_regress/read_all/").content, b'')
|
||||
|
||||
def test_read_numbytes_from_empty_request(self):
|
||||
"""HttpRequest.read(LARGE_BUFFER) on a test client GET request should
|
||||
return the empty string."""
|
||||
self.assertEqual(self.client.get("/test_client_regress/read_buffer/").content, '')
|
||||
self.assertEqual(self.client.get("/test_client_regress/read_buffer/").content, b'')
|
||||
|
||||
def test_read_from_nonempty_request(self):
|
||||
"""HttpRequest.read() on a test client PUT request with some payload
|
||||
should return that payload."""
|
||||
payload = 'foobar'
|
||||
payload = b'foobar'
|
||||
self.assertEqual(self.client.put("/test_client_regress/read_all/",
|
||||
data=payload,
|
||||
content_type='text/plain').content, payload)
|
||||
|
|
@ -979,7 +979,7 @@ class ReadLimitedStreamTest(TestCase):
|
|||
def test_read_numbytes_from_nonempty_request(self):
|
||||
"""HttpRequest.read(LARGE_BUFFER) on a test client PUT request with
|
||||
some payload should return that payload."""
|
||||
payload = 'foobar'
|
||||
payload = b'foobar'
|
||||
self.assertEqual(self.client.put("/test_client_regress/read_buffer/",
|
||||
data=payload,
|
||||
content_type='text/plain').content, payload)
|
||||
|
|
|
|||
|
|
@ -3,8 +3,8 @@
|
|||
class BrokenException(Exception):
|
||||
pass
|
||||
|
||||
except_args = ('Broken!', # plain exception with ASCII text
|
||||
except_args = (b'Broken!', # plain exception with ASCII text
|
||||
u'¡Broken!', # non-ASCII unicode data
|
||||
'¡Broken!', # non-ASCII, utf-8 encoded bytestring
|
||||
'\xa1Broken!', ) # non-ASCII, latin1 bytestring
|
||||
u'¡Broken!'.encode('utf-8'), # non-ASCII, utf-8 encoded bytestring
|
||||
b'\xa1Broken!', ) # non-ASCII, latin1 bytestring
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue