def test__upload__upload_RadioField(client, faker, required, value, should_be_loaded):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
field = faker.get_test_field(field_group=study.field_group, field_type=FieldType.get_radio(), choices="xy|z", required=required)
_do_upload_field(client, faker, study, should_be_loaded, field, value)
def test__upload__upload_FileField(client, faker, required, allowed_file_extensions, file_sent, extension, should_be_loaded):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
field = faker.get_test_field(field_group=study.field_group, field_type=FieldType.get_file(), allowed_file_extensions=allowed_file_extensions, required=required)
content = faker.text()
filename = faker.file_name(extension=extension)
resp = _do_upload(
client,
faker,
study.id,
field_name=field.field_name,
field_value=(
BytesIO(content.encode('utf-8')),
filename
),
)
if should_be_loaded:
assert__redirect(resp, endpoint='ui.index')
_assert_uploaded_file(study, field, filename=filename, content=content)
else:
assert resp.status_code == status.HTTP_200_OK
assert__error__message(resp.soup, field.field_name)
_assert_upload_not_saved(study)
def test__upload__upload_IntegerField(client, faker, required, value, should_be_loaded):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
field = faker.get_test_field(field_group=study.field_group, field_type=FieldType.get_integer(), required=required)
_do_upload_field(client, faker, study, should_be_loaded, field, value)
def test__study_csv__download(client, faker, upload_count):
user = login(client, faker)
uploads = []
study = faker.get_test_study(owner=user)
for _ in range(upload_count):
upload = faker.get_test_upload(study=study, uploader=user)
uploads.append(upload)
resp = client.get(_url(study_id=study.id))
assert resp.status_code == status.HTTP_200_OK
decoded_content = resp.data.decode("utf-8")
rows = list(csv.reader(StringIO(decoded_content), delimiter=","))
assert rows[0] == [
"upload_id",
"study_name",
"Study Number",
"uploaded_by",
"date_created",
]
for u, row in zip(uploads, rows[1:]):
assert row[0] == str(u.id)
assert row[1] == u.study.name
assert row[2] == u.study_number
assert row[3] == u.uploader.full_name
assert row[4] == u.date_created.strftime("%Y-%m-%d %H:%M:%S.%f")
def test__study_list__owned_study__upload_count(client, faker, outstanding,
completed, deleted):
user = login(client, faker)
user2 = faker.get_test_user()
study = faker.get_test_study(owner=user)
study2 = faker.get_test_study(owner=user)
# Cycle is used to alternately allocate
# the uploads to a different user
# thus we can test that we can see
# uploads by users other than ourselves
users = cycle([user, user2])
for _ in range(outstanding):
u = faker.get_test_upload(study=study, uploader=next(users))
for _ in range(completed):
u = faker.get_test_upload(study=study,
completed=True,
uploader=next(users))
for _ in range(deleted):
u = faker.get_test_upload(study=study,
deleted=True,
uploader=next(users))
resp = get_and_assert_standards(client, _url(), user)
assert resp.status_code == status.HTTP_200_OK
study_row = resp.soup.find("td", string=study.name).parent
assert study_row.find_all("td")[2].string == str(outstanding + completed)
assert study_row.find_all("td")[3].string == str(outstanding)
def test__upload__form_dynamic_multiple(client, faker):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
field1 = faker.get_test_field(
field_type=FieldType.get_textarea(),
field_group=study.field_group,
order=1,
)
field2 = faker.get_test_field(
field_type=FieldType.get_string(),
field_group=study.field_group,
order=2,
)
resp = _get(client, _url(study_id=study.id), user, study)
f1 = resp.soup.find(id=field1.field_name)
assert f1
assert f1.name == "textarea"
f2 = f1.find_next(id=field2.field_name)
assert f2
assert f2.name == "input"
assert f2["type"] == "text"
def test__my_uploads__search__pages(client, faker, uploads):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
my_uploads = [faker.get_test_upload(study=study, uploader=user, study_number="fred") for _ in range(uploads)]
other = [faker.get_test_upload(study=study, uploader=user, study_number="margaret") for _ in range(100)]
assert__page_navigation(client, _url(study_id=study.id, search='fred', _external=False), uploads)
def test__my_uploads(client, faker, mine, others, deleted):
user = login(client, faker)
user2 = faker.get_test_user()
study = faker.get_test_study(collaborator=user)
uploads = []
for _ in range(mine):
u = faker.get_test_upload(study=study, uploader=user)
uploads.append(u)
for _ in range(others):
u = faker.get_test_upload(completed=True, uploader=user2)
# Cycle is used to alternately allocate
# the uploads to a different user
# thus we can test that we can see
# uploads by users other than ourselves
users = cycle([user, user2])
for _ in range(deleted):
u = faker.get_test_upload(uploader=next(users), deleted=True)
resp = _get(client, _url(study_id=study.id), user, study)
_assert_response(resp, study, uploads)
def test__upload__upload_StringField(client, faker, required, max_length, value, should_be_loaded):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
field = faker.get_test_field(field_group=study.field_group, field_type=FieldType.get_string(), max_length=max_length, required=required)
_do_upload_field(client, faker, study, should_be_loaded, field, value)
def test_user_meta_update_web(db, app):
users = [create_user(db) for x in range(0, 8)]
old_onlines = {}
for user in users:
with app.test_client() as client:
old_onlines[user.id] = user.last_online.timestamp()
login(user.username, "password", client=client)
rv = client.get("/")
assert rv.status_code == 200
update_user_meta()
db.expire_all()
for uid, oldtime in old_onlines.items():
updated = db.query(User).filter(User.id == uid).one()
check_valid_time(oldtime, updated.last_online.timestamp())
def test_user_meta_update_web(db, app):
users = [create_user(db) for x in range(0, 8)]
old_onlines = {}
for user in users:
with app.test_client() as client:
old_onlines[user.id] = user.last_online.timestamp()
login(user.username, "password", client=client)
rv = client.get("/")
assert rv.status_code == 200
update_user_meta()
db.expire_all()
for uid, oldtime in old_onlines.items():
updated = db.query(User).filter(User.id == uid).one()
check_valid_time(oldtime, updated.last_online.timestamp())
def test__study_list__no_studies__no_display(client, faker):
user = login(client, faker)
resp = get_and_assert_standards(client, _url(), user)
assert resp.status_code == status.HTTP_200_OK
assert resp.soup.find("h2", string="Owned Studies") is None
assert resp.soup.find("h2", string="Collaborating Studies") is None
assert len(resp.soup.find_all("table", "table study_list")) == 0
def test__upload__form_study_number(client, faker):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
resp = _get(client, _url(study_id=study.id), user, study)
sn = resp.soup.find("input", id="study_number")
assert sn
assert sn["type"] == "text"
def test__my_uploads__search_study_number(client, faker):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
upload_matching = faker.get_test_upload(study=study, study_number="fred", uploader=user)
upload_unmatching = faker.get_test_upload(study=study, study_number="margaret", uploader=user)
resp = _get(client, _url(study_id=study.id, search='fred'), user, study)
_assert_response(resp, study, [upload_matching])
def test__upload__upload_study_number__duplicate_allowed(client, faker):
user = login(client, faker)
study = faker.get_test_study(collaborator=user, allow_duplicate_study_number=True)
upload = faker.get_test_upload(study=study)
resp = _do_upload(client, faker, upload.study.id, study_number=upload.study_number)
assert__redirect(resp, endpoint='ui.index')
assert Upload.query.filter(
Upload.study_number == upload.study_number
).count() == 2
def test__upload__upload_study_number(client, faker):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
study_number = faker.pystr(min_chars=5, max_chars=10)
resp = _do_upload(client, faker, study.id, study_number=study_number)
assert__redirect(resp, endpoint='ui.index')
assert Upload.query.filter(
Upload.study_number == study_number and Upload.study_id == study.id
).first()
def test__upload__upload_study_number__duplicate_on_other_study(client, faker):
user = login(client, faker)
study2 = faker.get_test_study(collaborator=user)
study1 = faker.get_test_study(collaborator=user)
upload = faker.get_test_upload(study=study1)
resp = _do_upload(client, faker, study2.id, study_number=upload.study_number)
assert__redirect(resp, endpoint='ui.index')
assert Upload.query.filter(
Upload.study_number == upload.study_number and Upload.study_id == study2.id
).first()
def test__upload__upload_study_number__matches_format(client, faker):
user = login(client, faker)
study = faker.get_test_study(collaborator=user, study_number_format='Tst\\d{8}[A-Z]')
study_number = "Tst12345678X"
resp = _do_upload(client, faker, study.id, study_number=study_number)
assert__redirect(resp, endpoint='ui.index')
assert Upload.query.filter(
Upload.study_number == study_number and Upload.study_id == study.id
).first()
def test__upload__complete__must_be_owner(client, faker):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
upload = faker.get_test_upload(study=study)
resp = client.post(_url(upload_id=upload.id), data={"id": upload.id})
assert resp.status_code == status.HTTP_403_FORBIDDEN
changed_upload = Upload.query.get(upload.id)
assert not changed_upload.completed
def test__upload__complete(client, faker):
user = login(client, faker)
study = faker.get_test_study(owner=user)
upload = faker.get_test_upload(study=study)
resp = client.post(
_url(upload_id=upload.id),
data={"id": upload.id},
headers={'Referer': faker.test_referrer()},
)
assert__redirect(resp, url=faker.test_referrer())
changed_upload = Upload.query.get(upload.id)
assert changed_upload.completed
def test__upload__upload_study_number__duplicate_not_allowed(client, faker):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
upload = faker.get_test_upload(study=study)
resp = _do_upload(client, faker, upload.study.id, study_number=upload.study_number)
assert resp.status_code == status.HTTP_200_OK
e = resp.soup.find("div", class_="alert")
assert 'Study Number' in e.text
assert Upload.query.filter(
Upload.study_number == upload.study_number
).count() == 1
def test__upload__upload_study_number__not_matches_format(client, faker):
user = login(client, faker)
study = faker.get_test_study(collaborator=user, study_number_format='Tst\\d{8}[A-Z]')
study_number = "Tst12345678"
resp = _do_upload(client, faker, study.id, study_number=study_number)
assert resp.status_code == status.HTTP_200_OK
e = resp.soup.find("div", class_="alert")
assert 'Study Number' in e.text
assert Upload.query.filter(
Upload.study_number == study_number
).count() == 0
def test__upload__upload_BooleanField(client, faker, required, value, should_be_loaded, saved_value):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
field = faker.get_test_field(field_group=study.field_group, field_type=FieldType.get_boolean(), required=required)
resp = _do_upload(client, faker, study.id, field_name=field.field_name, field_value=value)
if should_be_loaded:
assert__redirect(resp, endpoint='ui.index')
_assert_uploaded(study, field, value=saved_value)
else:
assert resp.status_code == status.HTTP_200_OK
assert__error__message(resp.soup, field.field_name)
_assert_upload_not_saved(study)
def test__upload__form_dynamic_textarea(client, faker):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
field = faker.get_test_field(
field_type=FieldType.get_textarea(),
field_group=study.field_group,
order=1,
)
resp = _get(client, _url(study_id=study.id), user, study)
sn = resp.soup.find(id=field.field_name)
assert sn
assert sn.name == "textarea"
def test__upload__form_dynamic_radio(client, faker):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
field = faker.get_test_field(
field_type=FieldType.get_radio(),
field_group=study.field_group,
order=1,
choices="xy|z",
)
resp = _get(client, _url(study_id=study.id), user, study)
sn = resp.soup.find(id=field.field_name)
assert sn
assert sn.name == "ul"
assert sn.find("input", attrs={"type": "radio", "value": "xy"})
assert sn.find("input", attrs={"type": "radio", "value": "z"})
def test__study_list__owns_mult_studies(client, faker, study_count):
user = login(client, faker)
studies = []
for _ in range(study_count):
studies.append(faker.get_test_study(owner=user))
resp = get_and_assert_standards(client, _url(), user)
assert resp.status_code == status.HTTP_200_OK
assert resp.soup.find("h2", string="Owned Studies") is not None
assert resp.soup.find("h2", string="Collaborating Studies") is None
assert len(resp.soup.select("table.table")) == 1
assert len(resp.soup.select("table.table > tbody > tr")) == study_count
for s in studies:
assert resp.soup.find("a", href=url_for("ui.study",
study_id=s.id)) is not None
assert (resp.soup.find("a",
href=url_for("ui.study_csv", study_id=s.id))
is not None)
assert resp.soup.find("td", string=s.name) is not None
def test__study_list__owns_1_study_redirects(client, faker):
user = login(client, faker)
study = faker.get_test_study(owner=user)
resp = client.get(_url())
assert__redirect(resp, endpoint='ui.study', study_id=study.id)
def test__my_uploads__pages(client, faker, uploads):
user = login(client, faker)
study = faker.get_test_study(collaborator=user)
my_uploads = [faker.get_test_upload(study=study, uploader=user) for _ in range(uploads)]
assert__page_navigation(client, _url(study_id=study.id, _external=False), uploads)
def test_account_login(client, normal_user):
rv = login(normal_user.username, "password", client)
assert b"log_out" in rv.data
def user_client(app, normal_user):
with app.test_client() as client:
login(normal_user.username, "password", client=client)
client.user = normal_user
yield client
def test_account_login(client, normal_user):
rv = login(normal_user.username, "password", client)
assert b"log_out" in rv.data
def admin_client(app, admin_user):
with app.test_client() as client:
login(admin_user.username, "password", client=client)
client.user = admin_user
yield client
