def handle(self, *args, **options):
# type: (*Any, **str) -> None
old_email = options['old_email']
if options['new_email']:
new_email = options['new_email']
else:
new_email = old_email
gravatar_url = "https://secure.gravatar.com/avatar/%s?d=identicon" % (gravatar_hash(old_email),)
gravatar_data = requests.get(gravatar_url).content
gravatar_file = SimpleUploadedFile('gravatar.jpg', gravatar_data, 'image/jpeg')
try:
user_profile = get_user_profile_by_email(old_email)
except UserProfile.DoesNotExist:
try:
user_profile = get_user_profile_by_email(new_email)
except UserProfile.DoesNotExist:
raise CommandError("Could not find specified user")
upload_avatar_image(gravatar_file, user_profile, old_email)
if old_email != new_email:
gravatar_file.seek(0)
upload_avatar_image(gravatar_file, user_profile, new_email)
user_profile.avatar_source = UserProfile.AVATAR_FROM_USER
user_profile.save(update_fields=['avatar_source'])
def image_create(request, **kwargs):
copy_from = kwargs.pop('copy_from', None)
data = kwargs.pop('data', None)
location = kwargs.pop('location', None)
image = glanceclient(request).images.create(**kwargs)
if data:
if isinstance(data, TemporaryUploadedFile):
# Hack to fool Django, so we can keep file open in the new thread.
data.file.close_called = True
if isinstance(data, InMemoryUploadedFile):
# Clone a new file for InMemeoryUploadedFile.
# Because the old one will be closed by Django.
data = SimpleUploadedFile(data.name,
data.read(),
data.content_type)
thread.start_new_thread(image_update,
(request, image.id),
{'data': data,
'purge_props': False})
elif copy_from:
thread.start_new_thread(image_update,
(request, image.id),
{'copy_from': copy_from,
'purge_props': False})
elif location:
thread.start_new_thread(image_update,
(request, image.id),
{'location': location,
'purge_props': False})
return image
def test_resize_image(self):
""" Testing image save """
person = Person.objects.get(pk=1)
self.assertEqual(person.get_img_url(), '/static/img/no_image.png')
photo = open('assets/img/no_image_test.png', 'rb')
data = {
'first_name': 'firstname',
'last_name': 'lastname',
'date_of_birth': '1991-01-01',
'contacts': 'contacts',
'bio': 'bio',
'email': '*****@*****.**',
'jabber': '*****@*****.**',
'skype': 'skypeid'
}
photo = SimpleUploadedFile(photo.name,
photo.read())
form = ProfileForm(data, dict(photo=photo), instance=person)
self.assertTrue(form.is_valid())
form.save()
person = Person.objects.get(pk=1)
self.assertNotEqual(person.get_img_url(),
'/static/img/no_image.png')
image_resized = Image.open(person.photo)
self.assertLessEqual(image_resized.height, 200)
self.assertLessEqual(image_resized.width, 200)
def image_create(request, **kwargs):
"""Create image.
:param kwargs:
* copy_from: URL from which Glance server should immediately copy
the data and store it in its configured image store.
* data: Form data posted from client.
* location: URL where the data for this image already resides.
In the case of 'copy_from' and 'location', the Glance server
will give us a immediate response from create and handle the data
asynchronously.
In the case of 'data' the process of uploading the data may take
some time and is handed off to a seperate thread.
"""
data = kwargs.pop("data", None)
image = glanceclient(request).images.create(**kwargs)
if data:
if isinstance(data, TemporaryUploadedFile):
# Hack to fool Django, so we can keep file open in the new thread.
data.file.close_called = True
if isinstance(data, InMemoryUploadedFile):
# Clone a new file for InMemeoryUploadedFile.
# Because the old one will be closed by Django.
data = SimpleUploadedFile(data.name, data.read(), data.content_type)
thread.start_new_thread(image_update, (request, image.id), {"data": data, "purge_props": False})
return image
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_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)
def test_calls_get_file_extension_by_content_type(self, mock_func, mock_os):
file = SimpleUploadedFile(
'img.png', open(self.get_valid_file(), 'rb').read())
file.content_type = 'image/png'
with patch('questionnaire.upload.open') as mock_open:
store_file(file)
mock_func.assert_called_once_with('image/png')
def populate_project(self):
f = SimpleUploadedFile("questions", "\n".join(self.quiz.keys()))
f.open("rb")
context = {"action": "Upload", "upload": f}
target = WebTarget("POST", main.views.project.project_upload,
args=(self.project.id,))
expectation = ViewExpectation(Conditions.null(), target)
expectation.check(self, context)
def image_create(request, **kwargs):
"""Create image.
:param kwargs:
* copy_from: URL from which Glance server should immediately copy
the data and store it in its configured image store.
* data: Form data posted from client.
* location: URL where the data for this image already resides.
In the case of 'copy_from' and 'location', the Glance server
will give us a immediate response from create and handle the data
asynchronously.
In the case of 'data' the process of uploading the data may take
some time and is handed off to a separate thread.
"""
data = kwargs.pop('data', None)
location = None
if VERSIONS.active >= 2:
location = kwargs.pop('location', None)
image = glanceclient(request).images.create(**kwargs)
if location is not None:
glanceclient(request).images.add_location(image.id, location, {})
if data:
if isinstance(data, six.string_types):
# The image data is meant to be uploaded externally, return a
# special wrapper to bypass the web server in a subsequent upload
return ExternallyUploadedImage(image, request)
elif isinstance(data, TemporaryUploadedFile):
# Hack to fool Django, so we can keep file open in the new thread.
data.file.close_called = True
elif isinstance(data, InMemoryUploadedFile):
# Clone a new file for InMemeoryUploadedFile.
# Because the old one will be closed by Django.
data = SimpleUploadedFile(data.name,
data.read(),
data.content_type)
if VERSIONS.active < 2:
thread.start_new_thread(image_update,
(request, image.id),
{'data': data})
else:
def upload():
try:
return glanceclient(request).images.upload(image.id, data)
finally:
filename = str(data.file.name)
try:
os.remove(filename)
except OSError as e:
LOG.warning('Failed to remove temporary image file '
'%(file)s (%(e)s)',
{'file': filename, 'e': e})
thread.start_new_thread(upload, ())
return Image(image)
def get_uploaded_file_from_path(self, path, quiet=True):
try:
with open(path, 'rb') as image:
file = SimpleUploadedFile(image.name, image.read())
file.content_type = mimetypes.guess_type(path)[0]
except IOError:
if not quiet:
raise
file = None
return file
def test_detect_file_value(self):
val = SimpleUploadedFile("sample_invalid_image.jpg", b"file_content", content_type="image/jpeg")
default_storage.save(val.name, val)
val.close()
self.event.settings.set('test', val)
self.event.settings._flush()
f = self.event.settings.get('test', as_type=File)
self.assertIsInstance(f, File)
self.assertTrue(f.name.endswith(val.name))
f.close()
def save_xhr(self, request):
filename = request.GET["qqfile"]
file = SimpleUploadedFile(filename, request.raw_post_data)
file.name = normalize("NFC", file.name)
expected_length = int(request.environ.get("CONTENT_LENGTH", 0))
if expected_length != file.size:
raise Exception("File not fully uploaded")
Image.objects.create(image=file, title="uploaded") # TODO: empty title
return rc.CREATED
def _update_from_upload_file(tutorial, update_file,
content_type="text/x-gettext-translation",
user=None, submission_type=None):
with open(update_file, "r") as f:
upload = SimpleUploadedFile(os.path.basename(update_file),
f.read(),
content_type)
test_store = getclass(upload)(upload.read())
tutorial.update(overwrite=False, only_newer=False)
tutorial.update(overwrite=True, store=test_store,
user=user, submission_type=submission_type)
def create_test_upload(file, encoding=None, project=None, user=None):
if project is None:
project = amcattest.create_test_project()
if user is None:
user = project.owner
if type(file) in (str, bytes):
file = open(file, mode='rb')
file = SimpleUploadedFile(os.path.basename(file.name), file.read())
upload = UploadedFile(file=file, user=user, project=project)
upload.save()
upload.encoding_override(encoding)
return upload
def test_saving_and_retrieving_files(self):
user = DummyUser().create_dummy_user()
file = SimpleUploadedFile("file.txt", b"file_content")
expected = file.read()
DummyUser().create_dummy_profile(user, picture=file)
saved_profile = UserProfile.objects.first()
# Вмісти збереженого файда і первинного співпадають?
self.assertEqual(saved_profile.picture.read(), expected)
# Чи правильний фактичний шлях до файла
basename = os.path.basename(saved_profile.picture.path)
self.assertEqual(basename, "1.jpg")
# Видляємо з диска (бо файл по-чесному записався в /media/profile_images/1.jpg)
saved_profile.picture.delete()
def _update_from_upload_file(store, update_file,
content_type="text/x-gettext-translation",
user=None, submission_type=None):
with open(update_file, "r") as f:
upload = SimpleUploadedFile(os.path.basename(update_file),
f.read(),
content_type)
if store.state < PARSED:
store.update(store.file.store)
test_store = getclass(upload)(upload.read())
store_revision = parse_pootle_revision(test_store)
store.update(test_store, store_revision=store_revision,
user=user, submission_type=submission_type)
class UploadZipViewTest(TestCase):
"""
Contains unit tests for the UploadZipView.
"""
def setUp(self):
"""
This method is called before each test and is responsible for setting up data needed by the tests.
"""
super(UploadZipViewTest, self).setUp()
# create a client for html requests
self.client = Client()
# open a file and create a file object
tmp_file = open(os.path.join(os.path.dirname(__file__), 'autoscottytest-7613.zip'), 'rb')
self.zip_file = SimpleUploadedFile(tmp_file.name, tmp_file.read())
# reset the file and create a hash, then close the file
tmp_file.seek(0)
self.hash = hashlib.sha1()
self.hash.update(tmp_file.read())
tmp_file.close()
def tearDown(self):
"""
This method is called after a test runs. It does any cleanup necessary, such as closing files.
"""
if self.zip_file:
self.zip_file.close()
def test_invalid_form(self):
"""
Makes requests with invalid data and ensures the proper response codes and context errors are returned.
"""
# test no data
response = self.client.post(reverse('autoscotty_upload'))
self.assertEqual(400, response.status_code)
self.assertEqual(response.context['form']['zip_file'].errors, [u'This field is required.'])
self.assertEqual(response.context['form']['zip_file_hash'].errors, [u'This field is required.'])
# test hash mismatch
kwargs = {'zip_file': self.zip_file, 'zip_file_hash': 'abc', 'sync': True}
response = self.client.post(reverse('autoscotty_upload'), kwargs)
self.assertEqual(460, response.status_code)
self.assertEqual(response.context['form'].errors['hash_mismatch'], [u'The hash does not match the file.'])
def test_valid_form(self):
"""
Performs a request with a valid form and checks for the proper response.
"""
kwargs = {'zip_file': self.zip_file, 'zip_file_hash': self.hash.hexdigest(),
'sync': False, 'model_type': 'EMOD'}
response = self.client.post(reverse('autoscotty_upload'), kwargs)
self.assertEqual(200, response.status_code)
def test_imagefield_annotate_with_image_after_clean(self):
f = ImageField()
img_path = get_img_path("filepath_test_files/1x1.png")
with open(img_path, "rb") as img_file:
img_data = img_file.read()
img_file = SimpleUploadedFile("1x1.png", img_data)
img_file.content_type = "text/plain"
uploaded_file = f.clean(img_file)
self.assertEqual("PNG", uploaded_file.image.format)
self.assertEqual("image/png", uploaded_file.content_type)
def save_xhr(self, request):
filename = request.GET['qqfile']
file = SimpleUploadedFile(filename, request.raw_post_data)
file.name = normalize('NFC', file.name)
expected_length = int(request.environ.get('CONTENT_LENGTH', 0))
if expected_length != file.size:
raise Exception('File not fully uploaded')
Image.objects.create(
image=file,
title='uploaded', # TODO: empty title
)
return rc.CREATED
def test_imagefield_annotate_with_image_after_clean(self):
f = ImageField()
img_path = get_img_path('filepath_test_files/1x1.png')
with open(img_path, 'rb') as img_file:
img_data = img_file.read()
img_file = SimpleUploadedFile('1x1.png', img_data)
img_file.content_type = 'text/plain'
uploaded_file = f.clean(img_file)
self.assertEqual('PNG', uploaded_file.image.format)
self.assertEqual('image/png', uploaded_file.content_type)
def insert_issue(request, client_path, project_path, jira_key):
try:
client = Client.objects.get(path=client_path)
project = client.projects.get(path=project_path)
soap = SOAPpy.WSDL.Proxy(JIRA_WSDL)
auth = request.session.get('jira_auth')
jira_project = JiraProject.objects.get(key=jira_key)
issue_url = None
if request.method == 'POST':
form = JiraTicketForm(request.POST, request.FILES)
if form.is_valid():
submitted = True
newissue = soap.createIssue(auth, {'project': jira_project.key,
'type': '1',
'description': form.cleaned_data['description'],
'summary': form.cleaned_data['summary'],
'customFieldValues': [{'customfieldId': 'customfield_10001',
'values': [form.cleaned_data['steps_to_reproduce']]}],
'assignee': JIRA_USER
})
if form.cleaned_data['attachment']:
filename="%s" % form.cleaned_data['attachment']
uploaded = SimpleUploadedFile(filename,
form.cleaned_data['attachment'].read())
b64t = base64.encodestring(uploaded.read())
soap.addBase64EncodedAttachmentsToIssue(auth,
newissue['key'],
[filename],
[b64t])
issue_url = newissue['key']
else:
form = JiraTicketForm()
return render_to_response('jira_create_issue.html', RequestContext(request, {'project':project,
'client':client,
'client_path': client_path,
'project_path': project_path,
'form': form,
'jira_project': jira_project,
'user':request.user,
'issue_url': issue_url,
'jira_key': jira_key}))
except Client.DoesNotExist, Project.DoesNotExist:
raise Http404
def setUp(self):
user = User.objects.get(username='******')
self.filename = 'cand.html'
path = os.path.join(settings.INSTALL_ROOT, 'cl', 'recap', 'test_assets',
self.filename)
with open(path, 'r') as f:
f = SimpleUploadedFile(self.filename, f.read())
self.pq = ProcessingQueue.objects.create(
court_id='scotus',
uploader=user,
pacer_case_id='asdf',
filepath_local=f,
status=ProcessingQueue.AWAITING_PROCESSING,
upload_type=ProcessingQueue.DOCKET,
)
def clean_upload_file_minidump(self):
file = self.cleaned_data["upload_file_minidump"]
if file.name.endswith('.tar'):
t_file = BytesIO(file.read())
t_file = tarfile.open(fileobj=t_file, mode='r')
self.cleaned_data['archive_file'] = file
dump_name = filter(lambda i: i.endswith('.dmp'), t_file.getnames())
try:
file_name = next(dump_name)
file = t_file.extractfile(file_name)
file = SimpleUploadedFile(file_name, file.read())
except StopIteration:
return None
return file
def to_editor(self, value):
"Returns a value suitable for display in a form widget"
if not value:
return None
file_name = pjoin(settings.MEDIA_ROOT, value)
try:
with open(file_name, "rb") as f:
uploaded_file = SimpleUploadedFile(value, f.read(), "image")
# hack to retrieve path from `name` attribute
uploaded_file.__dict__["_name"] = value
return uploaded_file
except IOError:
return None
def save(self, *args, **kwargs):
#self.image = SimpleUploadedFile(self.system_name, self.image_file, getattr(self.image, "content-type", "application/octet-stream"))
if self.content_type is None:
self.content_type = "image/jpg"
self.image = SimpleUploadedFile(self.system_name, self.image_file, self.content_type)
self.thumbnail = self.create_thumbnail()
super(Image, self).save(*args, **kwargs)
def test_sop_submit_form_in_memory_file(self):
inmemoryfile = SimpleUploadedFile(
'testfile.docx', b'this is test file')
inmemoryfile.content_type = "application/msword"
form = SOPSubmitForm(
data={
'name': "alamin",
'email': "*****@*****.**",
'msg': "hi",
},
files={'file': inmemoryfile}
)
# print(form.errors)
print(form.errors)
self.assertTrue(form.is_valid())
def get_form_kwargs(self):
"""
Get the kwargs to pass to the form for this script. By default, returns the task
arguments.
- 'data' list entries converted into a querydict.
- 'files' list entries converted to File objects
"""
kwargs = self.task.arguments.copy() # don't modify self.task.arguments['data']
if 'data' in kwargs:
d = QueryDict('').copy()
for k, v in kwargs['data'].iteritems():
if isinstance(v, list):
d.setlist(k, v)
else:
d[k] = v
kwargs['data'] = d
# Convert file dictionaries (as supplied by get_temporary_file_dict) to
# SimpleUploadedFile objects which Django understands.
if 'files' in kwargs:
files = MultiValueDict(kwargs['files'])
for filedict_list in files.viewvalues():
for i, fdict in enumerate(filedict_list):
if isinstance(fdict, dict):
fdict = dict(fdict)
fdict["content"] = open(fdict["path"], "rb").read()
filedict_list[i] = SimpleUploadedFile.from_dict(fdict)
kwargs['files'] = files
return kwargs
def setUp(self):
self.file_attrs = {
'filename': '°ßäöü.txt',
'content': 'โจ'.encode('utf-8'),
'content-type': 'text/utf8',
}
self.test_file = SimpleUploadedFile.from_dict(self.file_attrs)
self.follow_up = models.FollowUp(ticket=models.Ticket(queue=models.Queue()))
def download_url(self, name, url):
validate = URLValidator()
try:
validate(url)
except forms.ValidationError as _:
raise
return None
parsed_url = urlparse(url)
path = parsed_url[2].strip("/")
name = os.path.basename(path)
opener = urllib2.build_opener()
opener.addheaders = [('User-agent', 'Mozilla/5.0')]
ze_file = opener.open(url).read()
file_obj = SimpleUploadedFile(name=name, content=ze_file, content_type=mimetypes.guess_type(name))
file_obj.url = url
return file_obj
def test_account_views(self):
self.client.login(email='*****@*****.**', password='******')
response = self.client.get(reverse('accounts:list'))
self.assertEqual(200, response.status_code)
response = self.client.get(reverse('accounts:list') + '?tag=1')
self.assertEqual(200, response.status_code)
response = self.client.post(reverse('accounts:list'), {
'industry': 'industry',
'tag': [
1,
],
'tab_status': 'true'
})
self.assertEqual(200, response.status_code)
self.tag_name = Tags.objects.create(name='tag name')
self.team_account = Teams.objects.create(name='dev team')
self.team_account.users.add(self.user1.id)
self.client.logout()
self.client.login(email='*****@*****.**', password='******')
response = self.client.post(reverse('accounts:new_account'), {
'name': "account",
'email': "*****@*****.**",
'phone': "+911234567894",
'billing_address_line': "address line",
'billing_street': "billing street",
'billing_city': "billing city",
'billing_state': "state",
'billing_postcode': "1234",
'billing_country': "IN",
'website': "www.example.com",
'industry': "SOFTWARE",
'description': "Testing",
'contacts': [
self.contact_user1.id,
],
'tags': self.tag_name.name,
'assigned_to': [
self.user.id,
],
'teams': [
self.team_account.id,
]
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
response = self.client.post(
reverse('accounts:new_account'), {
'name': "account",
'email': "*****@*****.**",
'phone': "+911234567894",
'billing_address_line': "address line",
'billing_street': "billing street",
'billing_city': "billing city",
'billing_state': "state",
'billing_postcode': "1234",
'billing_country': "IN",
'website': "www.example.com",
'industry': "SOFTWARE",
'description': "Testing",
'contacts': [
self.contact_user1.id,
],
'tags': self.tag_name.name,
'assigned_to': [
self.user.id,
],
'teams': [
self.team_account.id,
]
})
self.assertEqual(response.status_code, 302)
response = self.client.post(
reverse('accounts:new_account'), {
'name': "account",
'email': "*****@*****.**",
'phone': "+911234567894",
'billing_address_line': "address line",
'billing_street': "billing street",
'billing_city': "billing city",
'billing_state': "state",
'billing_postcode': "1234",
'billing_country': "IN",
'website': "www.example.com",
'industry': "SOFTWARE",
'description': "Testing",
'contacts': [
self.contact_user1.id,
],
'tags': self.tag_name.name,
'assigned_to': [
self.user.id,
],
'teams': [
self.team_account.id,
],
'savenewform': 'true'
})
self.assertEqual(response.status_code, 302)
response = self.client.post(reverse('accounts:new_account'), {
'name': "account",
'email': "*****@*****.**",
'phone': "+91123456789",
'billing_address_line': "address line",
'billing_street': "billing street",
'billing_city': "billing city",
'billing_state': "state",
'billing_postcode': "1234",
'billing_country': "IN",
'website': "www.example.com",
'industry': "SOFTWARE",
'description': "Testing",
'tags': self.tag_name.name,
'assigned_to': [
0,
],
'teams': [
0,
],
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(response.status_code, 200)
self.client.logout()
self.client.login(email='*****@*****.**', password='******')
response = self.client.get(
reverse('accounts:view_account', args=(self.account.id, )))
self.assertEqual(403, response.status_code)
self.client.logout()
self.client.login(email='*****@*****.**', password='******')
response = self.client.post(reverse('accounts:new_account'), {
'name': "account",
'email': "*****@*****.**",
'phone': "+91-123-456-789",
'billing_address_line': "address line",
'billing_street': "billing street",
'billing_city': "billing city",
'billing_state': "state",
'billing_postcode': "1234",
'billing_country': "IN",
'website': "www.example.com",
'industry': "SOFTWARE",
'description': "Testing",
'contacts': [
self.contact_user1.id,
],
'tags': self.tag_name.name,
'assigned_to': [
self.user.id,
],
'teams': [
self.team_account.id,
]
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(200, response.status_code)
self.account_edit = Account.objects.create(
name="account edit",
email="*****@*****.**",
phone="123456789",
billing_address_line="",
billing_street="street name",
billing_city="city name",
billing_state="state",
billing_postcode="1234",
billing_country="US",
website="www.example.como",
created_by=self.user,
status="open",
industry="SOFTWARE",
description="Testing")
self.account_by_user = Account.objects.create(
name="account edit",
email="*****@*****.**",
phone="123456789",
billing_address_line="",
billing_street="street name",
billing_city="city name",
billing_state="state",
billing_postcode="1234",
billing_country="US",
website="www.example.como",
created_by=self.user,
status="open",
industry="SOFTWARE",
description="Testing")
upload_file = open('static/images/user.png', 'rb')
response = self.client.post(
reverse('accounts:edit_account', args=(self.account_edit.id, )), {
'name':
"account",
'email':
"*****@*****.**",
'phone':
"+91-123-456-7894",
'billing_address_line':
"address line",
'billing_street':
"billing street",
'billing_city':
"billing city",
'billing_state':
"state",
'billing_postcode':
"1234",
'billing_country':
"IN",
'website':
"www.example.com",
'industry':
"SOFTWARE",
'description':
"Testing",
'contacts': [
self.contact_user1.id,
],
'tags':
self.tag_name.name + ', another tag edit',
'assigned_to': [
self.user.id,
],
'teams': [
self.team_account.id,
],
'savenewform':
'true',
'account_attachment':
SimpleUploadedFile(upload_file.name, upload_file.read())
})
self.assertEqual(response.status_code, 302)
response = self.client.post(reverse(
'accounts:edit_account', args=(self.account_edit.id, )), {
'name': "account",
'email': "*****@*****.**",
'phone': "+91-123-456-7894",
'billing_address_line': "address line",
'billing_street': "billing street",
'billing_city': "billing city",
'billing_state': "state",
'billing_postcode': "1234",
'billing_country': "IN",
'website': "www.example.com",
'industry': "SOFTWARE",
'description': "Testing",
'contacts': [
self.contact_user1.id,
],
'tags': self.tag_name.name + ', another tag edit',
'teams': [
self.team_account.id,
],
'savenewform': 'true',
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(response.status_code, 200)
response = self.client.post(reverse(
'accounts:edit_account', args=(self.account_edit.id, )), {
'name': "account",
'email': "*****@*****.**",
'phone': "+91-123-456 ",
'billing_address_line': "address line",
'billing_street': "billing street",
'billing_city': "billing city",
'billing_state': "state",
'billing_postcode': "1234",
'billing_country': "IN",
'website': "www.example.com",
'industry': "SOFTWARE",
'description': "Testing",
'contacts': [
self.contact_user1.id,
],
'tags': self.tag_name.name + ', another tag edit',
'teams': [
self.team_account.id,
],
'savenewform': 'true',
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(response.status_code, 200)
self.client.logout()
self.client.login(email='*****@*****.**', password='******')
response = self.client.get(
reverse('accounts:edit_account', args=(self.account_by_user.id, )),
{})
self.assertEqual(403, response.status_code)
self.account_by_user1 = Account.objects.create(
name="account edit",
email="*****@*****.**",
phone="123456789",
billing_address_line="",
billing_street="street name",
billing_city="city name",
billing_state="state",
billing_postcode="1234",
billing_country="US",
website="www.example.como",
created_by=self.user1,
status="open",
industry="SOFTWARE",
description="Testing")
response = self.client.get(
reverse('accounts:edit_account',
args=(self.account_by_user1.id, )), {})
self.assertEqual(200, response.status_code)
response = self.client.get(
reverse('accounts:remove_account',
args=(self.account_by_user.id, )), {})
self.assertEqual(403, response.status_code)
response = self.client.post(reverse('accounts:add_comment'),
{'accountid': self.account_by_user.id})
self.assertEqual(200, response.status_code)
response = self.client.post(reverse('accounts:edit_comment'),
{'commentid': self.comment.id})
self.assertEqual(200, response.status_code)
self.client.logout()
self.client.login(email='*****@*****.**', password='******')
response = self.client.post(reverse('accounts:edit_comment'), {
'commentid': self.comment.id,
'comment': ''
})
self.assertEqual(200, response.status_code)
self.client.logout()
self.client.login(email='*****@*****.**', password='******')
response = self.client.post(reverse('accounts:remove_comment'), {
'comment_id': self.comment.id,
'comment': ''
})
self.assertEqual(200, response.status_code)
self.client.logout()
self.client.login(email='*****@*****.**', password='******')
response = self.client.post(reverse('accounts:add_attachment'), {
'accountid': self.account.id,
'comment': ''
})
self.assertEqual(200, response.status_code)
email_str = Email.objects.create(message_subject='message subject',
message_body='message body')
self.assertEqual(str(email_str), 'message subject')
response = self.client.post(
reverse('accounts:get_contacts_for_account'),
{'account_id': self.account.id})
self.assertEqual(200, response.status_code)
self.account.contacts.add(self.contact.id, self.contact_user1.id)
response = self.client.post(
reverse('accounts:get_contacts_for_account'),
{'account_id': self.account.id})
self.assertEqual(200, response.status_code)
response = self.client.get(
reverse('accounts:get_contacts_for_account'),
{'account_id': self.account.id})
self.assertEqual(200, response.status_code)
response = self.client.post(
reverse('accounts:get_email_data_for_account'),
{'email_account_id': email_str.id})
self.assertEqual(200, response.status_code)
response = self.client.get(
reverse('accounts:get_email_data_for_account'),
{'email_account_id': email_str.id})
self.assertEqual(200, response.status_code)
def test_create_with_parent_filediff_with_move_and_change(self):
"""Testing UploadDiffForm.create with a parent diff consisting of a
move/rename with content change
"""
revisions = [
b'93e6b3e8944c48737cb11a1e52b046fa30aea7a9',
b'4839fc480f47ca59cf05a9c39410ea744d1e17a2',
b'04861c126cfebd7e7cb93045ab0bff4a7acc4cf2',
]
parent_diff = SimpleUploadedFile('parent_diff',
(b'diff --git a/foo b/bar\n'
b'similarity index 55%%\n'
b'rename from foo\n'
b'rename to bar\n'
b'index %s..%s 100644\n'
b'--- a/foo\n'
b'+++ b/bar\n'
b'@@ -1,2 +1,3 @@\n'
b' Foo\n'
b'+Bar\n') %
(revisions[0], revisions[1]),
content_type='text/x-patch')
diff = SimpleUploadedFile('diff',
(b'diff --git a/bar b/bar\n'
b'index %s..%s 100644\n'
b'--- a/bar\n'
b'+++ b/bar\n'
b'@@ -1,3 +1,4 @@\n'
b' Foo\n'
b' Bar\n'
b'+Baz\n') % (revisions[1], revisions[2]),
content_type='text/x-patch')
repository = self.create_repository(tool_name='Test')
self.spy_on(repository.get_file_exists,
call_fake=lambda *args, **kwargs: True)
# We will only be making one call to get_file and we can fake it out.
self.spy_on(repository.get_file,
call_fake=lambda *args, **kwargs: b'Foo\n')
self.spy_on(patch)
form = UploadDiffForm(repository=repository,
data={
'basedir': '/',
},
files={
'path': diff,
'parent_diff_path': parent_diff,
})
self.assertTrue(form.is_valid())
diffset = form.create(diff, parent_diff)
self.assertEqual(diffset.files.count(), 1)
f = diffset.files.get()
self.assertEqual(f.source_revision, revisions[0])
self.assertEqual(f.dest_detail, revisions[2])
original_file = get_original_file(f, None, ['ascii'])
self.assertEqual(original_file, b'Foo\nBar\n')
self.assertTrue(patch.spy.called)
patched_file = get_patched_file(original_file, f, None)
self.assertEqual(patched_file, b'Foo\nBar\nBaz\n')
self.assertEqual(len(patch.spy.calls), 2)
def arquivo_processado():
return SimpleUploadedFile(
f'periodos_iniciais.csv',
bytes(f"""Código eol,periodo\n123456,2019.2\n00094,2019.1""",
encoding="utf-8"))
def get_dummy_uploaded_document(name='dummy_file.odt', size=128):
return SimpleUploadedFile(
name,
'*' * size,
content_type='application/vnd.oasis.opendocument.text')
def test_validation_disabled(self):
with self.settings(CLAMAV_ENABLED=False):
infected = SimpleUploadedFile('infected.txt', clamd.EICAR)
form = TestUploadForm(files={'upload': infected})
self.assertTrue(form.is_valid(), form.errors)
def get_dummy_uploaded_image_svg(name='dummy_img.svg'):
return SimpleUploadedFile(name, SVG_FILE, content_type='image/svg')
def real_transaction_source():
csv = open(
os.path.join(os.path.dirname(__file__),
"fixtures/transactions.csv")).read()
f = SimpleUploadedFile("testresource.csv", csv.encode())
return RealTransactionSource.objects.create(source_file=f)
def test_upload_to_callable(self):
UploadToCallableDossier.objects.create(
file=SimpleUploadedFile('test7.txt', b'test7'))
self.assertExists('UploadToCallableDossier', 'test', 'test7.txt')
def test_upload_subfolder(self):
obj = CustomerDossier.objects.create(customer='cust1',
file=SimpleUploadedFile(
'test3.txt', b'test3'))
self.assertExists('CustomerDossier', 'cust1', 'test3.txt')
def test_upload_to(self):
UploadToDossier.objects.create(
file=SimpleUploadedFile('test2.txt', b'test2'))
self.assertExists('UploadToDossier', 'test2.txt')
def test_simple(self):
SimpleDossier.objects.create(
file=SimpleUploadedFile('test1.txt', b'test1'))
self.assertExists('test1.txt')
def load_tasks(request, project):
""" Load tasks from different types of request.data / request.files
"""
file_upload_ids, found_formats, data_keys = [], [], set()
could_be_tasks_lists = False
# take tasks from request FILES
if len(request.FILES):
check_file_sizes_and_number(request.FILES)
for filename, file in request.FILES.items():
file_upload = create_file_upload(request, project, file)
if file_upload.format_could_be_tasks_list:
could_be_tasks_lists = True
file_upload_ids.append(file_upload.id)
tasks, found_formats, data_keys = FileUpload.load_tasks_from_uploaded_files(
project, file_upload_ids)
# take tasks from url address
elif 'application/x-www-form-urlencoded' in request.content_type:
ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
try:
url = request.data['url']
filename = url.rsplit('/', 1)[-1]
with urlopen(url, context=ctx) as file:
# check size
meta = file.info()
file.size = int(meta.get("Content-Length"))
file.urlopen = True
check_file_sizes_and_number({url: file})
file_content = file.read()
if isinstance(file_content, str):
file_content = file_content.encode()
file_upload = create_file_upload(
request, project,
SimpleUploadedFile(filename, file_content))
file_upload_ids.append(file_upload.id)
tasks, found_formats, data_keys = FileUpload.load_tasks_from_uploaded_files(
project, file_upload_ids)
except ValidationError as e:
raise e
except Exception as e:
raise ValidationError(str(e))
# take one task from request DATA
elif 'application/json' in request.content_type and isinstance(
request.data, dict):
tasks = [request.data]
# take many tasks from request DATA
elif 'application/json' in request.content_type and isinstance(
request.data, list):
tasks = request.data
# incorrect data source
else:
raise ValidationError('load_tasks: No data found in DATA or in FILES')
# check is data root is list
if not isinstance(tasks, list):
raise ValidationError('load_tasks: Data root must be list')
# empty tasks error
if not tasks:
raise ValidationError('load_tasks: No tasks added')
check_max_task_number(tasks)
return tasks, file_upload_ids, could_be_tasks_lists, found_formats, list(
data_keys)
def test_create_with_parent_filediff_with_move_and_change(self):
"""Testing UploadDiffForm.create with a parent diff consisting of a
move/rename with content change
"""
revisions = [
b'5d36b88bb697a2d778f024048bafabd443d74503',
b'9b32edcd37a88c6ada91efc562afa637ccfdad36',
b'8a567d328293f85d68332bc693b0a98869b23b47',
]
parent_diff = SimpleUploadedFile(
'parent_diff',
(b'diff --git a/foo b/bar\n'
b'similarity index 55%%\n'
b'rename from foo\n'
b'rename to bar\n'
b'index %s..%s 100644\n'
b'--- a/foo\n'
b'+++ b/bar\n'
b'@@ -1,2 +1,3 @@\n'
b' Foo\n'
b'+Bar\n') % (revisions[0], revisions[1]),
content_type='text/x-patch')
diff = SimpleUploadedFile(
'diff',
(b'diff --git a/bar b/bar\n'
b'index %s..%s 100644\n'
b'--- a/bar\n'
b'+++ b/bar\n'
b'@@ -1,3 +1,4 @@\n'
b' Foo\n'
b' Bar\n'
b'+Baz\n') % (revisions[1], revisions[2]),
content_type='text/x-patch')
repository = self.create_repository(tool_name='Test')
self.spy_on(repository.get_file_exists,
call_fake=lambda *args, **kwargs: True)
# We will only be making one call to get_file and we can fake it out.
self.spy_on(repository.get_file,
call_fake=lambda *args, **kwargs: b'Foo\n')
self.spy_on(patch)
form = UploadDiffForm(
repository=repository,
data={
'basedir': '/',
},
files={
'path': diff,
'parent_diff_path': parent_diff,
})
self.assertTrue(form.is_valid())
diffset = form.create()
self.assertEqual(diffset.files.count(), 1)
filediff = diffset.files.get()
self.assertEqual(filediff.source_file, 'bar')
self.assertEqual(filediff.dest_file, 'bar')
self.assertEqual(filediff.source_revision, revisions[1].decode('utf-8'))
self.assertEqual(filediff.dest_detail, revisions[2].decode('utf-8'))
self.assertEqual(filediff.extra_data, {
'__parent_diff_empty': False,
'is_symlink': False,
'parent_moved': True,
'parent_source_filename': '/foo',
'parent_source_revision': revisions[0],
'raw_delete_count': 0,
'raw_insert_count': 1,
})
original_file = get_original_file(filediff=filediff,
request=None,
encoding_list=['ascii'])
self.assertEqual(original_file, b'Foo\nBar\n')
self.assertTrue(patch.spy.called)
patched_file = get_patched_file(source_data=original_file,
filediff=filediff)
self.assertEqual(patched_file, b'Foo\nBar\nBaz\n')
self.assertEqual(len(patch.spy.calls), 2)
def test_valid_avatar(self):
data = SimpleUploadedFile(
self.faker.file_name(category='image'), self.faker.image(size=(150, 160), image_format='webp'))
form = self._init_form(files={'avatar': data}, instance=self.profile_with_no_places.obj)
self.assertTrue(form.is_valid(), msg=repr(form.errors))
def test_create_with_parent_filediff_with_move_and_no_change(self):
"""Testing UploadDiffForm.create with a parent diff consisting only
of a move/rename without content change
"""
revisions = [
b'93e6b3e8944c48737cb11a1e52b046fa30aea7a9',
b'4839fc480f47ca59cf05a9c39410ea744d1e17a2',
]
parent_diff = SimpleUploadedFile(
'parent_diff',
(b'diff --git a/foo b/bar\n'
b'similarity index 100%%\n'
b'rename from foo\n'
b'rename to bar\n'),
content_type='text/x-patch')
diff = SimpleUploadedFile(
'diff',
(b'diff --git a/bar b/bar\n'
b'index %s..%s 100644\n'
b'--- a/bar\n'
b'+++ b/bar\n'
b'@@ -1,2 +1,3 @@\n'
b' Foo\n'
b'+Bar\n') % (revisions[0], revisions[1]),
content_type='text/x-patch')
repository = self.create_repository(tool_name='Test')
self.spy_on(repository.get_file_exists,
call_fake=lambda *args, **kwargs: True)
# We will only be making one call to get_file and we can fake it out.
self.spy_on(repository.get_file,
call_fake=lambda *args, **kwargs: b'Foo\n')
self.spy_on(patch)
form = UploadDiffForm(
repository=repository,
data={
'basedir': '/',
},
files={
'path': diff,
'parent_diff_path': parent_diff,
})
self.assertTrue(form.is_valid())
diffset = form.create()
self.assertEqual(diffset.files.count(), 1)
f = diffset.files.get()
self.assertEqual(f.source_revision, revisions[0].decode('utf-8'))
self.assertEqual(f.dest_detail, revisions[1].decode('utf-8'))
# We shouldn't call out to patch because the parent diff is just a
# rename.
original_file = get_original_file(filediff=f,
request=None,
encoding_list=['ascii'])
self.assertEqual(original_file, b'Foo\n')
self.assertFalse(patch.spy.called)
patched_file = get_patched_file(source_data=original_file,
filediff=f)
self.assertEqual(patched_file, b'Foo\nBar\n')
self.assertTrue(patch.spy.called)
class ValidatorTest(TestCase):
"""
Test cases for validators.
"""
@staticmethod
def _validator(validator, value, other=None, verbose_key=None):
return validator('test', {'test': value, 'other': other}, verbose_key)
@ddt.data(
('required', RequiredValidator),
('required_with', RequiredWithValidator),
('required_without', RequiredWithoutValidator),
('required_if', RequiredIfValidator),
('max', MaxValidator),
('min', MinValidator),
('between', BetweenValidator),
('regex', RegexValidator),
('integer', IntegerValidator),
('numeric', NumericValidator),
('in', InValidator),
('not_in', NotInValidator),
)
@ddt.unpack
def test_registry(self, name, excepted_validator):
# Test the default validator registry
validator = ValidatorRegistry.get(name)
self.assertEqual(validator, excepted_validator)
@ddt.data(
# Required
(RequiredValidator(), True, 'test'),
(RequiredValidator(), False, None),
(RequiredValidator(), False, ''),
# Required with
(RequiredWithValidator('other'), True, 'test'),
(RequiredWithValidator('other'), True, 'test', 'test'),
(RequiredWithValidator('other'), True, None),
(RequiredWithValidator('other'), True, ''),
(RequiredWithValidator('other'), False, None, 'test'),
(RequiredWithValidator('other'), False, '', 'test'),
# Required without
(RequiredWithoutValidator('other'), True, 'test'),
(RequiredWithoutValidator('other'), True, 'test', 'test'),
(RequiredWithoutValidator('other'), True, None, 'test'),
(RequiredWithoutValidator('other'), True, '', 'test'),
(RequiredWithoutValidator('other'), False, None),
(RequiredWithoutValidator('other'), False, ''),
# Required if
(RequiredIfValidator('other', 'test'), True, 'test'),
(RequiredIfValidator('other', 'test'), True, 'test', 'test'),
(RequiredIfValidator('other', 'test'), True, 'test', 'other'),
(RequiredIfValidator('other', 'test'), True, None),
(RequiredIfValidator('other', 'test'), True, None, 'other'),
(RequiredIfValidator('other', 'test'), True, ''),
(RequiredIfValidator('other', 'test'), True, '', 'other'),
(RequiredIfValidator('other', 'test'), False, None, 'test'),
(RequiredIfValidator('other', 'test'), False, '', 'test'),
# Max
(MaxValidator(10), True, None),
(MaxValidator(10), True, -1),
(MaxValidator(10), True, 10),
(MaxValidator(10), True, 'test'),
(MaxValidator(10), True, 't' * 10),
(MaxValidator(10), False, 11),
(MaxValidator(10), False, 't' * 11),
(MaxValidator(10), True, SimpleUploadedFile('test',
string2byte('test'))),
(MaxValidator(10), False,
SimpleUploadedFile('test', string2byte('t' * 11))),
# Min
(MinValidator(10), True, None),
(MinValidator(10), True, 10),
(MinValidator(10), True, 20),
(MinValidator(10), True, 't' * 10),
(MinValidator(10), True, 't' * 20),
(MinValidator(10), False, 5),
(MinValidator(10), False, 'test'),
(MinValidator(10), True,
SimpleUploadedFile('test', string2byte('t' * 10))),
(MinValidator(10), False,
SimpleUploadedFile('test', string2byte('test'))),
# Between
(BetweenValidator(5, 10), True, None),
(BetweenValidator(5, 10), True, 5),
(BetweenValidator(5, 10), True, 8),
(BetweenValidator(5, 10), True, 10),
(BetweenValidator(5, 10), True, 't' * 5),
(BetweenValidator(5, 10), True, 't' * 8),
(BetweenValidator(5, 10), True, 't' * 10),
(BetweenValidator(5, 10), False, 0),
(BetweenValidator(5, 10), False, 20),
(BetweenValidator(5, 10), False, 'test'),
(BetweenValidator(5, 10), False, 't' * 20),
(BetweenValidator(
5, 10), True, SimpleUploadedFile('test', string2byte('t' * 10))),
(BetweenValidator(
5, 10), False, SimpleUploadedFile('test', string2byte('test'))),
(BetweenValidator(
5, 10), False, SimpleUploadedFile('test', string2byte('t' * 20))),
# Regex
(RegexValidator('^\w+$'), True, None),
(RegexValidator('^\w+$'), True, 'abc'),
(RegexValidator('^\w+$'), False, ''),
(RegexValidator('^\w+$'), False, '#abc'),
# Integer
(IntegerValidator(), True, None),
(IntegerValidator(), True, '1'),
(IntegerValidator(), True, '-1'),
(IntegerValidator(), True, 1),
(IntegerValidator(), True, -1),
(IntegerValidator(), False, 'a'),
(IntegerValidator(), False, '1-1'),
# Numeric
(NumericValidator(), True, None),
(NumericValidator(), True, '1'),
(NumericValidator(), True, '-1'),
(NumericValidator(), True, 1),
(NumericValidator(), True, -1),
(NumericValidator(), True, '1.1'),
(NumericValidator(), True, '1.01e10'),
(NumericValidator(), True, '1e10'),
(NumericValidator(), True, '0.1e-5'),
(NumericValidator(), True, '.1e-5'),
(NumericValidator(), False, '.'),
(NumericValidator(), False, 'number'),
(NumericValidator(), False, '4e4e4'),
# In
(InValidator('1', '2', '3'), True, None),
(InValidator('1', '2', '3'), True, 1),
(InValidator('1', '2', '3'), True, '1'),
(InValidator('1', '2', '3'), True, 2),
(InValidator('1', '2', '3'), True, 3),
(InValidator('1', '2', '3'), False, 0),
(InValidator('1', '2', '3'), False, '0'),
# Not in
(NotInValidator('1', '2', '3'), True, None),
(NotInValidator('1', '2', '3'), True, 0),
(NotInValidator('1', '2', '3'), True, '0'),
(NotInValidator('1', '2', '3'), False, 1),
(NotInValidator('1', '2', '3'), False, '1'),
(NotInValidator('1', '2', '3'), False, 2),
(NotInValidator('1', '2', '3'), False, 3),
# Ext in
(ExtInValidator('jpg',
'jpeg'), True, SimpleUploadedFile('test.jpg', None)),
(ExtInValidator('.jpg',
'.jpeg'), True, SimpleUploadedFile('test.jpg', None)),
(ExtInValidator('jpg',
'jpeg'), False, SimpleUploadedFile('test.png', None)),
# Ext not in
(ExtNotInValidator(
'jpg', 'jpeg'), True, SimpleUploadedFile('test.png', None)),
(ExtNotInValidator(
'jpg', 'jpeg'), False, SimpleUploadedFile('test.jpg', None)),
(ExtNotInValidator(
'.jpg', '.jpeg'), False, SimpleUploadedFile('test.jpg', None)),
)
@ddt.unpack
def test_validator(self, validator, valid, value, other=None):
if valid:
self.assertTrue(self._validator(validator, value, other))
else:
self.assertRaises(ValidationError, self._validator, validator,
value, other)
def test_verbose_key(self):
""" Test if the verbose key can throw from the validation error. """
validator = RequiredValidator()
self.assertRaisesRegexp(ValidationError,
'TEST_VERBOSE_KEY',
self._validator,
validator,
None,
verbose_key='TEST_VERBOSE_KEY')
def setUp(self):
super(TestPackagedAppForm, self).setUp()
path = self.packaged_app_path('mozball.zip')
self.files = {'upload': SimpleUploadedFile('mozball.zip',
open(path).read())}
def create_pdf_file_with_image_ext():
file_name = 'product.jpg'
file_data = SimpleUploadedFile(file_name, b'product_data',
'application/pdf')
return file_data, file_name
def test_create_with_files(self):
# 上传空文件列表
response = self.user1_client.post(TWEET_CREATE_API, {
'content': 'a selfie',
'files': [],
})
self.assertEqual(response.status_code, 201)
self.assertEqual(TweetPhoto.objects.count(), 0)
# 上传单个文件
# content 需要是一个 bytes 类型，所以用 str.encode 转换一下
file = SimpleUploadedFile(
name='selfie.jpg',
content=str.encode('a fake image'),
content_type='image/jpeg',
)
response = self.user1_client.post(TWEET_CREATE_API, {
'content': 'a selfie',
'files': [file],
})
self.assertEqual(response.status_code, 201)
self.assertEqual(TweetPhoto.objects.count(), 1)
# 测试多个文件上传
file1 = SimpleUploadedFile(
name='selfie1.jpg',
content=str.encode('selfie 1'),
content_type='image/jpeg',
)
file2 = SimpleUploadedFile(
name='selfie2.jpg',
content=str.encode('selfie 2'),
content_type='image/jpeg',
)
response = self.user1_client.post(TWEET_CREATE_API, {
'content': 'two selfies',
'files': [file1, file2],
})
self.assertEqual(response.status_code, 201)
self.assertEqual(TweetPhoto.objects.count(), 3)
# 从读取的 API 里确保已经包含了 photo 的地址
retrieve_url = TWEET_RETRIVE_API.format(response.data['id'])
response = self.user1_client.get(retrieve_url)
self.assertEqual(len(response.data['photo_urls']), 2)
self.assertEqual('selfie1' in response.data['photo_urls'][0], True)
self.assertEqual('selfie2' in response.data['photo_urls'][1], True)
# 测试上传超过 9 个文件会失败
files = [
SimpleUploadedFile(
name=f'selfie{i}.jpg',
content=str.encode(f'selfie{i}'),
content_type='image/jpeg',
)
for i in range(10)
]
response = self.user1_client.post(TWEET_CREATE_API, {
'content': 'failed due to number of photos exceeded limit',
'files': files,
})
self.assertEqual(response.status_code, 400)
self.assertEqual(TweetPhoto.objects.count(), 3)
def test_create_with_parent_filediff_with_new_file(self):
"""Testing UploadDiffForm.create with a parent diff consisting of a
newly-introduced file
"""
revisions = [
b'0000000000000000000000000000000000000000',
b'9b32edcd37a88c6ada91efc562afa637ccfdad36',
b'8a567d328293f85d68332bc693b0a98869b23b47',
]
parent_diff = SimpleUploadedFile(
'parent_diff',
(b'diff --git a/foo b/foo\n'
b'new file mode 100644\n'
b'index %s..%s\n'
b'--- /dev/null\n'
b'+++ b/foo\n'
b'@@ -0,0 +1,2 @@\n'
b'+Foo\n'
b'+Bar\n') % (revisions[0], revisions[1]),
content_type='text/x-patch')
diff = SimpleUploadedFile(
'diff',
(b'diff --git a/foo b/foo\n'
b'index %s..%s 100644\n'
b'--- a/foo\n'
b'+++ b/foo\n'
b'@@ -1,3 +1,4 @@\n'
b' Foo\n'
b' Bar\n'
b'+Baz\n') % (revisions[1], revisions[2]),
content_type='text/x-patch')
repository = self.create_repository(tool_name='Test')
self.spy_on(repository.get_file_exists,
call_fake=lambda *args, **kwargs: True)
# We will only be making one call to get_file and we can fake it out.
self.spy_on(repository.get_file,
call_fake=lambda *args, **kwargs: b'Foo\n')
self.spy_on(patch)
form = UploadDiffForm(
repository=repository,
data={
'basedir': '/',
},
files={
'parent_diff_path': parent_diff,
'path': diff,
})
self.assertTrue(form.is_valid())
diffset = form.create()
self.assertEqual(diffset.files.count(), 1)
filediff = diffset.files.get()
self.assertEqual(filediff.source_file, 'foo')
self.assertEqual(filediff.dest_file, 'foo')
self.assertEqual(filediff.source_revision, revisions[1])
self.assertEqual(filediff.dest_detail, revisions[2])
self.assertEqual(filediff.extra_data, {
'__parent_diff_empty': False,
'is_symlink': False,
'parent_source_filename': '/foo',
'parent_source_revision': 'PRE-CREATION',
'raw_delete_count': 0,
'raw_insert_count': 1,
})
# Double-check the types.
self.assertIsInstance(filediff.extra_data['parent_source_filename'],
six.text_type)
self.assertIsInstance(filediff.extra_data['parent_source_revision'],
six.text_type)
original_file = get_original_file(filediff=filediff,
request=None,
encoding_list=['ascii'])
self.assertEqual(original_file, b'Foo\nBar\n')
self.assertSpyCalled(patch)
patched_file = get_patched_file(source_data=original_file,
filediff=filediff)
self.assertEqual(patched_file, b'Foo\nBar\nBaz\n')
self.assertEqual(len(patch.calls), 2)
def get_dummy_uploaded_file(name='dummy_file.txt'):
return SimpleUploadedFile(name, 'HelloWorld', content_type='plain/text')
def image():
img_data = BytesIO()
image = Image.new("RGB", size=(1, 1))
image.save(img_data, format="JPEG")
return SimpleUploadedFile("product.jpg", img_data.getvalue())
def get_upload_file(filename='repo'):
file = File(
open('./tests/fixtures_static/{}.tar.gz'.format(filename), 'rb'))
return SimpleUploadedFile(filename,
file.read(),
content_type='multipart/form-data')
def other_resource(submission):
f = SimpleUploadedFile('testresource2.txt', b'another resource')
return Resource.objects.create(submission=submission,
resource=f,
description='Test resource 2')
def test_upload_subfolder_join(self):
obj = CustomerDossierJoin.objects.create(customer='cust4',
file=SimpleUploadedFile(
'test6.txt', b'test6'))
self.assertExists('CustomerDossierJoin', 'cust4', 'sub2', 'test6.txt')
def test_files(self):
temp_storage.save('tests/default.txt', ContentFile('default content'))
# Attempting to access a FileField from the class raises a descriptive
# error
self.assertRaises(AttributeError, lambda: Storage.normal)
# An object without a file has limited functionality.
obj1 = Storage()
self.assertEqual(obj1.normal.name, "")
self.assertRaises(ValueError, lambda: obj1.normal.size)
# Saving a file enables full functionality.
obj1.normal.save("django_test.txt", ContentFile("content"))
self.assertEqual(obj1.normal.name, "tests/django_test.txt")
self.assertEqual(obj1.normal.size, 7)
self.assertEqual(obj1.normal.read(), "content")
obj1.normal.close()
# File objects can be assigned to FileField attributes, but shouldn't
# get committed until the model it's attached to is saved.
obj1.normal = SimpleUploadedFile("assignment.txt", "content")
dirs, files = temp_storage.listdir("tests")
self.assertEqual(dirs, [])
self.assertEqual(sorted(files), ["default.txt", "django_test.txt"])
obj1.save()
dirs, files = temp_storage.listdir("tests")
self.assertEqual(sorted(files),
["assignment.txt", "default.txt", "django_test.txt"])
# Files can be read in a little at a time, if necessary.
obj1.normal.open()
self.assertEqual(obj1.normal.read(3), "con")
self.assertEqual(obj1.normal.read(), "tent")
self.assertEqual(list(obj1.normal.chunks(chunk_size=2)),
["co", "nt", "en", "t"])
obj1.normal.close()
# Save another file with the same name.
obj2 = Storage()
obj2.normal.save("django_test.txt", ContentFile("more content"))
self.assertEqual(obj2.normal.name, "tests/django_test_1.txt")
self.assertEqual(obj2.normal.size, 12)
# Push the objects into the cache to make sure they pickle properly
cache.set("obj1", obj1)
cache.set("obj2", obj2)
self.assertEqual(
cache.get("obj2").normal.name, "tests/django_test_1.txt")
# Deleting an object does not delete the file it uses.
obj2.delete()
obj2.normal.save("django_test.txt", ContentFile("more content"))
self.assertEqual(obj2.normal.name, "tests/django_test_2.txt")
# Multiple files with the same name get _N appended to them.
objs = [Storage() for i in range(3)]
for o in objs:
o.normal.save("multiple_files.txt", ContentFile("Same Content"))
self.assertEqual([o.normal.name for o in objs], [
"tests/multiple_files.txt", "tests/multiple_files_1.txt",
"tests/multiple_files_2.txt"
])
for o in objs:
o.delete()
# Default values allow an object to access a single file.
obj3 = Storage.objects.create()
self.assertEqual(obj3.default.name, "tests/default.txt")
self.assertEqual(obj3.default.read(), "default content")
obj3.default.close()
# But it shouldn't be deleted, even if there are no more objects using
# it.
obj3.delete()
obj3 = Storage()
self.assertEqual(obj3.default.read(), "default content")
obj3.default.close()
# Verify the fix for #5655, making sure the directory is only
# determined once.
obj4 = Storage()
obj4.random.save("random_file", ContentFile("random content"))
self.assertTrue(obj4.random.name.endswith("/random_file"))
# Clean up the temporary files and dir.
obj1.normal.delete()
obj2.normal.delete()
obj3.default.delete()
obj4.random.delete()
def upload_user_photo(request):
if request.method == "POST":
if request.user.is_authenticated:
if request.is_ajax():
user_photo = UserPhoto.objects.get(user=request.user)
if request.POST.get('remove', None) == 'remove':
user_photo.file_300 = None
user_photo.file_50 = None
user_photo.save()
return JsonResponse({
'res': 1,
'src': user_photo.file_300_url()
})
else:
form = UserPhotoForm(request.POST,
request.FILES,
instance=user_photo)
if form.is_valid():
user_photo = UserPhoto.objects.get(user=request.user)
DJANGO_TYPE = request.FILES['file'].content_type
if DJANGO_TYPE == 'image/jpeg':
PIL_TYPE = 'jpeg'
FILE_EXTENSION = 'jpg'
elif DJANGO_TYPE == 'image/png':
PIL_TYPE = 'png'
FILE_EXTENSION = 'png'
# DJANGO_TYPE == 'image/gif
else:
return JsonResponse({
'res':
0,
'message':
texts.UNEXPECTED_ERROR
})
from io import BytesIO
from PIL import Image
from django.core.files.uploadedfile import SimpleUploadedFile
import os
x = float(request.POST['x'])
y = float(request.POST['y'])
width = float(request.POST['width'])
height = float(request.POST['height'])
rotate = float(request.POST['rotate'])
# Open original photo which we want to thumbnail using PIL's Image
try:
with transaction.atomic():
image = Image.open(
BytesIO(request.FILES['file'].read()))
image_modified = image.rotate(
-1 * rotate, expand=True).crop(
(x, y, x + width, y + height))
# use our PIL Image object to create the thumbnail, which already
image = image_modified.resize((300, 300),
Image.ANTIALIAS)
# Save the thumbnail
temp_handle = BytesIO()
image.save(temp_handle, PIL_TYPE, quality=90)
temp_handle.seek(0)
# Save image to a SimpleUploadedFile which can be saved into ImageField
# print(os.path.split(request.FILES['file'].name)[-1])
suf = SimpleUploadedFile(
os.path.split(
request.FILES['file'].name)[-1],
temp_handle.read(),
content_type=DJANGO_TYPE)
# Save SimpleUploadedFile into image field
user_photo.file_300.save(
'%s.%s' % (os.path.splitext(
suf.name)[0], FILE_EXTENSION),
suf,
save=True)
# request.FILES['file'].seek(0)
# image = Image.open(BytesIO(request.FILES['file'].read()))
# use our PIL Image object to create the thumbnail, which already
image = image_modified.resize((50, 50),
Image.ANTIALIAS)
# Save the thumbnail
temp_handle = BytesIO()
image.save(temp_handle, PIL_TYPE, quality=90)
temp_handle.seek(0)
# Save image to a SimpleUploadedFile which can be saved into ImageField
# print(os.path.split(request.FILES['file'].name)[-1])
suf = SimpleUploadedFile(
os.path.split(
request.FILES['file'].name)[-1],
temp_handle.read(),
content_type=DJANGO_TYPE)
# Save SimpleUploadedFile into image field
# print(os.path.splitext(suf.name)[0])
# user_photo.file_50.save(
# '50_%s.%s' % (os.path.splitext(suf.name)[0], FILE_EXTENSION),
# suf, save=True)
user_photo.file_50.save(
'%s.%s' % (os.path.splitext(
suf.name)[0], FILE_EXTENSION),
suf,
save=True)
return JsonResponse({
'res':
1,
'url':
user_photo.file_300.url
})
except Exception:
return JsonResponse({
'res':
0,
'message':
texts.UNEXPECTED_ERROR
})
return JsonResponse({
'res': 0,
'message': texts.UNEXPECTED_ERROR
})
def object_from_message(message, queue, logger):
# 'message' must be an RFC822 formatted message.
message = email.message_from_string(message)
subject = message.get('subject', _('Comment from e-mail'))
subject = decode_mail_headers(decodeUnknown(message.get_charset(),
subject))
for affix in STRIPPED_SUBJECT_STRINGS:
subject = subject.replace(affix, "")
subject = subject.strip()
sender = message.get('from', _('Unknown Sender'))
sender = decode_mail_headers(decodeUnknown(message.get_charset(), sender))
# to address bug #832, we wrap all the text in front of the email address in
# double quotes by using replace() on the email string. Then,
# take first item of list, second item of tuple is the actual email address.
# Note that the replace won't work on just an email with no real name,
# but the getaddresses() function seems to be able to handle just unclosed quotes
# correctly. Not ideal, but this seems to work for now.
sender_email = email.utils.getaddresses(
['\"' + sender.replace('<', '\" <')])[0][1]
cc = message.get_all('cc', None)
if cc:
# first, fixup the encoding if necessary
cc = [
decode_mail_headers(decodeUnknown(message.get_charset(), x))
for x in cc
]
# get_all checks if multiple CC headers, but individual emails may be comma separated too
tempcc = []
for hdr in cc:
tempcc.extend(hdr.split(','))
# use a set to ensure no duplicates
cc = set([x.strip() for x in tempcc])
for ignore in IgnoreEmail.objects.filter(
Q(queues=queue) | Q(queues__isnull=True)):
if ignore.test(sender_email):
if ignore.keep_in_mailbox:
# By returning 'False' the message will be kept in the mailbox,
# and the 'True' will cause the message to be deleted.
return False
return True
matchobj = re.match(r".*\[" + queue.slug + r"-(?P<id>\d+)\]", subject)
if matchobj:
# This is a reply or forward.
ticket = matchobj.group('id')
logger.info("Matched tracking ID %s-%s" % (queue.slug, ticket))
else:
logger.info("No tracking ID matched.")
ticket = None
body = None
counter = 0
files = []
for part in message.walk():
if part.get_content_maintype() == 'multipart':
continue
name = part.get_param("name")
if name:
name = email.utils.collapse_rfc2231_value(name)
if part.get_content_maintype() == 'text' and name is None:
if part.get_content_subtype() == 'plain':
body = part.get_payload(decode=True)
# https://github.com/django-helpdesk/django-helpdesk/issues/732
if part['Content-Transfer-Encoding'] == '8bit' and part.get_content_charset(
) == 'utf-8':
body = body.decode('unicode_escape')
body = decodeUnknown(part.get_content_charset(), body)
body = EmailReplyParser.parse_reply(body)
# workaround to get unicode text out rather than escaped text
try:
body = body.encode('ascii').decode('unicode_escape')
except UnicodeEncodeError:
body.encode('utf-8')
logger.debug("Discovered plain text MIME part")
else:
try:
email_body = encoding.smart_text(
part.get_payload(decode=True))
except UnicodeDecodeError:
email_body = encoding.smart_text(
part.get_payload(decode=False))
payload = """
<html>
<head>
<meta charset="utf-8"/>
</head>
%s
</html>""" % email_body
files.append(
SimpleUploadedFile(_("email_html_body.html"),
payload.encode("utf-8"), 'text/html'))
logger.debug("Discovered HTML MIME part")
else:
if not name:
ext = mimetypes.guess_extension(part.get_content_type())
name = "part-%i%s" % (counter, ext)
else:
name = ("part-%i_" % counter) + name
# FIXME: this code gets the paylods, then does something with it and then completely ignores it
# writing the part.get_payload(decode=True) instead; and then the payload variable is
# replaced by some dict later.
# the `payloadToWrite` has been also ignored so was commented
payload = part.get_payload()
if isinstance(payload, list):
payload = payload.pop().as_string()
# payloadToWrite = payload
# check version of python to ensure use of only the correct error type
non_b64_err = TypeError
try:
logger.debug("Try to base64 decode the attachment payload")
# payloadToWrite = base64.decodebytes(payload)
except non_b64_err:
logger.debug("Payload was not base64 encoded, using raw bytes")
# payloadToWrite = payload
files.append(
SimpleUploadedFile(name, part.get_payload(decode=True),
mimetypes.guess_type(name)[0]))
logger.debug("Found MIME attachment %s" % name)
counter += 1
if not body:
mail = BeautifulSoup(str(message), "html.parser")
beautiful_body = mail.find('body')
if beautiful_body:
try:
body = beautiful_body.text
except AttributeError:
pass
if not body:
body = ""
smtp_priority = message.get('priority', '')
smtp_importance = message.get('importance', '')
high_priority_types = {'high', 'important', '1', 'urgent'}
priority = 2 if high_priority_types & {smtp_priority, smtp_importance
} else 3
payload = {
'body': body,
'subject': subject,
'queue': queue,
'sender_email': sender_email,
'priority': priority,
'files': files,
}
return create_object_from_email_message(message,
ticket,
payload,
files,
logger=logger)
def generate_file(self):
file_search = os.listdir(path="music/static/music/uploads")[10]
file_open = SimpleUploadedFile(file_search, b"")
return file_open
def create_djangoImageType(Dir, image):
#장고형식으로 이미지 변경
img = open(os.path.join(Dir, image), 'rb')
uploaded = SimpleUploadedFile(img.name, img.read())
return uploaded
def test_saving_and_retrieving_files(self):
root = DummyFolder().create_dummy_root_folder()
file = SimpleUploadedFile("file.txt", b"file_content")
expected = file.read()
DummyFolder().create_dummy_report(root, file=file)
saved_report = Report.objects.first()
# Перевіряємо, чи збереглася первинна назва файла
self.assertEqual(saved_report.filename, "file.txt")
# Чи правильний фактичний шлях до файла
basename = os.path.basename(saved_report.file.path)
self.assertEqual(basename, "1.data")
# Час створення (до секунди) співпадає з поточним?
self.assertAlmostEqual(saved_report.uploaded_on, now(), delta=timedelta(minutes=1))
# Вмісти збереженого файда і первинного співпадають?
self.assertEqual(saved_report.file.read(), expected)
# Видляємо з диска (бо файл по-чесному записався в /uploads/folders/0/1.data)
saved_report.file.delete()
