class ZaakInformatieobjectTypePaginationTestCase(APITestCase):
maxDiff = None
list_url = reverse_lazy(ZaakInformatieobjectType)
def test_pagination_default(self):
ZaakInformatieobjectTypeFactory.create_batch(
2, zaaktype__concept=False, informatieobjecttype__concept=False)
response = self.client.get(self.list_url)
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_pagination_page_param(self):
ZaakInformatieobjectTypeFactory.create_batch(
2, zaaktype__concept=False, informatieobjecttype__concept=False)
response = self.client.get(self.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'])
class EnkelvoudigInformatieObjectPaginationAPITests(JWTAuthMixin, APITestCase):
list_url = reverse_lazy(EnkelvoudigInformatieObject)
heeft_alle_autorisaties = True
def test_pagination_default(self):
"""
Deleting a Besluit causes all related objects to be deleted as well.
"""
EnkelvoudigInformatieObjectFactory.create_batch(2)
response = self.client.get(self.list_url)
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_pagination_page_param(self):
EnkelvoudigInformatieObjectFactory.create_batch(2)
response = self.client.get(self.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"])
class LocalRelevanteAndereZakenTests(JWTAuthMixin, APITestCase):
heeft_alle_autorisaties = True
list_url = reverse_lazy(Zaak)
def test_create_local_relevante_andere_zaak(self):
zaaktype = ZaakTypeFactory.create(concept=False)
zaaktype_url = f"http://testserver.com{reverse(zaaktype)}"
zaak = ZaakFactory.create(zaaktype=zaaktype)
zaak_url = f"http://testserver.com{reverse(zaak)}"
response = self.client.post(
self.list_url,
{
"zaaktype": zaaktype_url,
"bronorganisatie": "517439943",
"verantwoordelijkeOrganisatie": "517439943",
"registratiedatum": "2018-12-24",
"startdatum": "2018-12-24",
"vertrouwelijkheidaanduiding": VertrouwelijkheidsAanduiding.openbaar,
"relevanteAndereZaken": [
{"url": zaak_url, "aardRelatie": AardZaakRelatie.vervolg,}
],
},
**ZAAK_WRITE_KWARGS,
HTTP_HOST="testserver.com",
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED, response.data)
self.assertEqual(
response.data["relevante_andere_zaken"],
[{"url": zaak_url, "aardRelatie": AardZaakRelatie.vervolg}],
)
def test_read_local_relevante_andere_zaak(self):
zaaktype = ZaakTypeFactory.create(concept=False)
zaak = ZaakFactory.create(zaaktype=zaaktype)
zaak_url = f"http://testserver.com{reverse(zaak)}"
relevante_zaak = ZaakFactory.create(zaaktype=zaaktype)
relevante_zaak_url = f"http://testserver.com{reverse(relevante_zaak)}"
RelevanteZaakRelatieFactory.create(
url=relevante_zaak, zaak=zaak, aard_relatie=AardZaakRelatie.vervolg
)
response = self.client.get(
zaak_url, **ZAAK_READ_KWARGS, HTTP_HOST="testserver.com"
)
self.assertEqual(response.status_code, status.HTTP_200_OK, response.data)
self.assertEqual(
response.data["relevante_andere_zaken"],
[{"url": relevante_zaak_url, "aardRelatie": AardZaakRelatie.vervolg}],
)
class WebhookTests(JWTScopesMixin, APITestCase):
scopes = [SCOPE_NOTIFICATIES_STUREN]
url = reverse_lazy('notificaties-webhook')
def test_auth_required(self):
self.client.credentials() # clear any credentials
response = self.client.post(self.url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_receive_nofication(self):
data = {
"kanaal":
"zaken",
"hoofdObject":
"https://ref.tst.vng.cloud/zrc/api/v1/zaken/d7a22",
"resource":
"status",
"resourceUrl":
"https://ref.tst.vng.cloud/zrc/api/v1/statussen/d7a22/721c9",
"actie":
"create",
"aanmaakdatum":
"2018-01-01T17:00:00Z",
"kenmerken": [{
"bron": "082096752011"
}, {
"zaaktype":
"https://example.com/api/v1/zaaktypen/5aa5c"
}, {
"vertrouwelijkeidaanduiding": "openbaar"
}]
}
response = self.client.post(self.url, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
class ZaakTypeInformatieObjectTypeValidationTests(APITestCase):
maxDiff = None
list_url = reverse_lazy(ZaakTypeInformatieObjectType)
def test_catalogus_mismatch(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create()
informatieobjecttype_url = reverse(informatieobjecttype)
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"informatieobjecttype": f"http://testserver{informatieobjecttype_url}",
"volgnummer": 13,
"richting": RichtingChoices.inkomend,
}
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"], "relations-incorrect-catalogus")
class BesluitInformatieObjectCMISAPITests(JWTAuthMixin, APICMISTestCase):
list_url = reverse_lazy("besluitinformatieobject-list",
kwargs={"version": "1"})
heeft_alle_autorisaties = True
def test_create(self):
besluit = BesluitFactory.create()
io = EnkelvoudigInformatieObjectFactory.create(
informatieobjecttype__concept=False)
io_url = f"http://testserver{reverse(io)}"
self.adapter.get(io_url, json=serialise_eio(io, io_url))
besluit.besluittype.informatieobjecttypen.add(io.informatieobjecttype)
besluit_url = reverse(besluit)
content = {
"informatieobject": io_url,
"besluit": f"http://testserver{besluit_url}",
}
# Send to the API
response = self.client.post(self.list_url, content)
# Test response
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
# Test database
self.assertEqual(BesluitInformatieObject.objects.count(), 1)
stored_object = BesluitInformatieObject.objects.get()
self.assertEqual(stored_object.besluit, besluit)
expected_url = reverse(stored_object)
expected_response = content.copy()
expected_response.update({"url": f"http://testserver{expected_url}"})
self.assertEqual(response.json(), expected_response)
def test_duplicate_object(self):
"""
Test the (informatieobject, object) unique together validation.
"""
io = EnkelvoudigInformatieObjectFactory.create()
io_url = f"http://testserver{reverse(io)}"
self.adapter.get(io_url, json=serialise_eio(io, io_url))
bio = BesluitInformatieObjectFactory.create(informatieobject=io_url)
besluit_url = reverse(bio.besluit)
content = {
"informatieobject": io_url,
"besluit": f"http://testserver{besluit_url}",
}
# Send to the API
response = self.client.post(self.list_url, content)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "unique")
def test_read_besluit(self):
io = EnkelvoudigInformatieObjectFactory.create()
io_url = f"http://testserver{reverse(io)}"
self.adapter.get(io_url, json=serialise_eio(io, io_url))
bio = BesluitInformatieObjectFactory.create(informatieobject=io_url)
bio_detail_url = reverse(bio)
response = self.client.get(bio_detail_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
besluit_url = reverse(bio.besluit)
expected = {
"url": f"http://testserver{bio_detail_url}",
"informatieobject": io_url,
"besluit": f"http://testserver{besluit_url}",
}
self.assertEqual(response.json(), expected)
def test_filter_by_besluit(self):
io = EnkelvoudigInformatieObjectFactory.create()
io_url = io.get_url()
self.adapter.get(io_url, json=serialise_eio(io, io_url))
bio = BesluitInformatieObjectFactory.create(informatieobject=io_url)
besluit_url = reverse(bio.besluit)
bio_list_url = reverse("besluitinformatieobject-list")
response = self.client.get(
bio_list_url,
{"besluit": f"http://openzaak.nl{besluit_url}"},
HTTP_HOST="openzaak.nl",
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["besluit"],
f"http://openzaak.nl{besluit_url}")
def test_filter_by_informatieobject(self):
io = EnkelvoudigInformatieObjectFactory.create()
io_url = f"http://openzaak.nl{reverse(io)}"
self.adapter.get(io_url, json=serialise_eio(io, io_url))
BesluitInformatieObjectFactory.create(informatieobject=io_url)
bio_list_url = reverse("besluitinformatieobject-list")
response = self.client.get(
bio_list_url,
{"informatieobject": io_url},
HTTP_HOST="openzaak.nl",
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["informatieobject"], io_url)
def test_put_besluit_not_allowed(self):
io = EnkelvoudigInformatieObjectFactory.create()
io_url = io.get_url()
self.adapter.get(io_url, json=serialise_eio(io, io_url))
bio = BesluitInformatieObjectFactory.create(informatieobject=io_url)
bio_detail_url = reverse(bio)
besluit = BesluitFactory.create()
besluit_url = reverse(besluit)
io = EnkelvoudigInformatieObjectFactory.create()
io_url = reverse(io)
response = self.client.put(
bio_detail_url,
{
"besluit": f"http://testserver{besluit_url}",
"informatieobject": f"http://testserver{io_url}",
},
)
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED, response.data)
def test_patch_besluit_not_allowed(self):
io = EnkelvoudigInformatieObjectFactory.create()
io_url = io.get_url()
self.adapter.get(io_url, json=serialise_eio(io, io_url))
bio = BesluitInformatieObjectFactory.create(informatieobject=io_url)
bio_detail_url = reverse(bio)
besluit = BesluitFactory.create()
besluit_url = reverse(besluit)
io = EnkelvoudigInformatieObjectFactory.create()
io_url = reverse(io)
response = self.client.patch(
bio_detail_url,
{
"besluit": f"http://testserver{besluit_url}",
"informatieobject": f"http://testserver{io_url}",
},
)
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED, response.data)
def test_delete(self):
io = EnkelvoudigInformatieObjectFactory.create()
io_url = io.get_url()
self.adapter.get(io_url, json=serialise_eio(io, io_url))
bio = BesluitInformatieObjectFactory.create(informatieobject=io_url)
bio_url = reverse(bio)
response = self.client.delete(bio_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT,
response.data)
# Relation is gone, besluit still exists.
self.assertFalse(BesluitInformatieObject.objects.exists())
self.assertTrue(Besluit.objects.exists())
class ZaakInformatieobjectTypeAPITests(APITestCase):
maxDiff = None
list_url = reverse_lazy(ZaakInformatieobjectType)
def test_get_list(self):
ZaakInformatieobjectTypeFactory.create_batch(3)
response = self.client.get(self.list_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 3)
def test_get_detail(self):
ztiot = ZaakInformatieobjectTypeFactory.create()
url = reverse(ztiot)
zaaktype_url = reverse(
ztiot.zaaktype,
kwargs={'catalogus_uuid': ztiot.zaaktype.catalogus.uuid})
informatie_object_type_url = reverse(
ztiot.informatie_object_type,
kwargs={
'catalogus_uuid': ztiot.informatie_object_type.catalogus.uuid
})
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
expected = {
'url': f'http://testserver{url}',
'zaaktype': f'http://testserver{zaaktype_url}',
'informatieObjectType':
f'http://testserver{informatie_object_type_url}',
'volgnummer': ztiot.volgnummer,
'richting': ztiot.richting,
'statusType': None,
}
self.assertEqual(response.json(), expected)
def test_filter_zaaktype(self):
ztiot1, ztiot2 = ZaakInformatieobjectTypeFactory.create_batch(2)
url = f'http://testserver{reverse(ztiot1)}'
zaaktype1_url = reverse(
ztiot1.zaaktype,
kwargs={'catalogus_uuid': ztiot1.zaaktype.catalogus.uuid})
zaaktype2_url = reverse(
ztiot2.zaaktype,
kwargs={'catalogus_uuid': ztiot2.zaaktype.catalogus.uuid})
zaaktype1_url = f'http://testserver{zaaktype1_url}'
zaaktype2_url = f'http://testserver{zaaktype2_url}'
response = self.client.get(self.list_url, {'zaaktype': zaaktype1_url})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()[0]['url'], url)
self.assertEqual(response.json()[0]['zaaktype'], zaaktype1_url)
self.assertNotEqual(response.json()[0]['zaaktype'], zaaktype2_url)
def test_filter_informatieobjecttype(self):
ztiot1, ztiot2 = ZaakInformatieobjectTypeFactory.create_batch(2)
url = f'http://testserver{reverse(ztiot1)}'
informatie_object_type1_url = reverse(
ztiot1.informatie_object_type,
kwargs={
'catalogus_uuid': ztiot1.informatie_object_type.catalogus.uuid
})
informatie_object_type2_url = reverse(
ztiot2.informatie_object_type,
kwargs={
'catalogus_uuid': ztiot2.informatie_object_type.catalogus.uuid
})
informatie_object_type1_url = f'http://testserver{informatie_object_type1_url}'
informatie_object_type2_url = f'http://testserver{informatie_object_type2_url}'
response = self.client.get(
self.list_url,
{'informatieObjectType': informatie_object_type1_url})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json()[0]['url'], url)
self.assertEqual(response.json()[0]['informatieObjectType'],
informatie_object_type1_url)
self.assertNotEqual(response.json()[0]['informatieObjectType'],
informatie_object_type2_url)
class BesluitValidationTests(JWTAuthMixin, APITestCase):
url = reverse_lazy("besluit-list")
heeft_alle_autorisaties = True
def test_rsin_invalid(self):
cases = [
("1234567", "invalid-length"),
("12345678", "invalid-length"),
("123456789", "invalid"),
]
for rsin, error_code in cases:
with self.subTest(rsin=rsin, error_code=error_code):
response = self.client.post(
self.url, {"verantwoordelijkeOrganisatie": rsin})
self.assertEqual(response.status_code,
status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response,
"verantwoordelijkeOrganisatie")
self.assertEqual(error["code"], error_code)
@freeze_time("2018-09-06T12:08+0200")
def test_future_datum(self):
response = self.client.post(self.url, {"datum": "2018-09-07"})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "datum")
self.assertEqual(error["code"], UntilTodayValidator.code)
def test_duplicate_rsin_identificatie(self):
besluit = BesluitFactory.create(identificatie="123456")
besluittype_url = reverse(besluit.besluittype)
response = self.client.post(
self.url,
{
"verantwoordelijkeOrganisatie":
besluit.verantwoordelijke_organisatie,
"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, "identificatie")
self.assertEqual(error["code"], "identificatie-niet-uniek")
def test_change_immutable_fields(self):
besluit = BesluitFactory.create(identificatie="123456")
besluit2 = BesluitFactory.create(identificatie="123456")
url = reverse(besluit)
response = self.client.patch(
url,
{
"verantwoordelijkeOrganisatie":
besluit2.verantwoordelijke_organisatie,
"identificatie": "123456789",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
identificatie_error = get_validation_errors(response, "identificatie")
self.assertEqual(identificatie_error["code"],
IsImmutableValidator.code)
verantwoordelijke_organisatie_error = get_validation_errors(
response, "verantwoordelijkeOrganisatie")
self.assertEqual(verantwoordelijke_organisatie_error["code"],
IsImmutableValidator.code)
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 test_besluittype_invalid(self):
list_url = reverse("besluit-list")
response = self.client.post(
list_url,
{
"verantwoordelijkeOrganisatie": "000000000",
"identificatie": "123456",
"besluittype": "https://example.com/zrc/zaken/1234",
"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"], "no_match")
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_no_zaaktype_besluittype_relation(self):
besluittype = BesluitTypeFactory.create()
besluittype_url = reverse(besluittype)
zaak = ZaakFactory.create()
zaak_url = reverse(zaak)
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_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")
class ExternalDocumentsAPITests(JWTAuthMixin, APITestCase):
heeft_alle_autorisaties = True
list_url = reverse_lazy(BesluitInformatieObject)
base = "https://external.documenten.nl/api/v1/"
@classmethod
def setUpClass(cls):
super().setUpClass()
Service.objects.create(
api_type=APITypes.drc,
api_root=cls.base,
label="external documents",
auth_type=AuthTypes.no_auth,
)
def test_create_bio_external_document(self):
document = f"{self.base}enkelvoudiginformatieobjecten/{uuid.uuid4()}"
besluit = BesluitFactory.create(besluittype__concept=False)
besluit_url = f"http://openzaak.nl{reverse(besluit)}"
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=besluit.besluittype.catalogus, concept=False
)
informatieobjecttype_url = f"http://openzaak.nl{reverse(informatieobjecttype)}"
informatieobjecttype.besluittypen.add(besluit.besluittype)
eio_response = get_eio_response(
document, informatieobjecttype=informatieobjecttype_url
)
oio_response = get_oio_response(document, besluit_url, "besluit")
with self.subTest(section="bio-create"):
with requests_mock.Mocker(real_http=True) as m:
mock_service_oas_get(m, APITypes.drc, self.base)
m.get(document, json=eio_response)
m.post(
"https://external.documenten.nl/api/v1/objectinformatieobjecten",
json=oio_response,
status_code=201,
)
response = self.client.post(
self.list_url,
{"besluit": besluit_url, "informatieobject": document},
)
self.assertEqual(
response.status_code, status.HTTP_201_CREATED, response.data
)
posts = [req for req in m.request_history if req.method == "POST"]
self.assertEqual(len(posts), 1)
request = posts[0]
self.assertEqual(
request.url,
"https://external.documenten.nl/api/v1/objectinformatieobjecten",
)
self.assertEqual(
request.json(),
{
"informatieobject": document,
"object": besluit_url,
"objectType": "besluit",
},
)
self.assertFalse(ObjectInformatieObject.objects.exists())
bio = BesluitInformatieObject.objects.get()
self.assertEqual(bio._objectinformatieobject_url, oio_response["url"])
with self.subTest(section="bio-list"):
list_response = self.client.get(
self.list_url, {"besluit": besluit_url}, HTTP_HOST="openzaak.nl",
)
self.assertEqual(
list_response.status_code, status.HTTP_200_OK, response.data
)
data = list_response.json()
self.assertEqual(len(data), 1)
self.assertEqual(data[0]["informatieobject"], document)
def test_create_bio_fail_bad_url(self):
besluit = BesluitFactory.create(besluittype__concept=False)
besluit_url = f"http://openzaak.nl{reverse(besluit)}"
data = {"besluit": besluit_url, "informatieobject": "abcd"}
response = self.client.post(self.list_url, data, HTTP_HOST="openzaak.nl")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "informatieobject")
self.assertEqual(error["code"], "bad-url")
def test_create_bio_fail_not_json(self):
besluit = BesluitFactory.create(besluittype__concept=False)
besluit_url = f"http://openzaak.nl{reverse(besluit)}"
data = {"besluit": besluit_url, "informatieobject": "http://example.com"}
response = self.client.post(self.list_url, data, HTTP_HOST="openzaak.nl")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "informatieobject")
self.assertEqual(error["code"], "invalid-resource")
def test_create_bio_fail_invalid_schema(self):
base = "https://external.documenten.nl/api/v1/"
document = f"{base}enkelvoudiginformatieobjecten/{uuid.uuid4()}"
besluit = BesluitFactory.create(besluittype__concept=False)
besluit_url = f"http://openzaak.nl{reverse(besluit)}"
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=besluit.besluittype.catalogus, concept=False
)
informatieobjecttype_url = f"http://openzaak.nl{reverse(informatieobjecttype)}"
informatieobjecttype.besluittypen.add(besluit.besluittype)
with requests_mock.Mocker(real_http=True) as m:
m.get(
document,
json={
"url": document,
"beschrijving": "",
"ontvangstdatum": None,
"informatieobjecttype": informatieobjecttype_url,
"locked": False,
},
)
response = self.client.post(
self.list_url, {"besluit": besluit_url, "informatieobject": document},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "informatieobject")
self.assertEqual(error["code"], "invalid-resource")
class ResultaatTypeAPITests(TypeCheckMixin, APITestCase):
maxDiff = None
list_url = reverse_lazy(ResultaatType)
def test_get_list(self):
ResultaatTypeFactory.create_batch(3, zaaktype__concept=False)
response = self.api_client.get(self.list_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()['results']
self.assertEqual(len(data), 3)
self.assertResponseTypes(
data[0],
(
('url', str),
('zaaktype', str),
('omschrijving', str),
('resultaattypeomschrijving', str),
('omschrijvingGeneriek', str),
('selectielijstklasse', str),
('toelichting', str),
('archiefnominatie', str),
('archiefactietermijn', str),
('brondatumArchiefprocedure', dict),
)
)
def test_get_list_default_definitief(self):
resultaattype1 = ResultaatTypeFactory.create(zaaktype__concept=True)
resultaattype2 = ResultaatTypeFactory.create(zaaktype__concept=False)
resultaattype_list_url = reverse('resultaattype-list')
resultaattype2_url = reverse('resultaattype-detail', kwargs={'uuid': resultaattype2.uuid})
response = self.client.get(resultaattype_list_url)
self.assertEqual(response.status_code, 200)
data = response.json()['results']
self.assertEqual(len(data), 1)
self.assertEqual(data[0]['url'], f'http://testserver{resultaattype2_url}')
def test_get_detail(self):
resultaattype = ResultaatTypeFactory.create()
url = reverse(resultaattype)
zaaktype_url = reverse('zaaktype-detail', kwargs={
'uuid': resultaattype.zaaktype.uuid,
})
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertEqual(response_data, {
'url': f'http://testserver{url}',
'zaaktype': f'http://testserver{zaaktype_url}',
'omschrijving': resultaattype.omschrijving,
'resultaattypeomschrijving': resultaattype.resultaattypeomschrijving,
'omschrijvingGeneriek': resultaattype.omschrijving_generiek,
'selectielijstklasse': resultaattype.selectielijstklasse,
'toelichting': '',
'archiefnominatie': resultaattype.archiefnominatie,
'archiefactietermijn': 'P10Y',
'brondatumArchiefprocedure': {
'afleidingswijze': None,
'datumkenmerk': None,
'einddatumBekend': False,
'objecttype': None,
'registratie': None,
'procestermijn': None,
}
})
def test_resultaattypen_embedded_zaaktype(self):
resultaattype = ResultaatTypeFactory.create()
url = f'http://testserver{reverse(resultaattype)}'
zaaktype_url = reverse('zaaktype-detail', kwargs={
'uuid': resultaattype.zaaktype.uuid,
})
response = self.client.get(zaaktype_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.json()['resultaattypen'],
[url]
)
def test_resultaattype_afleidingswijze_procestermijn(self):
resultaattype = ResultaatTypeFactory.create(
brondatum_archiefprocedure_afleidingswijze='procestermijn',
brondatum_archiefprocedure_procestermijn='P5Y',
)
url = reverse(resultaattype)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
brondatumArchiefprocedure = response.json()['brondatumArchiefprocedure']
afleidingswijze = resultaattype.brondatum_archiefprocedure_afleidingswijze
procestermijn = resultaattype.brondatum_archiefprocedure_procestermijn
self.assertEqual(brondatumArchiefprocedure['afleidingswijze'], afleidingswijze)
# Verify that the procestermijn was serialized correctly
self.assertEqual(brondatumArchiefprocedure['procestermijn'], procestermijn)
@override_settings(LINK_FETCHER='vng_api_common.mocks.link_fetcher_200')
@patch('vng_api_common.oas.fetcher.fetch', return_value={})
@patch('vng_api_common.validators.obj_has_shape', return_value=True)
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
)
@override_settings(LINK_FETCHER='vng_api_common.mocks.link_fetcher_200')
@patch('vng_api_common.oas.fetcher.fetch', return_value={})
@patch('vng_api_common.validators.obj_has_shape', return_value=True)
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 test_delete_resultaattype(self):
resultaattype = ResultaatTypeFactory.create()
resultaattype_url = reverse('resultaattype-detail', kwargs={'uuid': resultaattype.uuid})
response = self.client.delete(resultaattype_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(ResultaatType.objects.filter(id=resultaattype.id))
def test_delete_resultaattype_fail_not_concept_zaaktype(self):
resultaattype = ResultaatTypeFactory.create(zaaktype__concept=False)
resultaattype_url = reverse('resultaattype-detail', kwargs={'uuid': resultaattype.uuid})
response = self.client.delete(resultaattype_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
data = response.json()
self.assertEqual(data['detail'], 'Alleen concepten kunnen worden verwijderd.')
class ExternalInformatieObjectAPITests(JWTAuthMixin, APITestCase):
heeft_alle_autorisaties = True
list_url = reverse_lazy(BesluitInformatieObject)
base = "https://external.documenten.nl/api/v1/"
document = f"{base}enkelvoudiginformatieobjecten/{uuid.uuid4()}"
@classmethod
def setUpClass(cls):
super().setUpClass()
Service.objects.create(
api_type=APITypes.drc,
api_root=cls.base,
label="external documents",
auth_type=AuthTypes.no_auth,
)
def test_besluittype_internal_iotype_internal_fail(self):
besluit = BesluitFactory.create()
besluit_url = f"http://openbesluit.nl{reverse(besluit)}"
informatieobjecttype = InformatieObjectTypeFactory.create()
eio_response = get_eio_response(
self.document,
informatieobjecttype=f"http://openbesluit.nl{reverse(informatieobjecttype)}",
)
with requests_mock.Mocker(real_http=True) as m:
m.get(self.document, json=eio_response)
response = self.client.post(
self.list_url,
{"besluit": besluit_url, "informatieobject": self.document},
HTTP_HOST="openbesluit.nl",
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(
error["code"], "missing-besluittype-informatieobjecttype-relation"
)
def test_besluittype_external_iotype_external_success(self):
catalogus = f"{self.base}catalogussen/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
besluittype = f"{self.base}besluittypen/b71f72ef-198d-44d8-af64-ae1932df830a"
besluit = BesluitFactory.create(besluittype=besluittype)
besluit_url = f"http://openbesluit.nl{reverse(besluit)}"
informatieobjecttype = f"{self.base}informatieobjecttypen/{uuid.uuid4()}"
besluittype_data = get_besluittype_response(catalogus, besluittype)
besluittype_data["informatieobjecttypen"] = [informatieobjecttype]
with requests_mock.Mocker(real_http=True) as m:
mock_service_oas_get(m, APITypes.drc, self.base)
m.get(besluittype, json=besluittype_data)
m.get(
informatieobjecttype,
json=get_informatieobjecttype_response(catalogus, informatieobjecttype),
)
m.get(
self.document,
json=get_eio_response(
self.document, informatieobjecttype=informatieobjecttype
),
)
m.post(
f"{self.base}objectinformatieobjecten",
json=get_oio_response(self.document, besluit_url),
status_code=201,
)
response = self.client.post(
self.list_url,
{"besluit": besluit_url, "informatieobject": self.document},
HTTP_HOST="openbesluit.nl",
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_besluittype_external_iotype_external_fail(self):
catalogus = f"{self.base}catalogussen/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
besluittype = f"{self.base}besluittypen/b71f72ef-198d-44d8-af64-ae1932df830a"
besluit = BesluitFactory.create(besluittype=besluittype)
besluit_url = f"http://openbesluit.nl{reverse(besluit)}"
informatieobjecttype = f"{self.base}informatieobjecttypen/{uuid.uuid4()}"
with requests_mock.Mocker(real_http=True) as m:
m.get(besluittype, json=get_besluittype_response(catalogus, besluittype))
m.get(
informatieobjecttype,
json=get_informatieobjecttype_response(catalogus, informatieobjecttype),
)
m.get(
self.document,
json=get_eio_response(
self.document, informatieobjecttype=informatieobjecttype
),
)
response = self.client.post(
self.list_url,
{"besluit": besluit_url, "informatieobject": self.document},
HTTP_HOST="openbesluit.nl",
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(
error["code"], "missing-besluittype-informatieobjecttype-relation"
)
def test_besluittype_internal_iotype_external(self):
besluit = BesluitFactory.create()
besluit_url = f"http://openbesluit.nl{reverse(besluit)}"
informatieobjecttype = f"{self.base}informatieobjecttypen/{uuid.uuid4()}"
catalogus = f"{self.base}catalogussen/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
with requests_mock.Mocker(real_http=True) as m:
m.get(
informatieobjecttype,
json=get_informatieobjecttype_response(catalogus, informatieobjecttype),
)
m.get(
catalogus, json=get_catalogus_response(catalogus, informatieobjecttype)
)
m.get(
self.document,
json=get_eio_response(
self.document, informatieobjecttype=informatieobjecttype
),
)
response = self.client.post(
self.list_url,
{"besluit": besluit_url, "informatieobject": self.document},
HTTP_HOST="openbesluit.nl",
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(
error["code"], "missing-besluittype-informatieobjecttype-relation"
)
def test_besluittype_external_iotype_internal(self):
catalogus = f"{self.base}catalogussen/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
besluittype = f"{self.base}besluittypen/b71f72ef-198d-44d8-af64-ae1932df830a"
besluit = BesluitFactory.create(besluittype=besluittype)
besluit_url = f"http://openbesluit.nl{reverse(besluit)}"
informatieobjecttype = InformatieObjectTypeFactory.create()
eio_response = get_eio_response(
self.document,
informatieobjecttype=f"http://openbesluit.nl{reverse(informatieobjecttype)}",
)
with requests_mock.Mocker(real_http=True) as m:
m.get(besluittype, json=get_besluittype_response(catalogus, besluittype))
m.get(self.document, json=eio_response)
response = self.client.post(
self.list_url,
{"besluit": besluit_url, "informatieobject": self.document},
HTTP_HOST="openbesluit.nl",
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(
error["code"], "missing-besluittype-informatieobjecttype-relation"
)
class EnkelvoudigInformatieObjectVersionHistoryAPITests(
JWTAuthMixin, APITestCase):
list_url = reverse_lazy(EnkelvoudigInformatieObject)
heeft_alle_autorisaties = True
def test_eio_update(self):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1", informatieobjecttype__concept=False)
eio_url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio.uuid})
eio_response = self.client.get(eio_url)
eio_data = eio_response.data
lock = self.client.post(f"{eio_url}/lock").data["lock"]
eio_data.update({
"beschrijving": "beschrijving2",
"inhoud": b64encode(b"aaaaa"),
"lock": lock,
})
for i in ["integriteit", "ondertekening"]:
eio_data.pop(i)
response = self.client.put(eio_url, eio_data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertEqual(response_data["beschrijving"], "beschrijving2")
eios = EnkelvoudigInformatieObject.objects.filter(
uuid=eio.uuid).order_by("-versie")
self.assertEqual(len(eios), 2)
latest_version = eios.first()
self.assertEqual(latest_version.versie, 2)
self.assertEqual(latest_version.beschrijving, "beschrijving2")
first_version = eios[1]
self.assertEqual(first_version.versie, 1)
self.assertEqual(first_version.beschrijving, "beschrijving1")
def test_eio_partial_update(self):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1")
eio_url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio.uuid})
lock = self.client.post(f"{eio_url}/lock").data["lock"]
response = self.client.patch(eio_url, {
"beschrijving": "beschrijving2",
"lock": lock
})
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertEqual(response_data["beschrijving"], "beschrijving2")
eios = EnkelvoudigInformatieObject.objects.filter(
uuid=eio.uuid).order_by("-versie")
self.assertEqual(len(eios), 2)
latest_version = eios.first()
self.assertEqual(latest_version.versie, 2)
self.assertEqual(latest_version.beschrijving, "beschrijving2")
first_version = eios[1]
self.assertEqual(first_version.versie, 1)
self.assertEqual(first_version.beschrijving, "beschrijving1")
def test_eio_delete(self):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1")
eio_url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio.uuid})
lock = self.client.post(f"{eio_url}/lock").data["lock"]
self.client.patch(eio_url, {
"beschrijving": "beschrijving2",
"lock": lock
})
response = self.client.delete(eio_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(EnkelvoudigInformatieObjectCanonical.objects.exists())
self.assertFalse(EnkelvoudigInformatieObject.objects.exists())
def test_eio_detail_retrieves_latest_version(self):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1")
eio_url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio.uuid})
lock = self.client.post(f"{eio_url}/lock").data["lock"]
self.client.patch(eio_url, {
"beschrijving": "beschrijving2",
"lock": lock
})
response = self.client.get(eio_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["beschrijving"], "beschrijving2")
def test_eio_list_shows_latest_versions(self):
eio1 = EnkelvoudigInformatieObjectFactory.create(
beschrijving="object1")
eio1_url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio1.uuid})
lock1 = self.client.post(f"{eio1_url}/lock").data["lock"]
self.client.patch(eio1_url, {
"beschrijving": "object1 versie2",
"lock": lock1
})
eio2 = EnkelvoudigInformatieObjectFactory.create(
beschrijving="object2")
eio2_url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio2.uuid})
lock2 = self.client.post(f"{eio2_url}/lock").data["lock"]
self.client.patch(eio2_url, {
"beschrijving": "object2 versie2",
"lock": lock2
})
response = self.client.get(reverse(EnkelvoudigInformatieObject))
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.data["results"]
self.assertEqual(len(response_data), 2)
self.assertEqual(response_data[0]["beschrijving"], "object1 versie2")
self.assertEqual(response_data[1]["beschrijving"], "object2 versie2")
def test_eio_detail_filter_by_version(self):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1")
eio_url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio.uuid})
lock = self.client.post(f"{eio_url}/lock").data["lock"]
self.client.patch(eio_url, {
"beschrijving": "beschrijving2",
"lock": lock
})
response = self.client.get(eio_url, {"versie": 1})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["beschrijving"], "beschrijving1")
def test_eio_detail_filter_by_wrong_version_gives_404(self):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1")
eio_url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio.uuid})
lock = self.client.post(f"{eio_url}/lock").data["lock"]
self.client.patch(eio_url, {
"beschrijving": "beschrijving2",
"lock": lock
})
response = self.client.get(eio_url, {"versie": 100})
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_eio_detail_filter_by_registratie_op(self):
with freeze_time("2019-01-01 12:00:00"):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1")
eio_url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio.uuid})
lock = self.client.post(f"{eio_url}/lock").data["lock"]
with freeze_time("2019-01-01 13:00:00"):
self.client.patch(eio_url, {
"beschrijving": "beschrijving2",
"lock": lock
})
response = self.client.get(eio_url,
{"registratieOp": "2019-01-01T12:00:00"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["beschrijving"], "beschrijving1")
@freeze_time("2019-01-01 12:00:00")
def test_eio_detail_filter_by_wrong_registratie_op_gives_404(self):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1")
eio_url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio.uuid})
lock = self.client.post(f"{eio_url}/lock").data["lock"]
self.client.patch(eio_url, {
"beschrijving": "beschrijving2",
"lock": lock
})
response = self.client.get(eio_url,
{"registratieOp": "2019-01-01T11:59:00"})
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_eio_download_content_filter_by_version(self):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1", inhoud__data=b"inhoud1")
eio_url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio.uuid})
lock = self.client.post(f"{eio_url}/lock").data["lock"]
self.client.patch(
eio_url,
{
"inhoud": b64encode(b"inhoud2"),
"beschrijving": "beschrijving2",
"lock": lock,
},
)
response = self.client.get(eio_url, {"versie": "1"})
response_download = self.client.get(response.data["inhoud"])
try:
self.assertEqual(
list(response_download.streaming_content)[0], b"inhoud1")
except AttributeError:
self.assertEqual(response_download.content, b"inhoud1")
def test_eio_download_content_filter_by_registratie(self):
with freeze_time("2019-01-01 12:00:00"):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1", inhoud__data=b"inhoud1")
eio_url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio.uuid})
lock = self.client.post(f"{eio_url}/lock").data["lock"]
with freeze_time("2019-01-01 13:00:00"):
self.client.patch(
eio_url,
{
"inhoud": b64encode(b"inhoud2"),
"beschrijving": "beschrijving2",
"lock": lock,
},
)
response = self.client.get(eio_url,
{"registratieOp": "2019-01-01T12:00:00"})
response_download = self.client.get(response.data["inhoud"])
try:
self.assertEqual(
list(response_download.streaming_content)[0], b"inhoud1")
except AttributeError:
self.assertEqual(response_download.content, b"inhoud1")
class ZaakInformatieObjectCMISAPITests(JWTAuthMixin, APICMISTestCase,
OioMixin):
list_url = reverse_lazy(ZaakInformatieObject)
heeft_alle_autorisaties = True
def setUp(self):
super().setUp()
site = Site.objects.get_current()
site.domain = "testserver"
site.save()
@freeze_time("2018-09-19T12:25:19+0200")
def test_create(self):
self.create_zaak_besluit_services()
zaak = self.create_zaak()
zaak_url = reverse(zaak)
io = EnkelvoudigInformatieObjectFactory.create(
informatieobjecttype__concept=False)
io_url = f"http://testserver{reverse(io)}"
self.adapter.get(io_url, json=serialise_eio(io, io_url))
ZaakTypeInformatieObjectTypeFactory.create(
informatieobjecttype=io.informatieobjecttype,
zaaktype=zaak.zaaktype)
titel = "some titel"
beschrijving = "some beschrijving"
content = {
"informatieobject": io_url,
"zaak": f"http://testserver{zaak_url}",
"titel": titel,
"beschrijving": beschrijving,
"aardRelatieWeergave": "bla", # Should be ignored by the API
}
# Send to the API
response = self.client.post(self.list_url, content)
# Test response
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
# Test database
self.assertEqual(ZaakInformatieObject.objects.count(), 1)
stored_object = ZaakInformatieObject.objects.get()
self.assertEqual(stored_object.zaak, zaak)
self.assertEqual(stored_object.aard_relatie, RelatieAarden.hoort_bij)
expected_url = reverse(stored_object)
expected_response = content.copy()
expected_response.update({
"url":
f"http://testserver{expected_url}",
"uuid":
str(stored_object.uuid),
"titel":
titel,
"beschrijving":
beschrijving,
"registratiedatum":
"2018-09-19T10:25:19Z",
"aardRelatieWeergave":
RelatieAarden.labels[RelatieAarden.hoort_bij],
})
self.assertEqual(response.json(), expected_response)
self.assertEqual(ObjectInformatieObject.objects.count(), 1)
self.assertEqual(EnkelvoudigInformatieObject.objects.count(), 1)
@freeze_time("2018-09-20 12:00:00")
def test_registratiedatum_ignored(self):
self.create_zaak_besluit_services()
zaak = self.create_zaak()
zaak_url = reverse(zaak)
io = EnkelvoudigInformatieObjectFactory.create(
informatieobjecttype__concept=False)
io_url = f"http://testserver{reverse(io)}"
self.adapter.get(io_url, json=serialise_eio(io, io_url))
ZaakTypeInformatieObjectTypeFactory.create(
informatieobjecttype=io.informatieobjecttype,
zaaktype=zaak.zaaktype)
content = {
"informatieobject": io_url,
"zaak": f"http://testserver{zaak_url}",
"registratiedatum": "2018-09-19T12:25:20+0200",
}
# Send to the API
self.client.post(self.list_url, content)
oio = ZaakInformatieObject.objects.get()
self.assertEqual(
oio.registratiedatum,
datetime(2018, 9, 20, 12, 0, 0).replace(tzinfo=timezone.utc),
)
def test_duplicate_object(self):
"""
Test the (informatieobject, object) unique together validation.
"""
eio = EnkelvoudigInformatieObjectFactory.create()
eio_url = f"http://testserver{reverse(eio)}"
self.adapter.get(eio_url, json=serialise_eio(eio, eio_url))
zio_type = ZaakTypeInformatieObjectTypeFactory.create(
informatieobjecttype__concept=False, zaaktype__concept=False)
self.create_zaak_besluit_services()
zaak = self.create_zaak()
zio = ZaakInformatieObjectFactory.create(
informatieobject=eio_url,
zaak=zaak,
informatieobject__latest_version__informatieobjecttype=zio_type.
informatieobjecttype,
)
zaak_url = reverse(zio.zaak)
content = {
"informatieobject": eio_url,
"zaak": f"http://testserver{zaak_url}",
}
# Send to the API
response = self.client.post(self.list_url, content)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "unique")
@freeze_time("2018-09-20 12:00:00")
def test_read_zaakinformatieobject(self):
eio = EnkelvoudigInformatieObjectFactory.create()
eio_url = f"http://testserver{reverse(eio)}"
self.adapter.get(eio_url, json=serialise_eio(eio, eio_url))
self.create_zaak_besluit_services()
zaak = self.create_zaak()
zio = ZaakInformatieObjectFactory.create(informatieobject=eio_url,
zaak=zaak)
zio_detail_url = reverse(zio)
response = self.client.get(zio_detail_url)
# Test response
self.assertEqual(response.status_code, status.HTTP_200_OK)
zaak_url = reverse(zio.zaak)
expected = {
"url": f"http://testserver{zio_detail_url}",
"uuid": str(zio.uuid),
"informatieobject": eio_url,
"zaak": f"http://testserver{zaak_url}",
"aardRelatieWeergave":
RelatieAarden.labels[RelatieAarden.hoort_bij],
"titel": "",
"beschrijving": "",
"registratiedatum": "2018-09-20T12:00:00Z",
}
self.assertEqual(response.json(), expected)
def test_filter_by_zaak(self):
eio = EnkelvoudigInformatieObjectFactory.create()
eio_url = eio.get_url()
self.adapter.get(eio_url, json=serialise_eio(eio, eio_url))
self.create_zaak_besluit_services()
zaak = self.create_zaak()
zio = ZaakInformatieObjectFactory.create(informatieobject=eio_url,
zaak=zaak)
zaak_url = reverse(zio.zaak)
zio_list_url = reverse("zaakinformatieobject-list")
response = self.client.get(
zio_list_url,
{"zaak": f"http://openzaak.nl{zaak_url}"},
HTTP_HOST="openzaak.nl",
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["zaak"],
f"http://openzaak.nl{zaak_url}")
def test_filter_by_informatieobject(self):
eio = EnkelvoudigInformatieObjectFactory.create()
eio_url = f"http://openzaak.nl{reverse(eio)}"
self.adapter.get(eio_url, json=serialise_eio(eio, eio_url))
self.create_zaak_besluit_services()
zaak = self.create_zaak()
ZaakInformatieObjectFactory.create(informatieobject=eio_url, zaak=zaak)
zio_list_url = reverse("zaakinformatieobject-list")
response = self.client.get(
zio_list_url,
{"informatieobject": eio_url},
HTTP_HOST="openzaak.nl",
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["informatieobject"], eio_url)
def test_update_zaak_and_informatieobject_fails(self):
zaak = ZaakFactory.create()
zaak_url = reverse(zaak)
eio1 = EnkelvoudigInformatieObjectFactory.create()
eio1_url = f"http://testserver{reverse(eio1)}"
self.adapter.get(eio1_url, json=serialise_eio(eio1, eio1_url))
self.create_zaak_besluit_services()
zaak = self.create_zaak()
zio = ZaakInformatieObjectFactory.create(informatieobject=eio1_url,
zaak=zaak)
zio_detail_url = reverse(zio)
eio2 = EnkelvoudigInformatieObjectFactory.create()
eio2_url = f"http://testserver{reverse(eio2)}"
self.adapter.get(eio2_url, json=serialise_eio(eio2, eio2_url))
response = self.client.put(
zio_detail_url,
{
"zaak": f"http://testserver{zaak_url}",
"informatieobject": eio2_url,
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
for field in ["zaak", "informatieobject"]:
with self.subTest(field=field):
error = get_validation_errors(response, field)
self.assertEqual(error["code"], IsImmutableValidator.code)
def test_partial_update_zaak_and_informatieobject_fails(self):
self.create_zaak_besluit_services()
zaak1 = self.create_zaak()
zaak2 = self.create_zaak()
zaak1_url = reverse(zaak1)
eio1 = EnkelvoudigInformatieObjectFactory.create()
eio1_url = eio1.get_url()
self.adapter.get(eio1_url, json=serialise_eio(eio1, eio1_url))
zio = ZaakInformatieObjectFactory.create(informatieobject=eio1_url,
zaak=zaak2)
zio_detail_url = reverse(zio)
eio2 = EnkelvoudigInformatieObjectFactory.create()
eio2_url = f"http://testserver{reverse(eio2)}"
self.adapter.get(eio2_url, json=serialise_eio(eio2, eio2_url))
response = self.client.patch(
zio_detail_url,
{
"zaak": f"http://testserver{zaak1_url}",
"informatieobject": eio2_url,
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
for field in ["zaak", "informatieobject"]:
with self.subTest(field=field):
error = get_validation_errors(response, field)
self.assertEqual(error["code"], IsImmutableValidator.code)
def test_update_zio_metadata(self):
self.create_zaak_besluit_services()
zaak = self.create_zaak()
zaak_url = reverse(zaak)
io = EnkelvoudigInformatieObjectFactory.create()
io_url = f"http://testserver{reverse(io)}"
self.adapter.get(io_url, json=serialise_eio(io, io_url))
ZaakTypeInformatieObjectTypeFactory.create(
zaaktype=zaak.zaaktype,
informatieobjecttype=io.informatieobjecttype)
zio = ZaakInformatieObjectFactory.create(zaak=zaak,
informatieobject=io_url)
zio_detail_url = reverse(zio)
response = self.client.put(
zio_detail_url,
{
"zaak": f"http://testserver{zaak_url}",
"informatieobject": io_url,
"titel": "updated title",
"beschrijving": "same",
},
)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertEqual(response.data["titel"], "updated title")
self.assertEqual(response.data["beschrijving"], "same")
zio.refresh_from_db()
self.assertEqual(zio.titel, "updated title")
self.assertEqual(zio.beschrijving, "same")
def test_partial_update_zio_metadata(self):
self.create_zaak_besluit_services()
zaak = self.create_zaak()
io = EnkelvoudigInformatieObjectFactory.create()
io_url = io.get_url()
self.adapter.get(io_url, json=serialise_eio(io, io_url))
ZaakTypeInformatieObjectTypeFactory.create(
zaaktype=zaak.zaaktype,
informatieobjecttype=io.informatieobjecttype)
zio = ZaakInformatieObjectFactory.create(zaak=zaak,
informatieobject=io_url)
zio_detail_url = reverse(zio)
response = self.client.patch(zio_detail_url, {
"titel": "updated title",
"beschrijving": "same"
})
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertEqual(response.data["titel"], "updated title")
self.assertEqual(response.data["beschrijving"], "same")
zio.refresh_from_db()
self.assertEqual(zio.titel, "updated title")
self.assertEqual(zio.beschrijving, "same")
@freeze_time("2018-09-19T12:25:19+0200")
def test_delete(self):
eio = EnkelvoudigInformatieObjectFactory.create()
eio_url = eio.get_url()
self.adapter.get(eio_url, json=serialise_eio(eio, eio_url))
self.create_zaak_besluit_services()
zaak = self.create_zaak()
zio = ZaakInformatieObjectFactory.create(informatieobject=eio_url,
zaak=zaak)
zio_url = reverse(zio)
response = self.client.delete(zio_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT,
response.data)
# Relation is gone, zaak still exists.
self.assertFalse(ZaakInformatieObject.objects.exists())
self.assertTrue(Zaak.objects.exists())
def test_representation(self):
self.create_zaak_besluit_services()
zaak = self.create_zaak()
io = EnkelvoudigInformatieObjectFactory.create(
informatieobjecttype__concept=False)
io_url = f"http://testserver{reverse(io)}"
self.adapter.get(io_url, json=serialise_eio(io, io_url))
ZaakTypeInformatieObjectTypeFactory.create(
informatieobjecttype=io.informatieobjecttype,
zaaktype=zaak.zaaktype)
zio = ZaakInformatieObjectFactory.create(
zaak=zaak,
informatieobject=io_url,
)
zio_representation = str(zio)
expected_representation = f"{zaak.identificatie} - {io_url}"
self.assertEqual(expected_representation, zio_representation)
def test_delete_document_unrelated_to_zaak(self):
self.create_zaak_besluit_services()
zaak = self.create_zaak()
# Create a document related to a zaak
eio_related = EnkelvoudigInformatieObjectFactory.create()
eio_related_url = f"http://openzaak.nl{reverse(eio_related)}"
self.adapter.get(eio_related_url,
json=serialise_eio(eio_related, eio_related_url))
ZaakInformatieObjectFactory.create(informatieobject=eio_related_url,
zaak=zaak)
# Create a document unrelated to a zaak
eio_unrelated = EnkelvoudigInformatieObjectFactory.create()
eio_unrelated_url = f"http://openzaak.nl{reverse(eio_unrelated)}"
response = self.client.delete(eio_unrelated_url)
self.assertEqual(status.HTTP_204_NO_CONTENT, response.status_code)
class ZaakInformatieobjectTypeFilterAPITests(APITestCase):
maxDiff = None
list_url = reverse_lazy(ZaakInformatieobjectType)
def test_filter_zaaktype(self):
ztiot1, ztiot2 = ZaakInformatieobjectTypeFactory.create_batch(
2, zaaktype__concept=False, informatieobjecttype__concept=False)
url = f"http://testserver.com{reverse(ztiot1)}"
zaaktype1_url = reverse(ztiot1.zaaktype)
zaaktype2_url = reverse(ztiot2.zaaktype)
zaaktype1_url = f"http://testserver.com{zaaktype1_url}"
zaaktype2_url = f"http://testserver.com{zaaktype2_url}"
response = self.client.get(self.list_url, {"zaaktype": zaaktype1_url},
HTTP_HOST="testserver.com")
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()["results"]
self.assertEqual(data[0]["url"], url)
self.assertEqual(data[0]["zaaktype"], zaaktype1_url)
self.assertNotEqual(data[0]["zaaktype"], zaaktype2_url)
def test_filter_informatieobjecttype(self):
ztiot1, ztiot2 = ZaakInformatieobjectTypeFactory.create_batch(
2, zaaktype__concept=False, informatieobjecttype__concept=False)
url = f"http://testserver.com{reverse(ztiot1)}"
informatieobjecttype1_url = reverse(ztiot1.informatieobjecttype)
informatieobjecttype2_url = reverse(ztiot2.informatieobjecttype)
informatieobjecttype1_url = f"http://testserver.com{informatieobjecttype1_url}"
informatieobjecttype2_url = f"http://testserver.com{informatieobjecttype2_url}"
response = self.client.get(
self.list_url,
{"informatieobjecttype": informatieobjecttype1_url},
HTTP_HOST="testserver.com",
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()["results"]
self.assertEqual(data[0]["url"], url)
self.assertEqual(data[0]["informatieobjecttype"],
informatieobjecttype1_url)
self.assertNotEqual(data[0]["informatieobjecttype"],
informatieobjecttype2_url)
def test_filter_ziot_status_alles(self):
ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=True)
ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=True)
ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=False)
ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=False)
response = self.client.get(self.list_url, {"status": "alles"})
self.assertEqual(response.status_code, 200)
data = response.json()["results"]
self.assertEqual(len(data), 4)
def test_filter_ziot_status_concept(self):
ziot1 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=True)
ziot2 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=True)
ziot3 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=False)
ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=False)
ziot1_url = reverse(ziot1)
ziot2_url = reverse(ziot2)
ziot3_url = reverse(ziot3)
response = self.client.get(self.list_url, {"status": "concept"})
self.assertEqual(response.status_code, 200)
data = response.json()["results"]
self.assertEqual(len(data), 3)
urls = {obj["url"] for obj in data}
self.assertEqual(
urls,
{
f"http://testserver{ziot1_url}",
f"http://testserver{ziot2_url}",
f"http://testserver{ziot3_url}",
},
)
def test_filter_ziot_status_definitief(self):
ziot1 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=True)
ziot2 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=True)
ziot3 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=False)
ziot4 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=False)
ziot4_url = reverse(ziot4)
response = self.client.get(self.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{ziot4_url}")
class EnkelvoudigInformatieObjectAPITests(JWTAuthMixin, APITestCase):
list_url = reverse_lazy(EnkelvoudigInformatieObject)
heeft_alle_autorisaties = True
def test_list(self):
EnkelvoudigInformatieObjectFactory.create_batch(4)
url = reverse("enkelvoudiginformatieobject-list")
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertEqual(len(response.data["results"]), 4)
def test_create(self):
informatieobjecttype = InformatieObjectTypeFactory.create(
concept=False)
informatieobjecttype_url = reverse(informatieobjecttype)
content = {
"identificatie": uuid.uuid4().hex,
"bronorganisatie": "159351741",
"creatiedatum": "2018-06-27",
"titel": "detailed summary",
"auteur": "test_auteur",
"formaat": "txt",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"inhoud": b64encode(b"some file content").decode("utf-8"),
"link": "http://een.link",
"beschrijving": "test_beschrijving",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"vertrouwelijkheidaanduiding": "openbaar",
}
# Send to the API
response = self.client.post(self.list_url, content)
# Test response
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
# Test database
stored_object = EnkelvoudigInformatieObject.objects.get()
self.assertEqual(EnkelvoudigInformatieObject.objects.count(), 1)
self.assertEqual(stored_object.identificatie, content["identificatie"])
self.assertEqual(stored_object.bronorganisatie, "159351741")
self.assertEqual(stored_object.creatiedatum, date(2018, 6, 27))
self.assertEqual(stored_object.titel, "detailed summary")
self.assertEqual(stored_object.auteur, "test_auteur")
self.assertEqual(stored_object.formaat, "txt")
self.assertEqual(stored_object.taal, "eng")
self.assertEqual(stored_object.versie, 1)
self.assertAlmostEqual(stored_object.begin_registratie, timezone.now())
self.assertEqual(stored_object.bestandsnaam, "dummy.txt")
self.assertEqual(stored_object.inhoud.read(), b"some file content")
self.assertEqual(stored_object.link, "http://een.link")
self.assertEqual(stored_object.beschrijving, "test_beschrijving")
self.assertEqual(stored_object.informatieobjecttype,
informatieobjecttype)
self.assertEqual(stored_object.vertrouwelijkheidaanduiding, "openbaar")
expected_url = reverse(stored_object)
expected_file_url = get_operation_url(
"enkelvoudiginformatieobject_download", uuid=stored_object.uuid)
expected_response = content.copy()
expected_response.update({
"url":
f"http://testserver{expected_url}",
"inhoud":
f"http://testserver{expected_file_url}?versie=1",
"versie":
1,
"beginRegistratie":
stored_object.begin_registratie.isoformat().replace("+00:00", "Z"),
"vertrouwelijkheidaanduiding":
"openbaar",
"bestandsomvang":
stored_object.inhoud.size,
"integriteit": {
"algoritme": "",
"waarde": "",
"datum": None
},
"ontvangstdatum":
None,
"verzenddatum":
None,
"ondertekening": {
"soort": "",
"datum": None
},
"indicatieGebruiksrecht":
None,
"status":
"",
"locked":
False,
})
response_data = response.json()
self.assertEqual(sorted(response_data.keys()),
sorted(expected_response.keys()))
for key in response_data.keys():
with self.subTest(field=key):
self.assertEqual(response_data[key], expected_response[key])
def test_create_without_identificatie(self):
informatieobjecttype = InformatieObjectTypeFactory.create(
concept=False)
informatieobjecttype_url = reverse(informatieobjecttype)
content = {
"bronorganisatie": "159351741",
"creatiedatum": "2018-06-27",
"titel": "detailed summary",
"auteur": "test_auteur",
"formaat": "txt",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"inhoud": b64encode(b"some file content").decode("utf-8"),
"link": "http://een.link",
"beschrijving": "test_beschrijving",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"vertrouwelijkheidaanduiding": "openbaar",
}
# Send to the API
response = self.client.post(self.list_url, content)
# Test response
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
# Test database
stored_object = EnkelvoudigInformatieObject.objects.get()
self.assertEqual(EnkelvoudigInformatieObject.objects.count(), 1)
# Test generation of human readable identificatie
self.assertEqual(stored_object.identificatie,
"DOCUMENT-2018-0000000001")
def test_create_fail_informatieobjecttype_max_length(self):
informatieobjecttype = InformatieObjectTypeFactory.create()
informatieobjecttype_url = reverse(informatieobjecttype)
content = {
"identificatie":
uuid.uuid4().hex,
"bronorganisatie":
"159351741",
"creatiedatum":
"2018-06-27",
"titel":
"detailed summary",
"auteur":
"test_auteur",
"formaat":
"txt",
"taal":
"eng",
"bestandsnaam":
"dummy.txt",
"inhoud":
b64encode(b"some file content").decode("utf-8"),
"link":
"http://een.link",
"beschrijving":
"test_beschrijving",
"informatieobjecttype":
f"http://testserver/some-very-long-url-addres-which-exceeds-maximum-"
f"length-of-hyperlinkedrelatedfield/aaaaaaaaaaaaaaaaaaaaaaaaa/"
f"{informatieobjecttype_url}",
"vertrouwelijkheidaanduiding":
"openbaar",
}
# Send to the API
response = self.client.post(self.list_url, content)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
error = get_validation_errors(response, "informatieobjecttype")
self.assertEqual(error["code"], "max_length")
def test_read(self):
test_object = EnkelvoudigInformatieObjectFactory.create()
# Retrieve from the API
detail_url = reverse(test_object)
response = self.client.get(detail_url)
# Test response
self.assertEqual(response.status_code, status.HTTP_200_OK)
file_url = get_operation_url("enkelvoudiginformatieobject_download",
uuid=test_object.uuid)
expected = {
"url":
f"http://testserver{detail_url}",
"identificatie":
str(test_object.identificatie),
"bronorganisatie":
test_object.bronorganisatie,
"creatiedatum":
"2018-06-27",
"titel":
"some titel",
"auteur":
"some auteur",
"status":
"",
"formaat":
"some formaat",
"taal":
"nld",
"beginRegistratie":
test_object.begin_registratie.isoformat().replace("+00:00", "Z"),
"versie":
1,
"bestandsnaam":
"",
"inhoud":
f"http://testserver{file_url}?versie=1",
"bestandsomvang":
test_object.inhoud.size,
"link":
"",
"beschrijving":
"",
"ontvangstdatum":
None,
"verzenddatum":
None,
"ondertekening": {
"soort": "",
"datum": None
},
"indicatieGebruiksrecht":
None,
"vertrouwelijkheidaanduiding":
"openbaar",
"integriteit": {
"algoritme": "",
"waarde": "",
"datum": None
},
"informatieobjecttype":
f"http://testserver{reverse(test_object.informatieobjecttype)}",
"locked":
False,
}
response_data = response.json()
self.assertEqual(sorted(response_data.keys()), sorted(expected.keys()))
for key in response_data.keys():
with self.subTest(field=key):
self.assertEqual(response_data[key], expected[key])
def test_bestandsomvang(self):
"""
Assert that the API shows the filesize.
"""
test_object = EnkelvoudigInformatieObjectFactory.create(
inhoud__data=b"some content")
# Retrieve from the API
detail_url = reverse(
"enkelvoudiginformatieobject-detail",
kwargs={
"version": "1",
"uuid": test_object.uuid
},
)
response = self.client.get(detail_url)
# Test response
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["bestandsomvang"], 12) # 12 bytes
def test_integrity_empty(self):
"""
Assert that integrity is optional.
"""
informatieobjecttype = InformatieObjectTypeFactory.create(
concept=False)
informatieobjecttype_url = reverse(informatieobjecttype)
content = {
"identificatie": uuid.uuid4().hex,
"bronorganisatie": "159351741",
"creatiedatum": "2018-12-13",
"titel": "Voorbeelddocument",
"auteur": "test_auteur",
"formaat": "text/plain",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"vertrouwelijkheidaanduiding": "openbaar",
"inhoud": b64encode(b"some file content").decode("utf-8"),
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"integriteit": None,
}
# Send to the API
response = self.client.post(self.list_url, content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
stored_object = EnkelvoudigInformatieObject.objects.get()
self.assertEqual(stored_object.integriteit, {
"algoritme": "",
"waarde": "",
"datum": None
})
def test_integrity_provided(self):
"""
Assert that integrity is saved.
"""
informatieobjecttype = InformatieObjectTypeFactory.create(
concept=False)
informatieobjecttype_url = reverse(informatieobjecttype)
content = {
"identificatie": uuid.uuid4().hex,
"bronorganisatie": "159351741",
"creatiedatum": "2018-12-13",
"titel": "Voorbeelddocument",
"auteur": "test_auteur",
"formaat": "text/plain",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"vertrouwelijkheidaanduiding": "openbaar",
"inhoud": b64encode(b"some file content").decode("utf-8"),
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"integriteit": {
"algoritme": "md5",
"waarde": "27c3a009a3cbba674d0b3e836f2d4685",
"datum": "2018-12-13",
},
}
# Send to the API
response = self.client.post(self.list_url, content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
stored_object = EnkelvoudigInformatieObject.objects.get()
self.assertEqual(
stored_object.integriteit,
{
"algoritme": "md5",
"waarde": "27c3a009a3cbba674d0b3e836f2d4685",
"datum": date(2018, 12, 13),
},
)
def test_filter_by_identification(self):
EnkelvoudigInformatieObjectFactory.create(identificatie="foo")
EnkelvoudigInformatieObjectFactory.create(identificatie="bar")
response = self.client.get(self.list_url, {"identificatie": "foo"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()["results"]
self.assertEqual(len(response_data), 1)
self.assertEqual(response_data[0]["identificatie"], "foo")
def test_destroy_no_relations_allowed(self):
"""
Assert that destroying is possible when there are no relations.
"""
eio = EnkelvoudigInformatieObjectFactory.create()
url = reverse(eio)
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(EnkelvoudigInformatieObject.objects.exists())
def test_destroy_with_relations_not_allowed(self):
"""
Assert that destroying is not possible when there are relations.
"""
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
ZaakInformatieObjectFactory.create(informatieobject=eio.canonical)
response = self.client.delete(eio_path)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "pending-relations")
def test_validate_unknown_query_params(self):
EnkelvoudigInformatieObjectFactory.create_batch(2)
url = reverse(EnkelvoudigInformatieObject)
response = self.client.get(url, {"someparam": "somevalue"})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "unknown-parameters")
def test_eio_download_with_accept_application_octet_stream_header(self):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1", inhoud__data=b"inhoud1")
eio_url = get_operation_url("enkelvoudiginformatieobject_download",
uuid=eio.uuid)
response = self.client.get(eio_url,
HTTP_ACCEPT="application/octet-stream")
self.assertEqual(response.status_code, status.HTTP_200_OK)
try:
self.assertEqual(list(response.streaming_content)[0], b"inhoud1")
except AttributeError:
self.assertEqual(response._container[0], b"inhoud1")
def test_invalid_inhoud(self):
informatieobjecttype = InformatieObjectTypeFactory.create(
concept=False)
informatieobjecttype_url = reverse(informatieobjecttype)
content = {
"identificatie": uuid.uuid4().hex,
"bronorganisatie": "159351741",
"creatiedatum": "2018-06-27",
"titel": "detailed summary",
"auteur": "test_auteur",
"formaat": "txt",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"inhoud": [1, 2, 3],
"link": "http://een.link",
"beschrijving": "test_beschrijving",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"vertrouwelijkheidaanduiding": "openbaar",
}
# Send to the API
response = self.client.post(self.list_url, content)
# Test response
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
error = get_validation_errors(response, "inhoud")
self.assertEqual(error["code"], "invalid")
def test_inhoud_invalid_utf8_char_not_b64_encoded(self):
informatieobjecttype = InformatieObjectTypeFactory.create(
concept=False)
informatieobjecttype_url = reverse(informatieobjecttype)
content = {
"identificatie": uuid.uuid4().hex,
"bronorganisatie": "159351741",
"creatiedatum": "2018-06-27",
"titel": "detailed summary",
"auteur": "test_auteur",
"formaat": "txt",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"inhoud": "<",
"link": "http://een.link",
"beschrijving": "test_beschrijving",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"vertrouwelijkheidaanduiding": "openbaar",
}
# Send to the API
response = self.client.post(self.list_url, content)
# Test response
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_download_deleted_eio(self):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1", inhoud__data=b"inhoud1")
eio_url = get_operation_url("enkelvoudiginformatieobject_download",
uuid=eio.uuid)
response = self.client.delete(reverse(eio))
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
response = self.client.get(eio_url,
HTTP_ACCEPT="application/octet-stream")
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
class ZaakInformatieobjectTypeAPITests(APITestCase):
maxDiff = None
heeft_alle_autorisaties = False
scopes = [SCOPE_CATALOGI_WRITE, SCOPE_CATALOGI_READ]
list_url = reverse_lazy(ZaakInformatieobjectType)
def test_get_list_default_definitief(self):
ziot1 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=True)
ziot2 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=True)
ziot3 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=False)
ziot4 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=False)
ziot4_url = reverse(ziot4)
response = self.client.get(self.list_url)
self.assertEqual(response.status_code, 200)
data = response.json()["results"]
self.assertEqual(len(data), 1)
self.assertEqual(data[0]["url"], f"http://testserver{ziot4_url}")
def test_get_detail(self):
ztiot = ZaakInformatieobjectTypeFactory.create()
url = reverse(ztiot)
zaaktype_url = reverse(ztiot.zaaktype)
informatieobjecttype_url = reverse(ztiot.informatieobjecttype)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
expected = {
"url": f"http://testserver{url}",
"zaaktype": f"http://testserver{zaaktype_url}",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"volgnummer": ztiot.volgnummer,
"richting": ztiot.richting,
"statustype": None,
}
self.assertEqual(response.json(), expected)
def test_create_ziot(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=zaaktype.catalogus)
informatieobjecttype_url = reverse(informatieobjecttype)
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"volgnummer": 13,
"richting": RichtingChoices.inkomend,
}
response = self.client.post(self.list_url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
ziot = ZaakInformatieobjectType.objects.get(volgnummer=13)
self.assertEqual(ziot.zaaktype, zaaktype)
self.assertEqual(ziot.informatieobjecttype, informatieobjecttype)
def test_create_ziot_not_concept_zaaktype(self):
zaaktype = ZaakTypeFactory.create(concept=False)
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=zaaktype.catalogus)
informatieobjecttype_url = reverse(informatieobjecttype)
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"volgnummer": 13,
"richting": RichtingChoices.inkomend,
}
response = self.client.post(self.list_url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_create_ziot_not_concept_informatieobjecttype(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
concept=False, catalogus=zaaktype.catalogus)
informatieobjecttype_url = reverse(informatieobjecttype)
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"volgnummer": 13,
"richting": RichtingChoices.inkomend,
}
response = self.client.post(self.list_url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_create_ziot_fail_not_concept_zaaktype_and_informatieobjecttype(
self):
zaaktype = ZaakTypeFactory.create(concept=False)
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
concept=False, catalogus=zaaktype.catalogus)
informatieobjecttype_url = reverse(informatieobjecttype)
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"volgnummer": 13,
"richting": RichtingChoices.inkomend,
}
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"], "non-concept-relation")
def test_create_ziot_fail_catalogus_mismatch(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
concept=False)
informatieobjecttype_url = reverse(informatieobjecttype)
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"volgnummer": 13,
"richting": RichtingChoices.inkomend,
}
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"], "relations-incorrect-catalogus")
def test_create_ziot_fail_not_unique(self):
ziot = ZaakInformatieobjectTypeFactory(volgnummer=1)
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=ziot.zaaktype.catalogus)
data = {
"zaaktype": f"http://testserver.com{reverse(ziot.zaaktype)}",
"informatieobjecttype":
f"http://testserver.com{reverse(informatieobjecttype)}",
"volgnummer": ziot.volgnummer,
"richting": RichtingChoices.inkomend,
}
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"], "unique")
def test_delete_ziot(self):
ziot = ZaakInformatieobjectTypeFactory.create()
ziot_url = reverse(ziot)
response = self.client.delete(ziot_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(ZaakInformatieobjectType.objects.filter(id=ziot.id))
def test_delete_ziot_not_concept_zaaktype(self):
ziot = ZaakInformatieobjectTypeFactory.create(zaaktype__concept=False)
ziot_url = reverse(ziot)
response = self.client.delete(ziot_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(ZaakInformatieobjectType.objects.filter(id=ziot.id))
def test_delete_ziot_not_concept_informatieobjecttype(self):
ziot = ZaakInformatieobjectTypeFactory.create(
informatieobjecttype__concept=False)
ziot_url = reverse(ziot)
response = self.client.delete(ziot_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(ZaakInformatieobjectType.objects.filter(id=ziot.id))
def test_delete_ziot_fail_not_concept(self):
ziot = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=False)
ziot_url = reverse(ziot)
response = self.client.delete(ziot_url)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "non-concept-relation")
def test_update_ziot(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=zaaktype.catalogus)
informatieobjecttype_url = reverse(informatieobjecttype)
ziot = ZaakInformatieobjectTypeFactory.create(
zaaktype=zaaktype, informatieobjecttype=informatieobjecttype)
ziot_url = reverse(ziot)
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"volgnummer": 13,
"richting": RichtingChoices.inkomend,
}
response = self.client.put(ziot_url, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["volgnummer"], 13)
ziot.refresh_from_db()
self.assertEqual(ziot.volgnummer, 13)
def test_partial_update_ziot(self):
zaaktype = ZaakTypeFactory.create()
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=zaaktype.catalogus)
ziot = ZaakInformatieobjectTypeFactory.create(
zaaktype=zaaktype, informatieobjecttype=informatieobjecttype)
ziot_url = reverse(ziot)
response = self.client.patch(ziot_url, {"volgnummer": 12})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["volgnummer"], 12)
ziot.refresh_from_db()
self.assertEqual(ziot.volgnummer, 12)
def test_partial_update_ziot_informatieobjecttype(self):
zaaktype = ZaakTypeFactory.create()
ziot = ZaakInformatieobjectTypeFactory.create(zaaktype=zaaktype)
ziot_url = reverse(ziot)
informatieobjecttype = InformatieObjectTypeFactory.create()
informatieobjecttype_url = reverse(informatieobjecttype)
response = self.client.patch(
ziot_url, {"informatieobjecttype": informatieobjecttype_url})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "relations-incorrect-catalogus")
def test_update_ziot_not_concept_zaaktype(self):
zaaktype = ZaakTypeFactory.create(concept=False)
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=zaaktype.catalogus)
informatieobjecttype_url = reverse(informatieobjecttype)
ziot = ZaakInformatieobjectTypeFactory.create(
zaaktype=zaaktype, informatieobjecttype=informatieobjecttype)
ziot_url = reverse(ziot)
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"volgnummer": 13,
"richting": RichtingChoices.inkomend,
}
response = self.client.put(ziot_url, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["volgnummer"], 13)
ziot.refresh_from_db()
self.assertEqual(ziot.volgnummer, 13)
def test_update_ziot_not_concept_informatieobjecttype(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=zaaktype.catalogus, concept=False)
informatieobjecttype_url = reverse(informatieobjecttype)
ziot = ZaakInformatieobjectTypeFactory.create(
zaaktype=zaaktype, informatieobjecttype=informatieobjecttype)
ziot_url = reverse(ziot)
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"volgnummer": 13,
"richting": RichtingChoices.inkomend,
}
response = self.client.put(ziot_url, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["volgnummer"], 13)
ziot.refresh_from_db()
self.assertEqual(ziot.volgnummer, 13)
def test_update_ziot_not_concept_zaaktype_and_informatieobjecttype_fails(
self):
zaaktype = ZaakTypeFactory.create(concept=False)
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=zaaktype.catalogus, concept=False)
informatieobjecttype_url = reverse(informatieobjecttype)
ziot = ZaakInformatieobjectTypeFactory.create(
zaaktype=zaaktype, informatieobjecttype=informatieobjecttype)
ziot_url = reverse(ziot)
data = {
"zaaktype": f"http://testserver{zaaktype_url}",
"informatieobjecttype":
f"http://testserver{informatieobjecttype_url}",
"volgnummer": 13,
"richting": RichtingChoices.inkomend,
}
response = self.client.put(ziot_url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "non-concept-relation")
def test_partial_update_ziot_not_concept_zaaktype(self):
zaaktype = ZaakTypeFactory.create(concept=False)
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=zaaktype.catalogus)
informatieobjecttype_url = reverse(informatieobjecttype)
ziot = ZaakInformatieobjectTypeFactory.create(
zaaktype=zaaktype, informatieobjecttype=informatieobjecttype)
ziot_url = reverse(ziot)
response = self.client.patch(ziot_url, {"volgnummer": 12})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["volgnummer"], 12)
ziot.refresh_from_db()
self.assertEqual(ziot.volgnummer, 12)
def test_partial_update_ziot_not_concept_informatieobjecttype(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=zaaktype.catalogus, concept=False)
informatieobjecttype_url = reverse(informatieobjecttype)
ziot = ZaakInformatieobjectTypeFactory.create(
zaaktype=zaaktype, informatieobjecttype=informatieobjecttype)
ziot_url = reverse(ziot)
response = self.client.patch(ziot_url, {"volgnummer": 12})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["volgnummer"], 12)
ziot.refresh_from_db()
self.assertEqual(ziot.volgnummer, 12)
def test_partial_update_ziot_not_concept_zaaktype_and_informatieobjecttype_fails(
self, ):
zaaktype = ZaakTypeFactory.create(concept=False)
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=zaaktype.catalogus, concept=False)
informatieobjecttype_url = reverse(informatieobjecttype)
ziot = ZaakInformatieobjectTypeFactory.create(
zaaktype=zaaktype, informatieobjecttype=informatieobjecttype)
ziot_url = reverse(ziot)
response = self.client.patch(ziot_url, {"volgnummer": 12})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "non-concept-relation")
def test_full_update_ziot_informatieobjecttype(self):
zaaktype = ZaakTypeFactory.create()
ziot = ZaakInformatieobjectTypeFactory.create(zaaktype=zaaktype)
ziot_url = reverse(ziot)
informatieobjecttype = InformatieObjectTypeFactory.create()
informatieobjecttype_url = reverse(informatieobjecttype)
zaaktype_url = reverse(ziot.zaaktype)
response = self.client.put(
ziot_url,
{
"zaaktype": f"http://testserver{zaaktype_url}",
"informatieobjecttype": informatieobjecttype_url,
"volgnummer": ziot.volgnummer,
"richting": ziot.richting,
"statustype": None,
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "relations-incorrect-catalogus")
class EnkelvoudigInformatieObjectVersionHistoryAPITests(JWTAuthMixin, APICMISTestCase):
list_url = reverse_lazy(EnkelvoudigInformatieObject)
heeft_alle_autorisaties = True
def test_eio_update(self):
import os
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1", informatieobjecttype__concept=False
)
eio_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio.uuid}
)
eio_response = self.client.get(eio_url)
eio_data = eio_response.data
lock_response = self.client.post(f"{eio_url}/lock")
self.assertEqual(lock_response.status_code, status.HTTP_200_OK)
lock = lock_response.data["lock"]
eio_data.update(
{
"beschrijving": "beschrijving2",
"inhoud": b64encode(b"aaaaa"),
"lock": lock,
}
)
del eio_data["integriteit"]
del eio_data["ondertekening"]
response = self.client.put(eio_url, eio_data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertEqual(response_data["beschrijving"], "beschrijving2")
# The private working copy and the original count as 2 documents in Alfresco
eios = EnkelvoudigInformatieObject.objects.filter(uuid=eio.uuid).order_by(
"-versie"
)
os.environ["foo"] = "bar"
self.assertEqual(len(eios), 2)
latest_version = eios[0]
self.assertEqual(latest_version.versie, 2)
self.assertEqual(latest_version.beschrijving, "beschrijving2")
first_version = eios[1]
self.assertEqual(first_version.versie, 1)
self.assertEqual(first_version.beschrijving, "beschrijving1")
def test_eio_partial_update(self):
eio = EnkelvoudigInformatieObjectFactory.create(beschrijving="beschrijving1")
eio_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio.uuid}
)
lock = self.client.post(f"{eio_url}/lock").data["lock"]
response = self.client.patch(
eio_url, {"beschrijving": "beschrijving2", "lock": lock}
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertEqual(response_data["beschrijving"], "beschrijving2")
eios = EnkelvoudigInformatieObject.objects.filter(uuid=eio.uuid).order_by(
"-versie"
)
self.assertEqual(len(eios), 2)
latest_version = eios.first()
self.assertEqual(latest_version.versie, 2)
self.assertEqual(latest_version.beschrijving, "beschrijving2")
first_version = eios[1]
self.assertEqual(first_version.versie, 1)
self.assertEqual(first_version.beschrijving, "beschrijving1")
def test_eio_delete(self):
eio = EnkelvoudigInformatieObjectFactory.create(beschrijving="beschrijving1")
eio_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio.uuid}
)
lock = self.client.post(f"{eio_url}/lock").data["lock"]
self.client.patch(eio_url, {"beschrijving": "beschrijving2", "lock": lock})
response = self.client.delete(eio_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(EnkelvoudigInformatieObjectCanonical.objects.exists())
self.assertFalse(EnkelvoudigInformatieObject.objects.exists())
def test_eio_update_content(self):
eio = EnkelvoudigInformatieObjectFactory.create(
inhoud=BytesIO(b"Content before update"),
informatieobjecttype__concept=False,
)
eio_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio.uuid}
)
eio_response = self.client.get(eio_url)
eio_data = eio_response.data
lock_response = self.client.post(f"{eio_url}/lock")
self.assertEqual(lock_response.status_code, status.HTTP_200_OK)
lock = lock_response.data["lock"]
eio_data.update(
{"inhoud": b64encode(b"Content after update"), "lock": lock,}
)
del eio_data["integriteit"]
del eio_data["ondertekening"]
update_response = self.client.put(eio_url, eio_data)
self.assertEqual(update_response.status_code, status.HTTP_200_OK)
unlock_url = get_operation_url(
"enkelvoudiginformatieobject_unlock", uuid=eio.uuid
)
unlock_content = {"lock": lock}
unlock_response = self.client.post(unlock_url, unlock_content)
self.assertEqual(unlock_response.status_code, status.HTTP_204_NO_CONTENT)
updated_eio = EnkelvoudigInformatieObject.objects.first()
self.assertEqual(updated_eio.inhoud.read(), b"Content after update")
def test_eio_detail_retrieves_latest_version(self):
eio = EnkelvoudigInformatieObjectFactory.create(beschrijving="beschrijving1")
eio_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio.uuid}
)
lock = self.client.post(f"{eio_url}/lock").data["lock"]
self.client.patch(eio_url, {"beschrijving": "beschrijving2", "lock": lock})
response = self.client.get(eio_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["beschrijving"], "beschrijving2")
def test_eio_list_shows_latest_versions(self):
eio1 = EnkelvoudigInformatieObjectFactory.create(beschrijving="object1")
eio1_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio1.uuid}
)
lock1 = self.client.post(f"{eio1_url}/lock").data["lock"]
self.client.patch(eio1_url, {"beschrijving": "object1 versie2", "lock": lock1})
eio2 = EnkelvoudigInformatieObjectFactory.create(beschrijving="object2",)
eio2_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio2.uuid}
)
lock2 = self.client.post(f"{eio2_url}/lock").data["lock"]
self.client.patch(eio2_url, {"beschrijving": "object2 versie2", "lock": lock2})
import os
os.environ["foo"] = "bar"
response = self.client.get(reverse(EnkelvoudigInformatieObject))
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.data["results"]
self.assertEqual(len(response_data), 2)
self.assertEqual(response_data[0]["beschrijving"], "object1 versie2")
self.assertEqual(response_data[1]["beschrijving"], "object2 versie2")
def test_eio_detail_filter_by_version(self):
eio = EnkelvoudigInformatieObjectFactory.create(beschrijving="beschrijving1")
eio_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio.uuid}
)
lock = self.client.post(f"{eio_url}/lock").data["lock"]
self.client.patch(eio_url, {"beschrijving": "beschrijving2", "lock": lock})
response = self.client.get(eio_url, {"versie": 1})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["beschrijving"], "beschrijving1")
def test_eio_detail_filter_by_wrong_version_gives_404(self):
eio = EnkelvoudigInformatieObjectFactory.create(beschrijving="beschrijving1")
eio_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio.uuid}
)
lock = self.client.post(f"{eio_url}/lock").data["lock"]
self.client.patch(eio_url, {"beschrijving": "beschrijving2", "lock": lock})
response = self.client.get(eio_url, {"versie": 100})
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_eio_detail_filter_by_registratie_op(self):
with freeze_time("2019-01-01 12:00:00"):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1"
)
eio_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio.uuid}
)
lock = self.client.post(f"{eio_url}/lock").data["lock"]
with freeze_time("2019-01-01 13:00:00"):
self.client.patch(eio_url, {"beschrijving": "beschrijving2", "lock": lock})
response = self.client.get(eio_url, {"registratieOp": "2019-01-01T12:00:00"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["beschrijving"], "beschrijving1")
@freeze_time("2019-01-01 12:00:00")
def test_eio_detail_filter_by_wrong_registratie_op_gives_404(self):
eio = EnkelvoudigInformatieObjectFactory.create(beschrijving="beschrijving1")
eio_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio.uuid}
)
lock = self.client.post(f"{eio_url}/lock").data["lock"]
self.client.patch(eio_url, {"beschrijving": "beschrijving2", "lock": lock})
response = self.client.get(eio_url, {"registratieOp": "2019-01-01T11:59:00"})
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_eio_download_content_filter_by_version(self):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1", inhoud__data=b"inhoud1"
)
eio_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio.uuid}
)
lock = self.client.post(f"{eio_url}/lock").data["lock"]
self.client.patch(
eio_url,
{
"inhoud": b64encode(b"inhoud2"),
"beschrijving": "beschrijving2",
"lock": lock,
},
)
response = self.client.get(eio_url, {"versie": "1"})
response_download = self.client.get(response.data["inhoud"])
self.assertTrue(response_download.streaming)
self.assertEqual(response_download.getvalue(), b"inhoud1")
def test_eio_download_content_filter_by_registratie(self):
with freeze_time("2019-01-01 12:00:00"):
eio = EnkelvoudigInformatieObjectFactory.create(
beschrijving="beschrijving1", inhoud__data=b"inhoud1"
)
eio_url = reverse(
"enkelvoudiginformatieobject-detail", kwargs={"uuid": eio.uuid}
)
lock = self.client.post(f"{eio_url}/lock").data["lock"]
with freeze_time("2019-01-01 13:00:00"):
self.client.patch(
eio_url,
{
"inhoud": b64encode(b"inhoud2"),
"beschrijving": "beschrijving2",
"lock": lock,
},
)
response = self.client.get(eio_url, {"registratieOp": "2019-01-01T12:00:00"})
response_download = self.client.get(response.data["inhoud"])
self.assertEqual(response_download.getvalue(), b"inhoud1")
class ExternalDocumentDestroyTests(JWTAuthMixin, APITestCase):
heeft_alle_autorisaties = True
list_url = reverse_lazy(BesluitInformatieObject)
base = "https://external.documenten.nl/api/v1/"
document = f"{base}enkelvoudiginformatieobjecten/{uuid.uuid4()}"
@classmethod
def setUpClass(cls):
super().setUpClass()
Service.objects.create(
api_type=APITypes.drc,
api_root=cls.base,
label="external documents",
auth_type=AuthTypes.no_auth,
)
def test_destroy_with_external_informatieobject(self):
oio = f"{self.base}objectinformatieobjecten/{uuid.uuid4()}"
informatieobjecttype = InformatieObjectTypeFactory.create()
with requests_mock.Mocker(real_http=True) as m:
mock_service_oas_get(m, APITypes.drc, self.base)
m.get(
self.document,
json=get_eio_response(
self.document,
informatieobjecttype=f"http://openzaak.nl{reverse(informatieobjecttype)}",
),
)
m.delete(oio, status_code=204)
bio = BesluitInformatieObjectFactory.create(
informatieobject=self.document, _objectinformatieobject_url=oio
)
bio_url = reverse(bio)
response = self.client.delete(bio_url, HTTP_HOST="openzaak.nl")
self.assertEqual(
response.status_code, status.HTTP_204_NO_CONTENT, response.data
)
self.assertEqual(BesluitInformatieObject.objects.count(), 0)
history_delete = [
req
for req in m.request_history
if req.method == "DELETE" and req.url == oio
]
self.assertEqual(len(history_delete), 1)
def test_destroy_with_external_informatieobject_fail_send(self):
oio = f"{self.base}objectinformatieobjecten/{uuid.uuid4()}"
informatieobjecttype = InformatieObjectTypeFactory.create()
with requests_mock.Mocker(real_http=True) as m:
mock_service_oas_get(m, APITypes.drc, self.base)
m.get(
self.document,
json=get_eio_response(
self.document,
informatieobjecttype=f"http://openzaak.nl{reverse(informatieobjecttype)}",
),
)
m.delete(oio, status_code=404, text="Not found")
bio = BesluitInformatieObjectFactory.create(
informatieobject=self.document, _objectinformatieobject_url=oio
)
bio_url = reverse(bio)
response = self.client.delete(bio_url, HTTP_HOST="openzaak.nl")
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "informatieobject")
self.assertEqual(error["code"], "pending-relations")
class InformatieObjectStatusTests(JWTAuthMixin, APITestCase):
url = reverse_lazy("enkelvoudiginformatieobject-list")
heeft_alle_autorisaties = True
def test_ontvangen_informatieobjecten(self):
"""
Assert certain statuses are not allowed for received documents.
RGBZ 2.00.02 deel II Concept 20180613: De waarden ?in bewerking?
en ?ter vaststelling? zijn niet van toepassing op ontvangen
informatieobjecten.
"""
informatieobjecttype = InformatieObjectTypeFactory.create()
informatieobjecttype_url = reverse(informatieobjecttype)
invalid_statuses = (Statussen.in_bewerking, Statussen.ter_vaststelling)
data = {
"bronorganisatie": "319582462",
"creatiedatum": "2018-12-24",
"titel": "dummy",
"auteur": "dummy",
"taal": "nld",
"inhoud": "aGVsbG8gd29ybGQ=",
"informatieobjecttype": informatieobjecttype_url,
"ontvangstdatum": "2018-12-24",
}
for invalid_status in invalid_statuses:
with self.subTest(status=invalid_status):
_data = data.copy()
_data["status"] = invalid_status
response = self.client.post(self.url, _data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "status")
self.assertEqual(error["code"], "invalid_for_received")
def test_informatieobjecten_niet_ontvangen(self):
"""
All statusses should be allowed when the informatieobject doesn't have
a receive date.
"""
for valid_status, _ in Statussen.choices:
with self.subTest(status=status):
data = {"ontvangstdatum": None, "status": valid_status}
response = self.client.post(self.url, data)
error = get_validation_errors(response, "status")
self.assertIsNone(error)
def test_status_set_ontvangstdatum_is_set_later(self):
"""
Assert that setting the ontvangstdatum later, after an 'invalid' status
has been set, is not possible.
"""
eio = EnkelvoudigInformatieObjectFactory.create(ontvangstdatum=None)
url = reverse("enkelvoudiginformatieobject-detail",
kwargs={"uuid": eio.uuid})
for invalid_status in (Statussen.in_bewerking,
Statussen.ter_vaststelling):
with self.subTest(status=invalid_status):
eio.status = invalid_status
eio.save()
data = {"ontvangstdatum": "2018-12-24"}
response = self.client.patch(url, data)
self.assertEqual(response.status_code,
status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "status")
self.assertEqual(error["code"], "invalid_for_received")
class OIOCreateExternalURLsTests(JWTAuthMixin, APICMISTestCase):
heeft_alle_autorisaties = True
list_url = reverse_lazy(ObjectInformatieObject)
besluit = "https://externe.catalogus.nl/api/v1/besluiten/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
besluittype = "https://externe.catalogus.nl/api/v1/besluittypen/b71f72ef-198d-44d8-af64-ae1932df830a"
zaak = (
"https://externe.catalogus.nl/api/v1/zaken/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
)
zaaktype = "https://externe.catalogus.nl/api/v1/zaaktypen/b71f72ef-198d-44d8-af64-ae1932df830a"
catalogus = "https://externe.catalogus.nl/api/v1/catalogussen/5c4c492b-3548-4258-b17f-0e2e31dcfe25"
@classmethod
def setUpClass(cls):
super().setUpClass()
# Mocking the calls for the CMIS adapter
Service.objects.create(
api_type=APITypes.zrc,
api_root="https://externe.catalogus.nl/api/v1/",
label="external zaken",
auth_type=AuthTypes.no_auth,
)
def test_create_external_zaak(self):
mock_service_oas_get(self.adapter, APITypes.zrc,
"https://externe.catalogus.nl/api/v1/")
self.adapter.get(self.zaak,
json=get_zaak_response(self.zaak, self.zaaktype))
self.adapter.get(self.zaaktype,
json=get_zaak_response(self.catalogus, self.zaaktype))
# The test
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
response = self.client.post(
self.list_url,
{
"object": self.zaak,
"informatieobject": eio_url,
"objectType": "zaak",
},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
oio = ObjectInformatieObject.objects.get()
self.assertEqual(oio.get_informatieobject_url(), eio_url)
self.assertEqual(oio.object, self.zaak)
def test_create_external_besluit(self):
mock_service_oas_get(self.adapter, APITypes.zrc,
"https://externe.catalogus.nl/api/v1/")
self.adapter.get(
self.besluit,
json=get_besluit_response(self.besluit, self.besluittype,
self.zaak),
)
self.adapter.get(self.zaak,
json=get_zaak_response(self.zaak, self.zaaktype))
self.adapter.get(self.zaaktype,
json=get_zaak_response(self.catalogus, self.zaaktype))
# The test
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
response = self.client.post(
self.list_url,
{
"object": self.besluit,
"informatieobject": eio_url,
"objectType": "besluit",
},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
oio = ObjectInformatieObject.objects.get()
self.assertEqual(oio.get_informatieobject_url(), eio_url)
self.assertEqual(oio.object, self.besluit)
def test_create_external_zaak_fail_invalid_schema(self):
zaak = "https://externe.catalogus.nl/api/v1/zaken/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
zaaktype = "https://externe.catalogus.nl/api/v1/zaaktypen/b71f72ef-198d-44d8-af64-ae1932df830a"
eio = EnkelvoudigInformatieObjectFactory.create()
eio_url = reverse(eio)
self.adapter.register_uri(
"GET",
zaak,
json={
"url": zaak,
"uuid": "d781cd1b-f100-4051-9543-153b93299da4",
"identificatie": "ZAAK-2019-0000000001",
"zaaktype": zaaktype,
},
)
response = self.client.post(
self.list_url,
{
"object": zaak,
"informatieobject": f"http://testserver{eio_url}",
"objectType": "zaak",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "object")
self.assertEqual(error["code"], "invalid-resource")
def test_create_external_besluit_fail_invalid_schema(self):
besluit = "https://externe.catalogus.nl/api/v1/besluiten/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
besluittype = "https://externe.catalogus.nl/api/v1/besluittypen/b71f72ef-198d-44d8-af64-ae1932df830a"
eio = EnkelvoudigInformatieObjectFactory.create()
eio_url = reverse(eio)
self.adapter.register_uri(
"GET",
besluit,
json={
"url": besluit,
"identificatie": "BESLUIT-2019-0000000001",
"besluittype": besluittype,
},
)
response = self.client.post(
self.list_url,
{
"object": besluit,
"informatieobject": f"http://testserver{eio_url}",
"objectType": "besluit",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "object")
self.assertEqual(error["code"], "invalid-resource")
def test_create_fail_not_unique(self):
mock_service_oas_get(self.adapter, APITypes.zrc,
"https://externe.catalogus.nl/api/v1/")
self.adapter.get(
self.besluit,
json=get_besluit_response(self.besluit, self.besluittype,
self.zaak),
)
self.adapter.get(self.zaak,
json=get_zaak_response(self.zaak, self.zaaktype))
self.adapter.get(self.zaaktype,
json=get_zaak_response(self.catalogus, self.zaaktype))
# The test
eio = EnkelvoudigInformatieObjectFactory.create()
eio_url = f"http://testserver{reverse(eio)}"
ObjectInformatieObject.objects.create(informatieobject=eio_url,
besluit=self.besluit,
object_type="besluit")
response = self.client.post(
self.list_url,
{
"object": self.besluit,
"informatieobject": eio_url,
"objectType": "besluit",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "unique")
def test_read_external_zaak(self):
mock_service_oas_get(self.adapter, APITypes.zrc,
"https://externe.catalogus.nl/api/v1/")
self.adapter.get(self.zaak,
json=get_zaak_response(self.zaak, self.zaaktype))
self.adapter.get(self.zaaktype,
json=get_zaak_response(self.catalogus, self.zaaktype))
eio = EnkelvoudigInformatieObjectFactory.create()
oio = ObjectInformatieObject.objects.create(
informatieobject=f"http://testserver{reverse(eio)}",
zaak=self.zaak,
object_type="zaak",
)
url = reverse(oio)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(data["object"], self.zaak)
self.assertEqual(data["informatieobject"],
f"http://testserver{reverse(eio)}")
def test_read_external_besluit(self):
mock_service_oas_get(self.adapter, APITypes.zrc,
"https://externe.catalogus.nl/api/v1/")
self.adapter.get(
self.besluit,
json=get_besluit_response(self.besluit, self.besluittype,
self.zaak),
)
self.adapter.get(self.zaak,
json=get_zaak_response(self.zaak, self.zaaktype))
self.adapter.get(self.zaaktype,
json=get_zaak_response(self.catalogus, self.zaaktype))
# The test
eio = EnkelvoudigInformatieObjectFactory.create()
oio = ObjectInformatieObject.objects.create(
informatieobject=f"http://testserver{reverse(eio)}",
besluit=self.besluit,
object_type="besluit",
)
url = reverse(oio)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(data["object"], self.besluit)
self.assertEqual(data["informatieobject"],
f"http://testserver{reverse(eio)}")
def test_list_filter_by_external_zaak(self):
eio = EnkelvoudigInformatieObjectFactory.create()
mock_service_oas_get(self.adapter, APITypes.zrc,
"https://externe.catalogus.nl/api/v1/")
zaak1 = "https://externe.catalogus.nl/api/v1/zaken/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
zaak2 = "https://externe.catalogus.nl/api/v1/zaken/b923543f-97aa-4a55-8c20-889b5906cf75"
zaaktype1 = "https://externe.catalogus.nl/api/v1/zaaktypen/b71f72ef-198d-44d8-af64-ae1932df830a"
zaaktype2 = "https://externe.catalogus.nl/api/v1/zaaktypen/5c4c492b-3548-4258-b17f-0e2e31dcfe25"
catalogus1 = "https://externe.catalogus.nl/api/v1/catalogussen/5c4c492b-3548-4258-b17f-0e2e31dcfe25"
catalogus2 = "https://externe.catalogus.nl/api/v1/catalogussen/a8e03e86-152d-4e8c-83fc-047645cfc585"
self.adapter.get(zaak1, json=get_zaak_response(zaak1, zaaktype1))
self.adapter.get(zaaktype1,
json=get_zaak_response(catalogus1, zaaktype1))
self.adapter.get(zaak2, json=get_zaak_response(zaak2, zaaktype2))
self.adapter.get(zaaktype2,
json=get_zaak_response(catalogus2, zaaktype2))
ObjectInformatieObject.objects.create(
informatieobject=f"http://testserver{reverse(eio)}",
zaak=zaak1,
object_type="zaak",
)
ObjectInformatieObject.objects.create(
informatieobject=f"http://testserver{reverse(eio)}",
zaak=zaak2,
object_type="zaak",
)
url = reverse(ObjectInformatieObject)
response = self.client.get(url, {"object": zaak2})
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["object"], zaak2)
def test_list_filter_by_external_besluit(self):
eio = EnkelvoudigInformatieObjectFactory.create()
mock_service_oas_get(self.adapter, APITypes.zrc,
"https://externe.catalogus.nl/api/v1/")
# Needed for the CMIS adapter
zaak1 = "https://externe.catalogus.nl/api/v1/zaken/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
zaak2 = "https://externe.catalogus.nl/api/v1/zaken/b923543f-97aa-4a55-8c20-889b5906cf75"
zaaktype1 = "https://externe.catalogus.nl/api/v1/zaaktypen/b71f72ef-198d-44d8-af64-ae1932df830a"
zaaktype2 = "https://externe.catalogus.nl/api/v1/zaaktypen/5c4c492b-3548-4258-b17f-0e2e31dcfe25"
catalogus1 = "https://externe.catalogus.nl/api/v1/catalogussen/5c4c492b-3548-4258-b17f-0e2e31dcfe25"
catalogus2 = "https://externe.catalogus.nl/api/v1/catalogussen/a8e03e86-152d-4e8c-83fc-047645cfc585"
besluit1 = "https://externe.catalogus.nl/api/v1/besluiten/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
besluit2 = "https://externe.catalogus.nl/api/v1/besluiten/b923543f-97aa-4a55-8c20-889b5906cf75"
besluittype1 = "https://externe.catalogus.nl/api/v1/besluittypen/b71f72ef-198d-44d8-af64-ae1932df830a"
besluittype2 = "https://externe.catalogus.nl/api/v1/besluittypen/3665b9be-6ac5-4075-8736-d79598e5325c"
self.adapter.get(zaak1, json=get_zaak_response(zaak1, zaaktype1))
self.adapter.get(zaaktype1,
json=get_zaak_response(catalogus1, zaaktype1))
self.adapter.get(zaak2, json=get_zaak_response(zaak2, zaaktype2))
self.adapter.get(zaaktype2,
json=get_zaak_response(catalogus2, zaaktype2))
self.adapter.get(besluit1,
json=get_besluit_response(besluit1, besluittype1,
zaak1))
self.adapter.get(besluit2,
json=get_besluit_response(besluit2, besluittype2,
zaak2))
ObjectInformatieObject.objects.create(
informatieobject=f"http://testserver{reverse(eio)}",
besluit=besluit1,
object_type="besluit",
)
ObjectInformatieObject.objects.create(
informatieobject=f"http://testserver{reverse(eio)}",
besluit=besluit2,
object_type="besluit",
)
url = reverse(ObjectInformatieObject)
response = self.client.get(url, {"object": besluit2})
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["object"], besluit2)
def test_destroy_external_zaak(self):
mock_service_oas_get(self.adapter, APITypes.zrc,
"https://externe.catalogus.nl/api/v1/")
self.adapter.get(self.zaak,
json=get_zaak_response(self.zaak, self.zaaktype))
self.adapter.get(self.zaaktype,
json=get_zaak_response(self.catalogus, self.zaaktype))
eio = EnkelvoudigInformatieObjectFactory.create()
oio = ObjectInformatieObject.objects.create(
informatieobject=f"http://testserver{reverse(eio)}",
zaak=self.zaak,
object_type="zaak",
)
url = reverse(oio)
self.adapter.get(self.zaak,
json=get_zaak_response(self.zaak, self.zaaktype))
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(ObjectInformatieObject.objects.count(), 0)
def test_destroy_external_besluit(self):
mock_service_oas_get(self.adapter, APITypes.zrc,
"https://externe.catalogus.nl/api/v1/")
self.adapter.get(
self.besluit,
json=get_besluit_response(self.besluit, self.besluittype,
self.zaak),
)
self.adapter.get(self.zaak,
json=get_zaak_response(self.zaak, self.zaaktype))
self.adapter.get(self.zaaktype,
json=get_zaak_response(self.catalogus, self.zaaktype))
eio = EnkelvoudigInformatieObjectFactory.create()
oio = ObjectInformatieObject.objects.create(
informatieobject=f"http://testserver{reverse(eio)}",
besluit=self.besluit,
object_type="besluit",
)
url = reverse(oio)
self.adapter.register_uri(
"GET",
self.besluit,
json=get_besluit_response(self.besluit, self.besluittype),
)
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(ObjectInformatieObject.objects.count(), 0)
class AuditTrailTests(JWTAuthMixin, APITestCase):
informatieobject_list_url = reverse_lazy(EnkelvoudigInformatieObject)
objectinformatieobject_list_url = reverse_lazy(ObjectInformatieObject)
gebruiksrechten_list_url = reverse_lazy(Gebruiksrechten)
heeft_alle_autorisaties = True
def _create_enkelvoudiginformatieobject(self, **HEADERS):
content = {
'identificatie': uuid.uuid4().hex,
'bronorganisatie': '159351741',
'creatiedatum': '2018-06-27',
'titel': 'detailed summary',
'auteur': 'test_auteur',
'formaat': 'txt',
'taal': 'eng',
'bestandsnaam': 'dummy.txt',
'inhoud': b64encode(b'some file content').decode('utf-8'),
'link': 'http://een.link',
'beschrijving': 'test_beschrijving',
'informatieobjecttype':
'https://example.com/ztc/api/v1/catalogus/1/informatieobjecttype/1',
'vertrouwelijkheidaanduiding': 'openbaar',
}
response = self.client.post(self.informatieobject_list_url, content,
**HEADERS)
return response.data
def test_create_enkelvoudiginformatieobject_audittrail(self):
informatieobject_data = self._create_enkelvoudiginformatieobject()
informatieobject_url = informatieobject_data['url']
audittrails = AuditTrail.objects.filter(
hoofd_object=informatieobject_url)
self.assertEqual(audittrails.count(), 1)
# Verify that the audittrail for the EnkelvoudigInformatieObject creation contains the correct
# information
informatieobject_create_audittrail = audittrails.get()
self.assertEqual(informatieobject_create_audittrail.bron, 'DRC')
self.assertEqual(informatieobject_create_audittrail.actie, 'create')
self.assertEqual(informatieobject_create_audittrail.resultaat, 201)
self.assertEqual(informatieobject_create_audittrail.oud, None)
self.assertEqual(informatieobject_create_audittrail.nieuw,
informatieobject_data)
@override_settings(ZDS_CLIENT_CLASS='vng_api_common.mocks.MockClient')
def test_create_objectinformatieobject_audittrail(self):
informatieobject = EnkelvoudigInformatieObjectFactory.create()
content = {
'informatieobject':
reverse('enkelvoudiginformatieobject-detail',
kwargs={'uuid': informatieobject.uuid}),
'object':
ZAAK,
'objectType':
ObjectTypes.zaak,
}
# Send to the API
objectinformatieobject_response = self.client.post(
self.objectinformatieobject_list_url, content).data
informatieobject_url = objectinformatieobject_response[
'informatieobject']
audittrails = AuditTrail.objects.filter(
hoofd_object=informatieobject_url)
self.assertEqual(audittrails.count(), 1)
# Verify that the audittrail for the ObjectInformatieObject creation
# contains the correct information
objectinformatieobject_create_audittrail = audittrails.get()
self.assertEqual(objectinformatieobject_create_audittrail.bron, 'DRC')
self.assertEqual(objectinformatieobject_create_audittrail.actie,
'create')
self.assertEqual(objectinformatieobject_create_audittrail.resultaat,
201)
self.assertEqual(objectinformatieobject_create_audittrail.oud, None)
self.assertEqual(objectinformatieobject_create_audittrail.nieuw,
objectinformatieobject_response)
def test_create_and_delete_gebruiksrechten_audittrail(self):
informatieobject = EnkelvoudigInformatieObjectFactory.create()
content = {
'informatieobject':
reverse('enkelvoudiginformatieobject-detail',
kwargs={'uuid': informatieobject.uuid}),
'startdatum':
datetime.now(),
'omschrijvingVoorwaarden':
'test'
}
gebruiksrechten_response = self.client.post(
self.gebruiksrechten_list_url, content).data
informatieobject_url = gebruiksrechten_response['informatieobject']
audittrails = AuditTrail.objects.filter(
hoofd_object=informatieobject_url)
self.assertEqual(audittrails.count(), 1)
# Verify that the audittrail for the Gebruiksrechten creation
# contains the correct information
gebruiksrechten_create_audittrail = audittrails.get()
self.assertEqual(gebruiksrechten_create_audittrail.bron, 'DRC')
self.assertEqual(gebruiksrechten_create_audittrail.actie, 'create')
self.assertEqual(gebruiksrechten_create_audittrail.resultaat, 201)
self.assertEqual(gebruiksrechten_create_audittrail.oud, None)
self.assertEqual(gebruiksrechten_create_audittrail.nieuw,
gebruiksrechten_response)
delete_response = self.client.delete(gebruiksrechten_response['url'])
self.assertEqual(delete_response.status_code,
status.HTTP_204_NO_CONTENT)
audittrails = AuditTrail.objects.filter(
hoofd_object=informatieobject_url)
self.assertEqual(audittrails.count(), 2)
# Verify that the audittrail for the Gebruiksrechten deletion
# contains the correct information
gebruiksrechten_delete_audittrail = audittrails[1]
self.assertEqual(gebruiksrechten_delete_audittrail.bron, 'DRC')
self.assertEqual(gebruiksrechten_delete_audittrail.actie, 'destroy')
self.assertEqual(gebruiksrechten_delete_audittrail.resultaat, 204)
self.assertEqual(gebruiksrechten_delete_audittrail.oud,
gebruiksrechten_response)
self.assertEqual(gebruiksrechten_delete_audittrail.nieuw, None)
def test_update_enkelvoudiginformatieobject_audittrail(self):
informatieobject_data = self._create_enkelvoudiginformatieobject()
informatieobject_url = informatieobject_data['url']
# lock for update
eio = EnkelvoudigInformatieObjectCanonical.objects.get()
eio.lock = '0f60f6d2d2714c809ed762372f5a363a'
eio.save()
content = {
'identificatie': uuid.uuid4().hex,
'bronorganisatie': '159351741',
'creatiedatum': '2018-06-27',
'titel': 'aangepast',
'auteur': 'aangepaste auteur',
'formaat': 'txt',
'taal': 'eng',
'bestandsnaam': 'dummy.txt',
'inhoud': b64encode(b'some file content').decode('utf-8'),
'link': 'http://een.link',
'beschrijving': 'test_beschrijving',
'informatieobjecttype':
'https://example.com/ztc/api/v1/catalogus/1/informatieobjecttype/1',
'vertrouwelijkheidaanduiding': 'openbaar',
'lock': '0f60f6d2d2714c809ed762372f5a363a'
}
informatieobject_response = self.client.put(informatieobject_url,
content).data
audittrails = AuditTrail.objects.filter(
hoofd_object=informatieobject_url)
self.assertEqual(audittrails.count(), 2)
# Verify that the audittrail for the EnkelvoudigInformatieObject update
# contains the correct information
informatieobject_update_audittrail = audittrails[1]
self.assertEqual(informatieobject_update_audittrail.bron, 'DRC')
self.assertEqual(informatieobject_update_audittrail.actie, 'update')
self.assertEqual(informatieobject_update_audittrail.resultaat, 200)
# locked is False upon InformatieObject creation, but the
# InformatieObject must be locked before updating is possible, so
# locked will be True in the version before changes as shown
# in the audittrail
informatieobject_data['locked'] = True
self.assertEqual(informatieobject_update_audittrail.oud,
informatieobject_data)
self.assertEqual(informatieobject_update_audittrail.nieuw,
informatieobject_response)
def test_partial_update_enkelvoudiginformatieobject_audittrail(self):
informatieobject_data = self._create_enkelvoudiginformatieobject()
informatieobject_url = informatieobject_data['url']
# lock for update
eio = EnkelvoudigInformatieObjectCanonical.objects.get()
eio.lock = '0f60f6d2d2714c809ed762372f5a363a'
eio.save()
informatieobject_response = self.client.patch(
informatieobject_url, {
'titel': 'changed',
'lock': '0f60f6d2d2714c809ed762372f5a363a'
}).data
audittrails = AuditTrail.objects.filter(
hoofd_object=informatieobject_url)
self.assertEqual(audittrails.count(), 2)
# Verify that the audittrail for the EnkelvoudigInformatieObject
# partial update contains the correct information
informatieobject_partial_update_audittrail = audittrails[1]
self.assertEqual(informatieobject_partial_update_audittrail.bron,
'DRC')
self.assertEqual(informatieobject_partial_update_audittrail.actie,
'partial_update')
self.assertEqual(informatieobject_partial_update_audittrail.resultaat,
200)
# locked is False upon InformatieObject creation, but the
# InformatieObject must be locked before updating is possible, so
# locked will be True in the version before changes as shown
# in the audittrail
informatieobject_data['locked'] = True
self.assertEqual(informatieobject_partial_update_audittrail.oud,
informatieobject_data)
self.assertEqual(informatieobject_partial_update_audittrail.nieuw,
informatieobject_response)
def test_audittrail_applicatie_information(self):
object_response = self._create_enkelvoudiginformatieobject()
audittrail = AuditTrail.objects.filter(
hoofd_object=object_response['url']).get()
# Verify that the application id stored in the AuditTrail matches
# the id of the Application used for the request
self.assertEqual(audittrail.applicatie_id, str(self.applicatie.uuid))
# Verify that the application representation stored in the AuditTrail
# matches the label of the Application used for the request
self.assertEqual(audittrail.applicatie_weergave, self.applicatie.label)
def test_audittrail_user_information(self):
object_response = self._create_enkelvoudiginformatieobject()
audittrail = AuditTrail.objects.filter(
hoofd_object=object_response['url']).get()
# Verify that the user id stored in the AuditTrail matches
# the user id in the JWT token for the request
self.assertIn(audittrail.gebruikers_id, self.user_id)
# Verify that the user representation stored in the AuditTrail matches
# the user representation in the JWT token for the request
self.assertEqual(audittrail.gebruikers_weergave,
self.user_representation)
def test_audittrail_toelichting(self):
toelichting = 'blaaaa'
object_response = self._create_enkelvoudiginformatieobject(
HTTP_X_AUDIT_TOELICHTING=toelichting)
audittrail = AuditTrail.objects.filter(
hoofd_object=object_response['url']).get()
# Verify that the toelichting stored in the AuditTrail matches
# the X-Audit-Toelichting header in the HTTP request
self.assertEqual(audittrail.toelichting, toelichting)
def test_read_audittrail(self):
self._create_enkelvoudiginformatieobject()
eio = EnkelvoudigInformatieObject.objects.get()
audittrails = AuditTrail.objects.get()
audittrails_url = reverse(
audittrails, kwargs={'enkelvoudiginformatieobject_uuid': eio.uuid})
response_audittrails = self.client.get(audittrails_url)
self.assertEqual(response_audittrails.status_code, status.HTTP_200_OK)
def test_audittrail_resource_weergave(self):
eio_response = self._create_enkelvoudiginformatieobject()
eio_uuid = get_uuid_from_path(eio_response['url'])
eio_unique_representation = EnkelvoudigInformatieObject.objects.get(
uuid=eio_uuid).unique_representation()
audittrail = AuditTrail.objects.filter(
hoofd_object=eio_response['url']).get()
# Verify that the resource weergave stored in the AuditTrail matches
# the unique representation as defined in the Zaak model
self.assertIn(audittrail.resource_weergave, eio_unique_representation)
class OIOCreateExternalURLsTests(JWTAuthMixin, APITestCase):
heeft_alle_autorisaties = True
list_url = reverse_lazy(ObjectInformatieObject)
def test_create_external_zaak(self):
zaak = "https://externe.catalogus.nl/api/v1/zaken/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
zaaktype = "https://externe.catalogus.nl/api/v1/zaaktypen/b71f72ef-198d-44d8-af64-ae1932df830a"
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
with requests_mock.Mocker(real_http=True) as m:
m.get(zaak, json=get_zaak_response(zaak, zaaktype))
response = self.client.post(
self.list_url,
{"object": zaak, "informatieobject": eio_url, "objectType": "zaak",},
)
self.assertEqual(
response.status_code, status.HTTP_201_CREATED, response.data
)
oio = ObjectInformatieObject.objects.get()
self.assertEqual(oio.informatieobject, eio.canonical)
self.assertEqual(oio.object, zaak)
def test_create_external_besluit(self):
besluit = "https://externe.catalogus.nl/api/v1/besluiten/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
besluittype = "https://externe.catalogus.nl/api/v1/besluittypen/b71f72ef-198d-44d8-af64-ae1932df830a"
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
with requests_mock.Mocker(real_http=True) as m:
m.get(besluit, json=get_besluit_response(besluit, besluittype))
response = self.client.post(
self.list_url,
{
"object": besluit,
"informatieobject": eio_url,
"objectType": "besluit",
},
)
self.assertEqual(
response.status_code, status.HTTP_201_CREATED, response.data
)
oio = ObjectInformatieObject.objects.get()
self.assertEqual(oio.informatieobject, eio.canonical)
self.assertEqual(oio.object, besluit)
def test_create_external_zaak_fail_invalid_schema(self):
zaak = "https://externe.catalogus.nl/api/v1/zaken/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
zaaktype = "https://externe.catalogus.nl/api/v1/zaaktypen/b71f72ef-198d-44d8-af64-ae1932df830a"
eio = EnkelvoudigInformatieObjectFactory.create()
eio_url = reverse(eio)
with requests_mock.Mocker(real_http=True) as m:
m.get(
zaak,
json={
"url": zaak,
"uuid": "d781cd1b-f100-4051-9543-153b93299da4",
"identificatie": "ZAAK-2019-0000000001",
"zaaktype": zaaktype,
},
)
response = self.client.post(
self.list_url,
{
"object": zaak,
"informatieobject": f"http://testserver{eio_url}",
"objectType": "zaak",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "object")
self.assertEqual(error["code"], "invalid-resource")
def test_create_external_besluit_fail_invalid_schema(self):
besluit = "https://externe.catalogus.nl/api/v1/besluiten/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
besluittype = "https://externe.catalogus.nl/api/v1/besluittypen/b71f72ef-198d-44d8-af64-ae1932df830a"
eio = EnkelvoudigInformatieObjectFactory.create()
eio_url = reverse(eio)
with requests_mock.Mocker(real_http=True) as m:
m.get(
besluit,
json={
"url": besluit,
"identificatie": "BESLUIT-2019-0000000001",
"besluittype": besluittype,
},
)
response = self.client.post(
self.list_url,
{
"object": besluit,
"informatieobject": f"http://testserver{eio_url}",
"objectType": "besluit",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "object")
self.assertEqual(error["code"], "invalid-resource")
def test_create_fail_not_unique(self):
besluit = "https://externe.catalogus.nl/api/v1/besluiten/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
besluittype = "https://externe.catalogus.nl/api/v1/besluittypen/b71f72ef-198d-44d8-af64-ae1932df830a"
eio = EnkelvoudigInformatieObjectFactory.create()
eio_url = f"http://testserver{reverse(eio)}"
ObjectInformatieObject.objects.create(
informatieobject=eio.canonical, besluit=besluit, object_type="besluit"
)
with requests_mock.Mocker(real_http=True) as m:
m.get(besluit, json=get_besluit_response(besluit, besluittype))
response = self.client.post(
self.list_url,
{
"object": besluit,
"informatieobject": eio_url,
"objectType": "besluit",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "unique")
def test_read_external_zaak(self):
zaak = "https://externe.catalogus.nl/api/v1/zaken/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
eio = EnkelvoudigInformatieObjectFactory.create()
oio = ObjectInformatieObject.objects.create(
informatieobject=eio.canonical, zaak=zaak, object_type="zaak"
)
url = reverse(oio)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(data["object"], zaak)
self.assertEqual(data["informatieobject"], f"http://testserver{reverse(eio)}")
def test_read_external_besluit(self):
besluit = "https://externe.catalogus.nl/api/v1/besluiten/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
eio = EnkelvoudigInformatieObjectFactory.create()
oio = ObjectInformatieObject.objects.create(
informatieobject=eio.canonical, besluit=besluit, object_type="besluit"
)
url = reverse(oio)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(data["object"], besluit)
self.assertEqual(data["informatieobject"], f"http://testserver{reverse(eio)}")
def test_list_filter_by_external_zaak(self):
eio = EnkelvoudigInformatieObjectFactory.create()
zaak1 = "https://externe.catalogus.nl/api/v1/zaken/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
zaak2 = "https://externe.catalogus.nl/api/v1/zaken/b923543f-97aa-4a55-8c20-889b5906cf75"
ObjectInformatieObject.objects.create(
informatieobject=eio.canonical, zaak=zaak1, object_type="zaak"
)
ObjectInformatieObject.objects.create(
informatieobject=eio.canonical, zaak=zaak2, object_type="zaak"
)
url = reverse(ObjectInformatieObject)
response = self.client.get(url, {"object": zaak2})
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["object"], zaak2)
def test_list_filter_by_external_besluit(self):
eio = EnkelvoudigInformatieObjectFactory.create()
besluit1 = "https://externe.catalogus.nl/api/v1/besluiten/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
besluit2 = "https://externe.catalogus.nl/api/v1/besluiten/b923543f-97aa-4a55-8c20-889b5906cf75"
ObjectInformatieObject.objects.create(
informatieobject=eio.canonical, besluit=besluit1, object_type="besluit"
)
ObjectInformatieObject.objects.create(
informatieobject=eio.canonical, besluit=besluit2, object_type="besluit"
)
url = reverse(ObjectInformatieObject)
response = self.client.get(url, {"object": besluit2})
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["object"], besluit2)
def test_destroy_external_zaak(self):
zaak = "https://externe.catalogus.nl/api/v1/zaken/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
zaaktype = "https://externe.catalogus.nl/api/v1/zaaktypen/b71f72ef-198d-44d8-af64-ae1932df830a"
eio = EnkelvoudigInformatieObjectFactory.create()
oio = ObjectInformatieObject.objects.create(
informatieobject=eio.canonical, zaak=zaak, object_type="zaak"
)
url = reverse(oio)
with requests_mock.Mocker(real_http=True) as m:
m.get(zaak, json=get_zaak_response(zaak, zaaktype))
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(ObjectInformatieObject.objects.count(), 0)
def test_destroy_external_besluit(self):
besluit = "https://externe.catalogus.nl/api/v1/besluiten/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
besluittype = "https://externe.catalogus.nl/api/v1/besluittypen/b71f72ef-198d-44d8-af64-ae1932df830a"
eio = EnkelvoudigInformatieObjectFactory.create()
oio = ObjectInformatieObject.objects.create(
informatieobject=eio.canonical, besluit=besluit, object_type="besluit"
)
url = reverse(oio)
with requests_mock.Mocker(real_http=True) as m:
m.get(besluit, json=get_besluit_response(besluit, besluittype))
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(ObjectInformatieObject.objects.count(), 0)
class ResultaatTypeValidationTests(APITestCase):
list_url = reverse_lazy(ResultaatType)
@patch('vng_api_common.oas.fetcher.fetch', return_value={})
@patch('vng_api_common.validators.obj_has_shape', return_value=False)
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')
@override_settings(LINK_FETCHER='vng_api_common.mocks.link_fetcher_200')
def test_selectielijstklasse_invalid_resource(self):
zaaktype = ZaakTypeFactory.create(concept=False)
zaaktype_url = reverse('zaaktype-detail', kwargs={
'uuid': zaaktype.uuid,
})
responses = {
'http://example.com/resultaten/1234': {
'some': 'incorrect property'
}
}
data = {
'zaaktype': f'http://testserver{zaaktype_url}',
'omschrijving': 'illum',
'resultaattypeomschrijving': 'https://garcia.org/',
'selectielijstklasse': 'http://example.com/resultaten/1234',
'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, 'selectielijstklasse')
self.assertEqual(error['code'], 'invalid-resource')
@override_settings(LINK_FETCHER='vng_api_common.mocks.link_fetcher_200')
@patch('vng_api_common.validators.obj_has_shape', return_value=True)
def test_selectielijstklasse_procestype_no_match_with_zaaktype_procestype(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': 'http://somedifferentprocestypeurl.com/',
'procestermijn': Procestermijn.nihil,
},
}
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'], 'procestype-mismatch')
@override_settings(LINK_FETCHER='vng_api_common.mocks.link_fetcher_200')
@patch('vng_api_common.validators.obj_has_shape', return_value=True)
def test_procestermijn_nihil_and_afleidingswijze_niet_afgehandeld_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.nihil,
},
}
data = {
'zaaktype': f'http://testserver{zaaktype_url}',
'omschrijving': 'illum',
'resultaattypeomschrijving': 'https://garcia.org/',
'selectielijstklasse': SELECTIELIJSTKLASSE_URL,
'archiefnominatie': 'blijvend_bewaren',
'archiefactietermijn': 'P10Y',
'brondatumArchiefprocedure': {
'afleidingswijze': BrondatumArchiefprocedureAfleidingswijze.ander_datumkenmerk,
'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')
@override_settings(LINK_FETCHER='vng_api_common.mocks.link_fetcher_200')
@patch('vng_api_common.validators.obj_has_shape', return_value=True)
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')
class ExternalDocumentsAPITransactionTests(JWTAuthMixin, APITransactionTestCase):
heeft_alle_autorisaties = True
list_url = reverse_lazy(BesluitInformatieObject)
base = "https://external.documenten.nl/api/v1/"
@classmethod
def setUpClass(cls):
super().setUpClass()
Service.objects.create(
api_type=APITypes.drc,
api_root=cls.base,
label="external documents",
auth_type=AuthTypes.no_auth,
)
@tag("gh-819")
def test_bio_visibility_outside_transaction(self):
self.setUpTestData()
document = f"{self.base}enkelvoudiginformatieobjecten/{uuid.uuid4()}"
besluit = BesluitFactory.create(besluittype__concept=False)
besluit_url = f"http://openzaak.nl{reverse(besluit)}"
informatieobjecttype = InformatieObjectTypeFactory.create(
catalogus=besluit.besluittype.catalogus, concept=False
)
informatieobjecttype_url = f"http://openzaak.nl{reverse(informatieobjecttype)}"
informatieobjecttype.besluittypen.add(besluit.besluittype)
eio_response = get_eio_response(
document, informatieobjecttype=informatieobjecttype_url
)
def worker(besluit_id: int):
"""
Worker to run in a thread.
When this worker runs, there should be one ZIO visible in the database - it
must have been committed so that the remote DRC can view this record too.
"""
bios = BesluitInformatieObject.objects.filter(besluit__id=besluit_id)
self.assertEqual(bios.count(), 1)
close_old_connections()
def mock_create_remote_oio(*args, **kwargs):
with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
future = executor.submit(worker, besluit.id)
future.result() # raises any exceptions, such as assertionerrors
return {"url": f"{self.base}objectinformatieobjecten/{uuid.uuid4()}"}
with patch(
"openzaak.components.besluiten.api.serializers.create_remote_oio",
side_effect=mock_create_remote_oio,
):
with requests_mock.Mocker() as m:
mock_service_oas_get(
m, APITypes.drc, self.base, oas_url=settings.DRC_API_SPEC
)
m.get(document, json=eio_response)
response = self.client.post(
self.list_url,
{"besluit": besluit_url, "informatieobject": document},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED, response.data)
class ObjectInformatieObjectTests(JWTAuthMixin, APICMISTestCase, OioMixin):
heeft_alle_autorisaties = True
list_url = reverse_lazy("objectinformatieobject-list")
def test_retrieve_multiple_oios(self):
self.create_zaak_besluit_services()
zaak = self.create_zaak()
# This creates 2 OIOs
eio_1 = EnkelvoudigInformatieObjectFactory.create()
eio_1_path = reverse(eio_1)
eio_1_url = f"http://testserver{eio_1_path}"
# relate the two
self.adapter.get(eio_1_url, json=serialise_eio(eio_1, eio_1_url))
ZaakInformatieObjectFactory.create(zaak=zaak,
informatieobject=eio_1_url)
eio_2 = EnkelvoudigInformatieObjectFactory.create()
eio_2_path = reverse(eio_2)
eio_2_url = f"http://testserver{eio_2_path}"
# relate the two
self.adapter.get(eio_2_url, json=serialise_eio(eio_2, eio_2_url))
ZaakInformatieObjectFactory.create(zaak=zaak,
informatieobject=eio_2_url)
# Retrieve oios from API
response = self.client.get(self.list_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 2)
self.assertTrue(eio_1_url == response.data[0]["informatieobject"]
or eio_1_url == response.data[1]["informatieobject"])
self.assertTrue(eio_2_url == response.data[0]["informatieobject"]
or eio_2_url == response.data[1]["informatieobject"])
def test_create_with_objecttype_zaak(self):
self.create_zaak_besluit_services()
zaak = self.create_zaak()
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
# relate the two
self.adapter.get(eio_url, json=serialise_eio(eio, eio_url))
ZaakInformatieObjectFactory.create(zaak=zaak, informatieobject=eio_url)
# get OIO created via signals
ObjectInformatieObject.objects.get()
zaak_url = reverse(zaak)
response = self.client.post(
self.list_url,
{
"object": f"http://testserver{zaak_url}",
"informatieobject": eio_url,
"objectType": "zaak",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "unique")
def test_create_with_objecttype_besluit(self):
self.create_zaak_besluit_services()
besluit = self.create_besluit()
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
self.adapter.get(eio_url, json=serialise_eio(eio, eio_url))
BesluitInformatieObjectFactory.create(besluit=besluit,
informatieobject=eio_url)
# get OIO created via signals
ObjectInformatieObject.objects.get()
besluit_url = reverse(besluit)
response = self.client.post(
self.list_url,
{
"object": f"http://testserver{besluit_url}",
"informatieobject": f"http://testserver{eio_path}",
"objectType": "besluit",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "unique")
def test_create_with_objecttype_other_fail(self):
self.create_zaak_besluit_services()
besluit = self.create_besluit()
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
# relate the two
self.adapter.get(eio_url, json=serialise_eio(eio, eio_url))
BesluitInformatieObjectFactory.create(besluit=besluit,
informatieobject=eio_url)
besluit_url = reverse(besluit)
response = self.client.post(
self.list_url,
{
"object": f"http://testserver{besluit_url}",
"informatieobject": eio_url,
"objectType": "other",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
error = get_validation_errors(response, "objectType")
self.assertEqual(error["code"], "invalid_choice")
def test_read_with_objecttype_zaak(self):
self.create_zaak_besluit_services()
zaak = self.create_zaak()
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
# relate the two
self.adapter.get(eio_url, json=serialise_eio(eio, eio_url))
ZaakInformatieObjectFactory.create(zaak=zaak, informatieobject=eio_url)
# get OIO created via signals
oio = ObjectInformatieObject.objects.get()
oio_url = reverse("objectinformatieobject-detail",
kwargs={"uuid": oio.uuid})
zaak_url = reverse(zaak)
response = self.client.get(oio_url)
expeceted_response_data = {
"url": f"http://testserver{oio_url}",
"object": make_absolute_uri(zaak_url),
"informatieobject": eio_url,
"object_type": "zaak",
}
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertEqual(response.data, expeceted_response_data)
def test_read_with_objecttype_besluit(self):
self.create_zaak_besluit_services()
besluit = self.create_besluit()
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
# relate the two
self.adapter.get(eio_url, json=serialise_eio(eio, eio_url))
BesluitInformatieObjectFactory.create(besluit=besluit,
informatieobject=eio_url)
# get OIO created via signals
oio = ObjectInformatieObject.objects.get()
oio_url = reverse("objectinformatieobject-detail",
kwargs={"uuid": oio.uuid})
besluit_url = reverse(besluit)
response = self.client.get(oio_url)
expeceted_response_data = {
"url": f"http://testserver{oio_url}",
"object": make_absolute_uri(besluit_url),
"informatieobject": eio_url,
"object_type": "besluit",
}
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.data)
self.assertEqual(response.data, expeceted_response_data)
def test_post_object_without_created_relations(self):
"""
Test the (informatieobject, object) unique together validation.
This is expected to fail, since there is no actual creation in database.
It will however become relevant again when we're handling remote
references.
"""
self.create_zaak_besluit_services()
zaak = self.create_zaak()
eio = EnkelvoudigInformatieObjectFactory.create()
zaak_url = reverse(zaak)
eio_url = reverse(eio)
content = {
"informatieobject": f"http://testserver{eio_url}",
"object": f"http://testserver{zaak_url}",
"objectType": ObjectTypes.zaak,
}
# Send to the API
response = self.client.post(self.list_url, content)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
response.data)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "inconsistent-relation")
def test_filter_eio(self):
eio_1 = EnkelvoudigInformatieObjectFactory.create()
eio_2 = EnkelvoudigInformatieObjectFactory.create()
eio_detail_url = f"http://openzaak.nl{reverse(eio_1)}"
self.adapter.register_uri("GET",
eio_detail_url,
json=serialise_eio(eio_1, eio_detail_url))
self.create_zaak_besluit_services()
zaak = self.create_zaak()
besluit = self.create_besluit()
BesluitInformatieObjectFactory.create(informatieobject=eio_detail_url,
besluit=besluit)
ZaakInformatieObjectFactory.create(
informatieobject=f"http://openzaak.nl{reverse(eio_2)}",
zaak=zaak) # may not show up
response = self.client.get(
self.list_url,
{"informatieobject": eio_detail_url},
HTTP_HOST="openzaak.nl",
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["informatieobject"], eio_detail_url)
def test_filter_zaak(self):
eio_1 = EnkelvoudigInformatieObjectFactory.create()
eio_detail_url = f"http://openzaak.nl{reverse(eio_1)}"
self.adapter.register_uri("GET",
eio_detail_url,
json=serialise_eio(eio_1, eio_detail_url))
self.create_zaak_besluit_services()
zaak1 = self.create_zaak()
zio = ZaakInformatieObjectFactory.create(
informatieobject=eio_detail_url, zaak=zaak1)
zaak2 = self.create_zaak()
ZaakInformatieObjectFactory.create(informatieobject=eio_detail_url,
zaak=zaak2) # may not show up
zaak_url = reverse(zio.zaak)
response = self.client.get(
self.list_url,
{"object": f"http://openzaak.nl{zaak_url}"},
HTTP_HOST="openzaak.nl",
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["informatieobject"], eio_detail_url)
def test_filter_besluit(self):
eio_1 = EnkelvoudigInformatieObjectFactory.create()
eio_detail_url = f"http://openzaak.nl{reverse(eio_1)}"
self.adapter.register_uri("GET",
eio_detail_url,
json=serialise_eio(eio_1, eio_detail_url))
self.create_zaak_besluit_services()
besluit1 = self.create_besluit()
bio = BesluitInformatieObjectFactory.create(
informatieobject=eio_detail_url, besluit=besluit1)
besluit2 = self.create_besluit()
BesluitInformatieObjectFactory.create(
informatieobject=eio_detail_url,
besluit=besluit2) # may not show up
besluit_url = reverse(bio.besluit)
response = self.client.get(
self.list_url,
{"object": f"http://openzaak.nl{besluit_url}"},
HTTP_HOST="openzaak.nl",
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["informatieobject"], eio_detail_url)
def test_validate_unknown_query_params(self):
url = reverse(ObjectInformatieObject)
response = self.client.get(url, {"someparam": "somevalue"})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "unknown-parameters")
class InformatieobjectCreateExternalURLsTests(JWTAuthMixin, APITestCase):
heeft_alle_autorisaties = True
list_url = reverse_lazy(EnkelvoudigInformatieObject)
def test_create_external_informatieobjecttype(self):
catalogus = "https://externe.catalogus.nl/api/v1/catalogussen/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
informatieobjecttype = (
"https://externe.catalogus.nl/api/v1/informatieobjecttypen/"
"b71f72ef-198d-44d8-af64-ae1932df830a")
with requests_mock.Mocker(real_http=True) as m:
m.register_uri(
"GET",
informatieobjecttype,
json=get_informatieobjecttype_response(catalogus,
informatieobjecttype),
)
m.register_uri(
"GET",
catalogus,
json=get_catalogus_response(catalogus, informatieobjecttype),
)
response = self.client.post(
self.list_url,
{
"identificatie": "12345",
"bronorganisatie": "159351741",
"creatiedatum": "2018-06-27",
"titel": "detailed summary",
"auteur": "test_auteur",
"formaat": "txt",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"inhoud": b64encode(b"some file content").decode("utf-8"),
"link": "http://een.link",
"beschrijving": "test_beschrijving",
"informatieobjecttype": informatieobjecttype,
"vertrouwelijkheidaanduiding": "openbaar",
},
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.data)
def test_create_external_informatieobjecttype_fail_bad_url(self):
response = self.client.post(
self.list_url,
{
"identificatie": "12345",
"bronorganisatie": "159351741",
"creatiedatum": "2018-06-27",
"titel": "detailed summary",
"auteur": "test_auteur",
"formaat": "txt",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"inhoud": b64encode(b"some file content").decode("utf-8"),
"link": "http://een.link",
"beschrijving": "test_beschrijving",
"informatieobjecttype": "abcd",
"vertrouwelijkheidaanduiding": "openbaar",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "informatieobjecttype")
self.assertEqual(error["code"], "bad-url")
@override_settings(ALLOWED_HOSTS=["testserver"])
def test_create_external_informatieobjecttype_fail_not_json_url(self):
response = self.client.post(
self.list_url,
{
"identificatie": "12345",
"bronorganisatie": "159351741",
"creatiedatum": "2018-06-27",
"titel": "detailed summary",
"auteur": "test_auteur",
"formaat": "txt",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"inhoud": b64encode(b"some file content").decode("utf-8"),
"link": "http://een.link",
"beschrijving": "test_beschrijving",
"informatieobjecttype": "http://example.com",
"vertrouwelijkheidaanduiding": "openbaar",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "informatieobjecttype")
self.assertEqual(error["code"], "invalid-resource")
def test_create_external_informatieobjecttype_fail_invalid_schema(self):
catalogus = "https://externe.catalogus.nl/api/v1/catalogussen/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
informatieobjecttype = (
"https://externe.catalogus.nl/api/v1/informatieobjecttypen/"
"b71f72ef-198d-44d8-af64-ae1932df830a")
with requests_mock.Mocker(real_http=True) as m:
m.register_uri(
"GET",
informatieobjecttype,
json={
"url": informatieobjecttype,
"catalogus": catalogus,
},
)
m.register_uri(
"GET",
catalogus,
json=get_catalogus_response(catalogus, informatieobjecttype),
)
response = self.client.post(
self.list_url,
{
"identificatie": "12345",
"bronorganisatie": "159351741",
"creatiedatum": "2018-06-27",
"titel": "detailed summary",
"auteur": "test_auteur",
"formaat": "txt",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"inhoud": b64encode(b"some file content").decode("utf-8"),
"link": "http://een.link",
"beschrijving": "test_beschrijving",
"informatieobjecttype": informatieobjecttype,
"vertrouwelijkheidaanduiding": "openbaar",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "informatieobjecttype")
self.assertEqual(error["code"], "invalid-resource")
def test_create_external_informatieobjecttype_fail_non_pulish(self):
catalogus = "https://externe.catalogus.nl/api/v1/catalogussen/1c8e36be-338c-4c07-ac5e-1adf55bec04a"
informatieobjecttype = (
"https://externe.catalogus.nl/api/v1/informatieobjecttypen/"
"b71f72ef-198d-44d8-af64-ae1932df830a")
informatieobjecttype_data = get_informatieobjecttype_response(
catalogus, informatieobjecttype)
informatieobjecttype_data["concept"] = True
with requests_mock.Mocker(real_http=True) as m:
m.register_uri(
"GET",
informatieobjecttype,
json=informatieobjecttype_data,
)
m.register_uri(
"GET",
catalogus,
json=get_catalogus_response(catalogus, informatieobjecttype),
)
response = self.client.post(
self.list_url,
{
"identificatie": "12345",
"bronorganisatie": "159351741",
"creatiedatum": "2018-06-27",
"titel": "detailed summary",
"auteur": "test_auteur",
"formaat": "txt",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"inhoud": b64encode(b"some file content").decode("utf-8"),
"link": "http://een.link",
"beschrijving": "test_beschrijving",
"informatieobjecttype": informatieobjecttype,
"vertrouwelijkheidaanduiding": "openbaar",
},
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "informatieobjecttype")
self.assertEqual(error["code"], "not-published")
class AuditTrailTests(JWTAuthMixin, APITestCase):
informatieobject_list_url = reverse_lazy(EnkelvoudigInformatieObject)
gebruiksrechten_list_url = reverse_lazy(Gebruiksrechten)
heeft_alle_autorisaties = True
def _create_enkelvoudiginformatieobject(self, **HEADERS):
informatieobjecttype = InformatieObjectTypeFactory.create()
informatieobjecttype_url = reverse(informatieobjecttype)
content = {
"identificatie": uuid.uuid4().hex,
"bronorganisatie": "159351741",
"creatiedatum": "2018-06-27",
"titel": "detailed summary",
"auteur": "test_auteur",
"formaat": "txt",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"inhoud": b64encode(b"some file content").decode("utf-8"),
"link": "http://een.link",
"beschrijving": "test_beschrijving",
"informatieobjecttype": informatieobjecttype_url,
"vertrouwelijkheidaanduiding": "openbaar",
}
response = self.client.post(self.informatieobject_list_url, content,
**HEADERS)
return response.data
def test_create_enkelvoudiginformatieobject_audittrail(self):
informatieobject_data = self._create_enkelvoudiginformatieobject()
informatieobject_url = informatieobject_data["url"]
audittrails = AuditTrail.objects.filter(
hoofd_object=informatieobject_url)
self.assertEqual(audittrails.count(), 1)
# Verify that the audittrail for the EnkelvoudigInformatieObject creation contains the correct
# information
informatieobject_create_audittrail = audittrails.get()
self.assertEqual(informatieobject_create_audittrail.bron, "DRC")
self.assertEqual(informatieobject_create_audittrail.actie, "create")
self.assertEqual(informatieobject_create_audittrail.resultaat, 201)
self.assertEqual(informatieobject_create_audittrail.oud, None)
self.assertEqual(informatieobject_create_audittrail.nieuw,
informatieobject_data)
@skip("ObjectInformatieObject is not implemented yet")
def test_create_objectinformatieobject_audittrail(self):
informatieobject = EnkelvoudigInformatieObjectFactory.create()
content = {
"informatieobject":
reverse(
"enkelvoudiginformatieobject-detail",
kwargs={"uuid": informatieobject.uuid},
),
"object":
ZAAK,
"objectType":
ObjectTypes.zaak,
}
# Send to the API
objectinformatieobject_response = self.client.post(
self.objectinformatieobject_list_url, content).data
informatieobject_url = objectinformatieobject_response[
"informatieobject"]
audittrails = AuditTrail.objects.filter(
hoofd_object=informatieobject_url)
self.assertEqual(audittrails.count(), 1)
# Verify that the audittrail for the ObjectInformatieObject creation
# contains the correct information
objectinformatieobject_create_audittrail = audittrails.get()
self.assertEqual(objectinformatieobject_create_audittrail.bron, "DRC")
self.assertEqual(objectinformatieobject_create_audittrail.actie,
"create")
self.assertEqual(objectinformatieobject_create_audittrail.resultaat,
201)
self.assertEqual(objectinformatieobject_create_audittrail.oud, None)
self.assertEqual(
objectinformatieobject_create_audittrail.nieuw,
objectinformatieobject_response,
)
def test_create_and_delete_gebruiksrechten_audittrail(self):
informatieobject = EnkelvoudigInformatieObjectFactory.create()
content = {
"informatieobject":
reverse(
"enkelvoudiginformatieobject-detail",
kwargs={"uuid": informatieobject.uuid},
),
"startdatum":
datetime.now(),
"omschrijvingVoorwaarden":
"test",
}
gebruiksrechten_response = self.client.post(
self.gebruiksrechten_list_url, content).data
informatieobject_url = gebruiksrechten_response["informatieobject"]
audittrails = AuditTrail.objects.filter(
hoofd_object=informatieobject_url)
self.assertEqual(audittrails.count(), 1)
# Verify that the audittrail for the Gebruiksrechten creation
# contains the correct information
gebruiksrechten_create_audittrail = audittrails.get()
self.assertEqual(gebruiksrechten_create_audittrail.bron, "DRC")
self.assertEqual(gebruiksrechten_create_audittrail.actie, "create")
self.assertEqual(gebruiksrechten_create_audittrail.resultaat, 201)
self.assertEqual(gebruiksrechten_create_audittrail.oud, None)
self.assertEqual(gebruiksrechten_create_audittrail.nieuw,
gebruiksrechten_response)
delete_response = self.client.delete(gebruiksrechten_response["url"])
self.assertEqual(delete_response.status_code,
status.HTTP_204_NO_CONTENT)
audittrails = AuditTrail.objects.filter(
hoofd_object=informatieobject_url)
self.assertEqual(audittrails.count(), 2)
# Verify that the audittrail for the Gebruiksrechten deletion
# contains the correct information
gebruiksrechten_delete_audittrail = audittrails[1]
self.assertEqual(gebruiksrechten_delete_audittrail.bron, "DRC")
self.assertEqual(gebruiksrechten_delete_audittrail.actie, "destroy")
self.assertEqual(gebruiksrechten_delete_audittrail.resultaat, 204)
self.assertEqual(gebruiksrechten_delete_audittrail.oud,
gebruiksrechten_response)
self.assertEqual(gebruiksrechten_delete_audittrail.nieuw, None)
def test_update_enkelvoudiginformatieobject_audittrail(self):
informatieobject_data = self._create_enkelvoudiginformatieobject()
informatieobject_url = informatieobject_data["url"]
informatieobjecttype_url = informatieobject_data[
"informatieobjecttype"]
# lock for update
eio = EnkelvoudigInformatieObjectCanonical.objects.get()
eio.lock = "0f60f6d2d2714c809ed762372f5a363a"
eio.save()
content = {
"identificatie": uuid.uuid4().hex,
"bronorganisatie": "159351741",
"creatiedatum": "2018-06-27",
"titel": "aangepast",
"auteur": "aangepaste auteur",
"formaat": "txt",
"taal": "eng",
"bestandsnaam": "dummy.txt",
"inhoud": b64encode(b"some file content").decode("utf-8"),
"link": "http://een.link",
"beschrijving": "test_beschrijving",
"informatieobjecttype": informatieobjecttype_url,
"vertrouwelijkheidaanduiding": "openbaar",
"lock": "0f60f6d2d2714c809ed762372f5a363a",
}
informatieobject_response = self.client.put(informatieobject_url,
content).data
audittrails = AuditTrail.objects.filter(
hoofd_object=informatieobject_url)
self.assertEqual(audittrails.count(), 2)
# Verify that the audittrail for the EnkelvoudigInformatieObject update
# contains the correct information
informatieobject_update_audittrail = audittrails[1]
self.assertEqual(informatieobject_update_audittrail.bron, "DRC")
self.assertEqual(informatieobject_update_audittrail.actie, "update")
self.assertEqual(informatieobject_update_audittrail.resultaat, 200)
# locked is False upon InformatieObject creation, but the
# InformatieObject must be locked before updating is possible, so
# locked will be True in the version before changes as shown
# in the audittrail
informatieobject_data["locked"] = True
self.assertEqual(informatieobject_update_audittrail.oud,
informatieobject_data)
self.assertEqual(informatieobject_update_audittrail.nieuw,
informatieobject_response)
def test_partial_update_enkelvoudiginformatieobject_audittrail(self):
informatieobject_data = self._create_enkelvoudiginformatieobject()
informatieobject_url = informatieobject_data["url"]
# lock for update
eio = EnkelvoudigInformatieObjectCanonical.objects.get()
eio.lock = "0f60f6d2d2714c809ed762372f5a363a"
eio.save()
informatieobject_response = self.client.patch(
informatieobject_url,
{
"titel": "changed",
"lock": "0f60f6d2d2714c809ed762372f5a363a"
},
).data
audittrails = AuditTrail.objects.filter(
hoofd_object=informatieobject_url)
self.assertEqual(audittrails.count(), 2)
# Verify that the audittrail for the EnkelvoudigInformatieObject
# partial update contains the correct information
informatieobject_partial_update_audittrail = audittrails[1]
self.assertEqual(informatieobject_partial_update_audittrail.bron,
"DRC")
self.assertEqual(informatieobject_partial_update_audittrail.actie,
"partial_update")
self.assertEqual(informatieobject_partial_update_audittrail.resultaat,
200)
# locked is False upon InformatieObject creation, but the
# InformatieObject must be locked before updating is possible, so
# locked will be True in the version before changes as shown
# in the audittrail
informatieobject_data["locked"] = True
self.assertEqual(informatieobject_partial_update_audittrail.oud,
informatieobject_data)
self.assertEqual(informatieobject_partial_update_audittrail.nieuw,
informatieobject_response)
def test_audittrail_applicatie_information(self):
object_response = self._create_enkelvoudiginformatieobject()
audittrail = AuditTrail.objects.filter(
hoofd_object=object_response["url"]).get()
# Verify that the application id stored in the AuditTrail matches
# the id of the Application used for the request
self.assertEqual(audittrail.applicatie_id, str(self.applicatie.uuid))
# Verify that the application representation stored in the AuditTrail
# matches the label of the Application used for the request
self.assertEqual(audittrail.applicatie_weergave, self.applicatie.label)
def test_audittrail_user_information(self):
object_response = self._create_enkelvoudiginformatieobject()
audittrail = AuditTrail.objects.filter(
hoofd_object=object_response["url"]).get()
# Verify that the user id stored in the AuditTrail matches
# the user id in the JWT token for the request
self.assertIn(audittrail.gebruikers_id, self.user_id)
# Verify that the user representation stored in the AuditTrail matches
# the user representation in the JWT token for the request
self.assertEqual(audittrail.gebruikers_weergave,
self.user_representation)
def test_audittrail_toelichting(self):
toelichting = "blaaaa"
object_response = self._create_enkelvoudiginformatieobject(
HTTP_X_AUDIT_TOELICHTING=toelichting)
audittrail = AuditTrail.objects.filter(
hoofd_object=object_response["url"]).get()
# Verify that the toelichting stored in the AuditTrail matches
# the X-Audit-Toelichting header in the HTTP request
self.assertEqual(audittrail.toelichting, toelichting)
def test_read_audittrail(self):
self._create_enkelvoudiginformatieobject()
eio = EnkelvoudigInformatieObject.objects.get()
audittrails = AuditTrail.objects.get()
audittrails_url = reverse(
audittrails, kwargs={"enkelvoudiginformatieobject_uuid": eio.uuid})
response_audittrails = self.client.get(audittrails_url)
self.assertEqual(response_audittrails.status_code, status.HTTP_200_OK)
def test_audittrail_resource_weergave(self):
eio_response = self._create_enkelvoudiginformatieobject()
eio_uuid = get_uuid_from_path(eio_response["url"])
eio_unique_representation = EnkelvoudigInformatieObject.objects.get(
uuid=eio_uuid).unique_representation()
audittrail = AuditTrail.objects.filter(
hoofd_object=eio_response["url"]).get()
# Verify that the resource weergave stored in the AuditTrail matches
# the unique representation as defined in the Zaak model
self.assertIn(audittrail.resource_weergave, eio_unique_representation)
class ZaakInformatieobjectTypeAPITests(APITestCase):
maxDiff = None
list_url = reverse_lazy(ZaakInformatieobjectType)
def test_get_list_default_definitief(self):
ziot1 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=True)
ziot2 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=True)
ziot3 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=False)
ziot4 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=False)
ziot4_url = reverse(ziot4)
response = self.client.get(self.list_url)
self.assertEqual(response.status_code, 200)
data = response.json()['results']
self.assertEqual(len(data), 1)
self.assertEqual(data[0]['url'], f'http://testserver{ziot4_url}')
def test_get_detail(self):
ztiot = ZaakInformatieobjectTypeFactory.create()
url = reverse(ztiot)
zaaktype_url = reverse(ztiot.zaaktype)
informatieobjecttype_url = reverse(ztiot.informatieobjecttype, )
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
expected = {
'url': f'http://testserver{url}',
'zaaktype': f'http://testserver{zaaktype_url}',
'informatieobjecttype':
f'http://testserver{informatieobjecttype_url}',
'volgnummer': ztiot.volgnummer,
'richting': ztiot.richting,
'statustype': None,
}
self.assertEqual(response.json(), expected)
def test_create_ziot(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create()
informatieobjecttype_url = reverse(informatieobjecttype)
data = {
'zaaktype': f'http://testserver{zaaktype_url}',
'informatieobjecttype':
f'http://testserver{informatieobjecttype_url}',
'volgnummer': 13,
'richting': RichtingChoices.inkomend,
}
response = self.client.post(self.list_url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
ziot = ZaakInformatieobjectType.objects.get(volgnummer=13)
self.assertEqual(ziot.zaaktype, zaaktype)
self.assertEqual(ziot.informatieobjecttype, informatieobjecttype)
def test_create_ziot_fail_not_concept_zaaktype(self):
zaaktype = ZaakTypeFactory.create(concept=False)
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create()
informatieobjecttype_url = reverse(informatieobjecttype)
data = {
'zaaktype': f'http://testserver{zaaktype_url}',
'informatieobjecttype':
f'http://testserver{informatieobjecttype_url}',
'volgnummer': 13,
'richting': RichtingChoices.inkomend,
}
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 relations between non-concept objects is forbidden')
def test_create_ziot_fail_not_concept_informatieobjecttype(self):
zaaktype = ZaakTypeFactory.create()
zaaktype_url = reverse(zaaktype)
informatieobjecttype = InformatieObjectTypeFactory.create(
concept=False)
informatieobjecttype_url = reverse(informatieobjecttype)
data = {
'zaaktype': f'http://testserver{zaaktype_url}',
'informatieobjecttype':
f'http://testserver{informatieobjecttype_url}',
'volgnummer': 13,
'richting': RichtingChoices.inkomend,
}
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 relations between non-concept objects is forbidden')
def test_delete_ziot(self):
ziot = ZaakInformatieobjectTypeFactory.create()
ziot_url = reverse(ziot)
response = self.client.delete(ziot_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(ZaakInformatieobjectType.objects.filter(id=ziot.id))
def test_delete_ziot_fail_not_concept_zaaktype(self):
ziot = ZaakInformatieobjectTypeFactory.create(zaaktype__concept=False)
ziot_url = reverse(ziot)
response = self.client.delete(ziot_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
data = response.json()
self.assertEqual(data['detail'],
'Alleen concepten kunnen worden verwijderd.')
def test_delete_ziot_fail_not_concept_informatieobjecttype(self):
ziot = ZaakInformatieobjectTypeFactory.create(
informatieobjecttype__concept=False)
ziot_url = reverse(ziot)
response = self.client.delete(ziot_url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
data = response.json()
self.assertEqual(data['detail'],
'Alleen concepten kunnen worden verwijderd.')
class ObjectInformatieObjectTests(JWTAuthMixin, APITestCase):
heeft_alle_autorisaties = True
list_url = reverse_lazy("objectinformatieobject-list")
def test_create_with_objecttype_zaak(self):
zaak = ZaakFactory.create()
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
# relate the two
ZaakInformatieObjectFactory.create(zaak=zaak, informatieobject=eio.canonical)
# get OIO created via signals
ObjectInformatieObject.objects.get()
zaak_url = reverse(zaak)
response = self.client.post(
self.list_url,
{
"object": f"http://testserver{zaak_url}",
"informatieobject": eio_url,
"objectType": "zaak",
},
)
self.assertEqual(
response.status_code, status.HTTP_400_BAD_REQUEST, response.data
)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "unique")
def test_create_with_objecttype_besluit(self):
besluit = BesluitFactory.create()
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
BesluitInformatieObjectFactory.create(
besluit=besluit, informatieobject=eio.canonical
)
# get OIO created via signals
ObjectInformatieObject.objects.get()
besluit_url = reverse(besluit)
response = self.client.post(
self.list_url,
{
"object": f"http://testserver{besluit_url}",
"informatieobject": f"http://testserver{eio_path}",
"objectType": "besluit",
},
)
self.assertEqual(
response.status_code, status.HTTP_400_BAD_REQUEST, response.data
)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "unique")
def test_create_with_objecttype_other_fail(self):
besluit = BesluitFactory.create()
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
# relate the two
BesluitInformatieObjectFactory.create(
besluit=besluit, informatieobject=eio.canonical
)
besluit_url = reverse(besluit)
response = self.client.post(
self.list_url,
{
"object": f"http://testserver{besluit_url}",
"informatieobject": eio_url,
"objectType": "other",
},
)
self.assertEqual(
response.status_code, status.HTTP_400_BAD_REQUEST, response.data
)
error = get_validation_errors(response, "objectType")
self.assertEqual(error["code"], "invalid_choice")
def test_read_with_objecttype_zaak(self):
zaak = ZaakFactory.create()
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
# relate the two
ZaakInformatieObjectFactory.create(zaak=zaak, informatieobject=eio.canonical)
# get OIO created via signals
oio = ObjectInformatieObject.objects.get()
oio_url = reverse("objectinformatieobject-detail", kwargs={"uuid": oio.uuid})
zaak_url = reverse(zaak)
response = self.client.get(oio_url)
expeceted_response_data = {
"url": f"http://testserver{oio_url}",
"object": f"http://testserver{zaak_url}",
"informatieobject": eio_url,
"object_type": "zaak",
}
self.assertEqual(response.status_code, status.HTTP_200_OK, response.data)
self.assertEqual(response.data, expeceted_response_data)
def test_read_with_objecttype_besluit(self):
besluit = BesluitFactory.create()
eio = EnkelvoudigInformatieObjectFactory.create()
eio_path = reverse(eio)
eio_url = f"http://testserver{eio_path}"
# relate the two
BesluitInformatieObjectFactory.create(
besluit=besluit, informatieobject=eio.canonical
)
# get OIO created via signals
oio = ObjectInformatieObject.objects.get()
oio_url = reverse("objectinformatieobject-detail", kwargs={"uuid": oio.uuid})
besluit_url = reverse(besluit)
response = self.client.get(oio_url)
expeceted_response_data = {
"url": f"http://testserver{oio_url}",
"object": f"http://testserver{besluit_url}",
"informatieobject": eio_url,
"object_type": "besluit",
}
self.assertEqual(response.status_code, status.HTTP_200_OK, response.data)
self.assertEqual(response.data, expeceted_response_data)
def test_post_object_without_created_relations(self):
"""
Test the (informatieobject, object) unique together validation.
This is expected to fail, since there is no actual creation in database.
It will however become relevant again when we're handling remote
references.
"""
zaak = ZaakFactory.create()
eio = EnkelvoudigInformatieObjectFactory.create()
zaak_url = reverse(zaak)
eio_url = reverse(eio)
content = {
"informatieobject": f"http://testserver{eio_url}",
"object": f"http://testserver{zaak_url}",
"objectType": ObjectTypes.zaak,
}
# Send to the API
response = self.client.post(self.list_url, content)
self.assertEqual(
response.status_code, status.HTTP_400_BAD_REQUEST, response.data
)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "inconsistent-relation")
def test_filter_eio(self):
bio = BesluitInformatieObjectFactory.create()
ZaakInformatieObjectFactory.create() # may not show up
eio_detail_url = (
f"http://openzaak.nl{reverse(bio.informatieobject.latest_version)}"
)
response = self.client.get(
self.list_url,
{"informatieobject": eio_detail_url},
HTTP_HOST="openzaak.nl",
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["informatieobject"], eio_detail_url)
def test_filter_zaak(self):
zio = ZaakInformatieObjectFactory.create()
ZaakInformatieObjectFactory.create() # may not show up
eio_detail_url = (
f"http://openzaak.nl{reverse(zio.informatieobject.latest_version)}"
)
zaak_url = reverse(zio.zaak)
response = self.client.get(
self.list_url,
{"object": f"http://openzaak.nl{zaak_url}"},
HTTP_HOST="openzaak.nl",
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["informatieobject"], eio_detail_url)
def test_filter_besluit(self):
bio = BesluitInformatieObjectFactory.create()
BesluitInformatieObjectFactory.create() # may not show up
eio_detail_url = (
f"http://openzaak.nl{reverse(bio.informatieobject.latest_version)}"
)
besluit_url = reverse(bio.besluit)
response = self.client.get(
self.list_url,
{"object": f"http://openzaak.nl{besluit_url}"},
HTTP_HOST="openzaak.nl",
)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]["informatieobject"], eio_detail_url)
def test_validate_unknown_query_params(self):
url = reverse(ObjectInformatieObject)
response = self.client.get(url, {"someparam": "somevalue"})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "nonFieldErrors")
self.assertEqual(error["code"], "unknown-parameters")
class ZaakInformatieobjectTypeFilterAPITests(APITestCase):
maxDiff = None
list_url = reverse_lazy(ZaakInformatieobjectType)
def test_filter_zaaktype(self):
ztiot1, ztiot2 = ZaakInformatieobjectTypeFactory.create_batch(
2, zaaktype__concept=False, informatieobjecttype__concept=False)
url = f'http://testserver{reverse(ztiot1)}'
zaaktype1_url = reverse(ztiot1.zaaktype)
zaaktype2_url = reverse(ztiot2.zaaktype)
zaaktype1_url = f'http://testserver{zaaktype1_url}'
zaaktype2_url = f'http://testserver{zaaktype2_url}'
response = self.client.get(self.list_url, {'zaaktype': zaaktype1_url})
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()['results']
self.assertEqual(data[0]['url'], url)
self.assertEqual(data[0]['zaaktype'], zaaktype1_url)
self.assertNotEqual(data[0]['zaaktype'], zaaktype2_url)
def test_filter_informatieobjecttype(self):
ztiot1, ztiot2 = ZaakInformatieobjectTypeFactory.create_batch(
2, zaaktype__concept=False, informatieobjecttype__concept=False)
url = f'http://testserver{reverse(ztiot1)}'
informatieobjecttype1_url = reverse(ztiot1.informatieobjecttype)
informatieobjecttype2_url = reverse(ztiot2.informatieobjecttype)
informatieobjecttype1_url = f'http://testserver{informatieobjecttype1_url}'
informatieobjecttype2_url = f'http://testserver{informatieobjecttype2_url}'
response = self.client.get(
self.list_url, {'informatieobjecttype': informatieobjecttype1_url})
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()['results']
self.assertEqual(data[0]['url'], url)
self.assertEqual(data[0]['informatieobjecttype'],
informatieobjecttype1_url)
self.assertNotEqual(data[0]['informatieobjecttype'],
informatieobjecttype2_url)
def test_filter_ziot_status_alles(self):
ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=True)
ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=True)
ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=False)
ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=False)
response = self.client.get(self.list_url, {'status': 'alles'})
self.assertEqual(response.status_code, 200)
data = response.json()['results']
self.assertEqual(len(data), 4)
def test_filter_ziot_status_concept(self):
ziot1 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=True)
ziot2 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=True)
ziot3 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=False)
ziot4 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=False)
ziot1_url = reverse(ziot1)
response = self.client.get(self.list_url, {'status': 'concept'})
self.assertEqual(response.status_code, 200)
data = response.json()['results']
self.assertEqual(len(data), 1)
self.assertEqual(data[0]['url'], f'http://testserver{ziot1_url}')
def test_filter_ziot_status_definitief(self):
ziot1 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=True)
ziot2 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=True)
ziot3 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=True, informatieobjecttype__concept=False)
ziot4 = ZaakInformatieobjectTypeFactory.create(
zaaktype__concept=False, informatieobjecttype__concept=False)
ziot4_url = reverse(ziot4)
response = self.client.get(self.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{ziot4_url}')
