Python webtest.Upload() Examples

def test_import_stock_invalid_csv(staffapp, tmpdir):
    source = tmpdir.join('stock.csv')
    source.write(
        'module,name\n'
        'digital,Auriculaire\n'
        )

    response = staffapp.get(reverse('monitoring:stock_import'))
    form = response.forms['import']
    form['source'] = Upload(str(source), source.read_binary(), 'text/csv')
    response = form.submit()
    assert response.status_code == 302
    assert response.location.endswith(reverse('monitoring:stock'))

    response = response.follow()
    assert response.status_code == 200
    assert 'Successfully imported {} elements' not in response.text
    assert 'Missing column "description" on line 1' in response.text
    assert 'Auriculaire' not in response.text

    assert not StockItem.objects.exists() 

def test_create(self, import_tool, siu):
        project = M.Project.query.get(shortname='test')
        params = {
            'discussions_json': webtest.Upload('discussions.json',
                                               b'{"key": "val"}'),
            'mount_label': 'mylabel',
            'mount_point': 'mymount',
        }
        r = self.app.post('/p/test/admin/ext/import/forge-discussion/create', params, status=302)
        self.assertEqual(r.location, 'http://localhost/p/test/admin/')
        siu.assert_called_once_with(project,
                                    'discussions.json',
                                    '{"key": "val"}'
                                    )
        self.assertEqual('mymount', import_tool.post.call_args[1]['mount_point'])
        self.assertEqual('mylabel', import_tool.post.call_args[1]['mount_label']) 

def test_upload_authorized(self):
        response = self.app.get(
            '/election/2015/post/65808/dulwich-and-west-norwood',
            user=self.user_who_can_upload_documents
        )
        self.assertIn(
            'As you have permission to upload documents',
            response.text
        )
        response = self.app.get(
            reverse('upload_document_view', args=('2015', self.post_extra.slug)),
            user=self.user_who_can_upload_documents,
        )
        form = response.forms['document-upload-form']
        form['source_url'] = 'http://example.org/foo'
        with open(self.example_image_filename, 'rb') as f:
            form['uploaded_file'] = Upload('pilot.jpg', f.read())
        form.submit()
        self.assertEqual(response.status_code, 200)
        ods = OfficialDocument.objects.all()
        self.assertEqual(ods.count(), 1)
        od = ods[0]
        self.assertEqual(od.source_url, 'http://example.org/foo')
        self.assertEqual(od.post.extra.slug, '65808') 

def test_import_from_ideascube_export(staffapp, monkeypatch):
    expected = {
        'isbn': '123456',
        'authors': 'Marcel Pagnol',
        'serie': "L'Eau des collines",
        'name': 'Jean de Florette',
        'description': u"Les Bastides Blanches, c'était une paroisse de cent cinquante habitants, perchée sur la proue de l'un des derniers contreforts du massif de l'Étoile, à deux lieues d'Aubagne… Une route de terre y conduisait par une montée si abrupte que de loin elle paraissait verticale : mais du côté des collines il n'en sortait qu'un chemin muletier d'où partaient quelques sentiers qui menaient au ciel.",  # noqa
        'publisher': u'Éditions de Provence',
        'lang': 'fr',
    }
    BookFactory(**expected)
    resp = staffapp.get(reverse('library:book_export'))
    Book.objects.all().delete()
    form = staffapp.get(reverse('library:book_import')).forms['import']
    form['files_format'] = 'ideascube'
    form['from_files'] = Upload('archive.zip', resp.content,
                                'application/zip')
    response = form.submit()
    response.follow()
    assert Book.objects.count()
    book = Book.objects.last()
    for name, value in expected.items():
        assert getattr(book, name) == value
    assert book.cover 

def test_import_from_invalid_format(staffapp, settings):
    settings.USER_IMPORT_FORMATS = (
        ('llavedelsaber', 'Llave del Saber'),
        ('ideascube', 'Ideascube'),
    )
    data = 'whatever, this will not be imported'

    form = staffapp.get(reverse('user_import')).forms['import']
    form['format'].force_value('no-such-format')
    form['source'] = Upload('users.csv', data.encode('utf-8'), 'text/csv')
    response = form.submit(status=200)
    assert (
        'Select a valid choice. no-such-format is not one of the available '
        'choices.') in response.text

    users = User.objects.all()
    assert users.count() == 1  # The staff 

def test_import_from_llavedelsaber_format_invalid_data(staffapp, settings):
    settings.USER_IMPORT_FORMATS = (
        ('llavedelsaber', 'Llave del Saber'),
        ('ideascube', 'Ideascube'),
    )

    # TODO: The format of Llave del Saber exports is not finalized
    data = '\n'.join([
        '"llave";"a_field";"another_field";"a_third_field";"last_field"',
        '"206678478";"";"";"";""',
        '"206678201";"";"";"";""',
    ])

    form = staffapp.get(reverse('user_import')).forms['import']
    form['format'] = 'llavedelsaber'
    form['source'] = Upload('users.csv', data.encode('utf-8'), 'text/csv')
    response = form.submit(status=302).follow(status=200)
    assert 'Invalid row at line 1: serial missing' in response.text
    assert 'Invalid row at line 2: serial missing' in response.text

    users = User.objects.all()
    assert users.count() == 1  # The staff 

def test_import_from_llavedelsaber_format(staffapp, settings):
    settings.USER_IMPORT_FORMATS = (
        ('llavedelsaber', 'Llave del Saber'),
        ('ideascube', 'Ideascube'),
    )

    # TODO: The format of Llave del Saber exports is not finalized
    data = '\n'.join([
        '"serial";"a_field";"another_field";"a_third_field";"last_field"',
        '"206678478";"";"";"";""',
        '"206678201";"";"";"";""',
    ])

    form = staffapp.get(reverse('user_import')).forms['import']
    form['format'] = 'llavedelsaber'
    form['source'] = Upload('users.csv', data.encode('utf-8'), 'text/csv')
    form.submit(status=302).follow(status=200)

    users = User.objects.all().order_by('serial')
    assert users.count() == 3  # The two imported, plus the staff

    # TODO: Test the other imported fields eventually
    serials = [u.serial for u in users]
    assert serials == ['123456staff', '206678201', '206678478'] 

def test_should_not_replace_is_staff(staffapp, monkeypatch):
    data = (b'serial,full_name,is_staff\n'
            b'12345,Gabriel Garcia Marquez,True\n'
            b'23456,Miguel de Cervantes,False')
    UserFactory(serial='12345', is_staff=False)
    UserFactory(serial='23456', is_staff=True)
    form = staffapp.get(reverse('user_import')).forms['import']
    form['source'] = Upload('users.csv', data, 'text/csv')
    response = form.submit()
    response.follow()
    user = User.objects.order_by('pk')[1]
    assert user.serial == '12345'
    assert user.full_name == 'Gabriel Garcia Marquez'
    assert user.is_staff is False
    user = User.objects.order_by('pk')[2]
    assert user.is_staff is True
    assert user.full_name == 'Miguel de Cervantes' 

def test_should_import_boolean(staffapp, monkeypatch):
    # True/False is how we do export the data, so let's accept this in input
    # too.
    data = (b'serial,full_name,is_sent_to_school\n'
            b'12345,Gabriel Garcia Marquez,True\n'
            b'23456,Miguel de Cervantes,False')
    form = staffapp.get(reverse('user_import')).forms['import']
    form['source'] = Upload('users.csv', data, 'text/csv')
    response = form.submit()
    response.follow()
    assert User.objects.count() == 3
    user = User.objects.order_by('pk')[1]
    assert user.serial == '12345'
    assert user.is_sent_to_school is True
    user = User.objects.order_by('pk')[2]
    assert user.serial == '23456'
    assert user.is_sent_to_school is False 

def test_should_create_users(staffapp, monkeypatch):
    data = (b'serial,full_name\n'
            b'12345,Gabriel Garcia Marquez\n'
            b'23456,Miguel de Cervantes')
    form = staffapp.get(reverse('user_import')).forms['import']
    form['source'] = Upload('users.csv', data, 'text/csv')
    response = form.submit()
    response = response.follow()
    assert User.objects.count() == 3  # Two users created plus the staff user.
    response.mustcontain('Successfully processed 2 users.')
    user = User.objects.order_by('pk')[1]
    assert user.serial == '12345'
    assert user.full_name == 'Gabriel Garcia Marquez'
    user = User.objects.order_by('pk')[2]
    assert user.serial == '23456'
    assert user.full_name == 'Miguel de Cervantes' 

def test_guess_kind_when_editing_without_changing_original(staffapp):
    assert not Document.objects.count()
    url = reverse('mediacenter:document_create')
    form = staffapp.get(url).forms['model_form']
    form['title'] = 'my document title'
    form['summary'] = 'my document summary'
    form['credits'] = 'my document credits'
    form['original'] = Upload('audio.mp3', b'xxxxxx', 'audio/mpeg')
    form['kind'] = Document.OTHER
    form.submit().follow()

    assert Document.objects.count() == 1
    document = Document.objects.first()
    assert document.kind == Document.AUDIO

    # Now edit again, only resetting the `kind` to 'other'
    url = reverse('mediacenter:document_update', kwargs={'pk': document.pk})
    form = staffapp.get(url).forms['model_form']
    form['kind'] = Document.OTHER
    form.submit().follow()
    assert Document.objects.count() == 1
    assert Document.objects.first().kind == Document.AUDIO 

def test_can_create_document_without_lang(staffapp):
    assert not Document.objects.count()
    url = reverse('mediacenter:document_create')
    form = staffapp.get(url).forms['model_form']
    form['title'] = 'my document title'
    form['summary'] = 'my document summary'
    form['credits'] = 'my document credits'
    form['original'] = Upload('image.jpg', b'xxxxxx', 'image/jpeg')
    form['lang'] = ''
    form.submit().follow()
    assert Document.objects.count() == 1 

def test_create_topic_attachment(self):
        r = self.app.get('/discussion/create_topic/')
        form = self.fill_new_topic_form(r)
        for field in form.fields.values():
            field = field[0]
            if field.id is None:
                continue
            if 'attachment' in field.id:
                form[field.name] = ('myfile.txt', b'foo bar baz')  # webtest.Upload dooesn't work here
        r = form.submit().follow()
        assert 'myfile.txt' in r, r 

def test_create_limit(self, import_tool, sui):
        project = M.Project.query.get(shortname='test')
        project.set_tool_data('ForgeTrackerImporter', pending=1)
        ThreadLocalORMSession.flush_all()
        params = {
            'tickets_json': webtest.Upload('tickets.json', b'{"key": "val"}'),
            'mount_label': 'mylabel',
            'mount_point': 'mymount',
        }
        r = self.app.post('/p/test/admin/bugs/_importer/create', params,
                          status=302).follow()
        self.assertIn('Please wait and try again', r)
        self.assertEqual(import_tool.post.call_count, 0) 

def test_create(self, import_tool, sui):
        project = M.Project.query.get(shortname='test')
        params = {
            'tickets_json': webtest.Upload('tickets.json', b'{"key": "val"}'),
            'mount_label': 'mylabel',
            'mount_point': 'mymount',
        }
        r = self.app.post('/p/test/admin/bugs/_importer/create', params,
                          status=302)
        self.assertEqual(r.location, 'http://localhost/p/test/admin/')
        sui.assert_called_once_with(project, 'tickets.json', '{"key": "val"}')
        self.assertEqual(
            'mymount', import_tool.post.call_args[1]['mount_point'])
        self.assertEqual(
            'mylabel', import_tool.post.call_args[1]['mount_label']) 

def test_create_limit(self, import_tool, siu):
        project = M.Project.query.get(shortname='test')
        project.set_tool_data('ForgeDiscussionImporter', pending=1)
        ThreadLocalORMSession.flush_all()
        params = {
            'discussions_json': webtest.Upload('discussions.json', b'{"key": "val"}'),
            'mount_label': 'mylabel',
            'mount_point': 'mymount',
        }
        r = self.app.post('/p/test/admin/ext/import/forge-discussion/create',
                          params,
                          status=302).follow()
        self.assertIn('Please wait and try again', r)
        self.assertEqual(import_tool.post.call_count, 0) 

def test_import_stock(staffapp, tmpdir):
    source = tmpdir.join('stock.csv')
    source.write_text(
        'module,name,description\n'
        'cinema,C\'est arrivé près de chez vous,"Conte féérique pour les '
        'petits et les grands, le film relate les aventures de Benoît, preux '
        'chevalier en quête de justice, et des ménestrels Rémy, André et '
        'Patrick.\n\nBenoît parviendra-t-il à leur enseigner le principe de '
        'la poussée d\'Archimède ? Patrick reverra-t-il Marie-Paule ?"\n'
        'notamodule,Not a name,This is not a description.\n',
        encoding='utf-8')

    response = staffapp.get(reverse('monitoring:stock_import'))
    form = response.forms['import']
    form['source'] = Upload(str(source), source.read_binary(), 'text/csv')
    response = form.submit()
    assert response.status_code == 302
    assert response.location.endswith(reverse('monitoring:stock'))

    response = response.follow()
    assert response.status_code == 200
    assert 'Successfully imported 1 items' in response.text
    assert 'C'est arrivé près de chez vous' in response.text
    assert 'Could not import line 2: ' in response.text
    assert 'Not a name' not in response.text

    assert StockItem.objects.count() == 1
    movie = StockItem.objects.last()
    assert movie.name == "C'est arrivé près de chez vous"
    assert movie.module == 'cinema'
    assert movie.description == (
        'Conte féérique pour les petits et les grands, le film relate les '
        'aventures de Benoît, preux chevalier en quête de justice, et des '
        'ménestrels Rémy, André et Patrick.\n\nBenoît parviendra-t-il à leur '
        'enseigner le principe de la poussée d\'Archimède ? Patrick '
        'reverra-t-il Marie-Paule ?') 

def test_can_create_document(staffapp):
    assert not Document.objects.count()
    url = reverse('mediacenter:document_create')
    form = staffapp.get(url).forms['model_form']
    form['title'] = 'my document title'
    form['summary'] = 'my document summary'
    form['credits'] = 'my document credits'
    form['original'] = Upload('image.jpg', b'xxxxxx', 'image/jpeg')
    form.submit().follow()
    assert Document.objects.count() == 1
    doc = Document.objects.first()
    assert doc.kind == Document.IMAGE 

def test_upload_unauthorized(self):
        response = self.app.get(
            '/election/2015/post/65808/dulwich-and-west-norwood',
            user=self.user
        )
        csrftoken = self.app.cookies['csrftoken']
        upload_url = reverse(
            'upload_document_view',
            kwargs={'election': '2015', 'post_id': self.post_extra.slug}
        )
        with open(self.example_image_filename, 'rb') as f:
            response = self.app.post(
                upload_url,
                {
                    'csrfmiddlewaretoken': csrftoken,
                    'post_id': self.post_extra.slug,
                    'document_type': OfficialDocument.NOMINATION_PAPER,
                    'source_url': 'http://example.org/foo',
                    '': Upload('pilot.jpg', f.read())
                },
                user=self.user,
                expect_errors=True,
            )
        self.assertEqual(response.status_code, 403)
        self.assertIn(
            'You must be in the member of a particular group in order to view that page',
            response.text
        ) 

def test_photo_upload(self):
        queued_images = QueuedImage.objects.all()
        initial_count = queued_images.count()
        upload_form_url = reverse(
            'photo-upload',
            kwargs={'person_id': '2009'}
        )
        form_page_response = self.app.get(
            upload_form_url,
            user=self.test_upload_user
        )
        form = form_page_response.forms['person-upload-photo']
        with open(self.example_image_filename, 'rb') as f:
            form['image'] = Upload('pilot.jpg', f.read())
        form['why_allowed'] = 'copyright-assigned'
        form['justification_for_use'] = 'I took this photo'
        upload_response = form.submit()
        self.assertEqual(upload_response.status_code, 302)
        split_location = urlsplit(upload_response.location)
        self.assertEqual('/moderation/photo/upload/2009/success', split_location.path)
        queued_images = QueuedImage.objects.all()
        self.assertEqual(initial_count + 1, queued_images.count())
        queued_image = queued_images.last()
        self.assertEqual(queued_image.decision, 'undecided')
        self.assertEqual(queued_image.why_allowed, 'copyright-assigned')
        self.assertEqual(
            queued_image.justification_for_use,
            'I took this photo'
        )
        self.assertEqual(queued_image.person.id, 2009)
        self.assertEqual(queued_image.user, self.test_upload_user) 

def test_import_book_specimens_without_csv(staffapp, tmpdir):
    zip_path = tmpdir.join('specimens.zip')

    with zipfile.ZipFile(str(zip_path), mode='w') as zip:
        zip.writestr('2.epub', b'Trust me, this is an epub')

    form = staffapp.get(reverse('library:specimen_import')).forms['import']
    form['source'] = Upload(
        zip_path.basename, zip_path.read_binary(), 'application/zip')
    response = form.submit()
    assert response.status_int == 200
    assert 'Archive does not contain a CSV' in response
    assert BookSpecimen.objects.count() == 0 

def test_when_only_file_is_set_specimen_is_created_as_digital(staffapp, book):
    url = reverse('library:specimen_create', kwargs={'book_pk': book.pk})
    form = staffapp.get(url).forms['model_form']
    assert not book.specimens.count()
    form['file'] = Upload('ideascube/library/tests/data/test-digital')
    form.submit()
    assert book.specimens.count()
    assert not BookSpecimen.objects.last().physical 

def test_cannot_create_digital_specimen_when_barcode_and_file_are_set(staffapp,
                                                                      book):
    url = reverse('library:specimen_create', kwargs={'book_pk': book.pk})
    form = staffapp.get(url).forms['model_form']
    assert not book.specimens.count()
    form['barcode'] = '123456'
    form['file'] = Upload('ideascube/library/tests/data/test-digital')
    form.submit()
    assert not book.specimens.count() 

def test_can_create_app_document(staffapp):
    assert not Document.objects.count()
    url = reverse('mediacenter:document_create')
    form = staffapp.get(url).forms['model_form']
    form['title'] = 'my document title'
    form['summary'] = 'my document summary'
    form['credits'] = 'my document credits'
    form['kind'] = Document.APP
    form['original'] = Upload('soft.exe', b'xxxxxx',
                              'application/x-msdos-program')
    form.submit().follow()
    assert Document.objects.count() == 1
    doc = Document.objects.first()
    assert doc.kind == Document.APP 

def test_import_from_files_load_cover_if_exists(staffapp, monkeypatch):
    assert Book.objects.count() == 0
    image = 'ideascube/tests/data/the-prophet.jpg'
    monkeypatch.setattr(
        'ideascube.library.utils.read_url',
        lambda x: open(image, 'rb').read()
    )
    form = staffapp.get(reverse('library:book_import')).forms['import']
    form['from_files'] = Upload('ideascube/library/tests/data/moccam.csv')
    response = form.submit()
    response.follow()
    assert Book.objects.count() == 2
    assert Book.objects.last().cover
    assert open(Book.objects.last().cover.path, 'rb').read() == open(image, 'rb').read() 

def test_import_from_files_does_not_duplicate(staffapp, monkeypatch):
    monkeypatch.setattr('ideascube.library.utils.read_url', lambda x: None)
    path = 'ideascube/library/tests/data/moccam.csv'
    with open(path, encoding='utf-8') as f:
        isbn = f.read().split('\t')[0]
    # Create a book with same isbn as first entry of CSV.
    BookFactory(isbn=isbn)
    form = staffapp.get(reverse('library:book_import')).forms['import']
    form['from_files'] = Upload(path)
    response = form.submit()
    response.follow()
    assert Book.objects.count() == 2 

def test_content_summary_is_not_cleaned_from_wanted_html_tags(staffapp):
    url = reverse('mediacenter:document_create')
    form = staffapp.get(url).forms['model_form']
    form['title'] = 'my content title'
    form['summary'] = 'my content summary <a href="foo">link</a>'
    form['credits'] = 'my document credits'
    form['original'] = Upload('image.jpg', b'xxxxxx', 'image/jpeg')
    form.submit().follow()
    document = Document.objects.first()
    assert document.summary == ('my content summary <a href="foo">link</a>') 

def test_guess_kind_when_creating(staffapp, filename, content_type, expected):
    assert not Document.objects.count()
    url = reverse('mediacenter:document_create')
    form = staffapp.get(url).forms['model_form']
    form['title'] = 'my document title'
    form['summary'] = 'my document summary'
    form['credits'] = 'my document credits'
    form['original'] = Upload(filename, b'xxxxxx', content_type)
    form['lang'] = ''
    form.submit().follow()
    assert Document.objects.count() == 1
    assert Document.objects.first().kind == expected 

def test_does_not_try_to_create_system_user(staffapp, monkeypatch):
    qs = User.objects.get_queryset_unfiltered()
    assert qs.count() == 2
    data = (b'serial,full_name,unknown\n'
            b'__system__,ANewFunkyName,xxxx')
    form = staffapp.get(reverse('user_import')).forms['import']
    form['source'] = Upload('users.csv', data, 'text/csv')
    response = form.submit()
    response.follow()
    assert qs.count() == 2
    user = qs.get(serial='__system__')
    assert user.full_name != 'ANewFunkyName' 

def test_should_not_change_password(staffapp, monkeypatch):
    data = (b'serial,full_name,password\n'
            b'12345,Gabriel Garcia Marquez,123456')
    before = UserFactory(serial='12345', is_staff=False)
    form = staffapp.get(reverse('user_import')).forms['import']
    form['source'] = Upload('users.csv', data, 'text/csv')
    response = form.submit()
    response.follow()
    user = User.objects.order_by('pk')[1]
    assert user.serial == '12345'
    assert user.full_name == 'Gabriel Garcia Marquez'
    assert user.password == before.password