def test_external_challenge_buttons(client):
create_url = reverse("challenges:external-create")
list_url = reverse("challenges:external-list")
response = get_view_for_user(client=client, viewname="challenges:list")
assert create_url not in response.rendered_content
assert list_url not in response.rendered_content
user = UserFactory()
response = get_view_for_user(
client=client, viewname="challenges:list", user=user
)
assert create_url not in response.rendered_content
assert list_url not in response.rendered_content
staff_user = UserFactory(is_staff=True)
response = get_view_for_user(
client=client, viewname="challenges:list", user=staff_user
)
assert create_url in response.rendered_content
assert list_url in response.rendered_content
def test_annotationset_creation(client, settings):
# Override the celery settings
settings.task_eager_propagates = (True,)
settings.task_always_eager = (True,)
user = UserFactory(is_staff=True)
client.login(username=user.username, password=SUPER_SECURE_TEST_PASSWORD)
imageset = ChallengeFactory().imageset_set.get(phase=ImageSet.TRAINING)
url = reverse(
"datasets:annotationset-create",
kwargs={
"challenge_short_name": imageset.challenge.short_name,
"base_pk": imageset.pk,
},
)
url, kwargs = get_http_host(url=url, kwargs={})
response = client.get(url, **kwargs)
assert response.status_code == 200
response = client.post(
url, data={"kind": AnnotationSet.GROUNDTRUTH}, **kwargs
)
assert response.status_code == 302
annotationset = AnnotationSet.objects.get(
base=imageset, kind=AnnotationSet.GROUNDTRUTH
)
assert len(annotationset.images.all()) == 0
assert annotationset.creator == user
assert response.url == reverse(
"datasets:annotationset-add-images",
kwargs={
"challenge_short_name": annotationset.base.challenge.short_name,
"pk": annotationset.pk,
},
)
images = ["image10x10x10.zraw", "image10x10x10.mhd"]
session, uploaded_images = create_raw_upload_image_session(
images, annotationset=annotationset
)
url, kwargs = get_http_host(
url=annotationset.get_absolute_url(), kwargs={}
)
response = client.get(url, **kwargs)
assert "image10x10x10.mhd" in response.rendered_content
assert str(session.pk) in response.rendered_content
annotationset.refresh_from_db()
assert len(annotationset.images.all()) == 1
def test_redirect_to_logout_url_absolute(self, client):
url = (
reverse("login_redirect")
+ f"?next={reverse('home')}{settings.LOGOUT_URL[1:]}"
)
response = client.get(url, follow=True)
assert response.redirect_chain[0][1] == status.HTTP_302_FOUND
assert response.redirect_chain[0][0] == reverse("home")
assert response.status_code == status.HTTP_200_OK
def test_challenge_list_is_filtered(client, TwoChallengeSets):
c1 = TwoChallengeSets.ChallengeSet1.challenge.short_name
c2 = TwoChallengeSets.ChallengeSet2.challenge.short_name
tests = [
([], [c1, c2], TwoChallengeSets.ChallengeSet1.non_participant),
([c1], [c2], TwoChallengeSets.ChallengeSet1.participant),
([c1], [c2], TwoChallengeSets.ChallengeSet1.participant1),
([c1], [c2], TwoChallengeSets.ChallengeSet1.creator),
([c1], [c2], TwoChallengeSets.ChallengeSet1.admin),
([], [c1, c2], TwoChallengeSets.ChallengeSet2.non_participant),
([c2], [c1], TwoChallengeSets.ChallengeSet2.participant),
([c2], [c1], TwoChallengeSets.ChallengeSet2.participant1),
([c2], [c1], TwoChallengeSets.ChallengeSet2.creator),
([c2], [c1], TwoChallengeSets.ChallengeSet2.admin),
([c1, c2], [], TwoChallengeSets.admin12),
([c1, c2], [], TwoChallengeSets.participant12),
([c1, c2], [], TwoChallengeSets.admin1participant2),
]
for test in tests:
response = get_view_for_user(
url=reverse("challenges:users-list"), client=client, user=test[2]
)
for short_name in test[0]:
assert short_name in response.rendered_content
for short_name in test[1]:
assert short_name not in response.rendered_content
def send_new_result_email(result):
challenge = result.job.submission.challenge
recipient_emails = [o.email for o in challenge.get_admins()]
message = (
f"There is a new result for {challenge.short_name} from "
f"{result.job.submission.creator.username}."
)
if result.published:
leaderboard_url = reverse(
"evaluation:result-list",
kwargs={"challenge_short_name": challenge.short_name},
)
message += (
f"You can view the result on the leaderboard here: "
f"{leaderboard_url}"
)
recipient_emails.append(result.job.submission.creator.email)
else:
message += (
f"You can publish the result on the leaderboard here: "
f"{result.get_absolute_url()}"
)
for email in recipient_emails:
send_mail(
subject=(
f"[{Site.objects.get_current().domain.lower()}] "
f"[{challenge.short_name.lower()}] "
f"New Result"
),
message=message,
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[email],
)
def test_workstation_create_detail(client):
user = UserFactory(is_staff=True)
title = "my Workstation"
description = "my AWESOME workstation"
response = get_view_for_user(
client=client, viewname="workstations:create", user=user
)
assert response.status_code == 200
response = get_view_for_user(
client=client,
method=client.post,
viewname="workstations:create",
user=user,
data={
"title": title,
"description": description,
"logo": get_temporary_image(),
},
)
assert response.status_code == 302
assert response.url == reverse(
"workstations:detail", kwargs={"slug": slugify(title)}
)
w = Workstation.objects.get(title=title)
assert w.title == title
assert w.description == description
response = get_view_for_user(url=response.url, client=client, user=user)
assert title in response.rendered_content
assert description in response.rendered_content
def test_access(self, client, user, expected_status):
image = ImageFactoryWithImageFile()
image.permit_viewing_by_retina_users()
url = reverse("retina:api:image-element-spacing-view", args=[image.pk])
client, _ = client_login(client, user=user)
response = client.get(url)
assert response.status_code == expected_status
def check_external_challenge_urls():
"""
Checks that all external challenge urls are reachable, and emails the
managers if not.
"""
challenges = ExternalChallenge.objects.filter(hidden=False)
errors = []
for challenge in challenges:
try:
url = challenge.homepage
if not url.startswith("http"):
url = "http://" + url
r = get(url)
# raise an exception when we receive a http error (e.g., 404)
r.raise_for_status()
except exceptions.RequestException as err:
update_url = reverse(
"challenges:external-update",
kwargs={"short_name": challenge.short_name},
)
errors.append(
f"Error when trying to access '{challenge}': {err}. You can "
f"update it here: {update_url}"
)
if errors:
mail_managers(
subject=f"Unreachable external challenges ({len(errors)})",
message="\n\n".join(errors),
)
def test_special_username(self, client):
user = UserFactory(username="******")
url = reverse("profile_redirect")
client.force_login(user)
response = client.get(url, follow=True)
assert response.status_code == status.HTTP_200_OK
assert "t%C3%A9st" in response.redirect_chain[0][0]
def create_element_spacing_request(
client, image_name=None, user="******", study=None, es=None
):
auth_header = get_auth_token_header(user)
url = reverse("retina:importers:set-element-spacing-for-image")
request_data = {}
if image_name is not None:
request_data["image_identifier"] = image_name
else:
image = ImageFactoryWithImageFile()
request_data["image_identifier"] = image.name
if es is not None:
request_data["element_spacing_x"] = es[0]
request_data["element_spacing_y"] = es[1]
else:
request_data["element_spacing_x"] = 10
request_data["element_spacing_y"] = 10
if study is not None:
request_data["study_identifier"] = study.name
data = json.dumps(request_data)
return client.post(
url, data=data, content_type="application/json", **auth_header
)
def test_normal_redirect(self, client):
redirect_to = "/challenges/"
url = reverse("login_redirect") + f"?next={redirect_to}"
response = client.get(url, follow=True)
assert response.redirect_chain[0][1] == status.HTTP_302_FOUND
assert response.redirect_chain[0][0] == redirect_to
assert response.status_code == status.HTTP_200_OK
def environment(self) -> dict:
"""
Returns
-------
The environment variables that should be set on the container.
"""
env = {
"GRAND_CHALLENGE_PROXY_URL_MAPPINGS": "",
"GRAND_CHALLENGE_QUERY_IMAGE_URL": unquote(
reverse("api:image-detail", kwargs={"pk": "{key}"})
),
}
if self.creator:
env.update(
{
"GRAND_CHALLENGE_AUTHORIZATION": f"TOKEN {Token.objects.get_or_create(user=self.creator)[0].key}"
}
)
if settings.DEBUG:
# Allow the container to communicate with the dev environment
env.update({"GRAND_CHALLENGE_UNSAFE": "True"})
return env
def test_workstation_proxy(client):
u1, u2 = UserFactory(), UserFactory()
session = SessionFactory(creator=u1)
url = reverse(
"workstations:session-proxy",
kwargs={
"slug": session.workstation_image.workstation.slug,
"pk": session.pk,
"path": "foo/bar/../baz/test",
},
)
response = get_view_for_user(client=client, url=url, user=u1)
assert response.status_code == 200
assert response.has_header("X-Accel-Redirect")
redirect_url = response.get("X-Accel-Redirect")
assert redirect_url.endswith("foo/baz/test")
assert redirect_url.startswith("/workstation-proxy/")
assert session.hostname in redirect_url
# try as another user
response = get_view_for_user(client=client, url=url, user=u2)
assert not response.has_header("X-Accel-Redirect")
assert response.status_code == 403
def test_new_registration_email(participant_review, client, ChallengeSet):
user = UserFactory()
ChallengeSet.challenge.require_participant_review = participant_review
ChallengeSet.challenge.save()
assert not RegistrationRequest.objects.filter(
user=user, challenge=ChallengeSet.challenge
).exists()
response = get_view_for_user(
viewname="participants:registration-create",
client=client,
method=client.post,
user=user,
challenge=ChallengeSet.challenge,
)
assert response.status_code == 302
assert RegistrationRequest.objects.filter(
user=user, challenge=ChallengeSet.challenge
).exists()
if participant_review:
email = mail.outbox[-1]
approval_link = reverse(
"participants:registration-list",
kwargs={"challenge_short_name": ChallengeSet.challenge.short_name},
)
assert ChallengeSet.admin.email in email.to
assert "new participation request" in email.subject.lower()
assert ChallengeSet.challenge.short_name in email.subject
assert approval_link in email.alternatives[0][0]
else:
with pytest.raises(IndexError):
# No emails if no review
# noinspection PyStatementEffect
mail.outbox[-1]
def get_success_url(self):
return reverse(
"datasets:annotationset-add-images",
kwargs={
"challenge_short_name": self.object.base.challenge.short_name,
"pk": self.object.pk,
},
)
def get_absolute_url(self):
return reverse(
"datasets:imageset-detail",
kwargs={
"challenge_short_name": self.challenge.short_name,
"pk": self.pk,
},
)
def get_absolute_url(self):
return reverse(
"workstations:session-detail",
kwargs={
"slug": self.workstation_image.workstation.slug,
"pk": self.pk,
},
)
def test_registration_request_create_get(client, ChallengeSet):
validate_logged_in_view(
viewname="participants:registration-create",
challenge_set=ChallengeSet,
client=client,
)
# Make sure the link to register is in the challenge page
url = reverse(
"challenge-homepage",
kwargs={"challenge_short_name": ChallengeSet.challenge.short_name},
)
response = get_view_for_user(url=url, client=client)
expected_link = reverse(
"participants:registration-create",
kwargs={"challenge_short_name": ChallengeSet.challenge.short_name},
)
assert f'"{expected_link}"' in str(response.content)
def get_absolute_url(self):
return reverse(
"evaluation:job-detail",
kwargs={
"pk": self.pk,
"challenge_short_name": self.submission.challenge.short_name,
},
)
def test_thumbnail_endpoint_authenticated_no_perm(
self, client, django_user_model
):
image = ImageFactoryWithImageFile()
url = reverse("retina:image-thumbnail", args=[image.id])
client, _ = client_login(client, user="******")
response = client.get(url)
assert response.status_code == status.HTTP_403_FORBIDDEN
def get_absolute_url(self):
return reverse(
"teams:detail",
kwargs={
"pk": self.pk,
"challenge_short_name": self.challenge.short_name,
},
)
def signup(request, extra_context=None, **kwargs):
success = reverse("profile_signup_complete")
response = userena_views.signup(
request=request,
extra_context=extra_context,
success_url=success,
**kwargs,
)
return response
def get_viewset_user_kwargs_url(
user_type, namespace, basename, grader, model, url_name
):
user = get_user_from_user_type(user_type, grader=grader)
kwargs = {"user_id": grader.id}
if url_name == "detail":
kwargs.update({"pk": model.pk})
url = reverse(f"{namespace}:{basename}-{url_name}", kwargs=kwargs)
return user, kwargs, url
def test_returns_correct_spacing(self, client):
image = ImageFactoryWithImageFile()
image.permit_viewing_by_retina_users()
url = reverse("retina:api:image-element-spacing-view", args=[image.pk])
client, _ = client_login(client, user="******")
response = client.get(url)
assert response.status_code == status.HTTP_200_OK
r = response.json()
assert list(image.get_sitk_image().GetSpacing()) == r
def test_auth_normal(self, client):
url = reverse("retina:home")
user, _ = get_retina_user_with_token()
client.force_login(user=user)
try:
response = client.get(url)
assert response.status_code == status.HTTP_200_OK
except ValueError as e:
assert "Missing staticfiles manifest entry for" in str(e)
def signin_redirect(redirect=None, user=None):
"""
Redirect user after successful sign in.
First looks for a ``requested_redirect``. If not supplied will fall-back to
the user specific account page. If all fails, will fall-back to redirect to
the homepage. Returns a string defining the URI to go next.
:param redirect:
A value normally supplied by ``next`` form field. Gets preference
before the default view which requires the user.
:param user:
A ``User`` object specifying the user who has just signed in.
:return: String containing the URI to redirect to.
"""
if redirect and settings.LOGOUT_URL not in redirect:
return redirect
elif user is not None and user.is_authenticated:
return reverse("profile_redirect")
else:
return reverse("home")
def get_absolute_url(self):
""" With this method, admin will show a 'view on site' button """
url = reverse(
"pages:detail",
kwargs={
"challenge_short_name": self.challenge.short_name,
"page_title": self.title,
},
)
return url
def test_admins_see_links(view, client, TwoChallengeSets):
url = reverse(
"challenge-homepage",
kwargs={
"challenge_short_name": TwoChallengeSets.ChallengeSet1.challenge.short_name
},
)
expected = reverse(
view,
kwargs={
"challenge_short_name": TwoChallengeSets.ChallengeSet1.challenge.short_name
},
)
validate_admin_only_text_in_page(
url=url,
expected_text=f'"{str(expected)}"',
two_challenge_set=TwoChallengeSets,
client=client,
)
def test_load_no_auth(self, client):
# create grader user
user = UserFactory()
ds = create_some_datastructure_data()
url = reverse(
"retina:api:data-api-view",
args=[data_type, user.id, ds["archive"].name, ds["patient"].name],
)
response = client.get(url)
assert response.status_code == status.HTTP_403_FORBIDDEN
def test_archive_view_retina_auth(self, client):
# Create data
create_datastructures_data()
# login client
client, _ = client_login(client, user="******")
url = reverse("retina:api:archives-api-view")
response = client.get(url, HTTP_ACCEPT="application/json")
assert response.status_code == status.HTTP_200_OK
def test_default_redirect(self, client):
response = self.get_redirect_response(client)
assert response.redirect_chain[0][1] == status.HTTP_302_FOUND
assert response.redirect_chain[0][0] == reverse("profile_redirect")
assert response.status_code == status.HTTP_200_OK
def get_success_url(self):
return reverse("verifications:detail")
def get_success_url(self):
return reverse("challenges:external-list")
def get_success_url(self, *args, **kwargs):
return reverse("social:begin", args=["google-oauth2"])
def test_archive_view_returns_correct_data(self, client):
# Clear cache manually (this is not done by pytest-django for some reason...)
cache.clear()
# Create data
datastructures, datastructures_aus, oct_obs_registration, oct_obs_registration_aus = (
create_datastructures_data())
# login client
client, _ = client_login(client, user="******")
url = reverse("retina:api:archives-api-view")
response = client.get(url, HTTP_ACCEPT="application/json")
response_data = json.loads(response.content)
# check if correct data is sent
expected_response_data = {
"subfolders": {
datastructures["archive"].name: {
"subfolders": {
datastructures["patient"].name: {
"subfolders": {
datastructures["study_oct"].name: {
"info": "level 5",
"images": {
datastructures["image_oct"].name: {
"images": {
"trc_000":
"no info",
"obs_000":
str(datastructures["image_obs"]
.id),
"mot_comp":
"no info",
"trc_001":
"no info",
"oct":
str(datastructures["image_oct"]
.id),
},
"info": {
"voxel_size": {
"axial": 0,
"lateral": 0,
"transversal": 0,
},
"date":
datastructures["study_oct"].
datetime.strftime(
"%Y/%m/%d %H:%M:%S"),
"registration": {
"obs":
"Checked separately",
"trc": [0, 0, 0, 0],
},
},
}
},
"name": datastructures["study_oct"].name,
"id": str(datastructures["study_oct"].id),
"subfolders": {},
},
datastructures["study"].name: {
"info": "level 5",
"images": {
datastructures["image_cf"].name:
str(datastructures["image_cf"].id)
},
"name": datastructures["study"].name,
"id": str(datastructures["study"].id),
"subfolders": {},
},
},
"info": "level 4",
"name": datastructures["patient"].name,
"id": str(datastructures["patient"].id),
"images": {},
}
},
"info": "level 3",
"name": datastructures["archive"].name,
"id": str(datastructures["archive"].id),
"images": {},
},
datastructures_aus["archive"].name: {
"subfolders": {
datastructures_aus["patient"].name: {
"subfolders": {},
"info": "level 4",
"name": datastructures_aus["patient"].name,
"id": str(datastructures_aus["patient"].id),
"images": {
datastructures_aus["image_oct"].name: {
"images": {
"trc_000":
"no info",
"obs_000":
str(datastructures_aus["image_obs"].id
),
"mot_comp":
"no info",
"trc_001":
"no info",
"oct":
str(datastructures_aus["image_oct"].id
),
},
"info": {
"voxel_size": {
"axial": 0,
"lateral": 0,
"transversal": 0,
},
"date":
datastructures_aus["study_oct"].
datetime.strftime("%Y/%m/%d %H:%M:%S"),
"registration": {
"obs": "Checked separately",
"trc": [0, 0, 0, 0],
},
},
},
datastructures_aus["image_cf"].name:
str(datastructures_aus["image_cf"].id),
},
}
},
"info": "level 3",
"name": datastructures_aus["archive"].name,
"id": str(datastructures_aus["archive"].id),
"images": {},
},
},
"info": "level 2",
"name": "Archives",
"id": "none",
"images": {},
}
# Compare floats separately because of intricacies of floating-point arithmetic in python
try:
# Get info objects of both archives in response data
response_archive_info = (response_data.get("subfolders").get(
datastructures["archive"].name).get("subfolders").get(
datastructures["patient"].name).get("subfolders").get(
datastructures["study_oct"].name).get("images").get(
datastructures["image_oct"].name).get("info"))
response_archive_australia_info = (
response_data.get("subfolders").get(
datastructures_aus["archive"].name).get("subfolders").get(
datastructures_aus["patient"].name).get("images").get(
datastructures_aus["image_oct"].name).get("info"))
floats_to_compare = (
[]) # list of (response_float, expected_float, name) tuples
for archive, response_info, ds, oor in (
(
"Rotterdam",
response_archive_info,
datastructures,
oct_obs_registration,
),
(
"Australia",
response_archive_australia_info,
datastructures_aus,
oct_obs_registration_aus,
),
):
# oct obs registration
response_obs = response_info.get("registration").get("obs")
rv = oor.registration_values
floats_to_compare.append((
response_obs[0],
rv[0][0],
archive + " obs oct registration top left x",
))
floats_to_compare.append((
response_obs[1],
rv[0][1],
archive + " obs oct registration top left y",
))
floats_to_compare.append((
response_obs[2],
rv[1][0],
archive + " obs oct registration bottom right x",
))
floats_to_compare.append((
response_obs[3],
rv[1][1],
archive + " obs oct registration bottom right y",
))
# Compare floats
for result, expected, name in floats_to_compare:
if result != pytest.approx(expected):
pytest.fail(name + " does not equal expected value")
# Clear voxel and obs registration objects before response object to expected object comparison
response_data["subfolders"][datastructures["archive"].name][
"subfolders"][datastructures["patient"].name]["subfolders"][
datastructures["study_oct"].name]["images"][
datastructures["image_oct"].name]["info"][
"registration"]["obs"] = "Checked separately"
response_data["subfolders"][datastructures_aus["archive"].name][
"subfolders"][datastructures_aus["patient"].name]["images"][
datastructures_aus["image_oct"].
name]["info"]["registration"]["obs"] = "Checked separately"
except (AttributeError, KeyError, TypeError):
pytest.fail("Response object structure is not correct")
assert response_data == expected_response_data
def test_no_access(self, client, user):
image = ImageFactoryWithImageFile()
url = reverse("retina:api:image-element-spacing-view", args=[image.pk])
client, _ = client_login(client, user=user)
response = client.get(url)
assert response.status_code == status.HTTP_403_FORBIDDEN
def get_absolute_url(self):
return reverse("archives:detail", kwargs={"slug": self.slug})
def upload_handler(request):
"""
Upload a file to the given challenge, display files previously uploaded
"""
challenge = request.challenge
view_url = reverse("uploads:create",
kwargs={"challenge_short_name": challenge.short_name})
if request.method == "POST":
# set values excluded from form here to make the model validate
uploadedFile = UploadModel(
challenge=challenge,
permission_lvl=UploadModel.ADMIN_ONLY,
user=request.user,
)
# ADMIN_ONLY
form = UserUploadForm(request.POST,
request.FILES,
instance=uploadedFile)
if form.is_valid():
form.save()
filename = basename(form.instance.file.file.name)
messages.success(
request,
(f"File '{filename}' sucessfully uploaded. "
f"An email has been sent to this projects organizers."),
)
send_file_uploaded_notification_email(
uploader=request.user,
filename=filename,
challenge=challenge,
site=request.site,
)
return HttpResponseRedirect(view_url)
else:
# continue to showing errors
pass
else:
form = UserUploadForm()
pages = challenge.page_set.all()
if not (challenge.is_admin(request.user)
or challenge.is_participant(request.user)):
p = Page(challenge=challenge, title="files")
currentpage = permissionMessage(request, p)
response = render(
request,
"page.html",
{
"challenge": challenge,
"currentpage": currentpage,
"pages": pages,
},
)
response.status_code = 403
return response
return render(
request,
"uploads/comicupload.html",
{
"form": form,
"upload_url": view_url,
"challenge": challenge,
"pages": pages,
},
)
def get_absolute_url(self):
return reverse("workstation-configs:detail",
kwargs={"slug": self.slug})
def get_success_url(self):
return reverse("reader-studies:list")
def test_profile_self_not_logged_in(self, rf):
UserFactory()
url = reverse("api:profiles-user-self")
request = rf.get(url)
response = UserProfileViewSet.as_view(actions={"get": "list"})(request)
assert response.status_code == 401
def test_default_redirect(self, client):
url = reverse("login_redirect")
response = client.get(url, follow=True)
assert response.redirect_chain[0][1] == status.HTTP_302_FOUND
assert response.redirect_chain[0][0] == reverse("home")
assert response.status_code == status.HTTP_200_OK
def url(view_name, *args, **kwargs):
return reverse(view_name, args=args, kwargs=kwargs)
def api_url(self):
return reverse("api:archive-detail", kwargs={"pk": self.pk})
def get_absolute_url(self):
url = reverse("documentation:detail", kwargs={"slug": self.slug},)
return url
def permission_list_url(self):
return reverse(
"archives:permission-request-list",
kwargs={"slug": self.base_object.slug},
)
def test_archive_view_non_auth(self, client):
# Clear cache manually (this is not done by pytest-django for some reason...)
cache.clear()
url = reverse("retina:api:archives-api-view")
response = client.get(url, HTTP_ACCEPT="application/json")
assert response.status_code == status.HTTP_403_FORBIDDEN
def get_absolute_url(self):
return reverse(
"workstations:image-detail",
kwargs={"slug": self.workstation.slug, "pk": self.pk},
)
def get_success_url(self):
return reverse("algorithms:detail",
kwargs={"slug": self.kwargs["slug"]})
def get_absolute_url(self):
return reverse("userena_profile_detail",
kwargs={"username": self.user.username})
def location(self, item):
return reverse(item)
def get_response_status_viewset(
rf,
viewset,
model_name,
namespace,
action_name,
request_method,
model_factory=None,
user=None,
required_relations={},
serializer=None,
extra_url_kwargs={},
):
# get model
if model_factory:
if action_name == "create" or action_name == "update":
model = model_factory()
model_build = model_factory.build()
model_serialized = serializer(model_build).data
# create related models
for relation_name, relation_factory in required_relations.items():
if isinstance(relation_factory, list):
# many to many
model_serialized[relation_name] = []
for single_relation_factory in relation_factory:
model_serialized[relation_name].append(
str(single_relation_factory().pk))
else:
# many to one
model_serialized[relation_name] = str(
relation_factory().pk)
else:
model = model_factory()
# determine url
if action_name == "list" or action_name == "create":
url = reverse(f"{namespace}:{model_name}-list",
kwargs=extra_url_kwargs)
else:
url = reverse(
f"{namespace}:{model_name}-detail",
kwargs={
"pk": model.pk,
**extra_url_kwargs
},
)
# determine request
if action_name == "create" or action_name == "update":
request = getattr(rf, request_method)(
url,
data=json.dumps(model_serialized),
content_type="application/json",
)
else:
request = getattr(rf, request_method)(url)
view = viewset.as_view(actions={request_method: action_name})
# authenticate user
if user == "user":
normal_user = UserFactory()
force_authenticate(request, user=normal_user)
elif user == "admin":
staff_user = UserFactory(is_staff=True)
force_authenticate(request, user=staff_user)
elif user == "retina_importer":
retina_import_user = get_user_model().objects.get(
username=settings.RETINA_IMPORT_USER_NAME)
force_authenticate(request, user=retina_import_user)
# get response
if action_name == "list" or action_name == "create":
response = view(request)
else:
response = view(request, pk=model.pk)
return response.status_code
def get_absolute_url(self):
return reverse("challenges:requests-detail", kwargs={"pk": self.pk})
def get_absolute_url(self):
return reverse(
"pages:home",
kwargs={"challenge_short_name": self.short_name},
)
def get_success_url(self):
return reverse(
"participants:registration-list",
kwargs={"challenge_short_name": self.object.challenge.short_name},
)
def get_success_url(self):
return reverse(
"admins:list",
kwargs={"challenge_short_name": self.request.challenge.short_name},
)
def test_permission_required_views(self, client):
ai = AlgorithmImageFactory(ready=True)
s = RawImageUploadSessionFactory()
u = UserFactory()
j = AlgorithmJobFactory(algorithm_image=ai)
p = AlgorithmPermissionRequestFactory(algorithm=ai.algorithm)
for view_name, kwargs, permission, obj, redirect in [
("create", {}, "algorithms.add_algorithm", None, None),
(
"detail",
{
"slug": ai.algorithm.slug
},
"view_algorithm",
ai.algorithm,
reverse(
"algorithms:permission-request-create",
kwargs={"slug": ai.algorithm.slug},
),
),
(
"update",
{
"slug": ai.algorithm.slug
},
"change_algorithm",
ai.algorithm,
None,
),
(
"image-create",
{
"slug": ai.algorithm.slug
},
"change_algorithm",
ai.algorithm,
None,
),
(
"image-detail",
{
"slug": ai.algorithm.slug,
"pk": ai.pk
},
"view_algorithmimage",
ai,
None,
),
(
"image-update",
{
"slug": ai.algorithm.slug,
"pk": ai.pk
},
"change_algorithmimage",
ai,
None,
),
(
"execution-session-create",
{
"slug": ai.algorithm.slug
},
"execute_algorithm",
ai.algorithm,
None,
),
(
"execution-session-create-new",
{
"slug": ai.algorithm.slug
},
"execute_algorithm",
ai.algorithm,
None,
),
(
"execution-session-detail",
{
"slug": ai.algorithm.slug,
"pk": s.pk
},
"view_rawimageuploadsession",
s,
None,
),
(
"job-experiment-detail",
{
"slug": ai.algorithm.slug,
"pk": j.pk
},
"view_job",
j,
None,
),
(
"job-detail",
{
"slug": ai.algorithm.slug,
"pk": j.pk
},
"view_job",
j,
None,
),
(
"job-update",
{
"slug": ai.algorithm.slug,
"pk": j.pk
},
"change_job",
j,
None,
),
(
"job-viewers-update",
{
"slug": ai.algorithm.slug,
"pk": j.pk
},
"change_job",
j,
None,
),
(
"editors-update",
{
"slug": ai.algorithm.slug
},
"change_algorithm",
ai.algorithm,
None,
),
(
"users-update",
{
"slug": ai.algorithm.slug
},
"change_algorithm",
ai.algorithm,
None,
),
(
"permission-request-update",
{
"slug": ai.algorithm.slug,
"pk": p.pk
},
"change_algorithm",
ai.algorithm,
None,
),
]:
def _get_view():
return get_view_for_user(
client=client,
viewname=f"algorithms:{view_name}",
reverse_kwargs=kwargs,
user=u,
)
response = _get_view()
if redirect is not None:
assert response.status_code == 302
assert response.url == redirect
else:
assert response.status_code == 403
assign_perm(permission, u, obj)
response = _get_view()
assert response.status_code == 200
remove_perm(permission, u, obj)
def test_redirect_to_logout_url(self, client):
url = reverse("login_redirect") + f"?next={settings.LOGOUT_URL}"
response = client.get(url, follow=True)
assert response.redirect_chain[0][1] == status.HTTP_302_FOUND
assert response.redirect_chain[0][0] == reverse("home")
assert response.status_code == status.HTTP_200_OK
def test_no_logout_redirect(self, client):
response = self.get_redirect_response(client, settings.LOGOUT_URL)
assert response.redirect_chain[0][1] == status.HTTP_302_FOUND
assert response.redirect_chain[0][0] == reverse("profile_redirect")
assert response.status_code == status.HTTP_200_OK
def get_success_url(self):
return reverse(
"reader-studies:detail", kwargs={"slug": self.kwargs["slug"]}
)
