django.core.files.uploadedfile.SimpleUploadedFile

Here are the examples of the python api django.core.files.uploadedfile.SimpleUploadedFile taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

183 Examples 7

Example 1

Project: pycon Source File: test_forms.py
    def test_valid_receipt_pdf(self):
        """Checks form is valid with SimpleUploadeFile extension pdf"""
        # Use StringIO to create files
        pdf_file = StringIO.StringIO('portable docuement format file')
        # Use PIL Image to create new png and pdf files
        Image.new('RGB', size=(50, 50), color=(256, 0, 0)).save(pdf_file, 'pdf')
        pdf_file.seek(0)
        file = SimpleUploadedFile('test_file.pdf', pdf_file.read())
        # Data for the form
        data_pdf = {'description': 'description pdf',
                    'amount': 1,
                    }
        files = {'receipt_image': file}
        form_pdf = ReceiptForm(data_pdf, files, instance=Receipt(application=self.application))

        self.assertTrue(form_pdf.is_valid(), msg=form_pdf.errors)
        form_pdf.save()

Example 2

Project: djangobb Source File: fields.py
    def save_form_data(self, instance, data):
        if data and self.width and self.height:
            content = self.resize_image(data.read(), width=self.width, height=self.height)
            salt = sha1(str(random.random()).encode('utf-8')).hexdigest()[:5]
            fname =  sha1(salt.encode('utf-8') + settings.SECRET_KEY.encode('utf-8')).hexdigest() + '.png'
            data = SimpleUploadedFile(fname, content, content_type='image/png')
        super(ExtendedImageField, self).save_form_data(instance, data)

Example 3

Project: wagtail Source File: test_admin_views.py
    @override_settings(DEFAULT_FILE_STORAGE='wagtail.tests.dummy_external_storage.DummyExternalStorage')
    def test_upload_with_external_storage(self):
        response = self.client.post(reverse('wagtailimages:chooser_upload'), {
            'title': "Test image",
            'file': SimpleUploadedFile('test.png', get_test_image_file().file.getvalue()),
        })

        # Check response
        self.assertEqual(response.status_code, 200)

        # Check that the image was created
        self.assertTrue(Image.objects.filter(title="Test image").exists())

Example 4

Project: django-page-cms Source File: test_templates.py
    def test_get_filename(self):
        placeholder = PlaceholderNode("placeholdername")
        page = self.new_page({'slug': 'page1'})
        fakefile = SimpleUploadedFile(name=u"some {}[]@$%*()+myfile.pdf", content=six.b('bytes'))
        filename = get_filename(page, placeholder, fakefile)
        self.assertTrue('some-myfile.pdf' in filename)
        self.assertTrue("page_%d" % page.id in filename)
        self.assertTrue(placeholder.name in filename)

Example 5

Project: django-libs Source File: factories.py
Function: create_image
    @classmethod
    def _create_image(self, image_format='JPEG', filename='img.jpg'):
        thumb = Image.new('RGB', (100, 100), 'blue')
        thumb_io = BytesIO()
        thumb.save(thumb_io, format=image_format)
        self._image = SimpleUploadedFile(filename, thumb_io.getvalue())
        return self._image

Example 6

Project: django-rest-framework Source File: test_request.py
    def test_request_POST_with_files(self):
        """
        Ensure request.POST returns no content for POST request with file content.
        """
        upload = SimpleUploadedFile("file.txt", b"file_content")
        request = Request(factory.post('/', {'upload': upload}))
        request.parsers = (FormParser(), MultiPartParser())
        self.assertEqual(list(request.POST.keys()), [])
        self.assertEqual(list(request.FILES.keys()), ['upload'])

Example 7

Project: django-smuggler Source File: test_views.py
Function: test_load_and_save
    @override_settings(SMUGGLER_FIXTURE_DIR=p('..', 'smuggler_fixtures'))
    def test_load_and_save(self):
        reload_module(settings)
        f = SimpleUploadedFile('uploaded.json',
                               b'[{"pk": 1, "model": "test_app.page",'
                               b' "fields": {"title": "test",'
                               b' "path": "", "body": "test body"}}]')
        self.c.post(self.url, {
            'store': True,
            'uploads': f
        }, follow=True)
        self.assertTrue(os.path.exists(
            p('..', 'smuggler_fixtures', 'uploaded.json')))
        os.unlink(p('..', 'smuggler_fixtures', 'uploaded.json'))

Example 8

Project: pootle Source File: import.py
@pytest.mark.django_db
def test_import_new_file(project0_nongnu, import_tps, site_users):
    tp = import_tps
    user = site_users["user"]
    store_pootle_path = tp.pootle_path + "import_new_file.po"
    filestore = create_store(store_pootle_path, "0",
                             [("Unit Source", "Unit Target")])

    # New store can't be created via current import command. This test will
    # need to be adjusted if we allow to create new stores via import command.
    from import_export.exceptions import FileImportError
    with pytest.raises(FileImportError):
        import_file(SimpleUploadedFile("import_new_file.po",
                                       str(filestore),
                                       "text/x-gettext-translation"), user)

Example 9

Project: django-rest-framework-fine-permissions Source File: test_views.py
    def test_permissions_import_json_exception(self):
        self.client.login(username='supertest', password='pass')
        self._add_field_perms('tests', 'account', 'expired_date')
        ufp = UserFieldPermissions.objects.get(user=self.user)
        permissions_str = 'empty'

        f = SimpleUploadedFile('file.txt', permissions_str.encode('utf-8'),
                               content_type='application/json')
        response = self.client.post('/drffp/import/%s/' % ufp.pk,
                                    {'perms_upload': f})

        self.assertEqual(response.status_code, 302)
        self.assertTrue(
            'Error in the import' in format(response.cookies['messages']))

Example 10

Project: django-gitstorage Source File: test_storage.py
    def test_overwrite_root(self):
        name = "foo.txt"
        self.storage.save(name, SimpleUploadedFile(name, b'toto'))

        content = self.storage.open(name)
        self.assertEqual(b"toto", content.read())

Example 11

Project: reviewboard Source File: tests.py
Function: set_up
    def setUp(self):
        uploaded_file = SimpleUploadedFile(
            'test.txt',
            b'<p>This is a test</p>',
            content_type='text/plain')

        review_request = self.create_review_request(publish=True)

        form = UploadFileForm(review_request, files={
            'path': uploaded_file,
        })
        self.assertTrue(form.is_valid())

        self.file_attachment = form.create()

Example 12

Project: SmartElect Source File: test_forms.py
    def test_upload_file(self):
        # We can successfully upload a file of NIDs and look up the citizens
        # and blank lines are okay
        data = self.data
        data['how_to_select'] = str(Changeset.SELECT_UPLOADED_NIDS)
        citizen1 = CitizenFactory()
        citizen2 = CitizenFactory()
        filetext = "{nid1}\n\n{nid2}\n".format(nid1=citizen1.national_id, nid2=citizen2.national_id)
        upload_file = SimpleUploadedFile('my_filename', filetext)
        mock_request = MagicMock(user=UserFactory())
        form = ChangesetForm(data=data, files={'upload_file': upload_file}, request=mock_request)
        self.assertTrue(form.is_valid(), msg=str(form.errors))
        changeset = form.save()
        self.assertIn(citizen1, changeset.selected_citizens.all())
        self.assertIn(citizen2, changeset.selected_citizens.all())

Example 13

Project: taiga-back Source File: test_attachments.py
def test_create_attachment_with_long_file_name(client):
    issue1 = f.create_issue()
    f.MembershipFactory(project=issue1.project, user=issue1.owner, is_admin=True)

    url = reverse("issue-attachments-list")

    data = {"description": "test",
            "object_id": issue1.pk,
            "project": issue1.project.id,
            "attached_file": SimpleUploadedFile(500*"x"+".txt", b"test")}

    client.login(issue1.owner)
    response = client.post(url, data)
    assert response.data["attached_file"].endswith("/"+100*"x"+".txt")

Example 14

Project: django-smuggler Source File: test_forms.py
    def test_valid_uppercase_file_extension(self):
        f = SimpleUploadedFile('valid.JSON', b'[]')
        form = ImportForm({}, {
            'uploads': f
        })
        self.assertTrue(form.is_valid())

Example 15

Project: wagtail Source File: test_admin_views.py
    @override_settings(DEFAULT_FILE_STORAGE='wagtail.tests.dummy_external_storage.DummyExternalStorage')
    def test_add_with_external_file_storage(self):
        response = self.post({
            'title': "Test image",
            'file': SimpleUploadedFile('test.png', get_test_image_file().file.getvalue()),
        })

        # Should redirect back to index
        self.assertRedirects(response, reverse('wagtailimages:index'))

        # Check that the image was created
        self.assertTrue(Image.objects.filter(title="Test image").exists())

Example 16

Project: PyClassLessons Source File: storage.py
    def test_reset_deletes_tmp_files(self):
        request = get_request()
        storage = self.get_storage()('wizard1', request, temp_storage)

        step = 'start'
        file_ = SimpleUploadedFile('file.txt', b'content')
        storage.set_step_files(step, {'file': file_})

        with storage.get_step_files(step)['file'] as file:
            tmp_name = file.name

        self.assertTrue(storage.file_storage.exists(tmp_name))

        storage.reset()
        storage.update_response(HttpResponse())
        self.assertFalse(storage.file_storage.exists(tmp_name))

Example 17

Project: wagtail Source File: tests.py
    def test_edit_file_upload_multipart(self):
        response = self.get()
        self.assertContains(response, 'enctype="multipart/form-data"')

        response = self.post(post_data={
            'file': SimpleUploadedFile('replacement.txt', b"Replacement docuement")})
        self.assertRedirects(response, reverse('wagtailsnippets:list',
                                               args=('snippetstests', 'fileuploadsnippet')))
        snippet = FileUploadSnippet.objects.get()
        self.assertEqual(snippet.file.read(), b"Replacement docuement")

Example 18

Project: oioioi Source File: tests.py
    def test_uploaded_file_name(self):
        tmp_file = TemporaryUploadedFile('whatever',
                'application/octet-stream', 0, 'utf-8')
        with utils.uploaded_file_name(tmp_file) as name:
            self.assertEquals(name, tmp_file.file.name)
        mem_file = SimpleUploadedFile('whatever', 'hello42')
        with utils.uploaded_file_name(mem_file) as name:
            self.assertTrue(name.endswith('whatever'))
            self.assertEqual(open(name, 'rb').read(), 'hello42')
        self.assertFalse(os.path.exists(name))

Example 19

Project: django-profile Source File: forms.py
Function: clean_url
    def clean_url(self):
        url = self.cleaned_data.get('url')
        if not url: return ''
        filename, headers = urllib.urlretrieve(url)
        if not mimetypes.guess_all_extensions(headers.get('Content-Type')):
            raise forms.ValidationError(_('The file type is invalid: %s' % type))
        return SimpleUploadedFile(filename, open(filename).read(), content_type=headers.get('Content-Type'))

Example 20

Project: pretix Source File: test_settings.py
    def test_serialize_file(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()

Example 21

Project: django-gitstorage Source File: test_storage.py
    def test_save_subtree(self):
        name = "foo/bar/baz/qux.txt"
        content = SimpleUploadedFile(name, b'qux')
        ret = self.storage.save(name, content)
        self.assertEqual(name, ret)

        # Introspect commit
        tree = self.storage.repository.open("foo/bar/baz")
        self.assertEqual(["qux.txt"], ls_tree(tree))
        blob = self.storage.repository[tree["qux.txt"].id]
        self.assertEqual(b"qux", blob.data)

Example 22

Project: reviewboard Source File: tests.py
    def make_uploaded_file(self):
        """Create a return a file to use for mocking in forms."""
        filename = os.path.join(settings.STATIC_ROOT,
                                'rb', 'images', 'logo.png')
        f = open(filename, 'r')
        uploaded_file = SimpleUploadedFile(f.name, f.read(),
                                           content_type='image/png')
        f.close()

        return uploaded_file

Example 23

Project: SmartElect Source File: test_forms.py
    def test_max_upload_errors(self):
        # We stop reporting upload errors beyond MAX_ERRORS
        data = self.data
        data['how_to_select'] = str(Changeset.SELECT_UPLOADED_NIDS)
        filetext = "1\n2\n3\n4\n"
        upload_file = SimpleUploadedFile('my_filename', filetext)
        form = ChangesetForm(data=data, files={'upload_file': upload_file}, request=MagicMock())
        with patch('changesets.forms.MAX_ERRORS', 1):
            self.assertFalse(form.is_valid())
        self.assertIn('upload_file', form.errors)
        self.assertIn('Stopping', str(form.errors))

Example 24

Project: pretix Source File: test_settings.py
    def test_unserialize_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()

Example 25

Project: SmartElect Source File: test_forms.py
    def test_upload_file_not_number(self):
        # We catch non-numbers in the upload file
        data = self.data
        data['how_to_select'] = str(Changeset.SELECT_UPLOADED_NIDS)
        citizen1 = CitizenFactory()
        citizen2 = CitizenFactory()
        nid1 = str(citizen1.national_id)
        nid1 = nid1[0] + '.' + nid1[2:]
        filetext = "{nid1}\n{nid2}\n".format(nid1=nid1, nid2=citizen2.national_id)
        upload_file = SimpleUploadedFile('my_filename', filetext)
        form = ChangesetForm(data=data, files={'upload_file': upload_file}, request=MagicMock())
        self.assertFalse(form.is_valid())
        self.assertIn('upload_file', form.errors)

Example 26

Project: django-dbsettings Source File: values.py
    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

Example 27

Project: SmartElect Source File: test_forms.py
    def test_upload_file_invalid_line(self):
        # We notice a file with too short a line
        data = self.data
        data['how_to_select'] = str(Changeset.SELECT_UPLOADED_NIDS)
        citizen1 = CitizenFactory()
        citizen2 = CitizenFactory()
        filetext = "1{nid1}\n{nid2}\n".format(nid1=citizen1.national_id, nid2=citizen2.national_id)
        upload_file = SimpleUploadedFile('my_filename', filetext)
        form = ChangesetForm(data=data, files={'upload_file': upload_file}, request=MagicMock())
        self.assertFalse(form.is_valid())
        self.assertIn('upload_file', form.errors)

Example 28

Project: taiga-back Source File: test_attachments.py
def test_create_attachment_on_wrong_project(client):
    issue1 = f.create_issue()
    issue2 = f.create_issue(owner=issue1.owner)
    f.MembershipFactory(project=issue1.project, user=issue1.owner, is_admin=True)

    assert issue1.owner == issue2.owner
    assert issue1.project.owner == issue2.project.owner

    url = reverse("issue-attachments-list")

    data = {"description": "test",
            "object_id": issue2.pk,
            "project": issue1.project.id,
            "attached_file": SimpleUploadedFile("test.txt", b"test")}

    client.login(issue1.owner)
    response = client.post(url, data)
    assert response.status_code == 400

Example 29

Project: django-smuggler Source File: test_forms.py
    def test_valid_file_extension(self):
        f = SimpleUploadedFile('valid.json', b'[]')
        form = ImportForm({}, {
            'uploads': f
        })
        self.assertTrue(form.is_valid())

Example 30

Project: gallery Source File: utils.py
Function: generate_thumbnail
def generate_thumbnail(file_field, size):
    """
    Generate a thumbnail from the given file_field and size.
    Returns a SimpleUploadedFile with the same name as the file_field.
    """
    handler = ImageHandler(file_field)
    return SimpleUploadedFile(handler.name, handler.resize(size))

Example 31

Project: pretix Source File: test_settings.py
    def test_autodetect_file_value_of_parent(self):
        val = SimpleUploadedFile("sample_invalid_image.jpg", b"file_content", content_type="image/jpeg")
        default_storage.save(val.name, val)
        val.close()
        self.organizer.settings.set('test', val)
        self.organizer.settings._flush()
        f = self.event.settings.get('test')
        self.assertIsInstance(f, File)
        self.assertTrue(f.name.endswith(val.name))
        f.close()

Example 32

Project: django-modelcluster Source File: test_serialize.py
    def test_serialise_saves_file_fields(self):
        doc = Docuement(title='Hello')
        doc.file = SimpleUploadedFile('hello.txt', b'Hello world')

        doc_json = doc.to_json()
        new_doc = Docuement.from_json(doc_json)

        self.assertEqual(new_doc.file.read(), b'Hello world')

Example 33

Project: django-smuggler Source File: test_forms.py
    def test_mix_valid_and_invalid(self):
        form = ImportForm({}, MultiValueDict({
            'uploads': [
                SimpleUploadedFile('valid.json', b'[]'),
                SimpleUploadedFile('invalid.txt', b'invalid')
            ]
        }))
        self.assertFalse(form.is_valid())
        self.assertEqual({'uploads': ["Invalid file extension: .txt."]},
                         form.errors)

Example 34

Project: wagtail Source File: test_admin_views.py
Function: test_upload
    def test_upload(self):
        response = self.client.post(reverse('wagtailimages:chooser_upload'), {
            'title': "Test image",
            'file': SimpleUploadedFile('test.png', get_test_image_file().file.getvalue()),
        })

        # Check response
        self.assertEqual(response.status_code, 200)

        # Check that the image was created
        images = Image.objects.filter(title="Test image")
        self.assertEqual(images.count(), 1)

        # Test that size was populated correctly
        image = images.first()
        self.assertEqual(image.width, 640)
        self.assertEqual(image.height, 480)

Example 35

Project: pinax-documents Source File: test_views.py
Function: test_download
    def test_download(self):
        """
        Ensure the requested Docuement file is served.
        """
        simple_file = SimpleUploadedFile("delicious.txt", self.file_contents)
        docuement = Docuement.objects.create(name="Honeycrisp",
                                           author=self.user,
                                           file=simple_file,
                                           )
        docuement.save()

        with self.login(self.user):
            # Verify `django.views.static.serve` is called to serve up the file.
            # See related note in .views.DocuementDownload.get().
            with mock.patch("django.views.static.serve") as serve:
                serve.return_value = HttpResponse()
                self.get_check_200(self.download_urlname, pk=docuement.pk)
                self.assertTrue(serve.called)

Example 36

Project: wagtail Source File: tests.py
    def test_create_file_upload_multipart(self):
        response = self.get(model=FileUploadSnippet)
        self.assertContains(response, 'enctype="multipart/form-data"')

        response = self.post(model=FileUploadSnippet, post_data={
            'file': SimpleUploadedFile('test.txt', b"Uploaded file")})
        self.assertRedirects(response, reverse('wagtailsnippets:list',
                                               args=('snippetstests', 'fileuploadsnippet')))
        snippet = FileUploadSnippet.objects.get()
        self.assertEqual(snippet.file.read(), b"Uploaded file")

Example 37

Project: django-attachments Source File: base.py
    def _upload_testfile(self, file_obj=None):
        """
        Uploads a sample file for the given user.
        """
        add_url = reverse('attachments:add', kwargs={
            'app_label': 'testapp',
            'model_name': 'testmodel',
            'pk': self.obj.pk,
        })

        if not file_obj:
            file_obj = SimpleUploadedFile("avatar.jpg", b"file content",
                                          content_type="image/jpeg")
        return self.client.post(add_url, {'attachment_file': file_obj},
                                follow=True)

Example 38

Project: pootle Source File: import.py
def _import_file(file_name, file_dir=None,
                 content_type="text/x-gettext-translation",
                 user=None):
    if not file_dir:
        file_dir = os.path.join(
            os.path.dirname(pytest_pootle.__file__),
            "data/po/tutorial/en")

    with open(os.path.join(file_dir, file_name), "r") as f:
        import_file(
            SimpleUploadedFile(file_name, f.read(), content_type),
            user=user)

Example 39

Project: pycon Source File: test_forms.py
    def test_valid_receipt_png(self):
        """Checks form is valid with SimpleUploadeFile extension png."""
        # Use StringIO to create files
        png_file = StringIO.StringIO('portable network graphics file')
        # Use PIL Image to create new png and pdf files
        Image.new('RGB', size=(50, 50), color=(256, 0, 0)).save(png_file, 'png')
        png_file.seek(0)
        # Django-friendly ContentFiles
        file = SimpleUploadedFile('test_file.png', png_file.read())
        # Data for the form
        data_png = {'description': 'description png',
                    'amount': 1,
                    }
        files = {'receipt_image': file}

        form_png = ReceiptForm(data_png, files, instance=Receipt(application=self.application))

        self.assertTrue(form_png.is_valid(), msg=form_png.errors)
        form_png.save()

Example 40

Project: pootle Source File: store.py
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)

Example 41

Project: django-page-cms Source File: test_regression.py
    def test_get_filename_encoding_bug(self):
        """Problem with encoding file names"""
        placeholder = PlaceholderNode("placeholdername")
        page = self.new_page({'slug': 'page1'})
        fakefile = SimpleUploadedFile(name=u"АБВГДЕЖ.pdf", content=six.b('bytes'))
        filename = get_filename(page, placeholder, fakefile)
        self.assertTrue(fakefile.name.lower() in filename)
        self.assertTrue("page_%d" % page.id in filename)
        self.assertTrue(placeholder.name in filename)

Example 42

Project: pinax-documents Source File: test_views.py
    @mock.patch("django.contrib.messages.success")
    def test_post_create_without_folder(self, mock_messages):
        """
        Ensure POST creates docuement without a folder.
        """
        simple_file = SimpleUploadedFile("delicious.txt", self.file_contents)

        post_args = {"name": "file", "file": simple_file}
        with self.login(self.user):
            response = self.post(self.create_urlname, data=post_args, follow=True)
            self.response_200(response)
            created = self.get_context("object")
            self.assertFalse(created.folder)
            self.assertTrue(Docuement.objects.get(name=simple_file.name))
            self.assertTrue(mock_messages.called)

Example 43

Project: django-spillway Source File: test_models.py
    def test_save_uploadfile(self):
        upload = SimpleUploadedFile('up.tif', self.object.image.read())
        rstore = RasterStore(image=upload)
        rstore.save()
        self.assertTrue(default_storage.exists(rstore.image))
        self.assertEqual(rstore.image.size, self.f.size)

Example 44

Project: django-page-cms Source File: test_templates.py
    def test_get_filename_edge_case(self):
        placeholder = PlaceholderNode("placeholdername")
        page = self.new_page({'slug': 'page1'})
        fakefile = SimpleUploadedFile(name=u"hello<script>world", content=six.b('bytes'))
        filename = get_filename(page, placeholder, fakefile)
        self.assertNotIn('<', filename)

Example 45

Project: SmartElect Source File: test_forms.py
    def test_upload_file_empty(self):
        # We don't allow an empty file
        data = self.data
        data['how_to_select'] = str(Changeset.SELECT_UPLOADED_NIDS)
        filetext = ""
        upload_file = SimpleUploadedFile('my_filename', filetext)
        form = ChangesetForm(data=data, files={'upload_file': upload_file}, request=MagicMock())
        self.assertFalse(form.is_valid())
        self.assertIn('upload_file', form.errors)
        self.assertIn("The submitted file is empty.", str(form.errors))

Example 46

Project: pinax-documents Source File: test.py
    def test_can_have_duplicate_docuement_names_at_different_paths(self):
        simple_file = SimpleUploadedFile("delicious.txt", b"something tasty")
        foo = Folder.objects.create(name="Foo", author=self.user, modified_by=self.user)
        bar = Folder.objects.create(name="Bar", parent=foo, author=self.user, modified_by=self.user)
        Docuement.objects.create(name="Foo", author=self.user, file=simple_file, modified_by=self.user)
        Docuement.objects.create(name="Bar", folder=foo, author=self.user, file=simple_file, modified_by=self.user)
        Docuement.objects.create(name="Foo", folder=bar, author=self.user, file=simple_file, modified_by=self.user)
        with self.assertRaises(DuplicateDocuementNameError):
            Docuement.objects.create(name="Bar", folder=foo, author=self.user, file=simple_file, modified_by=self.user)

Example 47

Project: pinax-documents Source File: test_views.py
Function: test_detail
    def test_detail(self):
        """
        Ensure we can see docuement detail.
        """
        simple_file = SimpleUploadedFile("delicious.txt", self.file_contents)
        docuement = Docuement.objects.create(name="Honeycrisp",
                                           author=self.user,
                                           file=simple_file,
                                           )

        with self.login(self.user):
            self.get_check_200(self.detail_urlname, pk=docuement.pk)
            context_docuement = self.get_context("object")
            self.assertEqual(context_docuement, docuement)

Example 48

Project: pretix Source File: test_settings.py
    def test_autodetect_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')
        self.assertIsInstance(f, File)
        self.assertTrue(f.name.endswith(val.name))
        f.close()

Example 49

Project: django-smuggler Source File: test_forms.py
    def test_invalid_file_extension(self):
        f = SimpleUploadedFile('invalid.txt', b'invalid')
        form = ImportForm({}, {
            'uploads': f
        })
        self.assertFalse(form.is_valid())
        self.assertEqual({'uploads': ["Invalid file extension: .txt."]},
                         form.errors)

Example 50

Project: easy-thumbnails Source File: test_widgets.py
    def test_render_uploaded(self):
        """
        The widget treats UploadedFile as no input.

        Rationale:
        When widget is used in ModelForm and the form (submitted with upload)
        is not valid, widget should discard the value (just like standard
        Django ClearableFileInput does).
        """
        widget = widgets.ImageClearableFileInput()
        base_widget = ClearableFileInput()
        file_name = 'test.jpg'
        # storage=None to get raw content.
        image = self.create_image(None, file_name)
        upload_file = SimpleUploadedFile(file_name, image.getvalue())
        html = widget.render('photo', upload_file)
        base_html = base_widget.render('photo', upload_file)
        self.assertEqual(base_html, html)
        self.assertNotIn(file_name, html)   # Widget is empty.
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3 Page 4