def test_visual_reupload_thumbnail_and_cover(app, submission_user):
# resized to be larger than COVER_SIZE so a cover is created
with BytesIO() as f:
read_asset_image('img/wesley1.png').resize(
(2200, 200)).save(f, format='PNG')
wesley1_large = webtest.Upload('wesley1.png', f.getvalue(),
'image/png')
with BytesIO() as f:
read_asset_image('img/help/wesley-jumpingtext.png').resize(
(2200, 100)).save(f, format='PNG')
wesley2_large = webtest.Upload('wesley-jumpingtext.png', f.getvalue(),
'image/png')
cookie = db_utils.create_session(submission_user)
# Create submission 1 with image 1
v1 = create_visual(app, submission_user, submitfile=wesley1_large)
# Reupload submission 1 with image 2
app.post('/reupload/submission', {
'targetid': u'%i' % (v1, ),
'submitfile': wesley2_large,
},
headers={
'Cookie': cookie
}).follow()
[thumb] = app.get('/~submissiontest').html.select('#user-thumbs img')
v1_new_thumbnail_url = thumb['src']
v1_new_cover_url = app.get('/~submissiontest/submissions/%i/test-title' %
(v1, )).html.find(id='detail-art').img['src']
# Remove submission 1, so uploading a duplicate image is allowed
app.post('/remove/submission', {
'submitid': u'%i' % (v1, ),
},
headers={
'Cookie': cookie
}).follow(headers={'Cookie': cookie})
# Upload submission 2 with image 2
v2 = create_visual(
app,
submission_user,
submitfile=wesley2_large,
)
[thumb] = app.get('/~submissiontest').html.select('#user-thumbs img')
v2_thumbnail_url = thumb['src']
v2_cover_url = app.get('/~submissiontest/submissions/%i/test-title' %
(v2, )).html.find(id='detail-art').img['src']
# The reupload of submission 1 should look like submission 2
assert _image_hash(
read_storage_image(v1_new_thumbnail_url)) == _image_hash(
read_storage_image(v2_thumbnail_url))
assert _image_hash(read_storage_image(v2_cover_url)) == _image_hash(
read_storage_image(v1_new_cover_url))
def test_post_multi(ngw_env, ngw_webtest_app):
resp = ngw_webtest_app.post(
'/api/component/file_upload/',
[['files[]', webtest.Upload(TEST_FILENAME, TEST_CONTENT)],
['files[]', webtest.Upload(TEST_FILENAME2, TEST_CONTENT2)]])
datafn, metafn = ngw_env.file_upload.get_filename(
resp.json['upload_meta'][0]['id'])
with open(datafn, 'rb') as fp:
assert fp.read() == TEST_CONTENT
datafn, metafn = ngw_env.file_upload.get_filename(
resp.json['upload_meta'][1]['id'])
with open(datafn, 'rb') as fp:
assert fp.read() == TEST_CONTENT2
def test_post_with_file_upload(self):
uploaded_file_name = 'test.txt'
uploaded_file_contents = to_bytes('test content file upload')
deform_upload_file_app = get_submit_app('deform',
deform_upload_fields_text)
app = webtest.TestApp(deform_upload_file_app)
display = app.post(
"/",
OrderedDict([('_charset_', ''), ('__formid__', 'deform'),
('title', 'testtitle'),
('__start__', 'fileupload:mapping'),
('fileupload',
webtest.Upload(uploaded_file_name,
uploaded_file_contents)),
('__end__', 'fileupload:mapping'),
('description', 'testdescription'),
('Submit', 'Submit')]))
self.assertIn(
"""
_charset_:
__formid__:deform
title:testtitle
__start__:fileupload:mapping
fileupload:test.txt:test content file upload
__end__:fileupload:mapping
description:testdescription
Submit:Submit""".strip(), display, display)
def test_download_file(self):
_ = self.app.post(
'/file',
{'f': webtest.Upload('あいうえお.txt', 'かきくけこ'.encode('utf-8'))},
content_type='multipart/form-data')
res = self.app.get('/download')
self.assertEqual('200 OK', res.status)
self.assertTrue('かきくけこ', res.body.decode('utf-8'))
def test_store_file(self):
res = self.app.post(
'/file',
{'f': webtest.Upload('あいうえお.txt', 'かきくけこ'.encode('utf-8'))},
content_type='multipart/form-data')
self.assertEqual('302 Found', res.status)
res = res.follow()
self.assertTrue(res.html.find(text=re.compile('あいうえお.txt')))
def test_post_single(ngw_env, ngw_webtest_app):
resp = ngw_webtest_app.post(
'/api/component/file_upload/',
dict(file=webtest.Upload(TEST_FILENAME, TEST_CONTENT)))
datafn, metafn = ngw_env.file_upload.get_filename(
resp.json['upload_meta'][0]['id'])
with open(datafn, 'rb') as fp:
assert fp.read() == TEST_CONTENT
def test_import_POST_nologin(django_app: wt.TestApp):
# https://docs.pylonsproject.org/projects/webtest/en/latest/api.html
excelfile = "anwesende/static/xlsx/roomdata-example.xlsx"
importpage = django_app.get(
reverse('room:import')) # can GET without login
form1 = importpage.form
form1['file'] = wt.Upload(excelfile)
resp = form1.submit().follow() # POST requires login: must redirect
assert resp.request.path == reverse('account_login')
def test_qiniu(app, auth_header, mocker):
mocker.patch('vision.controllers.qn.upload_storage', return_value="")
results = app.post('/api/v1/upload', {
'image': webtest.Upload('test.jpg', b'dummy content'),
},
headers=auth_header)
assert results.status == '200 OK'
assert results.json['data']['path'] == "http://"
def test_post(self):
ta = flask_webtest.TestApp(app)
resp = ta.get('/')
resp.form['csv_file'] = webtest.Upload(
'foo.csv',
b'foo, 2000-01-01\nbar, 1980-01-01',
content_type='text/csv')
resp = resp.form.submit()
assert resp.text == 'Age sum: 56'
def test_uploaded_document_is_attached_to_TripTemplate(self):
trips_year = self.init_trips_year()
tt = mommy.make(TripTemplate, trips_year=trips_year)
resp = self.app.get(tt.file_upload_url(), user=self.make_director())
resp.form['name'] = 'Map'
resp.form['file'] = webtest.Upload('map.txt', b'test data')
resp.form.submit()
tt.refresh_from_db()
files = tt.documents.all()
self.assertEqual(len(files), 1)
self.assertEqual(files[0].name, 'Map')
def test_encode_multipart_content_type(self):
data = self.app.encode_multipart(
[], [('file', 'data.txt', b'data', 'text/x-custom-mime-type')])
self.assertIn(to_bytes('Content-Type: text/x-custom-mime-type'),
data[-1])
data = self.app.encode_multipart(
[('file',
webtest.Upload('data.txt', b'data', 'text/x-custom-mime-type'))],
[])
self.assertIn(to_bytes('Content-Type: text/x-custom-mime-type'),
data[-1])
def test_female_age_limit_39(self):
ta = flask_webtest.TestApp(app)
resp = ta.get('/')
resp.form['csv_file'] = webtest.Upload(
'foo.csv',
b'foo, 2000-01-01\nbar, 1980-01-01\n,2010-01-01\nsuzy,1978-01-01,f',
content_type='text/csv'
)
resp = resp.form.submit()
assert resp.text == 'Age sum: 95'
def test_submission_view(app, submission_user):
submission = create_visual(
app,
submission_user,
submitfile=webtest.Upload('wesley1.png', read_asset('img/wesley1.png'),
'image/png'),
)
d.engine.execute(
'UPDATE submission SET unixtime = 1581092121 WHERE submitid = %(id)s',
id=submission)
resp_json = app.get('/api/submissions/%i/view' % (submission, )).json
media = resp_json.pop('media', None)
owner_media = resp_json.pop('owner_media', None)
assert resp_json == {
'comments': 0,
'description': '<p>Description</p>\n',
'embedlink': None,
'favorited': False,
'favorites': 0,
'folderid': None,
'folder_name': None,
'friends_only': False,
'link': 'http://localhost/submission/%i/test-title' % (submission, ),
'owner': 'submission_test',
'owner_login': '******',
'posted_at': '2020-02-07T21:15:21+00:00Z',
'rating': 'general',
'submitid': submission,
'subtype': 'visual',
'tags': ['bar', 'foo'],
'title': 'Test title',
'type': 'submission',
'views': 1,
}
assert set(media) == {
'thumbnail', 'submission', 'cover', 'thumbnail-generated-webp',
'thumbnail-generated'
}
assert type(media['submission'][0].pop('mediaid')) is int
assert set(media['submission'][0].pop('links')) == {'cover'}
assert media['submission'] == [{
'url':
'http://localhost/~submissiontest/submissions/%i/ca23760d8ca4bf6c2d721f5b02e389627b6b9181d5f323001f2d5801c086407b/submissiontest-test-title.png'
% (submission, ),
}]
assert owner_media == {
'avatar': [{
'mediaid': None,
'url': 'http://localhost/img/default-avatar-vuOx5v6OBn.jpg',
}],
}
def test_rating_accessibility(app, age):
submission_user = db_utils.create_user(
'submission_test', birthday=arrow.utcnow().shift(years=-age))
cookie = db_utils.create_session(submission_user)
def _post_expecting(form, expected_rating):
success = expected_rating is not None
resp = app.post('/submit/visual',
form,
headers={'Cookie': cookie},
status=303 if success else 422)
if success:
resp = resp.maybe_follow(headers={'Cookie': cookie})
assert "Rating: %s" % (expected_rating, ) in resp.html.find(
id='di-info').dl.text
else:
assert resp.html.find(
id='error_content'
).p.text == "The specified rating is invalid."
form = dict(
BASE_VISUAL_FORM,
rating=u'30',
submitfile=webtest.Upload('wesley1.png', read_asset('img/wesley1.png'),
'image/png'),
)
_post_expecting(form, 'Mature' if age >= 18 else None)
form['submitfile'] = webtest.Upload(
'wesley-jumpingtext.png',
read_asset('img/help/wesley-jumpingtext.png'), 'image/png')
form['rating'] = u'40'
_post_expecting(form, 'Explicit' if age >= 18 else None)
form['submitfile'] = webtest.Upload('wesley-draw.png',
read_asset('img/help/wesley-draw.png'),
'image/png')
form['rating'] = u'10'
_post_expecting(form, 'General')
def test_file_is_stored(self):
app = self.make_app()
form = app.get('/form').forms[0]
form['file'] = webtest.Upload(PATH_TO_FILE)
stored_filename = form.submit().text
stored_file_path = path.join(PATH_TO_STORAGE, stored_filename)
file_checksum = self.md5(PATH_TO_FILE)
stored_file_checksum = self.md5(stored_file_path)
assert file_checksum == stored_file_checksum
def test_form_upload(self):
app = build_test_app(TestService)
request = TestRequest(string='Test')
request = build_jsonrpc_request('testapi.test.upload', request)
response = app.post(
'/rpc', {
'request': request,
'upload': webtest.Upload('test.txt', 'Upload test')
})
self.assertEqual('Upload test',
json.loads(response.body)['result']['string'])
def test_triptemplate_documents_are_migrated(self):
trips_year = self.init_trips_year()
mommy.make(Timetable)
tt = mommy.make(TripTemplate, trips_year=trips_year)
resp = self.app.get(tt.file_upload_url(), user=self.make_director())
resp.form['name'] = 'Map'
resp.form['file'] = webtest.Upload('map.txt', b'test data')
resp.form.submit()
forward()
tt = TripTemplate.objects.get(trips_year=trips_year.year + 1)
files = tt.documents.all()
self.assertEqual(len(files), 1)
self.assertEqual(files[0].name, 'Map')
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', '{"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 testMyImagesForm(self):
"""As a registered user, when I load the "My Images" page I see a form that has
a file selection input and a button labelled "Upload Image".
"""
imagefilename = "iceland.jpg"
(password, nick, avatar) = self.users[0]
# login and then get the my images page
self.doLogin(nick, password)
response = self.app.get('/my')
# the page should contain an upload form
self.assertIn('uploadform', response.forms)
form = response.forms['uploadform']
# action should be /upload
self.assertEqual('/upload', form.action)
# try uploading a file
form['imagefile'] = webtest.Upload(imagefilename,
content_type='image/jpeg')
response = form.submit()
# expect a redirect to the /my page
self.assertIn(response.status, ['303 See Other', '302 Found'])
(_, _, path, _, _, _) = urlparse(response.headers['Location'])
self.assertEqual('/my', path)
# and when I retrieve that page I see my image at the top
response = self.app.get('/my')
flowtows = response.html.find_all(class_='flowtow')
# should find my image in the first one
div = flowtows[0]
img = div.find("img")
# should be the image src attribute
self.assertIn(imagefilename, img['src'])
# and we should be able to retrieve it
response = self.app.get(img['src'])
self.assertEqual("200 OK", response.status)
# remove the uploaded image
os.unlink('static/images/iceland.jpg')
def _character(app, db, character_user, no_csrf):
cookie = db_utils.create_session(character_user)
form = dict(
_BASE_FORM,
submitfile=webtest.Upload('wesley', read_asset('img/wesley1.png'),
'image/png'),
)
resp = app.post('/submit/character', form, headers={
'Cookie': cookie
}).follow(headers={'Cookie': cookie})
charid = int(resp.html.find('input', {'name': 'charid'})['value'])
return charid
def test_gif_thumbnail_static(app, submission_user):
create_visual(
app,
submission_user,
submitfile=webtest.Upload('loader.gif', read_asset('img/loader.gif'),
'image/gif'),
)
[thumb_compat
] = app.get('/~submissiontest').html.select('#user-thumbs img')
assert thumb_compat['src'].endswith('.jpg')
[thumb
] = app.get('/~submissiontest').html.select('#user-thumbs .thumb-bounds')
assert thumb.picture is not None
assert thumb.picture.source['srcset'].endswith('.webp')
def test_create(self, import_tool, sui):
project = M.Project.query.get(shortname='test')
params = {
'tickets_json': webtest.Upload('tickets.json', '{"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(u'mymount',
import_tool.post.call_args[1]['mount_point'])
self.assertEqual(u'mylabel',
import_tool.post.call_args[1]['mount_label'])
def testMyImagesFormNoLogin(self):
""" As an unregistered user (not logged in) if I try to upload an image by
accessing the /upload URL directly, I get a redirect response back to the home page.
"""
imagefilename = "iceland.jpg"
(password, nick, avatar) = self.users[0]
# login and then get the my images page
self.doLogin(nick, password)
response = self.app.get('/my')
# the page should contain an upload form
self.assertIn('uploadform', response.forms)
form = response.forms['uploadform']
# action should be /upload
self.assertEqual('/upload', form.action)
# try uploading a file
form['imagefile'] = webtest.Upload(imagefilename,
content_type='image/jpeg')
# before we submit, we'll logout
logoutform = response.forms['logoutform']
response3 = logoutform.submit()
# now submit the form as a regular user
response = form.submit()
# expect a redirect to the / page
self.assertIn(response.status, ['303 See Other', '302 Found'])
(_, _, path, _, _, _) = urlparse(response.headers['Location'])
self.assertEqual(
'/', path, "expected redirect to '/' after non-login file upload")
# and when I retrieve that page I should not see the image
response = self.app.get('/')
imgs = response.html.find_all('img')
for img in imgs:
self.assertNotIn(imagefilename, img['src'],
"found image that should not have uploaded")
def test_owner_reupload(app, character_user, character):
cookie = db_utils.create_session(character_user)
resp = app.post('/reupload/character', {
'targetid':
str(character),
'submitfile':
webtest.Upload('wesley', read_asset('img/help/wesley-draw.png'),
'image/png'),
},
headers={
'Cookie': cookie
}).follow()
image_url = resp.html.find(id='detail-art').a['href']
assert _read_character_image(image_url).tobytes() == read_asset_image(
'img/help/wesley-draw.png').tobytes()
def _test_excel_import(django_app, xlsx_file: str,
beacon: str) -> tg.Tuple[str, str]:
# --- get /import:
import_url = reverse('room:import')
import_page = django_app.get(import_url)
assert import_page.status == '200 OK'
# --- make file upload:
uploadform = import_page.form
uploadform['file'] = wt.Upload(xlsx_file)
resp = uploadform.submit()
qrcodes_page = resp.follow()
assert beacon in qrcodes_page.text # content from xlsx_file
# --- get a QR-code image:
seathash: str = arm.Seat.objects.last(
).hash # type: ignore[union-attr,assignment]
url = reverse('room:qrcode', kwargs=dict(hash=seathash))
qrcode_response = django_app.get(url)
assert qrcode_response.headers['Content-Type'] == 'image/svg+xml'
return (seathash, qrcodes_page.text)
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_multi_layers(ngw_webtest_app, ngw_auth_administrator):
data = 'two-layers.zip'
src = os.path.join(DATA_PATH, data)
resp = ngw_webtest_app.post('/api/component/file_upload/',
dict(file=webtest.Upload(src)))
upload_meta = resp.json['upload_meta'][0]
resp = ngw_webtest_app.post_json('/api/component/vector_layer/dataset',
dict(source=upload_meta),
status=200)
layers = resp.json['layers']
assert len(layers) == 2
assert 'layer1' in layers
assert 'layer2' in layers
resp = ngw_webtest_app.post_json(
'/api/resource/',
dict(resource=dict(cls='vector_layer',
display_name='test two layers',
parent=dict(id=0)),
vector_layer=dict(source=upload_meta,
source_layer='layer1',
srs=dict(id=3857),
fid_source='AUTO',
fid_field='id')),
status=201)
layer_id = resp.json['id']
resp = ngw_webtest_app.get('/api/resource/%d/feature/2' % layer_id,
status=200)
feature = resp.json
assert feature['fields'] == dict(name_point='Point two')
ngw_webtest_app.delete('/api/resource/%d' % layer_id)
def test_parse_files(self, testapp):
res = testapp.post('/echo_file',
{'myfile': webtest.Upload('README.rst', b'data')})
assert res.json == {'myfile': 'data'}
def test_parse_files(self, testapp):
res = testapp.post("/echo_file",
{"myfile": webtest.Upload("README.rst", b"data")})
assert res.json == {"myfile": "data"}
def test_upload_fields(self):
form = self.callFUT()
fu = webtest.Upload(__file__)
form['file'] = fu
self.assertEqual(form.upload_fields(), [['file', __file__]])
