def test_comment_file_upload_tmp_file(self):
"""
Check (tmp) upload files are checked
"""
utils.login(self)
file = BytesIO(
b'%PDF-1.0\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj 2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1'
b'>>endobj 3 0 obj<</Type/Page/MediaBox[0 0 3 3]>>endobj\nxref\n0 4\n0000000000 65535 f\n000000'
b'0010 00000 n\n0000000053 00000 n\n0000000102 00000 n\ntrailer<</Size 4/Root 1 0 R>>\nstartxre'
b'f\n149\n%EOF\n')
files = {
'file': SimpleUploadedFile(
'file_large.pdf', file.read(), content_type='application/pdf'),}
response = self.client.post(
reverse('spirit:comment:file-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data=files)
res = json.loads(response.content.decode('utf-8'))
file_url = os.path.join(
settings.MEDIA_URL, 'spirit', 'files', str(self.user.pk), "fadcb2389bb2b69b46bc54185de0ae91.pdf"
).replace("\\", "/")
self.assertEqual(res['url'], file_url)
file_path = os.path.join(
settings.MEDIA_ROOT, 'spirit', 'files', str(self.user.pk), "fadcb2389bb2b69b46bc54185de0ae91.pdf"
)
with open(file_path, 'rb') as fh:
file.seek(0)
self.assertEqual(fh.read(), file.read())
shutil.rmtree(settings.MEDIA_ROOT) # cleanup
def test_comment_file_upload_tmp_file(self):
"""
Check (tmp) upload files are checked
"""
utils.login(self)
file = BytesIO(
b'%PDF-1.0\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj 2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1'
b'>>endobj 3 0 obj<</Type/Page/MediaBox[0 0 3 3]>>endobj\nxref\n0 4\n0000000000 65535 f\n000000'
b'0010 00000 n\n0000000053 00000 n\n0000000102 00000 n\ntrailer<</Size 4/Root 1 0 R>>\nstartxre'
b'f\n149\n%EOF\n')
files = {
'file':
SimpleUploadedFile('file_large.pdf',
file.read(),
content_type='application/pdf'),
}
response = self.client.post(reverse('spirit:comment:file-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data=files)
res = json.loads(response.content.decode('utf-8'))
file_url = os.path.join(
settings.MEDIA_URL, 'spirit', 'files', str(self.user.pk),
"file_large_fadcb2389bb2b69b46bc54185de0ae91.pdf").replace(
"\\", "/")
self.assertEqual(res['url'], file_url)
file_path = os.path.join(
settings.MEDIA_ROOT, 'spirit', 'files', str(self.user.pk),
"file_large_fadcb2389bb2b69b46bc54185de0ae91.pdf")
with open(file_path, 'rb') as fh:
file.seek(0)
self.assertEqual(fh.read(), file.read())
shutil.rmtree(settings.MEDIA_ROOT) # cleanup
def test_comment_image_upload_unique(self):
user_images_parts = ('spirit', 'images', str(self.user.pk))
user_images_base = os.path.join(*user_images_parts)
user_media = os.path.join(settings.MEDIA_ROOT, user_images_base)
self.assertFalse(os.path.isdir(user_media))
utils.login(self)
img = BytesIO(
b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
image_name = 'foo_image.gif'
file = SimpleUploadedFile(
image_name, img.read(), content_type='image/gif')
response = self.client.post(
reverse('spirit:comment:image-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data={'image': file})
res = json.loads(response.content.decode('utf-8'))
self.assertTrue(os.path.isdir(user_media))
url_parts = res['url'].split('/')
self.assertEqual(
url_parts[:-2],
(settings.MEDIA_URL + '/'.join(user_images_parts)).split('/'))
self.assertEqual(len(url_parts[-2]), 32) # uuid
self.assertEqual(url_parts[-1], image_name)
self.assertEqual(len(os.listdir(user_media)), 1)
self.assertTrue(os.path.join(
user_media, os.listdir(user_media)[0], image_name))
shutil.rmtree(settings.MEDIA_ROOT) # cleanup
def test_comment_image_upload(self):
"""
comment image upload
"""
utils.login(self)
img = BytesIO(
b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
files = {'image': SimpleUploadedFile(
'image.gif', img.read(), content_type='image/gif'), }
response = self.client.post(
reverse('spirit:comment:image-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data=files)
res = json.loads(response.content.decode('utf-8'))
image_url = os.path.join(
settings.MEDIA_URL, 'spirit', 'images', str(self.user.pk),
"bf21c3043d749d5598366c26e7e4ab44.gif"
).replace("\\", "/")
self.assertEqual(res['url'], image_url)
image_path = os.path.join(
settings.MEDIA_ROOT, 'spirit', 'images', str(self.user.pk),
"bf21c3043d749d5598366c26e7e4ab44.gif"
)
self.assertTrue(os.path.isfile(image_path))
shutil.rmtree(settings.MEDIA_ROOT) # cleanup
def test_comment_image_upload_unique_no_duplication(self):
utils.login(self)
img = BytesIO(
b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
image_name = 'foo_image.gif'
file = SimpleUploadedFile(
image_name, img.read(), content_type='image/gif')
response = self.client.post(
reverse('spirit:comment:image-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data={'image': file})
res = json.loads(response.content.decode('utf-8'))
first_url = res['url']
utils.cache_clear()
file.seek(0)
response = self.client.post(
reverse('spirit:comment:image-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data={'image': file})
res = json.loads(response.content.decode('utf-8'))
second_url = res['url']
self.assertNotEqual(first_url, second_url)
def test_comment_file_upload_invalid_ext(self):
"""
comment file upload, invalid file extension
"""
utils.login(self)
# sample valid pdf - https://stackoverflow.com/a/17280876
file = BytesIO(
b'%PDF-1.0\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj 2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1'
b'>>endobj 3 0 obj<</Type/Page/MediaBox[0 0 3 3]>>endobj\nxref\n0 4\n0000000000 65535 f\n000000'
b'0010 00000 n\n0000000053 00000 n\n0000000102 00000 n\ntrailer<</Size 4/Root 1 0 R>>\nstartxre'
b'f\n149\n%EOF\n')
files = {
'file':
SimpleUploadedFile('fake.gif',
file.read(),
content_type='application/pdf'),
}
response = self.client.post(reverse('spirit:comment:file-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data=files)
res = json.loads(response.content.decode('utf-8'))
self.assertIn('error', res)
self.assertIn('file', res['error'])
self.assertEqual(res['error']['file'], [
'Unsupported file extension gif. Supported extensions are doc, docx, pdf.'
])
def setUp(self):
super().setUp()
self.data = Factory.MorFactory.get_valid_data()
self.test_url = reverse_lazy('whalesdb:create_mor')
# Since this is intended to be used as a pop-out form, the html file should start with an underscore
self.test_expected_template = 'shared_models/shared_entry_form.html'
self.expected_success_url = reverse_lazy('whalesdb:list_mor')
self.expected_view = views.MorCreate
self.expected_form = forms.MorForm
self.img_file_name = "MooringSetupTest.png"
self.img_file_path = os.path.dirname(os.path.realpath(__file__)) + os.path.sep + "data" + os.path.sep + \
self.img_file_name
data = BytesIO()
Image.open(self.img_file_path).save(data, "PNG")
data.seek(0)
file = ContentFile(data.read(), self.img_file_name)
# add the image to the data array
self.data['mor_setup_image'] = self.img_file_path
def test_logslice_api(test_repository, webapp, activate_responses, logname,
line_range, gzipped, num_loads):
job = Job.objects.create(repository=test_repository,
guid="12345", project_specific_id=1)
fake_log_url = 'http://www.fakelog.com/log.gz'
JobLog.objects.create(job=job, name=logname,
url=fake_log_url, status=JobLog.PARSED)
lines = ['cheezburger %s' % i for i in range(10)]
# set up a file response
text = "\n".join(lines) + '\n'
content = BytesIO()
if gzipped:
with gzip.GzipFile('none', 'w', fileobj=content) as gz:
gz.write(text)
else:
content.write(text)
content.seek(0)
responses.add(responses.GET, fake_log_url,
body=content.read(),
content_type="text/plain;charset=utf-8", status=200)
# now test it
for i in range(num_loads):
resp = webapp.get(reverse('logslice-list',
kwargs={"project": test_repository.name}) +
'?start_line={}&end_line={}&job_id=1'.format(line_range[0],
line_range[1]))
assert resp.json == [{'index': i + line_range[0], 'text': l + '\n'} for (i, l) in
enumerate(lines[line_range[0]:line_range[1]])]
class SFTPStorageFile(File):
def __init__(self, name, storage, mode):
self._name = name
self._storage = storage
self._mode = mode
self._is_dirty = False
self.file = BytesIO()
self._is_read = False
@property
def size(self):
if not hasattr(self, '_size'):
self._size = self._storage.size(self._name)
return self._size
def read(self, num_bytes=None):
if not self._is_read:
self.file = self._storage._read(self._name)
self._is_read = True
return self.file.read(num_bytes)
def write(self, content):
if 'w' not in self._mode:
raise AttributeError("File was opened for read-only access.")
self.file = BytesIO(content)
self._is_dirty = True
self._is_read = True
def close(self):
if self._is_dirty:
self._storage._save(self._name, self)
self.file.close()
def test_comment_image_upload(self):
"""
Image upload
"""
content = b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00' \
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;'
img = BytesIO(content)
files = {
'image':
SimpleUploadedFile('image.gif',
img.read(),
content_type='image/gif'),
}
form = CommentImageForm(user=self.user, data={}, files=files)
self.assertTrue(form.is_valid())
image = form.save()
self.assertEqual(image.name, "bf21c3043d749d5598366c26e7e4ab44.gif")
image_url = os.path.join(settings.MEDIA_URL, 'foro', 'images',
str(self.user.pk),
image.name).replace("\\", "/")
self.assertEqual(image.url, image_url)
image_path = os.path.join(settings.MEDIA_ROOT, 'foro', 'images',
str(self.user.pk), image.name)
self.assertTrue(os.path.isfile(image_path))
with open(image_path, "rb") as fh:
self.assertEqual(fh.read(), content)
os.remove(image_path)
def test_comment_image_upload(self):
"""
Image upload
"""
content = (
b"GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00"
b"\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;"
)
img = BytesIO(content)
files = {"image": SimpleUploadedFile("image.gif", img.read(), content_type="image/gif")}
form = CommentImageForm(user=self.user, data={}, files=files)
self.assertTrue(form.is_valid())
image = form.save()
self.assertEqual(image.name, "bf21c3043d749d5598366c26e7e4ab44.gif")
image_url = os.path.join(settings.MEDIA_URL, "spirit", "images", str(self.user.pk), image.name).replace(
"\\", "/"
)
self.assertEqual(image.url, image_url)
image_path = os.path.join(settings.MEDIA_ROOT, "spirit", "images", str(self.user.pk), image.name)
self.assertTrue(os.path.isfile(image_path))
with open(image_path, "rb") as fh:
self.assertEqual(fh.read(), content)
os.remove(image_path)
def test_comment_image_upload(self):
"""
comment image upload
"""
utils.login(self)
img = BytesIO(b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
files = {
'image':
SimpleUploadedFile('image.gif',
img.read(),
content_type='image/gif'),
}
response = self.client.post(reverse('foro:comment-image-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data=files)
res = json.loads(response.content.decode('utf-8'))
self.assertEqual(
res['url'],
os.path.join(settings.MEDIA_URL, 'foro', 'images',
str(self.user.pk),
"bf21c3043d749d5598366c26e7e4ab44.gif").replace(
"\\", "/"))
os.remove(
os.path.join(settings.MEDIA_ROOT, 'foro', 'images',
str(self.user.pk),
"bf21c3043d749d5598366c26e7e4ab44.gif"))
def test_comment_file_upload_unique_no_duplication(self):
utils.login(self)
pdf = BytesIO(
b'%PDF-1.0\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj 2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1'
b'>>endobj 3 0 obj<</Type/Page/MediaBox[0 0 3 3]>>endobj\nxref\n0 4\n0000000000 65535 f\n000000'
b'0010 00000 n\n0000000053 00000 n\n0000000102 00000 n\ntrailer<</Size 4/Root 1 0 R>>\nstartxre'
b'f\n149\n%EOF\n')
file_name = 'foo.pdf'
file = SimpleUploadedFile(
file_name, pdf.read(), content_type='application/pdf')
response = self.client.post(
reverse('spirit:comment:file-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data={'file': file})
res = json.loads(response.content.decode('utf-8'))
first_url = res['url']
utils.cache_clear()
file.seek(0)
response = self.client.post(
reverse('spirit:comment:file-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data={'file': file})
res = json.loads(response.content.decode('utf-8'))
second_url = res['url']
self.assertNotEqual(first_url, second_url)
class SFTPStorageFile(File):
def __init__(self, name, storage, mode):
self._name = name
self._storage = storage
self._mode = mode
self._is_dirty = False
self.file = BytesIO()
self._is_read = False
@property
def size(self):
if not hasattr(self, '_size'):
self._size = self._storage.size(self._name)
return self._size
def read(self, num_bytes=None):
if not self._is_read:
self.file = self._storage._read(self._name)
self._is_read = True
return self.file.read(num_bytes)
def write(self, content):
if 'w' not in self._mode:
raise AttributeError("File was opened for read-only access.")
self.file = BytesIO(content)
self._is_dirty = True
self._is_read = True
def close(self):
if self._is_dirty:
self._storage._save(self._name, self)
self.file.close()
def test_comment_file_upload_unique(self):
user_files_parts = ('spirit', 'files', str(self.user.pk))
user_files_base = os.path.join(*user_files_parts)
user_media = os.path.join(settings.MEDIA_ROOT, user_files_base)
self.assertFalse(os.path.isdir(user_media))
utils.login(self)
pdf = BytesIO(
b'%PDF-1.0\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj 2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1'
b'>>endobj 3 0 obj<</Type/Page/MediaBox[0 0 3 3]>>endobj\nxref\n0 4\n0000000000 65535 f\n000000'
b'0010 00000 n\n0000000053 00000 n\n0000000102 00000 n\ntrailer<</Size 4/Root 1 0 R>>\nstartxre'
b'f\n149\n%EOF\n')
file_name = 'foo.pdf'
file = SimpleUploadedFile(
file_name, pdf.read(), content_type='application/pdf')
response = self.client.post(
reverse('spirit:comment:file-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data={'file': file})
res = json.loads(response.content.decode('utf-8'))
self.assertTrue(os.path.isdir(user_media))
url_parts = res['url'].split('/')
self.assertEqual(
url_parts[:-2],
(settings.MEDIA_URL + '/'.join(user_files_parts)).split('/'))
self.assertEqual(len(url_parts[-2]), 32) # uuid
self.assertEqual(url_parts[-1], file_name)
self.assertEqual(len(os.listdir(user_media)), 1)
self.assertTrue(os.path.join(
user_media, os.listdir(user_media)[0], file_name))
shutil.rmtree(settings.MEDIA_ROOT) # cleanup
def test_create_mor(self):
img_file_name = "MooringSetupTest.png"
img_file_path = os.path.dirname(os.path.realpath(
__file__)) + os.path.sep + "data" + os.path.sep + img_file_name
data = BytesIO()
Image.open(img_file_path).save(data, "PNG")
data.seek(0)
file = ContentFile(data.read(), img_file_name)
self.mooring_dic = {}
mor_1 = models.MorMooringSetup(
mor_name="MOR001",
mor_max_depth=100,
mor_link_setup_image="https://somelink.com",
mor_setup_image=file)
mor_1.save()
# Check that the file was saved
expected_path = os.path.join(settings.MEDIA_DIR, "whalesdb",
"mooring_setup", img_file_name)
self.assertTrue(os.path.exists(expected_path))
self.assertTrue(os.path.isfile(expected_path))
# Delete the image
mor_1.delete()
self.assertFalse(os.path.exists(expected_path))
def test_comment_image_upload_invalid(self):
"""
Image upload, bad image
"""
img = BytesIO(b'bad\x00;')
files = {'image': SimpleUploadedFile('image.gif', img.read(), content_type='image/gif'), }
form = CommentImageForm(data={}, files=files)
self.assertFalse(form.is_valid())
def test_comment_image_upload_invalid(self):
"""
Image upload, bad image
"""
img = BytesIO(b'bad\x00;')
files = {'image': SimpleUploadedFile('image.gif', img.read(), content_type='image/gif'), }
form = CommentImageForm(data={}, files=files)
self.assertFalse(form.is_valid())
def test_comment_image_upload_invalid(self):
"""
Image upload, bad image
"""
img = BytesIO(b"bad\x00;")
files = {"image": SimpleUploadedFile("image.gif", img.read(), content_type="image/gif")}
form = CommentImageForm(data={}, files=files)
self.assertFalse(form.is_valid())
def test_comment_image_upload_invalid(self):
"""
Image upload with bad content but good extension should raise an error
"""
img = BytesIO(b'bad\x00;')
files = {'image': SimpleUploadedFile('image.gif', img.read(), content_type='image/gif'), }
form = CommentImageForm(data={}, files=files)
self.assertFalse(form.is_valid())
def test_comment_image_upload_invalid(self):
"""
Image upload with bad content but good extension should raise an error
"""
img = BytesIO(b'bad\x00;')
files = {'image': SimpleUploadedFile('image.gif', img.read(), content_type='image/gif'), }
form = CommentImageForm(data={}, files=files)
self.assertFalse(form.is_valid())
def test_comment_image_upload_not_allowed_ext(self):
"""
Image upload with good mime but not allowed extension should raise an error
"""
img = BytesIO(b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
files = {'image': SimpleUploadedFile('image.png', img.read(), content_type='image/png'), }
form = CommentImageForm(user=self.user, data={}, files=files)
self.assertFalse(form.is_valid())
def test_comment_image_upload_not_allowed_ext(self):
"""
Image upload with good mime but not allowed extension should raise an error
"""
img = BytesIO(b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
files = {'image': SimpleUploadedFile('image.png', img.read(), content_type='image/png'), }
form = CommentImageForm(user=self.user, data={}, files=files)
self.assertFalse(form.is_valid())
def test_comment_image_upload_not_allowed_format(self):
"""
Image upload, invalid format
"""
img = BytesIO(b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
# fake png extension
files = {'image': SimpleUploadedFile('image.png', img.read(), content_type='image/png'), }
form = CommentImageForm(data={}, files=files)
self.assertFalse(form.is_valid())
def test_comment_image_upload_not_allowed_format(self):
"""
Image upload, invalid format
"""
img = BytesIO(b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
# fake png extension
files = {'image': SimpleUploadedFile('image.png', img.read(), content_type='image/png'), }
form = CommentImageForm(data={}, files=files)
self.assertFalse(form.is_valid())
def test_comment_image_upload_no_extension(self):
"""
Image upload no extension
"""
img = BytesIO(b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
files = {'image': SimpleUploadedFile('image', img.read(), content_type='image/gif'), }
form = CommentImageForm(user=self.user, data={}, files=files)
self.assertTrue(form.is_valid())
image = form.save()
self.assertEqual(image.name, "bf21c3043d749d5598366c26e7e4ab44.gif")
os.remove(os.path.join(settings.MEDIA_ROOT, 'spirit', 'images', str(self.user.pk), image.name))
def test_gallery_model_file_field(self):
user = User.objects.create_user(username='******', password='******')
post = Post.objects.create(title='1 Post', body='1 post body', user_id=user.id)
img = BytesIO(
b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
image_file = SimpleUploadedFile('image.gif', img.read(), 'image/gif')
gallery = Gallery.objects.create(image=image_file, post_id=post.id)
self.assertTrue(gallery.image)
gallery.image.delete()
def test_comment_image_upload_no_extension(self):
"""
Image upload no extension
"""
img = BytesIO(b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
files = {'image': SimpleUploadedFile('image', img.read(), content_type='image/gif'), }
form = CommentImageForm(user=self.user, data={}, files=files)
self.assertTrue(form.is_valid())
image = form.save()
self.assertEqual(image.name, "bf21c3043d749d5598366c26e7e4ab44.gif")
os.remove(os.path.join(settings.MEDIA_ROOT, 'spirit', 'images', str(self.user.pk), image.name))
def create_image(filename,
storage=None,
size=(100, 100),
image_mode='RGB',
image_format='PNG'):
data = BytesIO()
Image.new(image_mode, size).save(data, image_format)
data.seek(0)
if not storage:
return data
image_file = ContentFile(data.read())
return storage.save(filename, image_file)
def test_comment_image_upload_mixed_case_ext(self):
utils.login(self)
img = BytesIO(
b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
image_name = 'foo_image.GiF'
file = SimpleUploadedFile(
image_name, img.read(), content_type='image/gif')
response = self.client.post(
reverse('spirit:comment:image-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data={'image': file})
res = json.loads(response.content.decode('utf-8'))
self.assertTrue(res['url'].endswith('/foo_image.gif'))
def create_image(storage, filename, size=(100, 100), image_mode='RGB', image_format='PNG'):
"""
Generate a test image, returning the filename that it was saved as.
If ``storage`` is ``None``, the BytesIO containing the image data
will be passed instead.
"""
data = BytesIO()
Image.new(image_mode, size).save(data, image_format)
data.seek(0)
if not storage:
return data
image_file = ContentFile(data.read())
return storage.save(filename, image_file)
def create_image(storage, filename, size=(100, 100), image_mode='RGB', image_format='PNG'):
"""
Generate a test image, returning the filename that it was saved as.
If ``storage`` is ``None``, the BytesIO containing the image data
will be passed instead.
"""
data = BytesIO()
Image.new(image_mode, size).save(data, image_format)
data.seek(0)
if not storage:
return data
image_file = ContentFile(data.read())
return storage.save(filename, image_file)
def test_profile_model(self):
user = User.objects.create_user(username='******', password='******')
img = BytesIO(b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
image_file = SimpleUploadedFile('image.gif', img.read(), 'image/gif')
user.profile.about = 'test about'
user.profile.avatar = image_file
user.save()
self.assertTrue(user.profile.avatar)
self.assertEqual(user.profile.about, 'test about')
user.profile.avatar.delete()
def test_comment_image_upload_invalid(self):
"""
comment image upload, invalid image
"""
utils.login(self)
image = BytesIO(b"BAD\x02D\x01\x00;")
image.name = "image.gif"
image.content_type = "image/gif"
files = {"image": SimpleUploadedFile(image.name, image.read())}
response = self.client.post(
reverse("spirit:comment:image-upload-ajax"), HTTP_X_REQUESTED_WITH="XMLHttpRequest", data=files
)
res = json.loads(response.content.decode("utf-8"))
self.assertIn("error", res.keys())
self.assertIn("image", res["error"].keys())
def test_comment_image_upload_invalid(self):
"""
comment image upload, invalid image
"""
utils.login(self)
image = BytesIO(b'BAD\x02D\x01\x00;')
image.name = 'image.gif'
image.content_type = 'image/gif'
files = {'image': SimpleUploadedFile(image.name, image.read()), }
response = self.client.post(reverse('spirit:comment:image-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data=files)
res = json.loads(response.content.decode('utf-8'))
self.assertIn('error', res.keys())
self.assertIn('image', res['error'].keys())
def test_comment_image_upload_invalid(self):
"""
comment image upload, invalid image
"""
utils.login(self)
image = BytesIO(b'BAD\x02D\x01\x00;')
image.name = 'image.gif'
image.content_type = 'image/gif'
files = {'image': SimpleUploadedFile(image.name, image.read()), }
response = self.client.post(reverse('spirit:comment:image-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data=files)
res = json.loads(response.content.decode('utf-8'))
self.assertIn('error', res.keys())
self.assertIn('image', res['error'].keys())
def test_comment_image_upload_unique_dots_name(self):
utils.login(self)
img = BytesIO(
b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
ext = '.gif'
image_name = '?...?...?' + ext
file = SimpleUploadedFile(
image_name, img.read(), content_type='image/gif')
response = self.client.post(
reverse('spirit:comment:image-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data={'image': file})
res = json.loads(response.content.decode('utf-8'))
self.assertTrue(res['url'].endswith(ext))
self.assertTrue(len(os.path.basename(res['url'])), len(ext) + 32) # uuid name
def test_comment_image_upload_unique_no_name(self):
utils.login(self)
img = BytesIO(
b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
image_name = '.gif'
file = SimpleUploadedFile(
image_name, img.read(), content_type='image/gif')
response = self.client.post(
reverse('spirit:comment:image-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data={'image': file})
res = json.loads(response.content.decode('utf-8'))
self.assertIn(
'File extension \'\' is not allowed',
res['error']['image'][0])
def test_comment_file_upload_no_libmagic(self):
"""
Magic lib should be optional
"""
utils.login(self)
file = BytesIO(
b'%PDF-1.0\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj 2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1'
b'>>endobj 3 0 obj<</Type/Page/MediaBox[0 0 3 3]>>endobj\nxref\n0 4\n0000000000 65535 f\n000000'
b'0010 00000 n\n0000000053 00000 n\n0000000102 00000 n\ntrailer<</Size 4/Root 1 0 R>>\nstartxre'
b'f\n149\n%EOF\n')
files = {'file': SimpleUploadedFile('file.pdf', file.read(), content_type='application/pdf'),}
form = CommentFileForm(data={}, files=files)
comment_forms_magic_orig, comment_forms.magic = comment_forms.magic, None
try:
self.assertFalse(form.is_valid())
finally:
comment_forms.magic = comment_forms_magic_orig
def test_comment_file_upload_no_libmagic(self):
"""
Magic lib should be optional
"""
utils.login(self)
file = BytesIO(
b'%PDF-1.0\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj 2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1'
b'>>endobj 3 0 obj<</Type/Page/MediaBox[0 0 3 3]>>endobj\nxref\n0 4\n0000000000 65535 f\n000000'
b'0010 00000 n\n0000000053 00000 n\n0000000102 00000 n\ntrailer<</Size 4/Root 1 0 R>>\nstartxre'
b'f\n149\n%EOF\n')
files = {'file': SimpleUploadedFile('file.pdf', file.read(), content_type='application/pdf'),}
form = CommentFileForm(data={}, files=files)
comment_forms_magic_orig, comment_forms.magic = comment_forms.magic, None
try:
self.assertFalse(form.is_valid())
finally:
comment_forms.magic = comment_forms_magic_orig
class FTPStorageFile(File):
def __init__(self, name, storage, mode):
self.name = name
self._storage = storage
self._mode = mode
self._is_dirty = False
self.file = BytesIO()
self._is_read = False
@property
def size(self):
if not hasattr(self, "_size"):
self._size = self._storage.size(self.name)
return self._size
def readlines(self):
if not self._is_read:
self._storage._start_connection()
self.file = self._storage._read(self.name)
self._is_read = True
return self.file.readlines()
def read(self, num_bytes=None):
if not self._is_read:
self._storage._start_connection()
self.file = self._storage._read(self.name)
self._is_read = True
return self.file.read(num_bytes)
def write(self, content):
if "w" not in self._mode:
raise AttributeError("File was opened for read-only access.")
self.file = BytesIO(content)
self._is_dirty = True
self._is_read = True
def close(self):
if self._is_dirty:
self._storage._start_connection()
self._storage._put_file(self.name, self)
self._storage.disconnect()
self.file.close()
def test_comment_file_upload_invalid_ext(self):
"""
comment file upload, invalid file extension
"""
utils.login(self)
# sample valid pdf - https://stackoverflow.com/a/17280876
file = BytesIO(
b'%PDF-1.0\n1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj 2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1'
b'>>endobj 3 0 obj<</Type/Page/MediaBox[0 0 3 3]>>endobj\nxref\n0 4\n0000000000 65535 f\n000000'
b'0010 00000 n\n0000000053 00000 n\n0000000102 00000 n\ntrailer<</Size 4/Root 1 0 R>>\nstartxre'
b'f\n149\n%EOF\n')
files = {'file': SimpleUploadedFile('fake.gif', file.read(), content_type='application/pdf'), }
response = self.client.post(
reverse('spirit:comment:file-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data=files)
res = json.loads(response.content.decode('utf-8'))
self.assertIn('error', res)
self.assertIn('file', res['error'])
self.assertEqual(
res['error']['file'],
['Unsupported file extension gif. Supported extensions are doc, docx, pdf.'])
def test_comment_file_upload_invalid_mime(self):
"""
comment file upload, invalid mime type
"""
utils.login(self)
file = BytesIO(b'BAD\x02D\x01\x00;')
files = {
'file': SimpleUploadedFile(
'file.pdf', file.read(), content_type='application/pdf')}
response = self.client.post(
reverse('spirit:comment:file-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data=files)
res = json.loads(response.content.decode('utf-8'))
self.assertIn('error', res)
self.assertIn('file', res['error'])
self.assertEqual(
res['error']['file'],
['Unsupported file mime type application/octet-stream. '
'Supported types are application/msword, '
'application/pdf, '
'application/vnd.openxmlformats-officedocument.wordprocessingml.document.'])
def test_post_form_data_with_image_submit(self):
self.client.login(username='******', password='******')
img = BytesIO(b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
image_file = SimpleUploadedFile('image.gif', img.read(), 'image/gif')
response = self.client.post(reverse('post_create_url'), {
'title': 'First post',
'body': 'Post body',
'files': image_file
})
self.assertRedirects(response,
reverse('posts_list_url'),
status_code=302,
target_status_code=200)
post = Post.objects.first()
self.assertEqual(post.title, 'First post')
self.assertTrue(post.gallery.first().image)
post.gallery.first().delete()
def test_comment_file_upload_invalid_mime(self):
"""
comment file upload, invalid mime type
"""
utils.login(self)
file = BytesIO(b'BAD\x02D\x01\x00;')
files = {
'file': SimpleUploadedFile(
'file.pdf', file.read(), content_type='application/pdf')}
response = self.client.post(
reverse('spirit:comment:file-upload-ajax'),
HTTP_X_REQUESTED_WITH='XMLHttpRequest',
data=files)
res = json.loads(response.content.decode('utf-8'))
self.assertIn('error', res)
self.assertIn('file', res['error'])
self.assertEqual(
res['error']['file'],
['Unsupported file mime type application/octet-stream. '
'Supported types are application/msword, '
'application/pdf, '
'application/vnd.openxmlformats-officedocument.wordprocessingml.document.'])
def test_user_profile_page(self):
user = User.objects.create_user(username='******', password='******')
user.email = '*****@*****.**'
user.first_name = 'Test first'
user.last_name = 'Test last'
user.save()
avatar = BytesIO(
b'GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00'
b'\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;')
avatar_file = SimpleUploadedFile('image.gif', avatar.read(), 'image/gif')
Profile.objects.create(about='About me', avatar=avatar_file, user_id=user.id)
self.client.login(username='******', password='******')
response = self.client.get(reverse('user_profile_url'))
self.assertEqual(response.status_code, 200)
self.assertContains(response, f'<h3>Привет, {user.username}!</h3>')
self.assertContains(response, f'{user.email}')
self.assertContains(response, f'{user.first_name}')
self.assertContains(response, f'{user.last_name}')
self.assertContains(response, f'{user.profile.about}')
self.assertContains(response, f'{user.profile.avatar}')
def test_comment_image_upload(self):
"""
comment image upload
"""
utils.login(self)
img = BytesIO(
b"GIF87a\x01\x00\x01\x00\x80\x01\x00\x00\x00\x00ccc,\x00"
b"\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;"
)
files = {"image": SimpleUploadedFile("image.gif", img.read(), content_type="image/gif")}
response = self.client.post(
reverse("spirit:comment:image-upload-ajax"), HTTP_X_REQUESTED_WITH="XMLHttpRequest", data=files
)
res = json.loads(response.content.decode("utf-8"))
image_url = os.path.join(
settings.MEDIA_URL, "spirit", "images", str(self.user.pk), "bf21c3043d749d5598366c26e7e4ab44.gif"
).replace("\\", "/")
self.assertEqual(res["url"], image_url)
image_path = os.path.join(
settings.MEDIA_ROOT, "spirit", "images", str(self.user.pk), "bf21c3043d749d5598366c26e7e4ab44.gif"
)
self.assertTrue(os.path.isfile(image_path))
shutil.rmtree(settings.MEDIA_ROOT) # cleanup
class ZipArchive(Archive):
def _open(self, file_object):
self._archive = zipfile.ZipFile(file_object)
def add_file(self, file_object, filename):
# Remove the zinfo_or_arcname and bytes keyword arguments
# so that the writestr methods works on Python 2 and 3
# Python 2 syntax:
# ZipFile.writestr(zinfo_or_arcname, bytes[, compress_type])
# Python 3 syntax:
# ZipFile.writestr(
# zinfo_or_arcname, data, compress_type=None, compresslevel=None
# )
# TODO: Change this to keyword arguments when the move to Python 3
# and Django 2.x is complete.
self._archive.writestr(filename,
file_object.read(),
compress_type=COMPRESSION)
def create(self):
self.string_buffer = BytesIO()
self._archive = zipfile.ZipFile(self.string_buffer, mode='w')
def member_contents(self, filename):
return self._archive.read(filename)
def members(self):
results = []
for filename in self._archive.namelist():
# Zip files only support UTF-8 and CP437 encodings.
# Attempt to decode CP437 to be able to check if it ends
# with a slash.
# Future improvement that violates the Zip format:
# Add chardet.detect to detect the most likely encoding
# if other than CP437.
try:
filename = filename.decode('CP437')
is_unicode = False
except AttributeError:
filename = force_text(filename)
is_unicode = True
except UnicodeEncodeError:
is_unicode = True
if not filename.endswith('/'):
# Re encode in the original encoding
if not is_unicode:
filename = filename.encode(encoding='CP437',
errors='strict')
results.append(filename)
return results
def open_member(self, filename):
return self._archive.open(filename)
def write(self, filename=None):
# fix for Linux zip files read in Windows
for entry in self._archive.filelist:
entry.create_system = 0
self.string_buffer.seek(0)
if filename:
with open(filename, 'w') as file_object:
file_object.write(self.string_buffer.read())
else:
return self.string_buffer
def as_file(self, filename):
return SimpleUploadedFile(name=filename, content=self.write().read())
