def test_filter_ook_zaaktype(self):
zaaktype1 = ZaakTypeFactory.create()
zaaktype2 = ZaakTypeFactory.create()
zaaktype1_url = reverse(zaaktype1)
# both in district
ZaakFactory.create(zaakgeometrie=Point(4.887990, 52.377595), zaaktype=zaaktype1)
ZaakFactory.create(zaakgeometrie=Point(4.887990, 52.377595), zaaktype=zaaktype2)
url = get_operation_url("zaak__zoek")
response = self.client.post(
url,
{
"zaakgeometrie": {
"within": {
"type": "Polygon",
"coordinates": [POLYGON_AMSTERDAM_CENTRUM],
}
},
"zaaktype": f"http://testserver{zaaktype1_url}",
},
**ZAAK_WRITE_KWARGS,
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()["results"]
self.assertEqual(len(response_data), 1)
def test_get_detail_404(self):
ZaakTypeFactory.create(catalogus=self.catalogus)
url = get_operation_url("zaaktype_read", uuid=uuid.uuid4())
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
resp_data = response.json()
del resp_data["instance"]
self.assertEqual(
resp_data,
{
"code": "not_found",
"title": "Niet gevonden.",
"status": 404,
"detail": "Niet gevonden.",
"type": "http://testserver{}".format(
django_reverse(
"vng_api_common:error-detail",
kwargs={"exception_class": "NotFound"},
)
),
},
)
def test_no_overlap(self):
ZaakTypeFactory.create(
catalogus=self.catalogus,
zaaktype_identificatie=1,
datum_begin_geldigheid=date(2019, 1, 1),
datum_einde_geldigheid=date(2020, 1, 1),
zaaktype_omschrijving="zaaktype",
)
data = {
"omschrijving": "zaaktype",
"identificatie": 1,
"catalogus": f"http://testserver{reverse(self.catalogus)}",
"beginGeldigheid": "2020-02-01",
"vertrouwelijkheidaanduiding": VertrouwelijkheidsAanduiding.openbaar,
"doel": "doel",
"aanleiding": "aanleiding",
"indicatieInternOfExtern": "extern",
"handelingInitiator": "aanvragen",
"onderwerp": "dummy",
"handelingBehandelaar": "behandelen",
"doorlooptijd": "P7D",
"opschortingEnAanhoudingMogelijk": False,
"verlengingMogelijk": False,
"publicatieIndicatie": False,
"productenOfDiensten": [],
"referentieproces": {"naam": "ref", "link": "https://example.com"},
"besluittypen": [],
"gerelateerdeZaaktypen": [],
"versiedatum": "2019-02-01",
}
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_filter_zaaktype_status_alles(self):
ZaakTypeFactory.create(concept=True)
ZaakTypeFactory.create(concept=False)
zaaktype_list_url = get_operation_url("zaaktype_list")
response = self.client.get(zaaktype_list_url, {"status": "alles"})
self.assertEqual(response.status_code, 200)
data = response.json()["results"]
self.assertEqual(len(data), 2)
def test_pagination_page_param(self):
ZaakTypeFactory.create_batch(2, concept=False)
zaaktype_list_url = get_operation_url("zaaktype_list")
response = self.client.get(zaaktype_list_url, {"page": 1})
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertEqual(response_data["count"], 2)
self.assertIsNone(response_data["previous"])
self.assertIsNone(response_data["next"])
def test_filter_zaaktype_status_definitief(self):
zaaktype1 = ZaakTypeFactory.create(concept=True)
zaaktype2 = ZaakTypeFactory.create(concept=False)
zaaktype_list_url = get_operation_url("zaaktype_list")
zaaktype2_url = get_operation_url("zaaktype_read", uuid=zaaktype2.uuid)
response = self.client.get(zaaktype_list_url, {"status": "definitief"})
self.assertEqual(response.status_code, 200)
data = response.json()["results"]
self.assertEqual(len(data), 1)
self.assertEqual(data[0]["url"], f"http://testserver{zaaktype2_url}")
def test_filter_identificatie(self):
zaaktype1 = ZaakTypeFactory.create(concept=False, zaaktype_identificatie=123)
zaaktype2 = ZaakTypeFactory.create(concept=False, zaaktype_identificatie=456)
zaaktype_list_url = get_operation_url("zaaktype_list")
zaaktype1_url = get_operation_url("zaaktype_read", uuid=zaaktype1.uuid)
response = self.client.get(zaaktype_list_url, {"identificatie": 123})
self.assertEqual(response.status_code, 200)
data = response.json()["results"]
self.assertEqual(len(data), 1)
self.assertEqual(data[0]["url"], f"http://testserver{zaaktype1_url}")
def test_validate_wrong_resultaattypeomschrijving(self, mock_shape,
mock_fetch):
zaaktype = ZaakTypeFactory.create(concept=False)
zaaktype_url = reverse("zaaktype-detail",
kwargs={"uuid": zaaktype.uuid})
resultaattypeomschrijving_url = "http://example.com/omschrijving/1"
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"omschrijving": "illum",
"resultaattypeomschrijving": resultaattypeomschrijving_url,
"selectielijstklasse": "https://garcia.org/",
"archiefnominatie": "blijvend_bewaren",
"archiefactietermijn": "P10Y",
"brondatumArchiefprocedure": {
"afleidingswijze":
BrondatumArchiefprocedureAfleidingswijze.afgehandeld,
"einddatumBekend": False,
"procestermijn": "P10Y",
"datumkenmerk": "",
"objecttype": "",
"registratie": "",
},
}
with requests_mock.Mocker() as m:
m.register_uri("GET",
resultaattypeomschrijving_url,
json={"omschrijving": "test"})
response = self.client.post(self.list_url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "resultaattypeomschrijving")
self.assertEqual(error["code"], "invalid-resource")
def test_get_detail(self):
zaaktype = ZaakTypeFactory.create(catalogus=self.catalogus)
zaaktype_url = reverse("zaaktype-detail",
kwargs={"uuid": zaaktype.uuid})
specificatie = EigenschapSpecificatieFactory.create(kardinaliteit="1",
lengte="1",
groep="groep")
eigenschap = EigenschapFactory.create(
eigenschapnaam="Beoogd product",
zaaktype=zaaktype,
specificatie_van_eigenschap=specificatie,
)
eigenschap_detail_url = reverse("eigenschap-detail",
kwargs={"uuid": eigenschap.uuid})
response = self.api_client.get(eigenschap_detail_url)
self.assertEqual(response.status_code, 200)
expected = {
"url": "http://testserver{}".format(eigenschap_detail_url),
"naam": "Beoogd product",
"definitie": "",
"specificatie": {
"formaat": "",
"groep": "groep",
"kardinaliteit": "1",
"lengte": "1",
"waardenverzameling": [],
},
"toelichting": "",
"zaaktype": "http://testserver{}".format(zaaktype_url),
}
self.assertEqual(expected, response.json())
def test_create_zaak_causes_archiving_defaults(self):
"""
Create ZAAK and validate default archive attributes
"""
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
zaak_create_url = get_operation_url("zaak_create")
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"vertrouwelijkheidaanduiding":
VertrouwelijkheidsAanduiding.openbaar,
"bronorganisatie": "517439943",
"verantwoordelijkeOrganisatie": VERANTWOORDELIJKE_ORGANISATIE,
"startdatum": "2018-07-25",
"einddatum": "2018-08-25",
"einddatumGepland": "2018-08-25",
"toelichting": "",
"omschrijving": "",
}
response = self.client.post(zaak_create_url, data, **ZAAK_WRITE_KWARGS)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
data = response.json()
self.assertIsNone(data["archiefnominatie"])
self.assertEqual(data["archiefstatus"],
Archiefstatus.nog_te_archiveren)
self.assertIsNone(data["archiefactiedatum"])
def test_api_51_status_codes(self):
with self.subTest(crud="create"):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
url = reverse("zaak-list")
response = self.client.post(
url,
{
"zaaktype": f"http://testserver{zaaktype_url}",
"vertrouwelijkheidaanduiding":
VertrouwelijkheidsAanduiding.openbaar,
"bronorganisatie": "517439943",
"verantwoordelijkeOrganisatie": "517439943",
"registratiedatum": "2018-06-11",
"startdatum": "2018-06-11",
},
**ZAAK_WRITE_KWARGS,
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response["Location"], response.data["url"])
with self.subTest(crud="read"):
response_detail = self.client.get(response.data["url"],
**ZAAK_READ_KWARGS)
self.assertEqual(response_detail.status_code, status.HTTP_200_OK)
def registreer_zaak(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
zaak_create_url = get_operation_url("zaak_create")
created = parser.parse(self.data["datetime"])
intern_id = self.data["id"]
response = self.client.post(
zaak_create_url,
{
"zaaktype": f"http://testserver{zaaktype_url}",
"vertrouwelijkheidaanduiding": VertrouwelijkheidsAanduiding.openbaar,
"bronorganisatie": "517439943",
"verantwoordelijkeOrganisatie": VERANTWOORDELIJKE_ORGANISATIE,
"identificatie": f"WATER_{intern_id}",
"registratiedatum": created.strftime("%Y-%m-%d"),
"startdatum": created.strftime("%Y-%m-%d"),
"toelichting": self.data["text"],
"zaakgeometrie": self.data["coordinates"],
},
**ZAAK_WRITE_KWARGS,
)
self.references["zaak_url"] = response.json()["url"]
self.references["zaaktype"] = zaaktype
def test_create_aanvraag(self):
"""
Maak een zaak voor een aanvraag.
"""
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
zaak_create_url = get_operation_url("zaak_create")
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"vertrouwelijkheidaanduiding":
VertrouwelijkheidsAanduiding.openbaar,
"bronorganisatie": "517439943",
"verantwoordelijkeOrganisatie": VERANTWOORDELIJKE_ORGANISATIE,
"identificatie": "HLM-straatartiest-42",
"omschrijving": "Dagontheffing - Station Haarlem",
"toelichting":
"Het betreft een clown met grote trom, mondharmonica en cymbalen.",
"startdatum": "2018-08-15",
}
# aanmaken zaak
response = self.client.post(zaak_create_url, data, **ZAAK_WRITE_KWARGS)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
data = response.json()
self.assertIn("identificatie", data)
self.assertEqual(data["registratiedatum"],
date.today().strftime("%Y-%m-%d"))
self.assertEqual(data["startdatum"], "2018-08-15")
def test_get_detail(self):
zaaktype = ZaakTypeFactory.create(catalogus=self.catalogus)
zaaktype_detail_url = get_operation_url("zaaktype_read", uuid=zaaktype.uuid)
response = self.api_client.get(zaaktype_detail_url)
self.assertEqual(response.status_code, 200)
expected = {
"url": f"http://testserver{zaaktype_detail_url}",
# 'ingangsdatumObject': '2018-01-01',
# 'einddatumObject': None,
"identificatie": zaaktype.zaaktype_identificatie,
"productenOfDiensten": ["https://example.com/product/123"],
# 'broncatalogus': None,
"publicatieIndicatie": zaaktype.publicatie_indicatie,
"trefwoorden": [],
# 'zaakcategorie': None,
"toelichting": "",
"handelingInitiator": zaaktype.handeling_initiator,
# 'bronzaaktype': None,
"aanleiding": zaaktype.aanleiding,
"verlengingstermijn": None if not zaaktype.verlenging_mogelijk else "P30D",
"opschortingEnAanhoudingMogelijk": zaaktype.opschorting_en_aanhouding_mogelijk,
"catalogus": f"http://testserver{self.catalogus_detail_url}",
"indicatieInternOfExtern": zaaktype.indicatie_intern_of_extern,
"verlengingMogelijk": zaaktype.verlenging_mogelijk,
"handelingBehandelaar": zaaktype.handeling_behandelaar,
"doel": zaaktype.doel,
# 'versiedatum': '2018-01-01',
# 'formulier': [],
"onderwerp": zaaktype.onderwerp,
"publicatietekst": "",
"omschrijvingGeneriek": "",
"vertrouwelijkheidaanduiding": "",
"verantwoordingsrelatie": [],
"selectielijstProcestype": zaaktype.selectielijst_procestype,
# 'isDeelzaaktypeVan': [],
"servicenorm": None,
# 'archiefclassificatiecode': None,
"referentieproces": {"naam": zaaktype.referentieproces_naam, "link": ""},
"doorlooptijd": "P30D",
# 'verantwoordelijke': '',
"omschrijving": "",
"eigenschappen": [],
"informatieobjecttypen": [],
"gerelateerdeZaaktypen": [],
# 'heeftRelevantBesluittype': [],
# 'heeftRelevantZaakObjecttype': [],
"statustypen": [],
"resultaattypen": [],
"roltypen": [],
"besluittypen": [],
"beginGeldigheid": "2018-01-01",
"eindeGeldigheid": None,
"versiedatum": "2018-01-01",
"concept": True,
}
self.assertEqual(expected, response.json())
def test_filter_trefwoorden(self):
zaaktype1 = ZaakTypeFactory.create(
concept=False, trefwoorden=["some", "key", "words"]
)
zaaktype2 = ZaakTypeFactory.create(
concept=False, trefwoorden=["other", "words"]
)
zaaktype_list_url = get_operation_url("zaaktype_list")
zaaktype1_url = get_operation_url("zaaktype_read", uuid=zaaktype1.uuid)
response = self.client.get(zaaktype_list_url, {"trefwoorden": "key"})
self.assertEqual(response.status_code, 200)
data = response.json()["results"]
self.assertEqual(len(data), 1)
self.assertEqual(data[0]["url"], f"http://testserver{zaaktype1_url}")
def test_delete_zaaktype(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = get_operation_url("zaaktype_read", uuid=zaaktype.uuid)
response = self.client.delete(zaaktype_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(ZaakType.objects.filter(id=zaaktype.id))
def setUpTestData(cls):
super().setUpTestData()
cls.zaaktype = ZaakTypeFactory.create()
cls.statustype = StatusTypeFactory.create(zaaktype=cls.zaaktype)
cls.statustype_end = StatusTypeFactory.create(zaaktype=cls.zaaktype)
cls.zaaktype_url = reverse(cls.zaaktype)
cls.statustype_url = reverse(cls.statustype)
cls.statustype_end_url = reverse(cls.statustype_end)
def test_delete_zaaktype_fail_not_concept(self):
zaaktype = ZaakTypeFactory.create(concept=False)
zaaktype_url = get_operation_url("zaaktype_read", uuid=zaaktype.uuid)
response = self.client.delete(zaaktype_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
data = response.json()
self.assertEqual(data["detail"], "Alleen concepten kunnen worden verwijderd.")
def test_publish_zaaktype(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = get_operation_url("zaaktype_publish", uuid=zaaktype.uuid)
response = self.client.post(zaaktype_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
zaaktype.refresh_from_db()
self.assertEqual(zaaktype.concept, False)
def test_create_zaak_zonder_bronorganisatie(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
url = get_operation_url("zaak_create")
data = {"zaaktype": zaaktype_url, "registratiedatum": "2018-06-11"}
response = self.client.post(url, data, **ZAAK_WRITE_KWARGS)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "bronorganisatie")
self.assertEqual(error["code"], "required")
def test_not_allowed_to_change_zaaktype(self):
zaak = ZaakFactory.create()
url = reverse(zaak)
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
response = self.client.patch(
url, {"zaaktype": f"http://testserver{zaaktype_url}"},
**ZAAK_WRITE_KWARGS)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
validation_error = get_validation_errors(response, "zaaktype")
self.assertEqual(validation_error["code"], IsImmutableValidator.code)
def test_ophalen_servicenorm_doorlooptijd(self):
zaaktype = ZaakTypeFactory.create()
url = get_operation_url("zaaktype_read",
catalogus_uuid=zaaktype.catalogus.uuid,
uuid=zaaktype.uuid)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertResponseTypes(response_data, (("doorlooptijd", str),
("servicenorm", type(None))))
self.assertEqual(response_data["doorlooptijd"], "P30D")
def test_create_resultaattype(self, mock_shape, mock_fetch):
zaaktype = ZaakTypeFactory.create(
selectielijst_procestype=PROCESTYPE_URL)
zaaktype_url = reverse("zaaktype-detail",
kwargs={"uuid": zaaktype.uuid})
resultaattypeomschrijving_url = "http://example.com/omschrijving/1"
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"omschrijving": "illum",
"resultaattypeomschrijving": resultaattypeomschrijving_url,
"selectielijstklasse": SELECTIELIJSTKLASSE_URL,
"archiefnominatie": "blijvend_bewaren",
"archiefactietermijn": "P10Y",
"brondatumArchiefprocedure": {
"afleidingswijze":
BrondatumArchiefprocedureAfleidingswijze.afgehandeld,
"einddatumBekend": False,
"procestermijn": "P10Y",
"datumkenmerk": "",
"objecttype": "",
"registratie": "",
},
}
responses = {
SELECTIELIJSTKLASSE_URL: {
"url": SELECTIELIJSTKLASSE_URL,
"procesType": PROCESTYPE_URL,
"procestermijn": Procestermijn.nihil,
}
}
with mock_client(responses):
with requests_mock.Mocker() as m:
m.register_uri("GET",
resultaattypeomschrijving_url,
json={"omschrijving": "test"})
response = self.client.post(self.list_url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
resultaattype = ResultaatType.objects.get()
self.assertEqual(resultaattype.omschrijving_generiek, "test")
self.assertEqual(resultaattype.zaaktype, zaaktype)
self.assertEqual(
resultaattype.brondatum_archiefprocedure_afleidingswijze,
BrondatumArchiefprocedureAfleidingswijze.afgehandeld,
)
def test_create_resultaattype_fail_not_concept_zaaktype(
self, mock_shape, mock_fetch):
zaaktype = ZaakTypeFactory.create(
selectielijst_procestype=PROCESTYPE_URL, concept=False)
zaaktype_url = reverse("zaaktype-detail",
kwargs={"uuid": zaaktype.uuid})
resultaattypeomschrijving_url = "http://example.com/omschrijving/1"
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"omschrijving": "illum",
"resultaattypeomschrijving": resultaattypeomschrijving_url,
"selectielijstklasse": SELECTIELIJSTKLASSE_URL,
"archiefnominatie": "blijvend_bewaren",
"archiefactietermijn": "P10Y",
"brondatumArchiefprocedure": {
"afleidingswijze":
BrondatumArchiefprocedureAfleidingswijze.afgehandeld,
"einddatumBekend": False,
"procestermijn": "P10Y",
"datumkenmerk": "",
"objecttype": "",
"registratie": "",
},
}
responses = {
SELECTIELIJSTKLASSE_URL: {
"url": SELECTIELIJSTKLASSE_URL,
"procesType": PROCESTYPE_URL,
"procestermijn": Procestermijn.nihil,
}
}
with mock_client(responses):
with requests_mock.Mocker() as m:
m.register_uri("GET",
resultaattypeomschrijving_url,
json={"omschrijving": "test"})
response = self.client.post(self.list_url, data)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
data = response.json()
self.assertEqual(
data["detail"],
"Creating a related object to non-concept object is forbidden",
)
def _create_zaak(self, **headers):
url = reverse(Zaak)
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
zaak_data = {
"zaaktype": zaaktype_url,
"vertrouwelijkheidaanduiding": VertrouwelijkheidsAanduiding.openbaar,
"bronorganisatie": "517439943",
"verantwoordelijkeOrganisatie": "517439943",
"registratiedatum": "2018-12-24",
"startdatum": "2018-12-24",
"productenOfDiensten": ["https://example.com/product/123"],
}
response = self.client.post(url, zaak_data, **ZAAK_WRITE_KWARGS, **headers)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
return response.data
def test_procestermijn_ingeschatte_bestaansduur_procesobject_and_afleidingswijze_niet_termijn_fails(
self, *mocks):
zaaktype = ZaakTypeFactory.create(
selectielijst_procestype=PROCESTYPE_URL, concept=False)
zaaktype_url = reverse("zaaktype-detail",
kwargs={"uuid": zaaktype.uuid})
responses = {
SELECTIELIJSTKLASSE_URL: {
"url":
SELECTIELIJSTKLASSE_URL,
"procesType":
PROCESTYPE_URL,
"procestermijn":
Procestermijn.ingeschatte_bestaansduur_procesobject,
}
}
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"omschrijving": "illum",
"resultaattypeomschrijving": "https://garcia.org/",
"selectielijstklasse": SELECTIELIJSTKLASSE_URL,
"archiefnominatie": "blijvend_bewaren",
"archiefactietermijn": "P10Y",
"brondatumArchiefprocedure": {
"afleidingswijze":
BrondatumArchiefprocedureAfleidingswijze.afgehandeld,
"einddatumBekend": False,
"procestermijn": "P10Y",
"datumkenmerk": "",
"objecttype": "",
"registratie": "",
},
}
with mock_client(responses):
response = self.client.post(self.list_url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"],
"invalid-afleidingswijze-for-procestermijn")
def test_create_zaak(self):
"""
Maak een zaak van een bepaald type.
"""
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
url = get_operation_url("zaak_create")
data = {
"zaaktype": zaaktype_url,
"vertrouwelijkheidaanduiding": VertrouwelijkheidsAanduiding.openbaar,
"bronorganisatie": "517439943",
"verantwoordelijkeOrganisatie": VERANTWOORDELIJKE_ORGANISATIE,
"registratiedatum": "2018-06-11",
"startdatum": "2018-06-11",
"toelichting": "Een stel dronken toeristen speelt versterkte "
"muziek af vanuit een gehuurde boot.",
"zaakgeometrie": {
"type": "Point",
"coordinates": [4.910649523925713, 52.37240093589432],
},
}
response = self.client.post(url, data, **ZAAK_WRITE_KWARGS)
self.assertEqual(response.status_code, status.HTTP_201_CREATED, response.data)
data = response.json()
self.assertIn("identificatie", data)
# verify that the identification has been generated
self.assertIsInstance(data["identificatie"], str)
self.assertNotEqual(data["identificatie"], "")
self.assertIsInstance(data["zaakgeometrie"], dict) # geojson object
zaak = Zaak.objects.get()
self.assertEqual(zaak.zaaktype, zaaktype)
self.assertEqual(zaak.registratiedatum, date(2018, 6, 11))
self.assertEqual(
zaak.toelichting,
"Een stel dronken toeristen speelt versterkte "
"muziek af vanuit een gehuurde boot.",
)
self.assertEqual(zaak.zaakgeometrie.x, 4.910649523925713)
self.assertEqual(zaak.zaakgeometrie.y, 52.37240093589432)
def test_create_statustype(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse("zaaktype-detail", kwargs={"uuid": zaaktype.uuid})
statustype_list_url = reverse("statustype-list")
data = {
"omschrijving": "Besluit genomen",
"omschrijvingGeneriek": "",
"statustekst": "",
"zaaktype": "http://testserver{}".format(zaaktype_url),
"volgnummer": 2,
}
response = self.client.post(statustype_list_url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
statustype = StatusType.objects.get()
self.assertEqual(statustype.statustype_omschrijving, "Besluit genomen")
self.assertEqual(statustype.zaaktype, zaaktype)
def test_create_eigenschap(self):
zaaktype = ZaakTypeFactory.create(catalogus=self.catalogus)
zaaktype_url = reverse("zaaktype-detail",
kwargs={"uuid": zaaktype.uuid})
eigenschap_list_url = reverse("eigenschap-list")
data = {
"naam": "Beoogd product",
"definitie": "test",
"toelichting": "",
"zaaktype": "http://testserver{}".format(zaaktype_url),
}
response = self.client.post(eigenschap_list_url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
eigenschap = Eigenschap.objects.get()
self.assertEqual(eigenschap.eigenschapnaam, "Beoogd product")
self.assertEqual(eigenschap.zaaktype, zaaktype)
def test_create_statustype_fail_not_concept_zaaktype(self):
zaaktype = ZaakTypeFactory.create(concept=False)
zaaktype_url = reverse("zaaktype-detail", kwargs={"uuid": zaaktype.uuid})
statustype_list_url = reverse("statustype-list")
data = {
"omschrijving": "Besluit genomen",
"omschrijvingGeneriek": "",
"statustekst": "",
"zaaktype": "http://testserver{}".format(zaaktype_url),
"volgnummer": 2,
}
response = self.client.post(statustype_list_url, data)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
data = response.json()
self.assertEqual(
data["detail"],
"Creating a related object to non-concept object is forbidden",
)
