def test_session_limit(http_image, docker_client, settings): path, sha256 = http_image wsi = WorkstationImageFactory(image__from_path=path, image_sha256=sha256, ready=True) # Execute the celery in place settings.WORKSTATIONS_MAXIMUM_SESSIONS = 1 settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) try: with capture_on_commit_callbacks(execute=True): s1 = SessionFactory(workstation_image=wsi) s1.refresh_from_db() assert s1.status == s1.STARTED with capture_on_commit_callbacks(execute=True): s2 = SessionFactory(workstation_image=wsi) s2.refresh_from_db() assert s2.status == s2.FAILED s1.stop() with capture_on_commit_callbacks(execute=True): s3 = SessionFactory(workstation_image=wsi) s3.refresh_from_db() assert s3.status == s3.STARTED finally: stop_all_sessions()
def test_submission_evaluation( client, evaluation_image, submission_file, settings ): # Override the celery settings settings.task_eager_propagates = (True,) settings.task_always_eager = (True,) # Upload a submission and create an evaluation eval_container, sha256 = evaluation_image method = MethodFactory( image__from_path=eval_container, image_sha256=sha256, ready=True ) # We should not be able to download methods with pytest.raises(NotImplementedError): _ = method.image.url # This will create an evaluation, and we'll wait for it to be executed with capture_on_commit_callbacks() as callbacks: submission = SubmissionFactory( predictions_file__from_path=submission_file, phase=method.phase ) recurse_callbacks(callbacks=callbacks) # The evaluation method should return the correct answer assert len(submission.evaluation_set.all()) == 1 evaluation = submission.evaluation_set.first() assert evaluation.stdout.endswith("Greetings from stdout\n") assert evaluation.stderr.endswith('warn("Hello from stderr")\n') assert evaluation.error_message == "" assert evaluation.status == evaluation.SUCCESS assert ( evaluation.outputs.get(interface__slug="metrics-json-file").value[ "acc" ] == 0.5 ) # Try with a csv file with capture_on_commit_callbacks() as callbacks: submission = SubmissionFactory( predictions_file__from_path=Path(__file__).parent / "resources" / "submission.csv", phase=method.phase, ) recurse_callbacks(callbacks=callbacks) evaluation = submission.evaluation_set.first() assert len(submission.evaluation_set.all()) == 1 assert evaluation.status == evaluation.SUCCESS assert ( evaluation.outputs.get(interface__slug="metrics-json-file").value[ "acc" ] == 0.5 )
def test_deleting_archive_item_removes_permissions(): ai1, ai2 = ArchiveItemFactory.create_batch(2) im = ImageFactory() civ = ComponentInterfaceValueFactory(image=im) with capture_on_commit_callbacks(execute=True): ai1.values.set([civ]) ai2.values.set([civ]) assert get_groups_with_set_perms(im) == { ai1.archive.editors_group: {"view_image"}, ai1.archive.uploaders_group: {"view_image"}, ai1.archive.users_group: {"view_image"}, ai2.archive.editors_group: {"view_image"}, ai2.archive.uploaders_group: {"view_image"}, ai2.archive.users_group: {"view_image"}, } with capture_on_commit_callbacks(execute=True): ai1.delete() assert get_groups_with_set_perms(im) == { ai2.archive.editors_group: {"view_image"}, ai2.archive.uploaders_group: {"view_image"}, ai2.archive.users_group: {"view_image"}, }
def test_session_with_user_upload_to_archive(client, settings): # Override the celery settings settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) user = UserFactory() archive = ArchiveFactory() archive.add_editor(user=user) upload = create_upload_from_file( file_path=Path(__file__).parent / "resources" / "image10x10x10.mha", creator=user, ) # with interface with capture_on_commit_callbacks(execute=True): response = get_view_for_user( viewname="api:upload-session-list", user=user, client=client, method=client.post, content_type="application/json", data={ "uploads": [upload.api_url], "archive": archive.slug, "interface": "generic-overlay", }, HTTP_X_FORWARDED_PROTO="https", ) assert response.status_code == 201 upload_session = response.json() assert upload_session["uploads"] == [upload.api_url] item = ArchiveItem.objects.get() assert item.values.get().interface.slug == "generic-overlay" ArchiveItem.objects.all().delete() upload2 = create_upload_from_file( file_path=Path(__file__).parent / "resources" / "image10x10x10.mha", creator=user, ) # without interface with capture_on_commit_callbacks(execute=True): response = get_view_for_user( viewname="api:upload-session-list", user=user, client=client, method=client.post, content_type="application/json", data={ "uploads": [upload2.api_url], "archive": archive.slug }, HTTP_X_FORWARDED_PROTO="https", ) assert response.status_code == 201 upload_session = response.json() assert upload_session["uploads"] == [upload2.api_url] item = ArchiveItem.objects.get() assert item.values.get().interface.slug == "generic-medical-image"
def test_failed_job_notifications(client, algorithm_io_image, settings): # Override the celery settings settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) creator = UserFactory() editor = UserFactory() # Create the algorithm image algorithm_container, sha256 = algorithm_io_image alg = AlgorithmImageFactory(image__from_path=algorithm_container, image_sha256=sha256, ready=True) alg.algorithm.add_editor(editor) job = Job.objects.create(creator=creator, algorithm_image=alg) # mark job as failed job.status = Job.FAILURE job.save() with capture_on_commit_callbacks(execute=True): send_failed_job_notification(job_pk=job.pk) # 2 notifications: for the editor of the algorithm and the job creator assert Notification.objects.count() == 2 assert creator.username in str(Notification.objects.all()) assert editor.username in str(Notification.objects.all()) for notification in Notification.objects.all(): assert ( f"Unfortunately one of the jobs for algorithm {alg.algorithm.title} failed with an error" in notification.print_notification(user=notification.user)) # delete notifications for easier testing below Notification.objects.all().delete() # unsubscribe editor from job notifications _ = get_view_for_user( viewname="api:follow-detail", client=client, method=client.patch, reverse_kwargs={ "pk": Follow.objects.filter(user=editor, flag="job-active").get().pk }, content_type="application/json", data={"flag": "job-inactive"}, user=editor, ) job = Job.objects.create(creator=creator, algorithm_image=alg) # mark job as failed job.status = Job.FAILURE job.save() with capture_on_commit_callbacks(execute=True): send_failed_job_notification(job_pk=job.pk) assert Notification.objects.count() == 1 assert Notification.objects.get().user is not editor
def test_changing_archive_updates_permissions(): ai = ArchiveItemFactory() im = ImageFactory() civ = ComponentInterfaceValueFactory(image=im) with capture_on_commit_callbacks(execute=True): ai.values.set([civ]) assert get_groups_with_set_perms(im) == { ai.archive.editors_group: {"view_image"}, ai.archive.uploaders_group: {"view_image"}, ai.archive.users_group: {"view_image"}, } a2 = ArchiveFactory() ai.archive = a2 with capture_on_commit_callbacks(execute=True): ai.save() assert get_groups_with_set_perms(im) == { a2.editors_group: {"view_image"}, a2.uploaders_group: {"view_image"}, a2.users_group: {"view_image"}, }
def test_api_archive_item_add_and_update_value(client, settings): # Override the celery settings settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) archive = ArchiveFactory() editor = UserFactory() archive.add_editor(editor) item = ArchiveItemFactory(archive=archive) ci = ComponentInterfaceFactory( kind=InterfaceKind.InterfaceKindChoices.BOOL) # add civ with capture_on_commit_callbacks(execute=True): response = get_view_for_user( viewname="api:archives-item-detail", reverse_kwargs={"pk": item.pk}, data={"values": [{ "interface": ci.slug, "value": True }]}, user=editor, client=client, method=client.patch, content_type="application/json", HTTP_X_FORWARDED_PROTO="https", ) assert response.status_code == 200 assert response.json()["pk"] == str(item.pk) item.refresh_from_db() assert item.values.count() == 1 civ = item.values.get() assert civ.interface.slug == ci.slug assert civ.value # update civ with capture_on_commit_callbacks(execute=True): response = get_view_for_user( viewname="api:archives-item-detail", reverse_kwargs={"pk": item.pk}, data={"values": [{ "interface": ci.slug, "value": False }]}, user=editor, client=client, method=client.patch, content_type="application/json", HTTP_X_FORWARDED_PROTO="https", ) assert response.status_code == 200 assert response.json()["pk"] == str(item.pk) item.refresh_from_db() assert item.values.count() == 1 new_civ = item.values.get() assert new_civ.interface.slug == ci.slug assert new_civ != civ
def test_session_with_user_upload_to_readerstudy(client, settings): # Override the celery settings settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) user = UserFactory() rs = ReaderStudyFactory(use_display_sets=False) rs.add_editor(user=user) upload = create_upload_from_file( file_path=Path(__file__).parent / "resources" / "image10x10x10.mha", creator=user, ) # try upload with interface with capture_on_commit_callbacks(execute=True): response = get_view_for_user( viewname="api:upload-session-list", user=user, client=client, method=client.post, content_type="application/json", data={ "uploads": [upload.api_url], "reader_study": rs.slug, "interface": "generic-overlay", }, HTTP_X_FORWARDED_PROTO="https", ) assert response.status_code == 400 assert ( "An interface can only be defined for archive, archive item or display set uploads." in response.json()["non_field_errors"]) # try without interface with capture_on_commit_callbacks(execute=True): response = get_view_for_user( viewname="api:upload-session-list", user=user, client=client, method=client.post, content_type="application/json", data={ "uploads": [upload.api_url], "reader_study": rs.slug }, HTTP_X_FORWARDED_PROTO="https", ) assert response.status_code == 201 upload_session = response.json() assert upload_session["uploads"] == [upload.api_url]
def test_create_evaluation_is_idempotent(self): s = SubmissionFactory(phase=self.method.phase, algorithm_image=self.algorithm_image) with capture_on_commit_callbacks(execute=False) as callbacks1: create_evaluation(submission_pk=s.pk, max_initial_jobs=None) with capture_on_commit_callbacks(execute=False) as callbacks2: create_evaluation(submission_pk=s.pk, max_initial_jobs=None) # Execute the callbacks non-recursively for c in chain(callbacks1, callbacks2): c() assert Job.objects.count() == 2
def test_archive_item_permissions_signal(client, reverse): # noqa: C901 ai1, ai2 = ArchiveItemFactory.create_batch(2) im1, im2, im3, im4 = ImageFactory.create_batch(4) civ1, civ2, civ3, civ4 = ( ComponentInterfaceValueFactory(image=im1), ComponentInterfaceValueFactory(image=im2), ComponentInterfaceValueFactory(image=im3), ComponentInterfaceValueFactory(image=im4), ) with capture_on_commit_callbacks(execute=True): if reverse: for civ in [civ1, civ2, civ3, civ4]: civ.archive_items.add(ai1, ai2) for civ in [civ3, civ4]: civ.archive_items.remove(ai1, ai2) for civ in [civ1, civ2]: civ.archive_items.remove(ai2) else: # Test that adding images works ai1.values.add(civ1, civ2, civ3, civ4) # Test that removing images works ai1.values.remove(civ3, civ4) assert get_groups_with_set_perms(im1) == { ai1.archive.editors_group: {"view_image"}, ai1.archive.uploaders_group: {"view_image"}, ai1.archive.users_group: {"view_image"}, } assert get_groups_with_set_perms(im2) == { ai1.archive.editors_group: {"view_image"}, ai1.archive.uploaders_group: {"view_image"}, ai1.archive.users_group: {"view_image"}, } assert get_groups_with_set_perms(im3) == {} assert get_groups_with_set_perms(im4) == {} # Test clearing with capture_on_commit_callbacks(execute=True): if reverse: civ1.archive_items.clear() civ2.archive_items.clear() else: ai1.values.clear() assert get_groups_with_set_perms(im1) == {} assert get_groups_with_set_perms(im2) == {}
def test_zaak_delete_oio_removed(self, m): mock_service_oas_get(m, APITypes.drc, self.base) document = f"{self.base}enkelvoudiginformatieobjecten/{uuid.uuid4()}" eio_response = get_eio_response( document, informatieobjecttype="http://testserver/catalogi/api/v1/iot/dummy", ) m.get(document, json=eio_response) zaak = ZaakFactory.create() zio = ZaakInformatieObjectFactory.create( zaak=zaak, informatieobject=document, _objectinformatieobject_url=f"{self.base}_objectinformatieobjecten/{uuid.uuid4()}", ) m.delete(zio._objectinformatieobject_url, status_code=204) zaak_delete_url = get_operation_url("zaak_delete", uuid=zaak.uuid) with capture_on_commit_callbacks(execute=True): response = self.client.delete(zaak_delete_url, **ZAAK_WRITE_KWARGS) self.assertEqual( response.status_code, status.HTTP_204_NO_CONTENT, response.data ) delete_call = next((req for req in m.request_history if req.method == "DELETE")) self.assertEqual(delete_call.url, zio._objectinformatieobject_url)
def test_unhiding_challenge_updates_perms(self, settings): """If a challenge is unhidden then the viewer group should be updated""" e: Evaluation = EvaluationFactory( submission__phase__auto_publish_new_results=True, submission__phase__challenge__hidden=True, ) participants = e.submission.phase.challenge.participants_group all_users = Group.objects.get( name=settings.REGISTERED_AND_ANON_USERS_GROUP_NAME) assert get_groups_with_set_perms(e) == { e.submission.phase.challenge.admins_group: { "change_evaluation", "view_evaluation", }, participants: {"view_evaluation"}, } # Override the celery settings settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) with capture_on_commit_callbacks(execute=True): e.submission.phase.challenge.hidden = False e.submission.phase.challenge.save() assert get_groups_with_set_perms(e) == { e.submission.phase.challenge.admins_group: { "change_evaluation", "view_evaluation", }, all_users: {"view_evaluation"}, }
def create_raw_upload_image_session( *, images: List[str], delete_file=False, user=None, linked_task=None, ) -> Tuple[RawImageUploadSession, Dict[str, RawImageFile]]: creator = user or UserFactory(email="*****@*****.**") upload_session = RawImageUploadSession(creator=creator) uploaded_images = {} for image in images: staged_file = create_file_from_filepath(RESOURCE_PATH / image) image = RawImageFile.objects.create( upload_session=upload_session, filename=staged_file.name, staged_file_id=staged_file.uuid, ) uploaded_images[staged_file.name] = image if delete_file: StagedAjaxFile( uploaded_images["image10x10x10.zraw"].staged_file_id).delete() upload_session.save() with capture_on_commit_callbacks(execute=True): upload_session.process_images(linked_task=linked_task) return upload_session, uploaded_images
def test_send_welcome_email_after_create(self): with capture_on_commit_callbacks(execute=True) as callbacks: UserAccount.objects.create(**self.stub_data) self.assertEquals(len(callbacks), 1, msg=f"{callbacks}") self.assertEqual(len(mail.outbox), 1) self.assertEqual(mail.outbox[0].subject, "Welcome!")
def test_user_upload_to_display_set_without_interface(client, settings): # Override the celery settings settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) user = UserFactory() rs = ReaderStudyFactory(use_display_sets=False) rs.add_editor(user=user) ci = ComponentInterface.objects.filter(slug="generic-overlay").get() civ = ComponentInterfaceValueFactory(interface=ci) ds = DisplaySetFactory(reader_study=rs) ds.values.add(civ) assert ds.values.count() == 1 upload = create_upload_from_file( file_path=Path(__file__).parent / "resources" / "image10x10x10.mha", creator=user, ) with capture_on_commit_callbacks(execute=True): response = get_view_for_user( viewname="api:upload-session-list", user=user, client=client, method=client.post, content_type="application/json", data={ "uploads": [upload.api_url], "display_set": ds.pk }, HTTP_X_FORWARDED_PROTO="https", ) assert response.status_code == 400 assert ("An interface needs to be defined to upload to a display set." in response.json()["non_field_errors"])
def test_send_notif_delete_resultaat(self, mock_client): """ Check if notifications will be send when resultaat is deleted """ client = mock_client.return_value besluit = BesluitFactory.create() besluit_url = get_operation_url("besluit_read", uuid=besluit.uuid) besluittype_url = reverse(besluit.besluittype) bio = BesluitInformatieObjectFactory.create(besluit=besluit) bio_url = get_operation_url("besluitinformatieobject_delete", uuid=bio.uuid) with capture_on_commit_callbacks(execute=True): response = self.client.delete(bio_url) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT, response.data) client.create.assert_called_once_with( "notificaties", { "kanaal": "besluiten", "hoofdObject": f"http://testserver{besluit_url}", "resource": "besluitinformatieobject", "resourceUrl": f"http://testserver{bio_url}", "actie": "destroy", "aanmaakdatum": "2018-09-07T00:00:00Z", "kenmerken": { "verantwoordelijkeOrganisatie": besluit.verantwoordelijke_organisatie, "besluittype": f"http://testserver{besluittype_url}", }, }, )
def test_non_zip_submission_failure(client, evaluation_image, submission_file, settings): # Override the celery settings settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) # Upload a submission and create an evaluation eval_container, sha256 = evaluation_image method = MethodFactory(image__from_path=eval_container, image_sha256=sha256, ready=True) # Try with a 7z file with capture_on_commit_callbacks(execute=True): submission = SubmissionFactory( predictions_file__from_path=Path(__file__).parent / "resources" / "submission.7z", phase=method.phase, ) # The evaluation method should return the correct answer assert len(submission.evaluation_set.all()) == 1 evaluation = submission.evaluation_set.first() assert evaluation.error_message.endswith( "7z-compressed files are not supported.") assert evaluation.status == evaluation.FAILURE
def test_api_archive_item_update_permissions(client, settings, add_to_group, status): # Override the celery settings settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) archive = ArchiveFactory() user = UserFactory() item = ArchiveItemFactory(archive=archive) if add_to_group: add_to_group(archive, user) ci = ComponentInterfaceFactory( kind=InterfaceKind.InterfaceKindChoices.BOOL) with capture_on_commit_callbacks(execute=True): response = get_view_for_user( viewname="api:archives-item-detail", reverse_kwargs={"pk": item.pk}, data={"values": [{ "interface": ci.slug, "value": True }]}, user=user, client=client, method=client.patch, content_type="application/json", HTTP_X_FORWARDED_PROTO="https", ) assert response.status_code == status
def test_besluitinformatieobject_delete_fail_send_notification_create_db_entry( self, ): bio = BesluitInformatieObjectFactory.create() url = reverse(bio) with capture_on_commit_callbacks(execute=True): response = self.client.delete(url) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) self.assertEqual(StatusLog.objects.count(), 1) logged_warning = StatusLog.objects.get() failed = FailedNotification.objects.get() message = { "aanmaakdatum": "2019-01-01T12:00:00Z", "actie": "destroy", "hoofdObject": f"http://testserver{reverse(bio.besluit)}", "kanaal": "besluiten", "kenmerken": { "verantwoordelijkeOrganisatie": bio.besluit.verantwoordelijke_organisatie, "besluittype": f"http://testserver{reverse(bio.besluit.besluittype)}", }, "resource": "besluitinformatieobject", "resourceUrl": f"http://testserver{url}", } self.assertEqual(failed.statuslog_ptr, logged_warning) self.assertEqual(failed.message, message)
def recurse_callbacks(callbacks): with capture_on_commit_callbacks() as new_callbacks: for callback in callbacks: callback() if new_callbacks: recurse_callbacks(callbacks=new_callbacks)
def test_gebruiksrechten_delete_fail_send_notification_create_db_entry( self): eio = EnkelvoudigInformatieObjectFactory.create() eio_url = f"http://testserver{reverse(eio)}" gebruiksrechten = GebruiksrechtenCMISFactory(informatieobject=eio_url) url = reverse(gebruiksrechten) with capture_on_commit_callbacks(execute=True): response = self.client.delete(url) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) self.assertEqual(StatusLog.objects.count(), 1) logged_warning = StatusLog.objects.get() failed = FailedNotification.objects.get() eio = EnkelvoudigInformatieObject.objects.get() message = { "aanmaakdatum": "2019-01-01T12:00:00Z", "actie": "destroy", "hoofdObject": f"http://testserver{reverse(eio)}", "kanaal": "documenten", "kenmerken": { "bronorganisatie": eio.bronorganisatie, "informatieobjecttype": f"http://testserver{reverse(eio.informatieobjecttype)}", "vertrouwelijkheidaanduiding": eio.vertrouwelijkheidaanduiding, }, "resource": "gebruiksrechten", "resourceUrl": f"http://testserver{url}", } self.assertEqual(failed.statuslog_ptr, logged_warning) self.assertEqual(failed.message, message)
def test_zaaktype_delete_fail_send_notification_create_db_entry(self): zaaktype = ZaakTypeFactory.create() url = reverse(zaaktype) with capture_on_commit_callbacks(execute=True): response = self.client.delete(url) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) self.assertEqual(StatusLog.objects.count(), 1) logged_warning = StatusLog.objects.get() failed = FailedNotification.objects.get() message = { "aanmaakdatum": "2019-01-01T12:00:00Z", "actie": "destroy", "hoofdObject": f"http://testserver{url}", "kanaal": "zaaktypen", "kenmerken": { "catalogus": f"http://testserver{reverse(zaaktype.catalogus)}", }, "resource": "zaaktype", "resourceUrl": f"http://testserver{url}", } self.assertEqual(failed.statuslog_ptr, logged_warning) self.assertEqual(failed.message, message)
def test_view_permission_when_reused(in_archive, in_rs, in_job): """When an image is reused it should have view_image set correctly""" im = ImageFactory() job = AlgorithmJobFactory() rs = ReaderStudyFactory(use_display_sets=False) archive = ArchiveFactory() if in_archive: civ = ComponentInterfaceValueFactory(image=im) ai = ArchiveItemFactory(archive=archive) with capture_on_commit_callbacks(execute=True): ai.values.add(civ) if in_rs: rs.images.add(im) if in_job: civ = ComponentInterfaceValueFactory(image=im) job.inputs.add(civ) assert ("view_image" in get_perms(archive.editors_group, im)) is in_archive assert ("view_image" in get_perms(archive.uploaders_group, im)) is in_archive assert ("view_image" in get_perms(archive.users_group, im)) is in_archive assert ("view_image" in get_perms(rs.editors_group, im)) is in_rs assert ("view_image" in get_perms(rs.readers_group, im)) is in_rs for g in job.viewer_groups.all(): assert ("view_image" in get_perms(g, im)) is in_job
def test_resultaat_delete_fail_send_notification_create_db_entry(self): resultaat = ResultaatFactory.create() url = reverse(resultaat) with capture_on_commit_callbacks(execute=True): response = self.client.delete(url) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) self.assertEqual(StatusLog.objects.count(), 1) logged_warning = StatusLog.objects.get() failed = FailedNotification.objects.get() message = { "aanmaakdatum": "2019-01-01T12:00:00Z", "actie": "destroy", "hoofdObject": f"http://testserver{reverse(resultaat.zaak)}", "kanaal": "zaken", "kenmerken": { "bronorganisatie": resultaat.zaak.bronorganisatie, "zaaktype": f"http://testserver{reverse(resultaat.zaak.zaaktype)}", "vertrouwelijkheidaanduiding": resultaat.zaak.vertrouwelijkheidaanduiding, }, "resource": "resultaat", "resourceUrl": f"http://testserver{url}", } self.assertEqual(failed.statuslog_ptr, logged_warning) self.assertEqual(failed.message, message)
def test_zaaktype_no_notify_on_no_change(self, m): procestype_url = ("https://selectielijst.openzaak.nl/api/v1/" "procestypen/e1b73b12-b2f6-4c4e-8929-94f84dd2a57d") mock_oas_get(m) mock_resource_list(m, "procestypen") mock_resource_get(m, "procestypen", procestype_url) mock_nrc_oas_get(m) m.post("https://notificaties-api.vng.cloud/api/v1/notificaties", status_code=201) zaaktype = ZaakTypeFactory.create( concept=True, zaaktype_omschrijving="test", vertrouwelijkheidaanduiding="openbaar", trefwoorden=["test"], verantwoordingsrelatie=["bla"], selectielijst_procestype=procestype_url, ) url = reverse("admin:catalogi_zaaktype_change", args=(zaaktype.pk, )) response = self.app.get(url) form = response.forms["zaaktype_form"] with capture_on_commit_callbacks(execute=True): form.submit("_save") called_urls = [item.url for item in m.request_history] self.assertNotIn( "https://notificaties-api.vng.cloud/api/v1/notificaties", called_urls)
def test_zaaktype_notify_on_create(self, m): mock_oas_get(m) mock_resource_list(m, "procestypen") mock_nrc_oas_get(m) m.post("https://notificaties-api.vng.cloud/api/v1/notificaties", status_code=201) url = reverse("admin:catalogi_zaaktype_add") response = self.app.get(url) form = response.forms["zaaktype_form"] form["zaaktype_omschrijving"] = "test" form["doel"] = "test" form["aanleiding"] = "test" form["indicatie_intern_of_extern"].select("intern") form["handeling_initiator"] = "test" form["onderwerp"] = "test" form["handeling_behandelaar"] = "test" form["doorlooptijd_behandeling_days"] = 12 form["opschorting_en_aanhouding_mogelijk"].select(False) form["verlenging_mogelijk"].select(False) form["vertrouwelijkheidaanduiding"].select("openbaar") form["producten_of_diensten"] = "https://example.com/foobarbaz" form["referentieproces_naam"] = "test" form["catalogus"] = self.catalogus.pk form["datum_begin_geldigheid"] = "21-11-2019" with capture_on_commit_callbacks(execute=True): form.submit("_save") called_urls = [item.url for item in m.request_history] self.assertIn("https://notificaties-api.vng.cloud/api/v1/notificaties", called_urls)
def test_send_notif_create_application(self, mock_client): """ Check if notifications will be send when applicaties is created """ client = mock_client.return_value url = get_operation_url("applicatie_create") data = { "client_ids": ["id1", "id2"], "label": "Melding Openbare Ruimte consumer", "heeftAlleAutorisaties": True, } with capture_on_commit_callbacks(execute=True): response = self.client.post(url, data) self.assertEqual(response.status_code, status.HTTP_201_CREATED) data = response.json() client.create.assert_called_once_with( "notificaties", { "kanaal": "autorisaties", "hoofdObject": data["url"], "resource": "applicatie", "resourceUrl": data["url"], "actie": "create", "aanmaakdatum": "2012-01-14T00:00:00Z", "kenmerken": {}, }, )
def test_algorithm_input_image_multiple_files(build_images, client, algorithm_io_image, settings, component_interfaces): # Override the celery settings settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) creator = UserFactory() assert Job.objects.count() == 0 # Create the algorithm image algorithm_container, sha256 = algorithm_io_image alg = AlgorithmImageFactory(image__from_path=algorithm_container, image_sha256=sha256, ready=True) alg.algorithm.add_editor(creator) alg.algorithm.inputs.set(ComponentInterface.objects.all()) # create the job job = Job.objects.create(creator=creator, algorithm_image=alg) us = RawImageUploadSessionFactory() ImageFactory(origin=us), ImageFactory(origin=us) ci = ComponentInterface.objects.get(slug=DEFAULT_INPUT_INTERFACE_SLUG) civ = ComponentInterfaceValue.objects.create(interface=ci) job.inputs.add(civ) with pytest.raises(ValueError): with capture_on_commit_callbacks(execute=True): run_algorithm_job_for_inputs(job_pk=job.pk, upload_pks={civ.pk: us.pk})
def test_algorithm_with_invalid_output(client, algorithm_image, settings): # Override the celery settings settings.task_eager_propagates = (True, ) settings.task_always_eager = (True, ) assert Job.objects.count() == 0 # Create the algorithm image algorithm_container, sha256 = algorithm_image alg = AlgorithmImageFactory(image__from_path=algorithm_container, image_sha256=sha256, ready=True) # Make sure the job fails when trying to upload an invalid file detection_interface = ComponentInterfaceFactory( store_in_database=False, relative_path="some_text.txt", slug="detection-json-file", kind=ComponentInterface.Kind.JSON, ) alg.algorithm.outputs.add(detection_interface) alg.save() image_file = ImageFileFactory(file__from_path=Path(__file__).parent / "resources" / "input_file.tif") with capture_on_commit_callbacks(execute=True): execute_jobs(algorithm_image=alg, images=[image_file.image]) jobs = Job.objects.filter(algorithm_image=alg, inputs__image=image_file.image, status=Job.FAILURE).all() assert len(jobs) == 1 assert jobs.first().error_message == "Invalid filetype." assert len(jobs[0].outputs.all()) == 2
def test_send_notif_update_application(self, mock_client): """ Check if notifications will be send when applicatie is updated """ client = mock_client.return_value autorisatie = AutorisatieFactory.create( applicatie__client_ids=["id1", "id2"], zaaktype="https://example.com", scopes=["dummy.scope"], max_vertrouwelijkheidaanduiding=VertrouwelijkheidsAanduiding. openbaar, ) applicatie = autorisatie.applicatie url = get_operation_url("applicatie_partial_update", uuid=applicatie.uuid) with capture_on_commit_callbacks(execute=True): response = self.client.patch(url, {"client_ids": ["id1"]}) self.assertEqual(response.status_code, status.HTTP_200_OK) data = response.json() client.create.assert_called_once_with( "notificaties", { "kanaal": "autorisaties", "hoofdObject": data["url"], "resource": "applicatie", "resourceUrl": data["url"], "actie": "partial_update", "aanmaakdatum": "2012-01-14T00:00:00Z", "kenmerken": {}, }, )