def test_get_break(testapp, session):
sid = session['id']
resp = testapp.post(
'/sessions/{}/files'.format(sid),
dict(file=Upload('foobar.py', b'print 123'), ),
status=201,
)
file_id = resp.json['file']['id']
resp = testapp.post(
'/sessions/{}/breaks'.format(sid),
dict(
lineno='123',
file_id=file_id,
local_vars=Upload('local_vars',
json.dumps(dict(
foo='bar',
eggs='spam',
))),
),
status=201,
)
break_ = resp.json['break']
resp = testapp.get('/breaks/{}'.format(break_['id']))
assert resp.json['break'] == break_
def test_product_images_upload(self):
page = self.get(self.url)
product_form = page.form
product_form['images-0-original'] = Upload(
'image1.png', self.generate_test_image('image1.png'), 'image/png')
product_form['images-1-original'] = Upload(
'image2.png', self.generate_test_image('image2.png'), 'image/png')
product_form.submit(name='action', value='continue').follow()
self.product = Product.objects.get(pk=self.product.id)
self.assertEqual(self.product.images.count(), 2)
page = self.get(self.url)
product_form = page.form
product_form['images-2-original'] = Upload(
'image3.png', self.generate_test_image('image3.png'), 'image/png')
product_form.submit()
self.product = Product.objects.get(pk=self.product.id)
self.assertEqual(self.product.images.count(), 3)
images = self.product.images.all()
self.assertEqual(images[0].original.name,
os.path.join(self.image_folder, 'image1.png'))
self.assertEqual(images[0].display_order, 0)
self.assertEqual(images[1].original.name,
os.path.join(self.image_folder, 'image2.png'))
self.assertEqual(images[1].display_order, 1)
self.assertEqual(images[2].original.name,
os.path.join(self.image_folder, 'image3.png'))
self.assertEqual(images[2].display_order, 2)
def test_create_break(testapp, session):
sid = session['id']
resp = testapp.post(
'/sessions/{}/files'.format(sid),
dict(file=Upload('foobar.py', b'print 123'), ),
status=201,
)
file_id = resp.json['file']['id']
resp = testapp.post(
'/sessions/{}/breaks'.format(sid),
dict(
lineno='123',
file_id=file_id,
local_vars=Upload('local_vars',
json.dumps(dict(
foo='bar',
eggs='spam',
))),
),
status=201,
)
assert resp.json['break']['id'].startswith('BK')
assert resp.json['break']['file'] == file_id
assert resp.json['break']['lineno'] == 123
local_vars = json.loads(resp.json['break']['local_vars'].decode('base64'))
assert local_vars == dict(
foo='bar',
eggs='spam',
)
def test_create_encrypted_break(testapp, encrypted_session):
sid = encrypted_session['id']
resp = testapp.post(
'/sessions/{}/files'.format(sid),
dict(
file=Upload('foobar.py', b'print 123'),
aes_iv=Upload('aes_iv', b'0123456789ABCDEF'),
),
status=201,
)
file_id = resp.json['file']['id']
resp = testapp.post(
'/sessions/{}/breaks'.format(sid),
dict(
lineno='123',
file_id=file_id,
local_vars=Upload('local_vars',
json.dumps(dict(
foo='bar',
eggs='spam',
))),
aes_iv=Upload('aes_iv', b'0123456789ABCDEF'),
),
status=201,
)
assert resp.json['break']['aes_iv'].decode('base64') == b'0123456789ABCDEF'
def test_product_update_attribute_values(self):
page = self.get(self.url)
product_form = page.form
# Send string field values due to an error
# in the Webtest during multipart form encode.
product_form['attr_text'] = 'test1'
product_form['attr_integer'] = '1'
product_form['attr_float'] = '1.2'
product_form['attr_boolean'] = 'yes'
product_form['attr_richtext'] = 'longread'
product_form['attr_date'] = '2016-10-12'
product_form['attr_file'] = Upload('file1.txt', b"test", 'text/plain')
product_form['attr_image'] = Upload(
'image1.png', self.generate_test_image('image1.png'), 'image/png')
product_form.submit()
# Reloading model instance to re-initiate ProductAttributeContainer
# with new attributes.
self.product = Product.objects.get(pk=self.product.id)
self.assertEqual(self.product.attr.text, 'test1')
self.assertEqual(self.product.attr.integer, 1)
self.assertEqual(self.product.attr.float, 1.2)
self.assertTrue(self.product.attr.boolean)
self.assertEqual(self.product.attr.richtext, 'longread')
self.assertEqual(self.product.attr.date, datetime.date(2016, 10, 12))
self.assertEqual(self.product.attr.file.name,
posixpath.join(self.image_folder, 'file1.txt'))
self.assertEqual(self.product.attr.image.name,
posixpath.join(self.image_folder, 'image1.png'))
page = self.get(self.url)
product_form = page.form
product_form['attr_text'] = 'test2'
product_form['attr_integer'] = '2'
product_form['attr_float'] = '5.2'
product_form['attr_boolean'] = ''
product_form['attr_richtext'] = 'article'
product_form['attr_date'] = '2016-10-10'
product_form['attr_file'] = Upload('file2.txt', b"test", 'text/plain')
product_form['attr_image'] = Upload(
'image2.png', self.generate_test_image('image2.png'), 'image/png')
product_form.submit()
self.product = Product.objects.get(pk=self.product.id)
self.assertEqual(self.product.attr.text, 'test2')
self.assertEqual(self.product.attr.integer, 2)
self.assertEqual(self.product.attr.float, 5.2)
self.assertFalse(self.product.attr.boolean)
self.assertEqual(self.product.attr.richtext, 'article')
self.assertEqual(self.product.attr.date, datetime.date(2016, 10, 10))
self.assertEqual(self.product.attr.file.name,
posixpath.join(self.image_folder, 'file2.txt'))
self.assertEqual(self.product.attr.image.name,
posixpath.join(self.image_folder, 'image2.png'))
def test_clone_should_override_file_from_original_object_on_submit_if_new_file_was_chosen(
self):
response = self.app.get(self.multimedia_url, user='******')
response.form['image'] = Upload('tests/files/img-2.jpg')
response.form['document'] = Upload('tests/files/file-2.txt')
response.form.submit()
multimedia = Multimedia.objects.latest('id')
assert 'images/img-2.jpg' == str(multimedia.image)
assert 'documents/file-2.txt' == str(multimedia.document)
def encrypted_session(testapp):
resp = testapp.post(
'/sessions',
dict(
encrypted='true',
validation_code='super_foobar',
encrypted_code=Upload('encrypted_code', b'encrypted'),
aes_iv=Upload('aes_iv', b'0123456789ABCDEF'),
),
)
return resp.json['session']
def test_photo_edition(
testclient,
slapd_server,
slapd_connection,
logged_user,
jpeg_photo,
):
# Add a photo
res = testclient.get("/profile/user", status=200)
res.form["jpegPhoto"] = Upload("logo.jpg", jpeg_photo)
res.form["jpegPhoto_delete"] = False
res = res.form.submit(name="action", value="edit", status=200)
assert "Profile updated successfuly." in res, str(res)
with testclient.app.app_context():
logged_user = User.get(dn=logged_user.dn, conn=slapd_connection)
assert [jpeg_photo] == logged_user.jpegPhoto
# No change
res = testclient.get("/profile/user", status=200)
res.form["jpegPhoto_delete"] = False
res = res.form.submit(name="action", value="edit", status=200)
assert "Profile updated successfuly." in res, str(res)
with testclient.app.app_context():
logged_user = User.get(dn=logged_user.dn, conn=slapd_connection)
assert [jpeg_photo] == logged_user.jpegPhoto
# Photo deletion
res = testclient.get("/profile/user", status=200)
res.form["jpegPhoto_delete"] = True
res = res.form.submit(name="action", value="edit", status=200)
assert "Profile updated successfuly." in res, str(res)
with testclient.app.app_context():
logged_user = User.get(dn=logged_user.dn, conn=slapd_connection)
assert [] == logged_user.jpegPhoto
# Photo deletion AND upload, this should never happen
res = testclient.get("/profile/user", status=200)
res.form["jpegPhoto"] = Upload("logo.jpg", jpeg_photo)
res.form["jpegPhoto_delete"] = True
res = res.form.submit(name="action", value="edit", status=200)
assert "Profile updated successfuly." in res, str(res)
with testclient.app.app_context():
logged_user = User.get(dn=logged_user.dn, conn=slapd_connection)
assert [] == logged_user.jpegPhoto
def test_clone_should_media_inlines_overrides_on_POST(self):
response = self.app.get(self.post_with_multimedia_url, user='******')
response.form['multimedia_set-0-image'] = Upload(
'tests/files/img-2.jpg')
response.form['multimedia_set-0-document'] = Upload(
'tests/files/file-2.txt')
response.form.submit()
post2 = Post.objects.get(title=self.post_with_multimedia.title +
' (duplicate)')
assert post2.multimedia_set.first().image.name == 'images/img-2.jpg'
assert post2.multimedia_set.first(
).document.name == 'documents/file-2.txt'
def test_create_encrypted_file(testapp, encrypted_session):
sid = encrypted_session['id']
resp = testapp.post(
'/sessions/{}/files'.format(sid),
dict(
file=Upload('foobar.py', b'print 123'),
aes_iv=Upload('aes_iv', b'0123456789ABCDEF'),
),
status=201,
)
assert resp.json['file']['id'].startswith('FL')
assert resp.json['file']['filename'] == 'foobar.py'
assert resp.json['file']['content'].decode('base64') == b'print 123'
assert resp.json['file']['aes_iv'].decode('base64') == b'0123456789ABCDEF'
def test_add_view(self):
xml_data = self.get_test_data("minimal.xml")
catalog = CatalogConfigFactory()
response = self.app.get(self.reverse_add_url(Job))
form = response.form
form["catalog"].select(value=catalog.id)
form["year"] = 2020
form["start_date"] = "2020-02-28"
form["close_published"] = True
form["source"] = Upload("export.xml", xml_data, "text/xml")
response = form.submit()
job = Job.objects.get()
self.assertEqual(job.year, 2020)
self.assertEqual(job.catalog, catalog)
self.assertEqual(job.start_date, date(2020, 2, 28))
self.assertEqual(job.close_published, True)
self.assertEqual(job.state, JobState.initialized)
self.assertEqual(job.source.read(), xml_data)
# verify we use Save & Continue to return to change page
self.assertRedirects(response, self.reverse_change_url(job))
def test_set_avatar(self):
""" Test if user avatar setting succeeds """
username = '******'
for image in [
photo('static/sample-photo.png'),
photo('static/sample-photo.jpg')
]:
paulproteus_page = self.app.get('/people/%s/' % (username, ),
user=username)
settings_page = paulproteus_page.click(href='/account/settings/')
photo_page = settings_page.click(href='/account/edit/photo/')
photo_form = photo_page.form
photo_form['photo'] = Upload(image)
photo_form.submit()
# Now check that the photo == what we uploaded
p = Person.objects.get(user__username=username)
self.assert_(p.photo.read() == open(image).read())
response = self.login_with_client().get(
reverse(mysite.account.views.edit_photo))
self.assertEqual(
response.context[0]['photo_url'], p.photo.url,
"Test that once you've uploaded a photo via the "
"photo editor, the template's photo_url "
"variable is correct.")
self.assert_(p.photo_thumbnail)
thumbnail_as_stored = mysite.base.depends.Image.open(
p.photo_thumbnail.file)
w, h = thumbnail_as_stored.size
self.assertEqual(w, 40)
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_upload_existing(self, mock_get_by_id, mock_get, mock_delete,
mock_upload, mock_connection):
mock_get.return_value = create_mock_draft_file() # File already exists
mock_get_by_id.return_value = None # To confirm deletion happened
mock_upload.return_value = {}
mock_connection.return_value = create_mock_connection()
# Define payload
filename = 'myfile.rst'
content = 'bazbaz'
path = '54321'
payload = {'file': Upload(filename, content, 'text/x-rst')}
# Attempt to upload the file
url = api_url_for('dataverse_upload_file',
pid=self.project._primary_key,
path=path)
res = self.app.post(url, payload, auth=self.user.auth)
# Old file was deleted
mock_delete.assert_called_once
# File was uploaded
assert_equal(res.status_code, http.CREATED)
mock_upload.assert_called_once
# Parameters are correct
assert_equal(self.node_settings.study_hdl,
mock_upload.call_args[0][0].doi)
assert_equal(filename, mock_upload.call_args[0][1])
assert_equal(content, mock_upload.call_args[0][2])
assert_equal('file_updated', json.loads(res.body)['actionTaken'])
def test_upload_liasse_with_table(
app, lecture_essoc2018_an_nouvelle_lecture_commission_fond,
user_david):
from zam_repondeur.models import Lecture
resp = app.get("/lectures/an.15.806.PO744107/options", user=user_david)
form = resp.forms["import-liasse-xml"]
form["liasse"] = Upload(
"liasse.xml", (SAMPLE_DATA / "liasse_with_table.xml").read_bytes())
resp = form.submit()
assert resp.status_code == 302
assert resp.location == "https://zam.test/lectures/an.15.806.PO744107/amendements"
resp = resp.follow()
assert "3 nouveaux amendements récupérés (import liasse XML)." in resp.text
lecture = Lecture.get(
chambre=lecture_essoc2018_an_nouvelle_lecture_commission_fond.chambre,
session_or_legislature=
lecture_essoc2018_an_nouvelle_lecture_commission_fond.session, # noqa
num_texte=lecture_essoc2018_an_nouvelle_lecture_commission_fond.texte.
numero,
partie=None,
organe=lecture_essoc2018_an_nouvelle_lecture_commission_fond.organe,
)
assert ("<table>\n<tbody>\n<tr>\n<td>Durée minimale de services"
in lecture.amendements[1].corps)
assert ("<table>\n<tbody>\n<tr>\n<td>Durée minimale de services"
in lecture.amendements[0].expose)
def test_post_form_semicolumns(app, dummy_lecture, dummy_amendements):
from zam_repondeur.models import DBSession, Amendement
form = app.get(
"/lectures/an.15.269.PO717460/amendements/").forms["import-form"]
path = Path(__file__).parent / "sample_data" / "reponses_semicolumns.csv"
form["reponses"] = Upload("file.csv", path.read_bytes())
resp = form.submit()
assert resp.status_code == 302
assert resp.location == "http://localhost/lectures/an.15.269.PO717460/amendements/"
resp = resp.follow()
assert resp.status_code == 200
assert "2 réponses chargées" in resp.text
amendement = DBSession.query(Amendement).filter(
Amendement.num == 666).first()
assert amendement.avis == "Défavorable"
assert amendement.position == 1
assert "<strong>ipsum</strong>" in amendement.observations
assert "<blink>amet</blink>" not in amendement.observations
assert "<i>tempor</i>" in amendement.reponse
assert "<u>aliqua</u>" not in amendement.reponse
amendement = DBSession.query(Amendement).filter(
Amendement.num == 999).first()
assert amendement.observations.startswith("Lorem")
assert amendement.position == 2
def test_upload_liasse_success(
app, lecture_essoc2018_an_nouvelle_lecture_commission_fond,
user_david):
from zam_repondeur.models import Lecture
resp = app.get("/lectures/an.15.806.PO744107/options", user=user_david)
form = resp.forms["import-liasse-xml"]
form["liasse"] = Upload("liasse.xml",
(SAMPLE_DATA / "liasse.xml").read_bytes())
resp = form.submit()
assert resp.status_code == 302
assert resp.location == "https://zam.test/lectures/an.15.806.PO744107/amendements"
resp = resp.follow()
assert "3 nouveaux amendements récupérés (import liasse XML)." in resp.text
lecture = Lecture.get(
chambre=lecture_essoc2018_an_nouvelle_lecture_commission_fond.chambre,
session_or_legislature=
lecture_essoc2018_an_nouvelle_lecture_commission_fond.session, # noqa
num_texte=lecture_essoc2018_an_nouvelle_lecture_commission_fond.texte.
numero,
partie=None,
organe=lecture_essoc2018_an_nouvelle_lecture_commission_fond.organe,
)
assert lecture.events[0].render_summary() == (
"<abbr title='*****@*****.**'>[email protected]</abbr> a importé "
"une liasse XML : 3 nouveaux amendements récupérés.")
def test_can_be_added_in_the_dashboard(self):
fancy_page = factories.FancyPageFactory(node__name='Sample Page')
self.assertEquals(fancy_page.image, None)
im = Image.new("RGB", (320, 240), "red")
__, filename = tempfile.mkstemp(suffix='.jpg', dir=TEMP_IMAGE_DIR)
im.save(filename, "JPEG")
page = self.get(
reverse('fp-dashboard:page-update', args=(fancy_page.id,)))
settings_form = page.form
settings_form['image'] = Upload(filename)
list_page = settings_form.submit()
self.assertRedirects(list_page, reverse('fp-dashboard:page-list'))
# This bit is required because when using Oscar, the upload directory
# is defined by the category's image field and differs from the one on
# the PageNode.
upload_url = None
for field in get_node_model()._meta.fields:
if field.name == 'image':
upload_url = field.upload_to
break
pages_path = os.path.join(settings.MEDIA_ROOT, upload_url)
fancy_page = FancyPage.objects.get(id=fancy_page.id)
self.assertEquals(
fancy_page.image.path,
os.path.join(pages_path, filename.rsplit('/')[-1]))
def test_does_not_import_with_empty_serial(staffapp, monkeypatch):
data = (b'serial,full_name\n' b',Gabriel Garcia Marquez')
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() == 1 # The staff user only.
def test_import_from_files(staffapp, monkeypatch):
monkeypatch.setattr('ideasbox.library.utils.read_url', lambda x: None)
form = staffapp.get(reverse('library:book_import')).forms['import']
form['from_files'] = Upload('ideasbox/library/tests/data/moccam.csv')
response = form.submit()
response.follow()
assert Book.objects.count() == 2
def testFileUpload(self):
r = self.testApp.get('/FileUpload')
self.assertEqual(r.status, '200 OK')
r.mustcontain('<title>File Upload Example</title>',
'<h1>Upload Test</h1>',
'This servlet shows how to handle uploaded files.',
'<form action="FileUpload"',
'multipart/form-data',
'</form>',
no="Here's the file")
from webtest import Upload # pylint: disable=import-error
r.form['filename'] = Upload('README.txt', b'Hello from uploaded file!',
'text/plain')
r = r.form.submit()
r.mustcontain(
'<title>File Upload Example</title>',
'<h1>Upload Test</h1>',
"Here's the file you submitted:",
'<th>name</th><td><strong>README.txt</strong></td>',
'<tr><th>disposition</th><td>form-data</td></tr>',
"<tr><th>disposition_options</th><td>"
"{'name': 'filename', 'filename': 'README.txt'}</td></tr>",
'<tr><th>headers</th><td>Content-Disposition: form-data;'
' name="filename"; filename="README.txt"',
'Content-Type: text/plain',
'<tr><th>size</th><td>25 bytes</td></tr>',
'<tr><th style="vertical-align:top">contents</th>',
'<pre style=',
'Hello from uploaded file!',
'</pre>',
no='<form')
def test_photo_upload_through_image_field(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-image"]
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_upload_too_small(self, mock_get, mock_delete, mock_upload,
mock_connection):
mock_get.return_value = create_mock_draft_file() # File already exists
mock_upload.return_value = {}
mock_connection.return_value = create_mock_connection()
# Define payload
filename = 'myfile.rst'
content = 'baz'
path = '54321'
payload = {'file': Upload(filename, content, 'text/x-rst')}
# Attempt to upload the file
url = api_url_for('dataverse_upload_file',
pid=self.project._primary_key,
path=path)
res = self.app.post(url,
payload,
auth=self.user.auth,
expect_errors=True)
# Old file was not deleted
assert_false(mock_delete.call_count)
# Bad request
assert_equal(res.status_code, http.UNSUPPORTED_MEDIA_TYPE)
assert_false(mock_upload.call_count)
def test_upload_liasse_success(
app, lecture_essoc2018_an_nouvelle_lecture_commission_fond,
user_david):
from zam_repondeur.models import DBSession, Lecture
with transaction.manager:
DBSession.add(user_david)
resp = app.get(
"/dossiers/etat-service-societe-confiance/lectures/an.15.806.PO744107/options",
user=user_david,
)
form = resp.forms["import-liasse-xml"]
form["liasse"] = Upload("liasse.xml",
(SAMPLE_DATA / "liasse.xml").read_bytes())
resp = form.submit()
assert resp.status_code == 302
assert resp.location == ("https://zam.test/"
"dossiers/etat-service-societe-confiance/"
"lectures/an.15.806.PO744107/"
"amendements/")
resp = resp.follow()
assert "3 nouveaux amendements récupérés (import liasse XML)." in resp.text
lecture = Lecture.get_by_pk(
lecture_essoc2018_an_nouvelle_lecture_commission_fond.pk)
assert lecture.events[0].render_summary() == (
"<abbr title='*****@*****.**'>David</abbr> a importé "
"une liasse XML : 3 nouveaux amendements récupérés.")
def test_manager_site_import_error(app, db, superuser):
site_import = login(app, superuser, '/manage/site-import/')
form = site_import.form
site_export = {
'roles': [{
"description": "",
"service": None,
"name": "basic",
"attributes": [],
"ou": {
"slug": "unkown-ou",
"uuid": "ba60d9e6c2874636883bdd604b23eab2",
"name": "unkown ou"
},
"external_id": "",
"slug": "basic",
"uuid": "6eb7bbf64bf547119120f925f0e560ac"
}]
}
form['site_json'] = Upload('site_export.json', json.dumps(site_export),
'application/octet-stream')
res = form.submit()
assert res.status_code == 200
assert 'missing Organizational Unit' in res.text
Role = get_role_model()
with pytest.raises(Role.DoesNotExist):
Role.objects.get(slug='basic')
def test_upload_liasse_with_table(
app, lecture_essoc2018_an_nouvelle_lecture_commission_fond,
user_david):
from zam_repondeur.models import Lecture
resp = app.get(
"/dossiers/etat-service-societe-confiance/lectures/an.15.806.PO744107/options",
user=user_david,
)
form = resp.forms["import-liasse-xml"]
form["liasse"] = Upload(
"liasse.xml", (SAMPLE_DATA / "liasse_with_table.xml").read_bytes())
resp = form.submit()
assert resp.status_code == 302
assert resp.location == ("https://zam.test/"
"dossiers/etat-service-societe-confiance/"
"lectures/an.15.806.PO744107/"
"amendements/")
resp = resp.follow()
assert "3 nouveaux amendements récupérés (import liasse XML)." in resp.text
lecture = Lecture.get_by_pk(
lecture_essoc2018_an_nouvelle_lecture_commission_fond.pk)
assert ("<table>\n<tbody>\n<tr>\n<td>Durée minimale de services"
in lecture.amendements[1].corps)
assert ("<table>\n<tbody>\n<tr>\n<td>Durée minimale de services"
in lecture.amendements[0].expose)
def test_invalid_photo(self):
"""
If the uploaded image is detected as being invalid, report a helpful
message to the user. The photo is not added to the user's profile.
"""
username = '******'
bad_image = tempfile.NamedTemporaryFile(delete=False)
try:
bad_image.write("garbage")
bad_image.close()
paulproteus_page = self.app.get('/people/%s/' % (username, ),
user=username)
photo_page = paulproteus_page.click(href='/account/edit/photo/')
photo_form = photo_page.form
photo_form['photo'] = Upload(bad_image.name)
form_response = photo_form.submit()
self.assertEqual(form_response.status_code, 200)
self.assertIn(
"The file you uploaded was either not an image or "
"a corrupted image", form_response.content)
# Test that user test object has no photo attribute
p = Person.objects.get(user__username=username)
self.assertFalse(p.photo.name)
finally:
os.unlink(bad_image.name)
def test_upload_avatar(self, user, testapp, get_token):
res = testapp.post('/admin/upload_avatar',
dict(avatar=Upload('tests/test_avatar.png')),
headers=get_token)
assert res.status_code == 200
assert res.json['code'] == 0
assert 'fileurl' in res.json['data']
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_post_form_with_comments(app, dummy_lecture, dummy_amendements):
from zam_repondeur.models import DBSession, Amendement
form = app.get(
"/lectures/an.15.269.PO717460/amendements/").forms["import-form"]
path = Path(__file__).parent / "sample_data" / "reponses_with_comments.csv"
form["reponses"] = Upload("file.csv", path.read_bytes())
resp = form.submit()
assert resp.status_code == 302
assert resp.location == "http://localhost/lectures/an.15.269.PO717460/amendements/"
resp = resp.follow()
assert resp.status_code == 200
assert "2 réponses chargées" in resp.text
amendement = DBSession.query(Amendement).filter(
Amendement.num == 666).first()
assert amendement.position == 1
assert amendement.comments == "A comment"
amendement = DBSession.query(Amendement).filter(
Amendement.num == 999).first()
assert amendement.position == 2
assert amendement.comments == ""
