def test_post_add_form(self): name = 'test_article' text = 'test_article text' tag = self.tag with open(os.path.join(settings.MEDIA_ROOT, r'test/images/test1.jpg'), 'rb') as image: image = SimpleUploadedFile('test1.jpg', image.read(), content_type='image/jpeg') response = self.client.post( reverse('blog:my_page'), { 'add_form': ['Save'], 'name': name, 'text': text, 'tag': tag.name, 'image': image, }) self.assertEqual(response.status_code, 302) self.assertTrue( Article.objects.get( author=self.writer, name=name, text=text, tag=tag, ).image.path.startswith( os.path.join(settings.MEDIA_ROOT, 'articles/images/test_writer_test_article')))
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): 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_format_package(self): files = [] documents = [] for i in range(0, 2): document = PACKAGE_DOCUMENT_FORMAT.copy() filename = 'form_{}.pdf'.format(i) document['name'] = filename file = SimpleUploadedFile(filename, b'test content') files.append(('files', (file.name, file.read()))) documents.append(document) responses = { 'last_name_you': 'Test', 'given_name_1_you': 'Party 0', 'last_name_spouse': 'Test', 'given_name_1_spouse': 'Party 1' } package = self.packaging.format_package(self.request, responses, documents) self.assertTrue(package) self.assertEqual(package['filingPackage']['documents'][0]['name'], 'form_0.pdf') self.assertEqual(package['filingPackage']['documents'][1]['name'], 'form_1.pdf') self.assertEqual(package['filingPackage']['parties'][0]['firstName'], 'Party 0') self.assertEqual(package['filingPackage']['parties'][1]['firstName'], 'Party 1')
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 = 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, str): # 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) if isinstance(data, TemporaryUploadedFile): # Hack to fool Django, so we can keep file open in the new thread. data.file._closer.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) def upload(): try: return glanceclient(request).images.upload(image.id, data) finally: try: filename = str(data.file.name) except AttributeError: pass else: 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 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) 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 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 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 _file_upload_csv( string, args, file_name,account): base_path = os.path.dirname(os.path.realpath(__file__)) base_path += '/accounting/testcases/sample_data/' data = open(base_path + file_name, 'rb') data = SimpleUploadedFile(content = data.read(),name = data.name,content_type='multipart/form-data') factory = RequestFactory() user = User.objects.get(username=UserConstant.ADMIN_USERNAME) if account is AccountingConstant.CHART_OF_ACCOUNTS: view = ChartOfAccounts.as_view() else : view = TrialBalanceView.as_view() content_type = 'multipart/form-data' headers= { 'HTTP_HOST': TestConstants.HOST_URL, 'HTTP_CONTENT_TYPE': content_type, 'HTTP_CONTENT_DISPOSITION': 'attachment; filename='+file_name} request = factory.post(reverse(string, args=[args]),{'file': data},secure = True, **headers) force_authenticate(request, user=user) response = view(request, args) return response.status_code, response.data
class FileProxyTest(TestCase): def setUp(self): self.dummy_file = SimpleUploadedFile(name="dummy.txt", content=b"I am content.\n") def test_create_file_proxy(self): """Test creation of `FileProxy` object.""" fp = FileProxy.objects.create(name=self.dummy_file.name, file=self.dummy_file) # Now refresh it and make sure it was saved and retrieved correctly. fp.refresh_from_db() self.dummy_file.seek(0) # Reset cursor since it was previously read self.assertEqual(fp.name, self.dummy_file.name) self.assertEqual(fp.file.read(), self.dummy_file.read()) def test_delete_file_proxy(self): """Test deletion of `FileProxy` object.""" fp = FileProxy.objects.create(name=self.dummy_file.name, file=self.dummy_file) # Assert counts before delete self.assertEqual(FileProxy.objects.count(), 1) self.assertEqual(FileAttachment.objects.count(), 1) # Assert counts after delete fp.delete() self.assertEqual(FileProxy.objects.count(), 0) self.assertEqual(FileAttachment.objects.count(), 0)
class Test(unittest.TestCase): def setUp(self): self.password = '******' self.wrong_password = '******' self.file = SimpleUploadedFile('test.pdf', b'these are the file contents!', content_type="application/pdf") self.invalid_file = 'output.pdf' def test_encryption_decryption_roundup(self): file_name = copy.deepcopy(self.file) encrypted_file = EncryptionService().encrypt_file(file_name, self.password) self.assertNotEqual(file_name.read(), encrypted_file.read()) decrypted_file = EncryptionService().decrypt_file(encrypted_file, self.password) self.assertEqual(self.file.read(), decrypted_file.read()) def test_encrypt_decrypt_with_extension_success(self): file_name = copy.deepcopy(self.file) encrypted_file = EncryptionService().encrypt_file(file_name, self.password, extension='enc') self.assertNotEqual(file_name.read(), encrypted_file.read()) decrypted_file = EncryptionService().decrypt_file(encrypted_file, self.password, extension='enc') self.assertEqual(self.file.read(), decrypted_file.read()) def test_decrypt_with_wrong_password_fails(self): file_name = copy.deepcopy(self.file) encrypted_file = EncryptionService().encrypt_file(file_name, self.password, extension='enc') self.assertNotEqual(file_name.read(), encrypted_file.read()) decrypted_file = EncryptionService().decrypt_file(encrypted_file, self.wrong_password, extension='enc') self.assertNotEquals(self.file.read(), decrypted_file.read()) def test_encrypt_decrypt_fail_without_password(self): file_name = copy.deepcopy(self.file) self.assertRaises(ValidationError, EncryptionService().encrypt_file, file_name, None) self.assertRaises(ValidationError, EncryptionService().decrypt_file, file_name, None) def test_encrypt_decrypt_fail_without_filename(self): self.assertRaises(ValidationError, EncryptionService().encrypt_file, None, self.password) self.assertRaises(ValidationError, EncryptionService().decrypt_file, None, self.password) def test_enrypt_decrypt_fail_for_invalid_file_type(self): self.assertRaises(ValidationError, EncryptionService().encrypt_file, self.invalid_file, self.password) self.assertRaises(ValidationError, EncryptionService().decrypt_file, self.invalid_file, self.password) def test_encrypt_decrypt_return_false_for_raise_exception_false_for_invalid_input(self): self.assertEqual(False, EncryptionService(raise_exception=False).encrypt_file( self.invalid_file, self.password)) self.assertEqual(False, EncryptionService(raise_exception=False).decrypt_file( self.invalid_file, self.password))
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 create_posts(self): """ create admin user and few post """ password = 12345678 email = "*****@*****.**" photo = open(f"{settings.BASE_DIR}/staticfiles/img/No-photo-m.png", 'rb') photo = SimpleUploadedFile(photo.name, photo.read(), content_type='image/png') user = UserModel.objects.create_superuser(email=email, password=password, photo=photo) data = {'email': email, 'password': password} self.admin_creds = data response = self.client.post(self.login_url, data=data) self.assertEqual(response.status_code, status.HTTP_200_OK) self.admin_token = response.data['access'] self.client.credentials( HTTP_AUTHORIZATION=f"Bearer {self.admin_token}") titles = [ "Cars", "onion", "People", "Dresses", "Food", "Job", "Vacancies" ] for title in titles: photo = open(f"{settings.BASE_DIR}/staticfiles/img/No-photo-m.png", 'rb') photo = SimpleUploadedFile(photo.name, photo.read(), content_type='image/png') data = { "title": title, "content": """Lorem ipsum dolor sit amet, consectetur adipisicing elit. Accusamus aliquam""", "image": photo, } with self.assertNumQueries(2): response = self.client.post(self.post_create, data=data) self.assertEqual(response.status_code, status.HTTP_201_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 make_pq(self, filename='azd.html', upload_type=UPLOAD_TYPE.DOCKET): """Make a simple pq object for processing""" path = self.make_path(filename) with open(path, 'r') as f: f = SimpleUploadedFile(filename, f.read()) return ProcessingQueue.objects.create( court_id='scotus', uploader=self.user, pacer_case_id='asdf', filepath_local=f, upload_type=upload_type, )
def test_post_image_form(self): with open(os.path.join(settings.MEDIA_ROOT, r'test/images/test2.jpg'), 'rb') as image: image = SimpleUploadedFile('test2.jpg', image.read(), content_type='image/jpeg') response = self.client.post(reverse('blog:my_page'), { 'image_form': ['Submit'], 'image': image, }) writer = Writer.objects.get(name=self.writer.name) self.assertEquals(response.status_code, 302) self.assertTrue(writer.image.path.startswith(os.path.join(settings.MEDIA_ROOT, r'writers/images/test_writer')))
def test_download_comment_attachment_without_accel_redirect(self): tmp_file = SimpleUploadedFile('filename.txt', b'File content') comment = CommentFactory(userrequest=self.request, attachment=tmp_file) self._set_permissions([ 'can_comment_requests', ]) response = self._get_comment_attachment(pk=comment.pk) self.assertEqual(status.HTTP_200_OK, response.status_code) self.assertEqual(f'attachment; filename={tmp_file.name}', response.get('Content-Disposition')) tmp_file.seek(0) self.assertEqual(response.content, tmp_file.read())
def test_create_comment(self): self.client.credentials() response = self.client.get(self.list_url) self.assertEqual(response.status_code, status.HTTP_200_OK) post_id = response.data['results'][0]['id'] # not authenticated comment_url = reverse('post:comment-create', args=[post_id]) response = self.client.post(comment_url, data={}) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) # not Visitor user self.client.login(**self.admin_creds) response = self.client.post(comment_url, data={}) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) # not valid form password = 12345678 email = "*****@*****.**" photo = open(f"{settings.BASE_DIR}/staticfiles/img/No-photo-m.png", 'rb') photo = SimpleUploadedFile(photo.name, photo.read(), content_type='image/png') user = VisitorModel.objects.create_user(email=email, password=password, photo=photo) data = {'email': email, 'password': password} self.client.login(**data) response = self.client.post(comment_url, data={}) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) # valid form with self.assertNumQueries(4): response = self.client.post(comment_url, data={"text": 'some text'}) self.assertEqual(response.status_code, status.HTTP_201_CREATED) with self.assertNumQueries(4): response = self.client.post(comment_url, data={"text": 'some new text'}) self.assertEqual(response.status_code, status.HTTP_201_CREATED) with self.assertNumQueries(4): response = self.client.post(comment_url, data={"text": 'weather'}) self.assertEqual(response.status_code, status.HTTP_201_CREATED) # get post post_detail_url = reverse('post:detail', args=[post_id]) with self.assertNumQueries(6): response = self.client.get(post_detail_url) self.assertEqual(response.status_code, status.HTTP_200_OK) schema = self.schemas.get_post_detail_schema() self.check_fields(schema, response.data) self.check_fields(schema['comments'][0], response.data['comments'][0])
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)
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 setUp(self): 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=self.user, pacer_case_id='asdf', filepath_local=f, upload_type=UPLOAD_TYPE.DOCKET, )
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 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(): return glanceclient(request).images.upload(image.id, data) thread.start_new_thread(upload, ()) return Image(image)
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 setUp(self): 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=self.user, pacer_case_id="asdf", filepath_local=f, upload_type=UPLOAD_TYPE.DOCKET, )
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, )
class GeometryFileFieldTestCase(SimpleTestCase): def setUp(self): self.field = GeometryFileField() self.fp = SimpleUploadedFile('geom.json', json.dumps(_geom).encode('ascii')) self.fp.seek(0) def test_to_python(self): self.assertIsInstance(self.field.to_python(self.fp), OGRGeometry) fp = SimpleUploadedFile('empty.json', b'{}') self.assertRaises(forms.ValidationError, self.field.to_python, fp) def test_feature_to_python(self): feature = Feature(geometry=_geom) self.fp.write(str(feature).encode('ascii')) self.fp.seek(0) v = self.field.to_python(self.fp) self.assertIsInstance(v, OGRGeometry) def test_shapefile(self): base = 'dir/geofield.shp' path = default_storage.path(base) os.mkdir(os.path.dirname(path)) write_shp(path, _geom) b = io.BytesIO() with zipfile.ZipFile(b, 'w') as zf: for ext in ('dbf', 'prj', 'shp', 'shx'): fname = base.replace('shp', ext) with default_storage.open(fname) as fp: zf.writestr(fname, fp.read()) shutil.rmtree(os.path.dirname(path)) upfile = SimpleUploadedFile('geofield.zip', b.getvalue()) b.close() result = self.field.to_python(upfile) self.assertIsInstance(result, OGRGeometry) self.assertIsNotNone(result.srs) def test_zipfile(self): zfile = io.BytesIO() with zipfile.ZipFile(zfile, 'w') as zf: zf.writestr(self.fp.name, self.fp.read()) zfile.seek(0) upfile = SimpleUploadedFile('geofield.zip', zfile.read()) zfile.close() self.assertIsInstance(self.field.to_python(upfile), OGRGeometry) def tearDown(self): self.fp.close()
class GeometryFileFieldTestCase(SimpleTestCase): def setUp(self): self.field = GeometryFileField() self.fp = SimpleUploadedFile( 'geom.json', json.dumps(_geom).encode('ascii')) self.fp.seek(0) def test_to_python(self): self.assertIsInstance(self.field.to_python(self.fp), OGRGeometry) fp = SimpleUploadedFile('empty.json', b'{}') self.assertRaises(forms.ValidationError, self.field.to_python, fp) def test_feature_to_python(self): feature = Feature(geometry=_geom) self.fp.write(str(feature).encode('ascii')) self.fp.seek(0) v = self.field.to_python(self.fp) self.assertIsInstance(v, OGRGeometry) def test_shapefile(self): base = 'dir/geofield.shp' path = default_storage.path(base) os.mkdir(os.path.dirname(path)) write_shp(path, _geom) b = io.BytesIO() with zipfile.ZipFile(b, 'w') as zf: for ext in ('dbf', 'prj', 'shp', 'shx'): fname = base.replace('shp', ext) with default_storage.open(fname) as fp: zf.writestr(fname, fp.read()) shutil.rmtree(os.path.dirname(path)) upfile = SimpleUploadedFile('geofield.zip', b.getvalue()) b.close() result = self.field.to_python(upfile) self.assertIsInstance(result, OGRGeometry) self.assertIsNotNone(result.srs) def test_zipfile(self): zfile = io.BytesIO() with zipfile.ZipFile(zfile, 'w') as zf: zf.writestr(self.fp.name, self.fp.read()) zfile.seek(0) upfile = SimpleUploadedFile('geofield.zip', zfile.read()) zfile.close() self.assertIsInstance(self.field.to_python(upfile), OGRGeometry) def tearDown(self): self.fp.close()
def test_changing_size(self, mock_is_testing_mode): mock_is_testing_mode.return_value = False TESTFILE = "small_kitten.jpeg" data = SimpleUploadedFile(name=TESTFILE, content=open(TESTFILE, "rb").read()) initial_size = data.size optimize_from_buffer(data) resized_data_size = data.size data.open() actual_final_size = len(data.read()) self.assertEqual(actual_final_size, resized_data_size) self.assertLess(actual_final_size, initial_size, msg="Test not valid - image was not reduced")
class Image(models.Model): name = models.CharField(max_length=50) image = models.ImageField(upload_to="bigpath/", null=True, blank=True) thumbnail = models.ImageField(upload_to="bigpath/thumbnails", null=True, blank=True) is_deleted = models.BooleanField(default=False) shelter = models.ForeignKey(Shelter) user = models.ForeignKey(User) def __unicode__(self): return u'%s => %s' % (self.name, self.id) 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 create_thumbnail(self): if not self.image: return import PIL, os from cStringIO import StringIO THUMBNAIL_SIZE = (200,200) DEFAULT_TYPE = 'JPEG' image = PIL.Image.open(StringIO(self.image.read())) image.thumbnail(THUMBNAIL_SIZE, PIL.Image.ANTIALIAS) thumbnail_type = self.content_type.split('/')[1] thumbnail_type = thumbnail_type.encode('ascii', 'ignore') #set default type if thumbnail_type is None: thumbnail_type = DEFAULT_TYPE elif thumbnail_type == 'jpg' or thumbnail_type == 'JPG': thumbnail_type = DEFAULT_TYPE temp_handle = StringIO() image.save(temp_handle, format=thumbnail_type) temp_handle.seek(0) return SimpleUploadedFile(self.system_name, temp_handle.read(), content_type=self.content_type)
def clean_upload_file_minidump(self): file = self.cleaned_data["upload_file_minidump"] if file and file.name.endswith('.tar'): try: 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 except tarfile.TarError as err: raise forms.ValidationError('The tar file is broken, error: {0}'.format(err.message)) return file
def test_format_package(self): files = [] for i in range(0, 2): file = SimpleUploadedFile('form_{}.pdf'.format(i), b'test content') files.append(('files', (file.name, file.read()))) parties = [] for i in range(0, 2): party = PACKAGE_PARTY_FORMAT.copy() party['firstName'] = 'Party {}'.format(i) party['lastName'] = 'Test' parties.append(party) package = self.hub._format_package(self.request, files, parties=parties) self.assertTrue(package) self.assertEqual(package['filingPackage']['documents'][0]['name'], 'form_0.pdf') self.assertEqual(package['filingPackage']['documents'][1]['name'], 'form_1.pdf') self.assertEqual(package['filingPackage']['parties'][0]['firstName'], 'Party 0') self.assertEqual(package['filingPackage']['parties'][1]['firstName'], 'Party 1')
def clean_upload_file_minidump(self): file = self.cleaned_data["upload_file_minidump"] if file and file.name.endswith('.tar'): try: 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 except tarfile.TarError as err: raise forms.ValidationError( 'The tar file is broken, error: {0}'.format(err.message)) return file
def clean(self,data,initial=None): if self.required and not (data.get('file') or (data.get('tmp_file_path') and data.get('tmp_file_name'))): raise ValidationError(self.error_messages['required']) if data['file']: file = data['file'] super(TempImageField,self).__init__(file,initial) tmp_file_path = file.temporary_file_path() tmp_file_name = os.path.split(tmp_file_path)[-1] tmp_file_url = os.path.join(settings.FILE_UPLOAD_TEMP_URL_DIR, tmp_file_name) self.widget.tmp_file_path = tmp_file_path self.widget.tmp_file_url = tmp_file_url self.widget.tmp_file_name = file.name elif data['tmp_file_path'] and os.path.exists(data['tmp_file_path']): file = open(data['tmp_file_path'],'rb') file = SimpleUploadedFile(data['tmp_file_name'],file.read()) else: raise ValidationError('Sorry you took too long to submit. Please upload picture again.') return file
def image_create(self, **kwargs): data = kwargs.pop('data', None) location = None if int(VERSIONS) >= 2: location = kwargs.pop('location', None) image = self.glance_client.images.create(**kwargs) if location is not None: self.glance_client.images.add_location(image.id, location, {}) if data: if isinstance(data, TemporaryUploadedFile): data.file.close_called = True elif isinstance(data, InMemoryUploadedFile): data = SimpleUploadedFile(data.name, data.read(), data.content_type) if int(VERSIONS) < 2: t = threading.Thread(target=self.image_update, args=(image.id, ), kwargs={'data': data}) t.start() else: def upload(): try: return self.glance_client.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 }) t = threading.Thread(target=upload) t.start() return image
def test_resize_image(self): """ is image save, resize """ person = Person.objects.first() photo = create_img() data = {'first_name': 'first_name', 'last_name': 'last_name', 'date_of_birth': '1990-10-09', 'other': 'other', 'bio': 'bio', 'email': '*****@*****.**', 'jabber': '*****@*****.**', 'skype': 'skype'} photo = SimpleUploadedFile(photo.name, photo.read()) form = PersonEditForm(data, dict(photo=photo), instance=person) self.assertTrue(form.is_valid()) form.save() person = Person.objects.first() self.assertLessEqual(person.photo.width/person.photo.height, 500/250) self.assertTrue(person.photo.width and person.photo.height <= 200)
def test_resize_image(self): """ Testing image save """ person = Person.objects.get(pk=1) photo = open('assets/images/default.png', 'rb') data = { 'name': 'Victoria', 'last_name': 'Prokophuck', 'date': '1992-08-29', 'other_contacts': 'contacts', 'bio': 'bio', 'email': '*****@*****.**', 'jubber': '*****@*****.**', 'skype': 'vviicckkyy', } photo = SimpleUploadedFile(photo.name, photo.read()) form = PersonForm(data, dict(photo=photo), instance=person) self.assertTrue(form.is_valid()) form.save() person = Person.objects.get(pk=1) self.assertNotEqual(person.photo.url, '/static/images/default.png') image_resized = Image.open(person.photo) self.assertLessEqual(image_resized.height, 200) self.assertLessEqual(image_resized.width, 200)
def get_source_code(self, pk=1): source_code = open(self._get_source_file(), 'rb') source_code = SimpleUploadedFile(source_code.name, source_code.read()) return source_code
class SimpleTest(TestCase): def setUp(self): self.u1 = User.objects.create(username='******') self.upload = SimpleUploadedFile('fake.pdf', 'This is a fake pdf') self.upload2 = SimpleUploadedFile('fake2.pdf', 'This is a second fake pdf') def test_document_upload(self): """ Tests that we can upload a file and get it back """ doc = uploaded_new_document(self.upload) doc.title = 'File uploaded' doc.author = self.u1 doc.file.read() doc.save() doc = Document.objects.get(title='File uploaded') self.upload.seek(0) self.assertEqual(doc.file.read(), self.upload.read()) def test_derived_document_upload(self): """ Test derived file upload """ doc = uploaded_new_document(self.upload) doc.title = 'File uploaded' doc.author = self.u1 doc.save() derived = uploaded_new_derived_document(self.upload2) derived.derived_from = doc._blob derived.index = 0 derived.save() derived2 = doc.get_derived_documents_of_type('pdf')[0] self.assertEqual(derived, derived2) self.upload2.seek(0) self.assertEqual(derived2.file.read(), self.upload2.read()) def test_png_container(self): doc = uploaded_new_document(self.upload) doc.title = 'File uploaded' doc.author = self.u1 doc.save() self.upload.name = 'fake.png' derived = uploaded_new_derived_document(self.upload) derived.derived_from = doc._blob derived.index = 0 derived.save() def test_orphaned_blobs(self): """Make sure that deleting a Document does not result in orphanded blobs""" doc = uploaded_new_document(self.upload) doc.title = 'File uploaded' doc.author = self.u1 doc.save() self.upload.name = 'fake.png' derived = uploaded_new_derived_document(self.upload) derived.derived_from = doc._blob derived.index = 0 derived.save() DerivedDocument.objects.all().delete() self.assertEqual(DerivedBlob.objects.count(), 0) Document.objects.all().delete() self.assertEqual(ParentBlob.objects.count(), 0) def test_deleted_derived(self): """ Make sure that derived documents are deleted when parent document and blob are deleted. """ doc = uploaded_new_document(self.upload) doc.title = 'File uploaded' doc.author = self.u1 doc.save() self.upload.name = 'fake.png' derived = uploaded_new_derived_document(self.upload) derived.derived_from = doc._blob derived.index = 0 derived.save() Document.objects.all().delete() self.assertEqual(DerivedBlob.objects.count(), 0) def test_files_are_deleted(self): """Make sure file is deleted when blob is""" doc = uploaded_new_document(self.upload) doc.title = 'File uploaded' doc.author = self.u1 doc.save() name = doc._blob.file.name from django.core.files.storage import get_storage_class storage = get_storage_class()() doc.delete() self.assertFalse(storage.exists(name)) def test_auto_blob_creation(self): """ Test that a blob is created when using file attriube on a document. """ doc = Document(title='New Doc', file_name='A File', file=self.upload, author=self.u1) doc.save() doc.file.seek(0) self.upload.seek(0) self.assertEqual(doc.file.read(), self.upload.read()) self.assertEqual(ParentBlob.objects.count(), 1) doc.file.seek(0) self.upload.seek(0) self.assertEqual(ParentBlob.objects.all()[0].file.read(), self.upload.read()) def test_auto_derived_blob_creation(self): """ Test that a blob is created when using the file attribue on a derived document. """ doc = Document(title='New Doc', file_name='A File', file=self.upload, author=self.u1) doc.save() derived = DerivedDocument(derived_from=doc._blob, index=0, file=self.upload2) derived.save() self.upload2.seek(0) self.upload.seek(0) self.assertEqual(derived.file.read(), self.upload2.read()) self.assertEqual(DerivedBlob.objects.count(), 1) self.upload2.seek(0) derived.file.seek(0) self.assertEqual(DerivedBlob.objects.all()[0].file.read(), self.upload2.read()) def test_read_only_file(self): doc = Document(title='New Doc', file_name='A File', file=self.upload, author=self.u1) doc.save() self.assertRaises(ReadOnlyFileError, doc.file.delete) self.assertRaises(ReadOnlyFileError, doc.file.write, 'test') self.assertRaises(ReadOnlyFileError, doc.file.writelines, 'test') def tearDown(self): self.u1.delete() Document.objects.all().delete()
def image_create(request, **kwargs): copy_from = kwargs.pop('copy_from', None) data = kwargs.pop('data', None) location = kwargs.pop('location', None) file_extension_list = ["png", "jpg", "jpeg","bmp","dib","gif","tif","jfif"] fileNotMatched = False if data: file_name = str(data).split(".") file_name_ext = file_name[len(file_name)-1] for ext in file_extension_list: if( file_name_ext.lower() == ext): fileNotMatched = True break if copy_from: file_name = str(copy_from).split(".") file_name_ext = file_name[len(file_name)-1] for ext in file_extension_list: if( file_name_ext.lower() == ext): fileNotMatched = True break if(fileNotMatched): print ("\n**INVALID IMAGE ============ CHECK IMAGE ext.") error_message = "You must provide valid image type (.png, .jpeg, .bmp are not valid)" messages.error(request, error_message) return False 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
class CVResumeTests(APITestCase): """ Tests CVResume model. """ def setUp(self): self.user = create_user() # Create a file like objects representing uploaded data self.cv = SimpleUploadedFile('my_cv.pdf', b'Impresive CV') self.resume = SimpleUploadedFile('my_resume.pdf', b'Impresive Resume') def tearDown(self): """ Close open files. """ self.cv.close() self.resume.close() def test_cv_created(self): """ Test whether a cv is saved correctly. """ # Pass a cv file object to CVResume to save to db/disk CVResume.objects.create( user=self.user, cv=self.cv ) self.cv.open() # Reopen the cv object - set seek to 0 cv_resume = CVResume.objects.get(pk=1) self.assertEqual( self.cv.read(), cv_resume.cv.read(), # Compare file like objects 'Created cv does not match the provided one.' ) def test_resume_created(self): """ Test whether a resume is saved correctly. """ # Pass a resume file object to CVResume to save to db/disk CVResume.objects.create( user=self.user, resume=self.resume ) self.resume.open() # Reopen the resume object - set seek to 0 cv_resume = CVResume.objects.get(pk=1) self.assertEqual( self.resume.read(), cv_resume.resume.read(), # Compare file like objects 'Created reusme does not match the provided one.' ) def test_cv_and_resume_created(self): """ Test whether both cv and resume are saved correctly. """ CVResume.objects.create( user=self.user, cv=self.cv, resume=self.resume ) # Set file positions to the begining self.cv.open() self.resume.open() # Retrieve the saved object cv_resume = CVResume.objects.get(pk=1) # Check if cv match self.assertEqual( self.cv.read(), cv_resume.cv.read(), # Compare file like objects 'Created cv does not match the provided one.' ) # Check if resume match self.assertEqual( self.resume.read(), cv_resume.resume.read(), # Compare file like objects 'Created reusme does not match the provided one.' )
def save_image(self): filename = self.get_filename() self.change_image() res = self.store_image() res = SimpleUploadedFile(filename, res.read()) return (filename, res)
class CVN(models.Model): cvn_file = models.FileField(_(u'PDF'), upload_to=get_cvn_path) xml_file = models.FileField(_(u'XML'), upload_to=get_cvn_path) fecha = models.DateField(_("Date of CVN")) created_at = models.DateTimeField(_("Created"), auto_now_add=True) updated_at = models.DateTimeField(_("Updated"), auto_now=True) uploaded_at = models.DateTimeField(_("Uploaded PDF"), default=datetime.datetime(2014, 10, 18)) user_profile = models.OneToOneField(UserProfile) status = models.IntegerField(_("Status"), choices=st_cvn.CVN_STATUS) is_inserted = models.BooleanField(_("Inserted"), default=False) def __init__(self, *args, **kwargs): user = kwargs.pop('user', None) pdf_path = kwargs.pop('pdf_path', None) pdf = kwargs.pop('pdf', None) super(CVN, self).__init__(*args, **kwargs) if user: self.user_profile = user.profile if pdf_path: pdf_file = open(pdf_path) pdf = pdf_file.read() if pdf and user: self.update_from_pdf(pdf, commit=False) def update_from_pdf(self, pdf, commit=True): name = 'CVN-' + self.user_profile.documento (xml, error) = fecyt.pdf2xml(pdf, name) if not error: CVN.remove_cvn_by_userprofile(self.user_profile) self.cvn_file = SimpleUploadedFile(name, pdf, content_type="application/pdf") self.initialize_fields(xml, commit) def update_from_xml(self, xml, commit=True): pdf = fecyt.xml2pdf(xml) if pdf: self.update_from_pdf(pdf, commit) def initialize_fields(self, xml, commit=True): # Warning: The filename is ignored by your extension is needed self.xml_file.save(u'fake-filename.xml', ContentFile(xml), save=False) tree_xml = etree.XML(xml) self.fecha = parse_date(tree_xml.find('Version/VersionID/Date')) self.is_inserted = False self.uploaded_at = datetime.datetime.now() self.update_status(commit) self.xml_file.close() if commit: self.save() def update_status(self, commit=True): status = self.status if self.fecha <= config.EXPIRY_DATE: self.status = st_cvn.CVNStatus.EXPIRED elif not self._is_valid_identity(): self.status = st_cvn.CVNStatus.INVALID_IDENTITY else: self.status = st_cvn.CVNStatus.UPDATED if self.status != status and commit: self.save() def _is_valid_identity(self): try: if self.xml_file.closed: self.xml_file.open() except IOError: return False xml_tree = etree.parse(self.xml_file) self.xml_file.seek(0) nif = parse_nif(xml_tree) self.xml_file.close() for character in [' ', '-']: if character in nif: nif = nif.replace(character, '') if nif.upper() == self.user_profile.documento.upper(): return True # NIF/NIE without final letter if len(nif) == 8 and nif == self.user_profile.documento[:-1]: return True return False @classmethod def get_user_pdf_ull(cls, user, start_date=None, end_date=None): if user.profile.rrhh_code is None: return None parser = CvnXmlWriter(user=user) learning = cls._insert_learning(user, parser, start_date, end_date) cargos = cls._insert_profession(st.WS_ULL_CARGOS, user, parser, start_date, end_date) contratos = cls._insert_profession(st.WS_ULL_CONTRATOS, user, parser, start_date, end_date) docencia = cls._insert_teaching(user, parser, start_date, end_date) if not learning and not cargos and not contratos and not docencia: return None xml = parser.tostring() return fecyt.xml2pdf(xml) @classmethod def _insert_learning(cls, user, parser, start_date, end_date): items = ws.get(url=st.WS_ULL_LEARNING % user.profile.id_without_control_digit, use_redis=True) counter = 0 if items is None: return counter for item in items: values = item.copy() cls._clean_data_learning(values) item_date_range = DateRange(values[u'f_expedicion'], values[u'f_expedicion']) if not item_date_range.intersect(DateRange(start_date, end_date)): continue if (u'des1_grado_titulacion' in item and item[u'des1_grado_titulacion'].upper() == u'DOCTOR'): del values[u'des1_grado_titulacion'] parser.add_learning_phd(**values) else: parser.add_learning(**values) counter += 1 return counter @staticmethod def _clean_data_learning(item): if u'f_expedicion' in item and item[u'f_expedicion'] is not None: item[u'f_expedicion'] = dateutil.parser.parse( item[u'f_expedicion']).date() else: item[u'f_expedicion'] = None @classmethod def _insert_profession(cls, ws_url, user, parser, start_date, end_date): items = ws.get(url=ws_url % user.profile.id_without_control_digit, use_redis=True) counter = 0 if items is None: return counter for item in items: values = item.copy() cls._clean_data_profession(values) if u'f_toma_posesion' in item: initial_date = values[u'f_toma_posesion'] else: initial_date = values[u'f_desde'] item_date_range = DateRange(initial_date, values[u'f_hasta']) if not item_date_range.intersect(DateRange(start_date, end_date)): continue parser.add_profession(**values) counter += 1 return counter @staticmethod def _clean_data_profession(item): if u'f_toma_posesion' in item and item[u'f_toma_posesion'] is not None: item[u'f_toma_posesion'] = dateutil.parser.parse( item[u'f_toma_posesion']).date() if u'f_desde' in item and item[u'f_desde'] is not None: item[u'f_desde'] = dateutil.parser.parse(item[u'f_desde']).date() if u'f_hasta' in item and item[u'f_hasta'] is not None: item[u'f_hasta'] = dateutil.parser.parse(item[u'f_hasta']).date() else: item[u'f_hasta'] = None if u'des1_dedicacion' in item: dedicacion = item[u'des1_dedicacion'].upper() item[u'des1_dedicacion'] = dedicacion == u'TIEMPO COMPLETO' @classmethod def _insert_teaching(cls, user, parser, start_date, end_date): items = ws.get(url=st.WS_ULL_TEACHING % user.profile.rrhh_code, use_redis=True) counter = 0 if items is None: return counter for item in items: values = item.copy() date = datetime.date(int(values[u'curso_inicio']), 1, 1) item_date_range = DateRange(date, date) if not item_date_range.intersect(DateRange(start_date, end_date)): continue parser.add_teaching(**values) counter += 1 return counter @staticmethod def create(user, xml=None): if not xml: parser = CvnXmlWriter(user=user) xml = parser.tostring() pdf = fecyt.xml2pdf(xml) if pdf is None: return None cvn = CVN(user=user, pdf=pdf) cvn.save() return cvn @classmethod def remove_cvn_by_userprofile(cls, user_profile): try: cvn_old = cls.objects.get(user_profile=user_profile) cvn_old.remove() except ObjectDoesNotExist: pass def remove(self): # Removes data related to CVN that is not on the CVN class. self._backup_pdf() try: if self.cvn_file: self.cvn_file.delete(False) # Remove PDF file except IOError as e: logger.error(str(e)) try: if self.xml_file: self.xml_file.delete(False) # Remove XML file except IOError as e: logger.error(str(e)) def _backup_pdf(self): filename = OldCvnPdf.create_filename(self.cvn_file.name, self.uploaded_at) try: old_cvn_file = SimpleUploadedFile(filename, self.cvn_file.read(), content_type="application/pdf") except IOError as e: logger.error(e.message) else: cvn_old = OldCvnPdf(user_profile=self.user_profile, cvn_file=old_cvn_file, uploaded_at=self.uploaded_at) cvn_old.save() def remove_producciones(self): Articulo.remove_by_userprofile(self.user_profile) Libro.remove_by_userprofile(self.user_profile) Capitulo.remove_by_userprofile(self.user_profile) Congreso.remove_by_userprofile(self.user_profile) Proyecto.remove_by_userprofile(self.user_profile) Convenio.remove_by_userprofile(self.user_profile) TesisDoctoral.remove_by_userprofile(self.user_profile) Patente.remove_by_userprofile(self.user_profile) def insert_xml(self): try: if self.xml_file.closed: self.xml_file.open() self.xml_file.seek(0) cvn_items = etree.parse(self.xml_file).findall('CvnItem') self._parse_cvn_items(cvn_items) self.is_inserted = True self.save() except IOError: if self.xml_file: logger.error( (u'No existe el fichero' + u' %s') % (self.xml_file.name)) else: logger.warning(u'Se requiere de un fichero CVN-XML') def _parse_cvn_items(self, cvn_items): for cvnitem in cvn_items: produccion = parse_cvnitem_to_class(cvnitem) if produccion is None: continue produccion.objects.create(cvnitem, self.user_profile) def update_document_in_path(self): # Latest CVN relative_pdf_path = get_cvn_path(self, u'fake.pdf') full_pdf_path = os_path_join(st.MEDIA_ROOT, relative_pdf_path) xml_path = get_cvn_path(self, u'fake.xml') full_xml_path = os_path_join(st.MEDIA_ROOT, xml_path) root_path = '/'.join(full_pdf_path.split('/')[:-1]) if not os_path_isdir(root_path): makedirs(root_path) if self.cvn_file.path != full_pdf_path: file_move_safe(self.cvn_file.path, full_pdf_path, allow_overwrite=True) self.cvn_file.name = relative_pdf_path if self.xml_file.path != full_xml_path: file_move_safe(self.xml_file.path, full_xml_path, allow_overwrite=True) self.xml_file.name = xml_path self.save() def __unicode__(self): return '%s ' % self.cvn_file.name.split('/')[-1] class Meta: verbose_name_plural = _("Normalized Curriculum Vitae") ordering = ['-uploaded_at', '-updated_at']
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()