def test_filter_telefoonnummer(self):
KlantFactory.create(telefoonnummer="123")
KlantFactory.create(telefoonnummer="321")
url = reverse(Klant)
response = self.client.get(url, {"telefoonnummer": "321"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertEqual(response_data["count"], 1)
result = response_data["results"][0]
self.assertEqual(result["telefoonnummer"], "321")
def test_filter_bedrijfsnaam(self):
KlantFactory.create(bedrijfsnaam="123")
KlantFactory.create(bedrijfsnaam="321")
url = reverse(Klant)
response = self.client.get(url, {"bedrijfsnaam": "321"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertEqual(response_data["count"], 1)
result = response_data["results"][0]
self.assertEqual(result["bedrijfsnaam"], "321")
def test_filter_bronorganisatie(self):
KlantFactory.create(bronorganisatie="000000000")
KlantFactory.create(bronorganisatie="123456782")
url = reverse(Klant)
response = self.client.get(url, {"bronorganisatie": "000000000"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertEqual(response_data["count"], 1)
result = response_data["results"][0]
self.assertEqual(result["bronorganisatie"], "000000000")
def test_filter_subject(self):
KlantFactory.create(subject="https://example.com/1")
KlantFactory.create(subject="https://example.com/2")
url = reverse(Klant)
response = self.client.get(url, {"subject": "https://example.com/2"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertEqual(response_data["count"], 1)
result = response_data["results"][0]
self.assertEqual(result["subject"], "https://example.com/2")
def test_filter_subject_type(self):
KlantFactory.create(subject_type=KlantType.natuurlijk_persoon)
KlantFactory.create(subject_type=KlantType.niet_natuurlijk_persoon)
url = reverse(Klant)
response = self.client.get(
url, {"subject_type": KlantType.niet_natuurlijk_persoon})
self.assertEqual(response.status_code, status.HTTP_200_OK)
response_data = response.json()
self.assertEqual(response_data["count"], 1)
result = response_data["results"][0]
self.assertEqual(result["subjectType"],
KlantType.niet_natuurlijk_persoon)
def test_update_klant_nietnaturlijkpersoon(self):
klant = KlantFactory.create(
subject_type=KlantType.niet_natuurlijk_persoon, subject=SUBJECT)
nietnatuurlijkpersoon = NietNatuurlijkPersoonFactory.create(
klant=klant)
buitenland = SubVerblijfBuitenlandFactory.create(
nietnatuurlijkpersoon=nietnatuurlijkpersoon)
detail_url = reverse(klant)
data = self.client.get(detail_url).json()
del data["url"]
data.update({
"voornaam": "New name",
"subject": "",
"subjectIdentificatie": {
"statutaireNaam": "New name2",
"subVerblijfBuitenland": {
"lndLandcode": "XXXX",
"lndLandnaam": "New land",
},
},
})
response = self.client.put(detail_url, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
klant.refresh_from_db()
self.assertEqual(klant.voornaam, "New name")
self.assertEqual(klant.subject, "")
nietnatuurlijkpersoon.refresh_from_db()
self.assertEqual(nietnatuurlijkpersoon.statutaire_naam, "New name2")
buitenland.refresh_from_db()
self.assertEqual(buitenland.lnd_landnaam, "New land")
def test_send_notif_delete_klant(self, mock_client):
"""
Check if notifications will be send when Klant is deleted
"""
client = mock_client.return_value
klant = KlantFactory.create(subject_type=KlantType.natuurlijk_persoon)
klant_url = get_operation_url("klant_delete", uuid=klant.uuid)
response = self.client.delete(klant_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT,
response.data)
client.create.assert_called_once_with(
"notificaties",
{
"kanaal": "klanten",
"hoofdObject": f"http://testserver{klant_url}",
"resource": "klant",
"resourceUrl": f"http://testserver{klant_url}",
"actie": "destroy",
"aanmaakdatum": "2018-09-07T00:00:00Z",
"kenmerken": {
"subjectType": KlantType.natuurlijk_persoon
},
},
)
def test_destroy_klant(self):
klant = KlantFactory.create()
detail_url = reverse(klant)
response = self.client.delete(detail_url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(Klant.objects.count(), 0)
def test_cannot_read_without_correct_scope(self):
klant = KlantFactory.create()
urls = [
reverse("klant-list"),
reverse(klant),
]
for url in urls:
with self.subTest(url=url):
self.assertForbidden(url, method="get")
def test_partial_update_klant_url(self):
klant = KlantFactory.create(subject=SUBJECT, voornaam="old name")
detail_url = reverse(klant)
response = self.client.patch(detail_url, {"voornaam": "new name"})
self.assertEqual(response.status_code, status.HTTP_200_OK)
klant.refresh_from_db()
self.assertEqual(klant.voornaam, "new name")
def test_partial_update_klant_subject_type_fail(self):
klant = KlantFactory.create(subject=SUBJECT,
subject_type=KlantType.natuurlijk_persoon)
detail_url = reverse(klant)
response = self.client.patch(detail_url,
{"subjectType": KlantType.vestiging})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
validation_error = get_validation_errors(response, "subjectType")
self.assertEqual(validation_error["code"], "wijzigen-niet-toegelaten")
def test_partial_update_klant_subject_url_invalid(self):
klant = KlantFactory.create(subject=SUBJECT, voornaam="old name")
detail_url = reverse(klant)
with requests_mock.Mocker() as m:
m.get("https://example.com/404", status_code=404)
response = self.client.patch(
detail_url, {"subject": "https://example.com/404"})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "subject")
self.assertEqual(error["code"], "bad-url")
def test_update_klant_url(self):
klant = KlantFactory.create(subject=SUBJECT, voornaam="old name")
detail_url = reverse(klant)
data = self.client.get(detail_url).json()
del data["url"]
del data["subjectIdentificatie"]
data["voornaam"] = "new name"
response = self.client.put(detail_url, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
klant.refresh_from_db()
self.assertEqual(klant.voornaam, "new name")
def test_update_klant_subject_url_invalid(self):
klant = KlantFactory.create(subject=SUBJECT, voornaam="old name")
detail_url = reverse(klant)
data = self.client.get(detail_url).json()
del data["url"]
del data["subjectIdentificatie"]
data["subject"] = "https://example.com/404"
with requests_mock.Mocker() as m:
m.get("https://example.com/404", status_code=404)
response = self.client.put(detail_url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
error = get_validation_errors(response, "subject")
self.assertEqual(error["code"], "bad-url")
def test_update_klant_vestiging(self):
klant = KlantFactory.create(subject_type=KlantType.vestiging)
detail_url = reverse(klant)
data = self.client.get(detail_url).json()
del data["url"]
data.update({
"subject": "",
"subjectIdentificatie": {
"vestigingsNummer": "123",
"handelsnaam": ["WB"],
"verblijfsadres": {
"aoaIdentificatie": "1234",
"wplWoonplaatsNaam": "East Meaganchester",
"gorOpenbareRuimteNaam": "New Amsterdam",
"aoaHuisnummer": 21,
},
"subVerblijfBuitenland": {
"lndLandcode": "ABCD",
"lndLandnaam": "Hollywood",
},
},
})
response = self.client.put(detail_url, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
klant.refresh_from_db()
self.assertEqual(klant.subject, "")
vestiging = klant.vestiging
self.assertEqual(vestiging.vestigings_nummer, "123")
self.assertEqual(vestiging.handelsnaam, ["WB"])
adres = vestiging.verblijfsadres
self.assertEqual(adres.aoa_identificatie, "1234")
self.assertEqual(adres.woonplaats_naam, "East Meaganchester")
self.assertEqual(adres.gor_openbare_ruimte_naam, "New Amsterdam")
self.assertEqual(adres.huisnummer, 21)
buitenland = vestiging.sub_verblijf_buitenland
self.assertEqual(buitenland.lnd_landcode, "ABCD")
self.assertEqual(buitenland.lnd_landnaam, "Hollywood")
def test_update_klant_naturlijkpersoon(self):
klant = KlantFactory.create(subject_type=KlantType.natuurlijk_persoon,
subject=SUBJECT)
natuurlijkpersoon = NatuurlijkPersoonFactory.create(klant=klant)
adres = VerblijfsAdresFactory.create(
natuurlijkpersoon=natuurlijkpersoon)
buitenland = SubVerblijfBuitenlandFactory.create(
natuurlijkpersoon=natuurlijkpersoon)
detail_url = reverse(klant)
data = self.client.get(detail_url).json()
del data["url"]
data.update({
"voornaam": "New name",
"subject": "",
"subjectIdentificatie": {
"geslachtsnaam": "New name2",
"verblijfsadres": {
"aoaIdentificatie": "1234",
"wplWoonplaatsNaam": "New place",
"gorOpenbareRuimteNaam": "New place2",
"aoaHuisnummer": 1,
},
"subVerblijfBuitenland": {
"lndLandcode": "XXXX",
"lndLandnaam": "New land",
},
},
})
response = self.client.put(detail_url, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
klant.refresh_from_db()
self.assertEqual(klant.voornaam, "New name")
self.assertEqual(klant.subject, "")
natuurlijkpersoon.refresh_from_db()
self.assertEqual(natuurlijkpersoon.geslachtsnaam, "New name2")
adres.refresh_from_db()
self.assertEqual(adres.woonplaats_naam, "New place")
buitenland.refresh_from_db()
self.assertEqual(buitenland.lnd_landnaam, "New land")
def test_read_klant_url(self):
klant = KlantFactory.create(subject=SUBJECT,
subject_type=KlantType.natuurlijk_persoon)
KlantAdresFactory.create(klant=klant)
detail_url = reverse(klant)
response = self.client.get(detail_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(
data,
{
"url": f"http://testserver{detail_url}",
"bronorganisatie": klant.bronorganisatie,
"klantnummer": klant.klantnummer,
"bedrijfsnaam": klant.bedrijfsnaam,
"functie": klant.functie,
"websiteUrl": klant.website_url,
"voornaam": klant.voornaam,
"voorvoegselAchternaam": klant.voorvoegsel_achternaam,
"achternaam": klant.achternaam,
"telefoonnummer": klant.telefoonnummer,
"emailadres": klant.emailadres,
"adres": {
"straatnaam": klant.adres.straatnaam,
"huisnummer": klant.adres.huisnummer,
"huisletter": klant.adres.huisletter,
"huisnummertoevoeging": klant.adres.huisnummertoevoeging,
"postcode": klant.adres.postcode,
"woonplaatsnaam": klant.adres.woonplaats_naam,
"landcode": klant.adres.landcode,
},
"subject": SUBJECT,
"subjectType": KlantType.natuurlijk_persoon,
"subjectIdentificatie": None,
},
)
def test_read_klant_natuurlijkpersoon(self):
klant = KlantFactory.create(subject=SUBJECT,
subject_type=KlantType.natuurlijk_persoon)
KlantAdresFactory.create(klant=klant)
natuurlijkpersoon = NatuurlijkPersoonFactory.create(klant=klant)
adres = VerblijfsAdresFactory.create(
natuurlijkpersoon=natuurlijkpersoon)
buitenland = SubVerblijfBuitenlandFactory.create(
natuurlijkpersoon=natuurlijkpersoon)
detail_url = reverse(klant)
response = self.client.get(detail_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(
data,
{
"url": f"http://testserver{detail_url}",
"bronorganisatie": klant.bronorganisatie,
"klantnummer": klant.klantnummer,
"bedrijfsnaam": klant.bedrijfsnaam,
"functie": klant.functie,
"websiteUrl": klant.website_url,
"voornaam": klant.voornaam,
"voorvoegselAchternaam": klant.voorvoegsel_achternaam,
"achternaam": klant.achternaam,
"telefoonnummer": klant.telefoonnummer,
"emailadres": klant.emailadres,
"adres": {
"straatnaam": klant.adres.straatnaam,
"huisnummer": klant.adres.huisnummer,
"huisletter": klant.adres.huisletter,
"huisnummertoevoeging": klant.adres.huisnummertoevoeging,
"postcode": klant.adres.postcode,
"woonplaatsnaam": klant.adres.woonplaats_naam,
"landcode": klant.adres.landcode,
},
"subject": SUBJECT,
"subjectType": KlantType.natuurlijk_persoon,
"subjectIdentificatie": {
"inpBsn": natuurlijkpersoon.inp_bsn,
"anpIdentificatie": natuurlijkpersoon.anp_identificatie,
"inpANummer": natuurlijkpersoon.inp_a_nummer,
"geslachtsnaam": natuurlijkpersoon.geslachtsnaam,
"voorvoegselGeslachtsnaam":
natuurlijkpersoon.voorvoegsel_geslachtsnaam,
"voorletters": natuurlijkpersoon.voorletters,
"voornamen": natuurlijkpersoon.voornamen,
"geslachtsaanduiding":
natuurlijkpersoon.geslachtsaanduiding,
"geboortedatum": natuurlijkpersoon.geboortedatum,
"verblijfsadres": {
"aoaIdentificatie": adres.aoa_identificatie,
"wplWoonplaatsNaam": adres.woonplaats_naam,
"gorOpenbareRuimteNaam":
adres.gor_openbare_ruimte_naam,
"aoaPostcode": adres.postcode,
"aoaHuisnummer": adres.huisnummer,
"aoaHuisletter": adres.huisletter,
"aoaHuisnummertoevoeging": adres.huisnummertoevoeging,
"inpLocatiebeschrijving":
adres.inp_locatiebeschrijving,
},
"subVerblijfBuitenland": {
"lndLandcode": buitenland.lnd_landcode,
"lndLandnaam": buitenland.lnd_landnaam,
"subAdresBuitenland1":
buitenland.sub_adres_buitenland_1,
"subAdresBuitenland2":
buitenland.sub_adres_buitenland_2,
"subAdresBuitenland3":
buitenland.sub_adres_buitenland_3,
},
},
},
)
def test_read_klant_nietnatuurlijkpersoon(self):
klant = KlantFactory.create(
subject=SUBJECT, subject_type=KlantType.niet_natuurlijk_persoon)
KlantAdresFactory.create(klant=klant)
nietnatuurlijkpersoon = NietNatuurlijkPersoonFactory.create(
klant=klant)
buitenland = SubVerblijfBuitenlandFactory.create(
nietnatuurlijkpersoon=nietnatuurlijkpersoon)
detail_url = reverse(klant)
response = self.client.get(detail_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
self.assertEqual(
data,
{
"url": f"http://testserver{detail_url}",
"bronorganisatie": klant.bronorganisatie,
"klantnummer": klant.klantnummer,
"bedrijfsnaam": klant.bedrijfsnaam,
"functie": klant.functie,
"websiteUrl": klant.website_url,
"voornaam": klant.voornaam,
"voorvoegselAchternaam": klant.voorvoegsel_achternaam,
"achternaam": klant.achternaam,
"telefoonnummer": klant.telefoonnummer,
"emailadres": klant.emailadres,
"adres": {
"straatnaam": klant.adres.straatnaam,
"huisnummer": klant.adres.huisnummer,
"huisletter": klant.adres.huisletter,
"huisnummertoevoeging": klant.adres.huisnummertoevoeging,
"postcode": klant.adres.postcode,
"woonplaatsnaam": klant.adres.woonplaats_naam,
"landcode": klant.adres.landcode,
},
"subject": SUBJECT,
"subjectType": KlantType.niet_natuurlijk_persoon,
"subjectIdentificatie": {
"innNnpId": nietnatuurlijkpersoon.inn_nnp_id,
"annIdentificatie":
nietnatuurlijkpersoon.ann_identificatie,
"statutaireNaam": nietnatuurlijkpersoon.statutaire_naam,
"innRechtsvorm": nietnatuurlijkpersoon.inn_rechtsvorm,
"bezoekadres": nietnatuurlijkpersoon.bezoekadres,
"subVerblijfBuitenland": {
"lndLandcode": buitenland.lnd_landcode,
"lndLandnaam": buitenland.lnd_landnaam,
"subAdresBuitenland1":
buitenland.sub_adres_buitenland_1,
"subAdresBuitenland2":
buitenland.sub_adres_buitenland_2,
"subAdresBuitenland3":
buitenland.sub_adres_buitenland_3,
},
},
},
)
