def test_add_autorisatie_all_current_and_future_besluittypen(self):
data = {
# management form
"form-TOTAL_FORMS":
1,
"form-INITIAL_FORMS":
0,
"form-MIN_NUM_FORMS":
0,
"form-MAX_NUM_FORMS":
1000,
"form-0-component":
ComponentTypes.brc,
"form-0-scopes": ["besluiten.lezen"],
"form-0-related_type_selection":
RelatedTypeSelectionMethods.all_current_and_future,
}
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, 302)
self.assertFalse(Autorisatie.objects.exists())
# create a besluittype - this should trigger a new autorisatie being installed
BesluitTypeFactory.create()
self.assertEqual(self.applicatie.autorisaties.count(), 1)
def test_noop_all_current_and_future_besluittypen(self):
bt = BesluitTypeFactory.create()
Autorisatie.objects.create(
applicatie=self.applicatie,
component=ComponentTypes.brc,
scopes=["besluiten.lezen"],
informatieobjecttype=f"http://testserver{bt.get_absolute_api_url()}",
max_vertrouwelijkheidaanduiding=VertrouwelijkheidsAanduiding.beperkt_openbaar,
)
data = {
# management form
"form-TOTAL_FORMS": 1,
"form-INITIAL_FORMS": 0,
"form-MIN_NUM_FORMS": 0,
"form-MAX_NUM_FORMS": 1000,
"form-0-component": ComponentTypes.brc,
"form-0-scopes": ["besluiten.lezen"],
"form-0-related_type_selection": RelatedTypeSelectionMethods.all_current_and_future,
}
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, 302)
self.assertEqual(self.applicatie.autorisaties.count(), 1)
# create a InformatieObjectType - this should trigger a new autorisatie
# being installed
BesluitTypeFactory.create()
self.assertEqual(self.applicatie.autorisaties.count(), 2)
# creating other types should not trigger anything, nor error
ZaakTypeFactory.create()
InformatieObjectTypeFactory.create()
self.assertEqual(self.applicatie.autorisaties.count(), 2)
def test_add_autorisatie_all_current_besluittypen(self):
bt1 = BesluitTypeFactory.create(concept=False)
bt2 = BesluitTypeFactory.create(concept=True)
data = {
# management form
"form-TOTAL_FORMS":
1,
"form-INITIAL_FORMS":
0,
"form-MIN_NUM_FORMS":
0,
"form-MAX_NUM_FORMS":
1000,
"form-0-component":
ComponentTypes.brc,
"form-0-scopes": ["besluiten.lezen"],
"form-0-related_type_selection":
RelatedTypeSelectionMethods.all_current,
}
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, 302)
self.assertEqual(Autorisatie.objects.count(), 2)
self.assertEqual(self.applicatie.autorisaties.count(), 2)
urls = [
reverse("besluittype-detail",
kwargs={
"version": 1,
"uuid": bt1.uuid
}),
reverse("besluittype-detail",
kwargs={
"version": 1,
"uuid": bt2.uuid
}),
]
for autorisatie in Autorisatie.objects.all():
with self.subTest(autorisatie=autorisatie):
self.assertEqual(autorisatie.component, ComponentTypes.brc)
self.assertEqual(autorisatie.scopes, ["besluiten.lezen"])
self.assertEqual(autorisatie.max_vertrouwelijkheidaanduiding,
"")
self.assertIsInstance(autorisatie.besluittype, str)
parsed = urlparse(autorisatie.besluittype)
self.assertEqual(parsed.scheme, "http")
self.assertEqual(parsed.netloc, "testserver")
self.assertIn(parsed.path, urls)
def test_relation_with_non_published_zaaktype(self):
zaak = ZaakFactory.create(zaaktype__concept=True)
zaak_url = reverse(zaak)
besluittype = BesluitTypeFactory.create()
besluittype_url = reverse(besluittype)
besluittype.zaaktypes.add(zaak.zaaktype)
list_url = reverse("besluit-list")
response = self.client.post(
list_url,
{
"verantwoordelijkeOrganisatie": "000000000",
"identificatie": "123456",
"besluittype": f"http://testserver{besluittype_url}",
"zaak": f"http://testserver{zaak_url}",
"datum": "2018-09-06",
"ingangsdatum": "2018-10-01",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "zaaktype-mismatch")
def test_create_with_external_zaak_fail_create_zaakbesluit(self):
besluittype = BesluitTypeFactory.create(concept=False)
zaaktype = ZaakTypeFactory.create(concept=False,
catalogus=besluittype.catalogus)
zaaktype.besluittypen.add(besluittype)
zaaktype_url = f"http://testserver{reverse(zaaktype)}"
zaak = f"{self.base}zaken/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
url = get_operation_url("besluit_create")
with requests_mock.Mocker(real_http=True) as m:
mock_service_oas_get(m, APITypes.zrc, self.base)
m.get(zaak, json=get_zaak_response(zaak, zaaktype_url))
m.post(f"{zaak}/besluiten", status_code=404, text="Not Found")
response = self.client.post(
url,
{
"verantwoordelijke_organisatie": "517439943",
"identificatie": "123123",
"besluittype": f"http://testserver{reverse(besluittype)}",
"datum": "2018-09-06",
"toelichting": "Vergunning verleend.",
"ingangsdatum": "2018-10-01",
"vervaldatum": "2018-11-01",
"vervalreden": VervalRedenen.tijdelijk,
"zaak": zaak,
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
error = get_validation_errors(response, "zaak")
self.assertEqual(error["code"], "pending-relations")
def test_zaakbesluiten(self):
besluittype = BesluitTypeFactory.create(zaaktypen=[self.zaaktype],
concept=False)
besluittype_url = f"http://testserver{reverse(besluittype)}"
Autorisatie.objects.create(
applicatie=self.applicatie,
component=ComponentTypes.brc,
scopes=[
SCOPE_BESLUITEN_AANMAKEN,
SCOPE_BESLUITEN_ALLES_LEZEN,
SCOPE_BESLUITEN_ALLES_VERWIJDEREN,
],
besluittype=besluittype_url,
)
self.assertCreateAllowed(
reverse(Besluit),
{
"besluittype": besluittype_url,
"zaak": f"http://testserver{reverse(self.zaak)}",
"verantwoordelijke_organisatie": "517439943", # RSIN
"identificatie": "123123",
"datum": "2018-09-06",
"toelichting": "Vergunning verleend.",
"ingangsdatum": "2018-10-01",
},
)
besluit = BesluitFactory.create(zaak=self.zaak,
besluittype=besluittype)
self.assertDestroyAllowed(reverse(besluit))
def test_inline_besluittype_autorisaties(self):
bt = BesluitTypeFactory.create()
self._add_autorisatie(bt,
component=ComponentTypes.brc,
scopes=["besluiten.lezen"])
response = self.app.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, str(bt))
def test_update_besluittype_fails(self):
besluit = BesluitFactory.create()
besluit_url = reverse(besluit)
besluittype = BesluitTypeFactory.create()
besluittype_url = reverse(besluittype)
response = self.client.patch(
besluit_url,
{"besluittype": f"http://testserver{besluittype_url}"})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
error = get_validation_errors(response, "besluittype")
self.assertEqual(error["code"], IsImmutableValidator.code)
def test_besluit_create(self):
besluit_url = reverse(Besluit)
besluittype = BesluitTypeFactory.create(concept=True)
besluittype_url = reverse(besluittype)
data = {
"verantwoordelijke_organisatie": "517439943",
"besluittype": f"http://testserver{besluittype_url}",
"datum": "2018-09-06",
"ingangsdatum": "2018-10-01",
}
response = self.client.post(besluit_url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED, response.data)
def _create_besluit(self, zaak: str) -> Besluit:
besluittype = BesluitTypeFactory.create(concept=False, zaaktypen=[])
zaaktype = besluittype.zaaktypen.get()
zaaktype_url = f"http://testserver{reverse(zaaktype)}"
zaakbesluit_data = get_zaakbesluit_response(zaak)
# create besluit
with requests_mock.Mocker(real_http=True) as m:
m.get(zaak, json=get_zaak_response(zaak, zaaktype_url))
m.post(f"{zaak}/besluiten", json=zaakbesluit_data)
besluit = BesluitFactory.create(
zaak=zaak,
besluittype=besluittype,
_zaakbesluit_url=zaakbesluit_data["url"],
)
return besluit
def _create_besluit(self, **HEADERS):
url = reverse(Besluit)
besluittype = BesluitTypeFactory.create(concept=False)
besluittype_url = reverse(besluittype)
besluit_data = {
"verantwoordelijkeOrganisatie": "000000000",
"besluittype": f"http://testserver{besluittype_url}",
"datum": "2019-04-25",
"ingangsdatum": "2019-04-26",
"vervaldatum": "2019-04-28",
"identificatie": "123123",
}
response = self.client.post(url, besluit_data, **HEADERS)
return response.data
def test_filter_besluittype(self):
url = get_operation_url("besluit_list")
type1, type2 = BesluitTypeFactory.create_batch(2)
BesluitFactory.create_batch(3, besluittype=type1)
BesluitFactory.create_batch(1, besluittype=type2)
type1_url = get_catalogus_operation_url("besluittype_read",
uuid=type1.uuid)
response = self.client.get(
url,
{"besluittype": f"http://openzaak.nl{type1_url}"},
HTTP_HOST="openzaak.nl",
)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertEqual(response.data["count"], 3)
def test_validate_besluittype_valid(self):
besluittype = BesluitTypeFactory.create()
besluittype_url = reverse(besluittype)
url = reverse("besluit-list")
response = self.client.post(
url,
{
"verantwoordelijkeOrganisatie": "000000000",
"identificatie": "123456",
"besluittype": f"http://testserver{besluittype_url}",
"datum": "2018-09-06",
"ingangsdatum": "2018-10-01",
},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
def _create_besluit(self):
besluittype = BesluitTypeFactory.create(concept=False)
add_url = reverse("admin:besluiten_besluit_add")
data = {
"uuid": uuid.uuid4(),
"_besluittype": besluittype.id,
"verantwoordelijke_organisatie": "517439943",
"datum": "15-11-2019",
"ingangsdatum": "15-11-2019",
"toelichting": "desc",
}
data.update(inline_data)
self.client.post(add_url, data)
self.assertEqual(Besluit.objects.count(), 1)
return Besluit.objects.get()
def test_besluit_create_fail_send_notification_create_db_entry(self):
besluittype = BesluitTypeFactory.create(concept=False)
besluittype_url = reverse(besluittype)
url = get_operation_url("besluit_create")
data = {
"verantwoordelijkeOrganisatie": "517439943", # RSIN
"besluittype": f"http://testserver{besluittype_url}",
"identificatie": "123123",
"datum": "2018-09-06",
"toelichting": "Vergunning verleend.",
"ingangsdatum": "2018-10-01",
"vervaldatum": "2018-11-01",
"vervalreden": VervalRedenen.tijdelijk,
}
with capture_on_commit_callbacks(execute=True):
response = self.client.post(url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
data = response.json()
self.assertEqual(StatusLog.objects.count(), 1)
logged_warning = StatusLog.objects.get()
failed = FailedNotification.objects.get()
message = {
"aanmaakdatum": "2019-01-01T12:00:00Z",
"actie": "create",
"hoofdObject": data["url"],
"kanaal": "besluiten",
"kenmerken": {
"verantwoordelijkeOrganisatie":
data["verantwoordelijkeOrganisatie"],
"besluittype":
f"http://testserver{besluittype_url}",
},
"resource": "besluit",
"resourceUrl": data["url"],
}
self.assertEqual(failed.statuslog_ptr, logged_warning)
self.assertEqual(failed.message, message)
def test_create_with_external_zaak(self):
zaak = f"{self.base}zaken/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
besluittype = BesluitTypeFactory.create(concept=False)
zaaktype = ZaakTypeFactory.create(
concept=False, catalogus=besluittype.catalogus
)
zaaktype.besluittypen.add(besluittype)
zaaktype_url = f"http://testserver{reverse(zaaktype)}"
zaakbesluit_data = get_zaakbesluit_response(zaak)
url = get_operation_url("besluit_create")
with requests_mock.Mocker(real_http=True) as m:
mock_service_oas_get(m, APITypes.zrc, self.base)
m.get(zaak, json=get_zaak_response(zaak, zaaktype_url))
m.post(f"{zaak}/besluiten", json=zaakbesluit_data, status_code=201)
response = self.client.post(
url,
{
"verantwoordelijke_organisatie": "517439943",
"identificatie": "123123",
"besluittype": f"http://testserver{reverse(besluittype)}",
"datum": "2018-09-06",
"toelichting": "Vergunning verleend.",
"ingangsdatum": "2018-10-01",
"vervaldatum": "2018-11-01",
"vervalreden": VervalRedenen.tijdelijk,
"zaak": zaak,
},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED, response.data)
besluit = Besluit.objects.get()
besluit_url = f"http://testserver{reverse(besluit)}"
self.assertEqual(besluit._zaakbesluit_url, zaakbesluit_data["url"])
history_post = [
req
for req in m.request_history
if req.method == "POST" and req.url == f"{zaak}/besluiten"
]
self.assertEqual(len(history_post), 1)
self.assertEqual(history_post[0].json(), {"besluit": besluit_url})
def test_besluittype_unpublished(self):
besluittype = BesluitTypeFactory.create()
besluittype_url = reverse(besluittype)
url = reverse("besluit-list")
response = self.client.post(
url,
{
"verantwoordelijkeOrganisatie": "000000000",
"identificatie": "123456",
"besluittype": f"http://testserver{besluittype_url}",
"datum": "2018-09-06",
"ingangsdatum": "2018-10-01",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "besluittype")
self.assertEqual(error["code"], "not-published")
def test_send_notif_create_besluit(self, mock_client, *mocks):
"""
Check if notifications will be send when Besluit is created
"""
client = mock_client.return_value
besluittype = BesluitTypeFactory.create(concept=False)
besluittype_url = reverse(besluittype)
url = get_operation_url("besluit_create")
data = {
"verantwoordelijkeOrganisatie": "517439943", # RSIN
"besluittype": f"http://testserver{besluittype_url}",
"identificatie": "123123",
"datum": "2018-09-06",
"toelichting": "Vergunning verleend.",
"ingangsdatum": "2018-10-01",
"vervaldatum": "2018-11-01",
"vervalreden": VervalRedenen.tijdelijk,
}
with capture_on_commit_callbacks(execute=True):
response = self.client.post(url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
data = response.json()
client.create.assert_called_once_with(
"notificaties",
{
"kanaal": "besluiten",
"hoofdObject": data["url"],
"resource": "besluit",
"resourceUrl": data["url"],
"actie": "create",
"aanmaakdatum": "2018-09-07T00:00:00Z",
"kenmerken": {
"verantwoordelijkeOrganisatie": "517439943",
"besluittype": f"http://testserver{besluittype_url}",
},
},
)
def test_zaaktype_besluittype_relation(self):
besluittype = BesluitTypeFactory.create()
besluittype_url = reverse(besluittype)
zaak = ZaakFactory.create(zaaktype__concept=False)
zaak_url = reverse(zaak)
besluittype.zaaktypes.add(zaak.zaaktype)
list_url = reverse("besluit-list")
response = self.client.post(
list_url,
{
"verantwoordelijkeOrganisatie": "000000000",
"identificatie": "123456",
"besluittype": f"http://testserver{besluittype_url}",
"zaak": f"http://testserver{zaak_url}",
"datum": "2018-09-06",
"ingangsdatum": "2018-10-01",
},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
def test_bulk_create(self):
besluittype = BesluitTypeFactory.create()
besluit = BesluitFactory.build(besluittype=besluittype)
self.assertRaises(QueryBlocked, Besluit.objects.bulk_create, [besluit])
def setUpTestData(cls):
cls.besluittype = BesluitTypeFactory.create()
super().setUpTestData()
def test_us162_voeg_besluit_toe_aan_zaak(self):
zaak = ZaakFactory.create(zaaktype__concept=False)
zaak_url = reverse(zaak)
besluittype = BesluitTypeFactory.create(concept=False)
besluittype_url = reverse(besluittype)
besluittype.zaaktypen.add(zaak.zaaktype)
io = EnkelvoudigInformatieObjectFactory.create(
informatieobjecttype__concept=False)
io_url = reverse(io)
self.adapter.get(io_url, json=serialise_eio(io, io_url))
besluittype.informatieobjecttypen.add(io.informatieobjecttype)
with self.subTest(part="besluit_create"):
url = get_operation_url("besluit_create")
response = self.client.post(
url,
{
"verantwoordelijke_organisatie": "517439943", # RSIN
"identificatie": "123123",
"besluittype": f"http://testserver{besluittype_url}",
"zaak": f"http://testserver{zaak_url}",
"datum": "2018-09-06",
"toelichting": "Vergunning verleend.",
"ingangsdatum": "2018-10-01",
"vervaldatum": "2018-11-01",
"vervalreden": VervalRedenen.tijdelijk,
},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
self.assertResponseTypes(
response.data,
(
("url", str),
("identificatie", str),
("verantwoordelijke_organisatie", str),
("besluittype", str),
("zaak", str),
("datum", str),
("toelichting", str),
("bestuursorgaan", str),
("ingangsdatum", str),
("vervaldatum", str),
("vervalreden", str),
("publicatiedatum", type(None)),
("verzenddatum", type(None)),
("uiterlijke_reactiedatum", type(None)),
),
)
self.assertEqual(Besluit.objects.count(), 1)
besluit = Besluit.objects.get()
self.assertEqual(besluit.verantwoordelijke_organisatie,
"517439943")
self.assertEqual(besluit.besluittype, besluittype)
self.assertEqual(besluit.zaak, zaak)
self.assertEqual(besluit.datum, date(2018, 9, 6))
self.assertEqual(besluit.toelichting, "Vergunning verleend.")
self.assertEqual(besluit.ingangsdatum, date(2018, 10, 1))
self.assertEqual(besluit.vervaldatum, date(2018, 11, 1))
self.assertEqual(besluit.vervalreden, VervalRedenen.tijdelijk)
with self.subTest(part="besluitinformatieobject_create"):
url = get_operation_url("besluitinformatieobject_create")
response = self.client.post(
url,
{
"besluit": reverse(besluit),
"informatieobject": f"http://testserver{io_url}",
},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
self.assertResponseTypes(response.data,
(("url", str), ("informatieobject", str)))
self.assertEqual(besluit.besluitinformatieobject_set.count(), 1)
self.assertEqual(
besluit.besluitinformatieobject_set.get().informatieobject.
uuid, io.uuid)
