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"]} )