def test_get_adellijke_titel_code(self):
self.assertEqual(MKSConverter.get_adellijke_titel_code('Prinses'),
'PS')
self.assertIsNone(MKSConverter.get_adellijke_titel_code(None))
with self.assertRaises(DataItemNotFoundException):
MKSConverter.get_adellijke_titel_code('Koning')
def verblijfstitel(
cls, verblijfstitel: Optional[int], datum_verkrijging: Optional[str],
datum_verlies: Optional[str], omschrijving: list[Optional[str]]
) -> Optional[dict[str, Union[dict, str]]]:
"""Returns verblijfstitel when correctly set.
:param verblijfstitel: code of the aanduiding.
:param datum_verkrijging: A date formatted YYYYMMDD
:param datum_verlies: A date formatted YYYYMMDD
:param omschrijving: Description of verblijfstitel
:return: A dict with all the verblijfstitel details.
"""
today = datetime.date.today()
if datum_verlies is not None and MKSConverter.to_date(
datum_verlies) < today:
return None
if verblijfstitel is None or datum_verkrijging is None:
return None
return {
"aanduiding": {
"code": f"{verblijfstitel}",
"omschrijving": omschrijving[0] if omschrijving else None
},
"datumIngang": MKSConverter.as_datum_broken_down(datum_verkrijging)
}
def test_as_gemeente_code(self, mock_code_resolver):
# Case in which the gemeente_code is known. Return padded gemeente_code
mock_code_resolver.get_gemeente.return_value = 'any gemeente'
self.assertEqual(MKSConverter.as_gemeente_code('363'), '0363')
# Gemeente_code is not known, return None (code will be set in gemeente omschrijving)
mock_code_resolver.get_gemeente.side_effect = DataItemNotFoundException
self.assertEqual(MKSConverter.as_gemeente_code('363'), None)
def test_as_soort_verbintenis(self):
valid = {'h': 'huwelijk', 'p': 'geregistreerd_partnerschap'}
for code, expected_result in valid.items():
for aanduiding in [code.upper(), code.lower()]:
self.assertEqual(MKSConverter.as_soort_verbintenis(aanduiding),
expected_result)
for a in ['x', 'X', '', 'anything', None]:
self.assertEqual(MKSConverter.as_soort_verbintenis(a), None)
def test_as_datum_broken_down(self):
self.assertEqual(MKSConverter.as_datum_broken_down("20200422"), {
'datum': '2020-04-22',
'jaar': 2020,
'maand': 4,
'dag': 22
})
self.assertEqual(MKSConverter.as_datum_broken_down("202004221"), None)
def test_as_code(self):
for length in range(1, 5):
as_code = MKSConverter.as_code(length)
code = as_code("1")
self.assertEqual(len(code), length)
as_code = MKSConverter.as_code(4)
self.assertIsNone(as_code(None))
def test_get_gemeente_omschrijving(self, mock_code_resolver):
mock_code_resolver.get_gemeente.return_value = 'any omschrijving'
self.assertEqual(
MKSConverter.get_gemeente_omschrijving("any gemeente"),
'any omschrijving')
# If gemeente is not found, return code as omschrijving
mock_code_resolver.get_gemeente.side_effect = DataItemNotFoundException
self.assertEqual(
MKSConverter.get_gemeente_omschrijving("any gemeente"),
'any gemeente')
def test_as_aanduiding_bijzonder_nederlanderschap(self):
valid = {
'b': 'behandeld_als_nederlander',
'v': 'vastgesteld_niet_nederlander',
}
for code, expected_result in valid.items():
for aanduiding in [code.upper(), code.lower()]:
self.assertEqual(
MKSConverter.as_aanduiding_bijzonder_nederlanderschap(
aanduiding), expected_result)
for aanduiding in ['x', 'X', '', 'anything', None]:
self.assertIsNone(
MKSConverter.as_aanduiding_bijzonder_nederlanderschap(
aanduiding))
def test_get_communicatie(self):
communicatie_parameters = {
'persoon': {
'geslachtsaanduiding': 'man',
'naam': {
'aanduidingNaamgebruik': 'eigen',
'voorletters': 'M.',
'geslachtsnaam': 'Ruyter',
'voorvoegsel': 'de',
}
},
'partners': [
{
'naam': {
'geslachtsnaam': 'Engels',
'voorvoegsel': '',
},
'aangaanHuwelijkPartnerschap': {
'datum': '16360701'
},
'ontbindingHuwelijkPartnerschap': {
'datum': None
}
},
{
'naam': {
'geslachtsnaam': 'Velders',
'voorvoegsel': '',
},
'aangaanHuwelijkPartnerschap': {
'datum': '16310316'
},
'ontbindingHuwelijkPartnerschap': {
'datum': '16311231'
}
},
]
}
communicatie = MKSConverter._get_communicatie(communicatie_parameters)
self.assertEqual(communicatie.persoon.geslachtsnaam, 'Ruyter')
self.assertEqual(communicatie.partner.geslachtsnaam, 'Engels')
self.assertEqual(communicatie.partners[0].geslachtsnaam, 'Engels')
self.assertEqual(communicatie.partnerhistorie[0].geslachtsnaam,
'Velders')
self.assertEqual(MKSConverter.get_aanhef(communicatie_parameters),
"Geachte heer De Ruyter")
self.assertEqual(
MKSConverter.get_aanschrijfwijze(communicatie_parameters),
"M. de Ruyter")
def test_as_aanduiding_naamgebruik(self):
valid = {
'e': 'eigen',
'n': 'eigen_partner',
'p': 'partner',
'v': 'partner_eigen',
}
for code, expected_result in valid.items():
for aanduiding in [code.upper(), code.lower()]:
self.assertEqual(
MKSConverter.as_aanduiding_naamgebruik(aanduiding),
expected_result)
for aanduiding in ['x', 'X', '', 'anything', None]:
self.assertIsNone(
MKSConverter.as_aanduiding_naamgebruik(aanduiding))
def mapping(self): # pragma: no cover
return {
'soortVerbintenis':
(MKSConverter.as_soort_verbintenis, 'BG:soortVerbintenis'),
'aangaanHuwelijkPartnerschap': {
'datum':
(MKSConverter.as_datum_broken_down, 'BG:datumSluiting',
'BG:datumSluiting@StUF:indOnvolledigeDatum'),
'plaats': {
'code':
(MKSConverter.as_gemeente_code, 'BG:plaatsSluiting'),
'omschrijving': (MKSConverter.get_gemeente_omschrijving,
'BG:plaatsSluiting'),
},
'land': {
'code': (MKSConverter.as_code(4), 'BG:landSluiting'),
'omschrijving':
(MKSConverter.get_land_omschrijving, 'BG:landSluiting'),
},
},
# datumOntbinding is used to filter out 'ontbonden huwelijken'.
# Note that this field will never be exposed because its value will be None on exposed objects.
'datumOntbinding':
'BG:datumOntbinding'
}
def test_true_if_equals(self):
values = [1, '1', True, False, '', None]
false_values = [2, '2', False, True, None, '']
for c, value in enumerate(values):
true_if_equals = MKSConverter.true_if_equals(value)
self.assertTrue(true_if_equals(value))
self.assertFalse(true_if_equals(false_values[c]))
def test_true_if_in(self):
values = [1, 2, 3, 4]
true_if_in = MKSConverter.true_if_in(values)
for value in [1, 2, 3, 4]:
self.assertTrue(true_if_in(value))
# A value not in the list should return None
self.assertIsNone(true_if_in(5))
# A None value should return a None value
self.assertIsNone(true_if_in(None))
def test_is_mks_datum(self):
self.assertTrue(MKSConverter._is_mks_datum("20200422"))
self.assertFalse(MKSConverter._is_mks_datum("2020042"))
self.assertFalse(MKSConverter._is_mks_datum("202004221"))
self.assertFalse(MKSConverter._is_mks_datum(None))
self.assertFalse(MKSConverter._is_mks_datum(""))
self.assertFalse(MKSConverter._is_mks_datum("yyyymmdd"))
def test_as_geslachtsaanduiding(self):
valid = {
'v': 'vrouw',
'm': 'man',
'o': 'onbekend',
}
for code, expected_result in valid.items():
for aanduiding in [code.upper(), code.lower()]:
self.assertEqual(
MKSConverter.as_geslachtsaanduiding(aanduiding),
expected_result)
for a in ['x', 'X', '', 'anything', None]:
self.assertIsNone(MKSConverter.as_geslachtsaanduiding(a))
self.assertEqual(
'onbekend',
MKSConverter.as_geslachtsaanduiding('something',
no_value='waardeOnbekend'))
self.assertEqual(
None,
MKSConverter.as_geslachtsaanduiding('something',
no_value='nietGeautoriseerd'))
def test_get_verblijf_buitenland(self):
parameters = {'land': {'code': None}}
self.assertIsNone(MKSConverter.get_verblijf_buitenland(parameters))
parameters = {
'land': {
'code': '0000',
}
}
self.assertEqual({
'vertrokkenOnbekendWaarheen': True,
}, MKSConverter.get_verblijf_buitenland(parameters))
parameters = {
'land': {
'code': '1000',
'omschrijving': 'Any Country',
},
'adresRegel1': '1',
'adresRegel2': '2',
'adresRegel3': '3',
}
self.assertEqual(parameters,
MKSConverter.get_verblijf_buitenland(parameters))
def test_get_nationaliteit(self):
nationaliteit_parameters = {
'aanduidingBijzonderNederlanderschap':
None,
'nationaliteiten': [{
'datumIngangGeldigheid': {
'datum': '2001-04-12',
'jaar': 2001,
'maand': 4,
'dag': 12
},
'datumVerlies': None,
'nationaliteit': {
'code': '0001',
'omschrijving': 'Nederlandse',
}
}, {
'datumIngangGeldigheid': {
'datum': '2001-04-12',
'jaar': 2001,
'maand': 4,
'dag': 12
},
'datumVerlies': "20020716",
'nationaliteit': {
'code': '0339',
'omschrijving': 'Turkse',
}
}]
}
nationaliteit = MKSConverter.get_nationaliteit(
nationaliteit_parameters)
# Expect one nationaliteit, Nederlandse
self.assertEqual(len(nationaliteit), 1)
self.assertEqual(nationaliteit[0]['nationaliteit']['omschrijving'],
'Nederlandse')
def test_get_gemeente_code(self, mock_code_resolver):
mock_code_resolver.get_gemeente_code.return_value = 'any code'
self.assertEqual(MKSConverter.get_gemeente_code("any omschrijving"),
'any code')
def test_as_dag(self):
self.assertEqual(MKSConverter.as_dag("20200422"), 22)
self.assertEqual(MKSConverter.as_dag("202004221"), None)
def test_as_maand(self):
self.assertEqual(MKSConverter.as_maand("20200422"), 4)
self.assertEqual(MKSConverter.as_maand("202004221"), None)
def test_as_jaar(self):
self.assertEqual(MKSConverter.as_jaar("20200422"), 2020)
self.assertEqual(MKSConverter.as_jaar("202004221"), None)
def mapping(self):
communicatie_parameters = {
'persoon': {
'geslachtsaanduiding': (MKSConverter.as_geslachtsaanduiding,
'BG:geslachtsaanduiding',
'BG:geslachtsaanduiding@StUF:noValue'),
'naam': {
'aanduidingNaamgebruik': (MKSConverter.as_aanduiding_naamgebruik, 'BG:aanduidingNaamgebruik'),
'voorletters': 'BG:voorletters',
'geslachtsnaam': 'BG:geslachtsnaam',
'voorvoegsel': 'BG:voorvoegselGeslachtsnaam',
}
},
'partners': ['BG:inp.heeftAlsEchtgenootPartner', {
'naam': {
'geslachtsnaam': 'BG:gerelateerde BG:geslachtsnaam',
'voorvoegsel': 'BG:gerelateerde BG:voorvoegselGeslachtsnaam',
},
'aangaanHuwelijkPartnerschap': {
'datum': (MKSConverter.as_datum_broken_down, 'BG:datumSluiting')
},
'ontbindingHuwelijkPartnerschap': {
'datum': (MKSConverter.as_datum_broken_down, 'BG:datumOntbinding')
}
}]
}
nationaliteit_parameters = {
'aanduidingBijzonderNederlanderschap': (MKSConverter.as_aanduiding_bijzonder_nederlanderschap,
'BG:inp.aanduidingBijzonderNederlanderschap'),
'nationaliteiten': ['BG:inp.heeftAlsNationaliteit', {
'datumIngangGeldigheid': (MKSConverter.as_datum_broken_down,
'BG:inp.datumVerkrijging',
'BG:inp.datumVerkrijging@StUF:indOnvolledigeDatum'),
'datumVerlies': 'BG:inp.datumVerlies',
'nationaliteit': {
'code': (MKSConverter.as_code(4), 'BG:gerelateerde BG:code'),
'omschrijving': 'BG:gerelateerde BG:omschrijving',
}
}]
}
return {
'geslachtsaanduiding': (MKSConverter.as_geslachtsaanduiding,
'BG:geslachtsaanduiding',
'BG:geslachtsaanduiding@StUF:noValue'),
'naam': {
'aanhef': (MKSConverter.get_aanhef, communicatie_parameters),
'aanschrijfwijze': (MKSConverter.get_aanschrijfwijze, communicatie_parameters),
'aanduidingNaamgebruik': (MKSConverter.as_aanduiding_naamgebruik, 'BG:aanduidingNaamgebruik'),
'voornamen': 'BG:voornamen',
'voorletters': 'BG:voorletters',
'geslachtsnaam': 'BG:geslachtsnaam',
'voorvoegsel': 'BG:voorvoegselGeslachtsnaam',
'adellijkeTitelPredikaat': {
'code': (MKSConverter.get_adellijke_titel_code, 'BG:adellijkeTitelPredikaat'),
'omschrijving': 'BG:adellijkeTitelPredikaat'
}
},
'leeftijd': (MKSConverter.as_leeftijd, 'BG:geboortedatum',
'BG:geboortedatum@StUF:indOnvolledigeDatum',
'BG:overlijdensdatum'),
'burgerservicenummer': 'BG:inp.bsn',
'geheimhoudingPersoonsgegevens':
(MKSConverter.true_if_in(['1', '2', '3', '4', '5', '6', '7']), 'BG:inp.indicatieGeheim'),
'geboorte': {
'datum': (
MKSConverter.as_datum_broken_down,
'BG:geboortedatum',
'BG:geboortedatum@StUF:indOnvolledigeDatum'
),
'land': {
'code': (MKSConverter.as_code(4), 'BG:inp.geboorteLand'),
'omschrijving': (MKSConverter.get_land_omschrijving, 'BG:inp.geboorteLand'),
},
'plaats': {
'code': (MKSConverter.as_gemeente_code, 'BG:inp.geboorteplaats'),
'omschrijving': (MKSConverter.get_gemeente_omschrijving, 'BG:inp.geboorteplaats'),
},
},
'verblijfplaats': {
'datumInschrijvingInGemeente': (MKSConverter.as_datum_broken_down, 'BG:inp.datumInschrijving'),
'gemeenteVanInschrijving': {
'code': (MKSConverter.as_gemeente_code, 'BG:inp.gemeenteVanInschrijving'),
'omschrijving': (MKSConverter.get_gemeente_omschrijving, 'BG:inp.gemeenteVanInschrijving')
},
'datumVestigingInNederland':
(MKSConverter.as_datum_broken_down, 'BG:inp.datumVestigingInNederland',
'BG:inp.datumVestigingInNederland@StUF:indOnvolledigeDatum'),
'indicatieVestigingVanuitBuitenland':
(MKSConverter.true_if_exists, 'BG:inp.datumVestigingInNederland'),
'vanuitVertrokkenOnbekendWaarheen':
(MKSConverter.true_if_equals('0000'), (MKSConverter.as_code(4), 'BG:inp.immigratieLand')),
'landVanwaarIngeschreven': {
'code': (MKSConverter.as_code(4), 'BG:inp.immigratieLand'),
'omschrijving': (MKSConverter.get_land_omschrijving, 'BG:inp.immigratieLand')
},
'woonadres': {
'identificatiecodeNummeraanduiding': 'BG:verblijfsadres BG:aoa.identificatie',
'identificatiecodeAdresseerbaarObject':
'BG:inp.verblijftIn BG:gerelateerde StUF:extraElementen' +
'!.//StUF:extraElement[@naam="identificatie"]',
'naamOpenbareRuimte': 'BG:verblijfsadres BG:gor.openbareRuimteNaam',
'huisletter': 'BG:verblijfsadres BG:aoa.huisletter',
'huisnummer': 'BG:verblijfsadres BG:aoa.huisnummer',
'huisnummertoevoeging': 'BG:verblijfsadres BG:aoa.huisnummertoevoeging',
'postcode': 'BG:verblijfsadres BG:aoa.postcode',
'woonplaatsnaam': 'BG:verblijfsadres BG:wpl.woonplaatsNaam',
'locatiebeschrijving': 'BG:verblijfsadres BG:inp.locatiebeschrijving',
'straatnaam': 'BG:verblijfsadres BG:gor.straatnaam',
'datumAanvangAdreshouding':
(MKSConverter.as_datum_broken_down, 'BG:verblijfsadres BG:begindatumVerblijf'),
},
'briefadres': {
'identificatiecodeNummeraanduiding': 'BG:sub.correspondentieAdres BG:aoa.identificatie',
'huisletter': 'BG:sub.correspondentieAdres BG:aoa.huisletter',
'huisnummer': 'BG:sub.correspondentieAdres BG:aoa.huisnummer',
'huisnummertoevoeging': 'BG:sub.correspondentieAdres BG:aoa.huisnummertoevoeging',
'postcode': 'BG:sub.correspondentieAdres BG:postcode',
'woonplaatsnaam': 'BG:sub.correspondentieAdres BG:wpl.woonplaatsNaam',
'locatiebeschrijving': 'BG:sub.correspondentieAdres BG:inp.locatiebeschrijving',
'straatnaam': 'BG:sub.correspondentieAdres BG:gor.straatnaam',
'naamOpenbareRuimte': 'BG:sub.correspondentieAdres BG:gor.openbareRuimteNaam',
},
'verblijfBuitenland': (MKSConverter.get_verblijf_buitenland, {
'adresRegel1': 'BG:sub.verblijfBuitenland BG:sub.adresBuitenland1',
'adresRegel2': 'BG:sub.verblijfBuitenland BG:sub.adresBuitenland2',
'adresRegel3': 'BG:sub.verblijfBuitenland BG:sub.adresBuitenland3',
'land': {
'code':
(MKSConverter.as_code(4), 'BG:sub.verblijfBuitenland BG:lnd.landcode'),
# Find omschrijving from codetabel like we do with geboorteland, although MKS does return the
# 'landnaam' in this case (as opposed to geboorteland for example). Just for consistency sake
'omschrijving':
(MKSConverter.get_land_omschrijving, 'BG:sub.verblijfBuitenland BG:lnd.landcode'),
},
})
},
'overlijden': {
'indicatieOverleden': (MKSConverter.true_if_exists, 'BG:overlijdensdatum'),
'datum': (
MKSConverter.as_datum_broken_down,
'BG:overlijdensdatum',
'BG:overlijdensdatum@StUF:indOnvolledigeDatum'
),
'land': {
'code': (MKSConverter.as_code(4), 'BG:inp.overlijdenLand'),
'omschrijving': (MKSConverter.get_land_omschrijving, 'BG:inp.overlijdenLand')
},
'plaats': {
'code': (MKSConverter.as_gemeente_code, 'BG:inp.overlijdenplaats'),
'omschrijving': (MKSConverter.get_gemeente_omschrijving, 'BG:inp.overlijdenplaats')
}
},
'nationaliteiten': (MKSConverter.get_nationaliteit, nationaliteit_parameters)
}
def test_yyyy(self):
self.assertEqual(MKSConverter._yyyy("20200422"), "2020")
self.assertEqual(MKSConverter._yyyy("202004221"), None)
def test_as_datum(self):
self.assertEqual(MKSConverter.as_datum("20200422"), "2020-04-22")
self.assertEqual(MKSConverter.as_datum("202004221"), None)
def test_as_leeftijd(self, mock_today):
mock_today.return_value = datetime.date(2020, 4, 22)
self.assertEqual(MKSConverter.as_leeftijd("20200422"), 0)
self.assertEqual(MKSConverter.as_leeftijd("20190423"), 0)
self.assertEqual(MKSConverter.as_leeftijd("20190422"), 1)
self.assertEqual(MKSConverter.as_leeftijd("20190421"), 1)
# https://github.com/VNG-Realisatie/Haal-Centraal-BRP-bevragen/blob/master/features/leeftijd_bepaling.feature
# Volledig geboortedatum
birthday = "19830526"
mock_today.return_value = datetime.date(2019, 5, 26)
self.assertEqual(MKSConverter.as_leeftijd(birthday), 36)
mock_today.return_value = datetime.date(2019, 11, 30)
self.assertEqual(MKSConverter.as_leeftijd(birthday), 36)
mock_today.return_value = datetime.date(2019, 1, 1)
self.assertEqual(MKSConverter.as_leeftijd(birthday), 35)
# Jaar en maand van geboorte datum zijn bekend
birthday = "19830515"
mock_today.return_value = datetime.date(2019, 5, 31)
self.assertEqual(
MKSConverter.as_leeftijd(birthday, ind_onvolledige_datum='D'),
None)
mock_today.return_value = datetime.date(2019, 6, 1)
self.assertEqual(
MKSConverter.as_leeftijd(birthday, ind_onvolledige_datum='D'), 36)
mock_today.return_value = datetime.date(2019, 4, 30)
self.assertEqual(
MKSConverter.as_leeftijd(birthday, ind_onvolledige_datum='D'), 35)
# Alleen jaar van geboorte datum is bekend
birthday = "19830515"
mock_today.return_value = datetime.date(2019, 5, 31)
self.assertEqual(
MKSConverter.as_leeftijd(birthday, ind_onvolledige_datum='M'),
None)
# Persoon is overleden
birthday = "19830526"
mock_today.return_value = datetime.date(2019, 5, 26)
self.assertEqual(
MKSConverter.as_leeftijd(birthday, overlijdensdatum="20000101"),
None)
# Volledig onbekend geboortedatum
birthday = "19830526"
mock_today.return_value = datetime.date(2019, 5, 26)
self.assertEqual(
MKSConverter.as_leeftijd(birthday, ind_onvolledige_datum='J2'),
None)
self.assertEqual(MKSConverter.as_leeftijd(None), None)
# Geboren op 29 februari in een schrikkeljaar
birthday = "19960229"
mock_today.return_value = datetime.date(2016, 2, 29)
self.assertEqual(MKSConverter.as_leeftijd(birthday), 20)
mock_today.return_value = datetime.date(2017, 2, 28)
self.assertEqual(MKSConverter.as_leeftijd(birthday), 20)
mock_today.return_value = datetime.date(2017, 3, 1)
self.assertEqual(MKSConverter.as_leeftijd(birthday), 21)
def test_mm(self):
self.assertEqual(MKSConverter._mm("20200422"), "04")
self.assertEqual(MKSConverter._mm("202004221"), None)
def test_true_if_exists(self):
self.assertTrue(MKSConverter.true_if_exists('anything'))
self.assertIsNone(MKSConverter.true_if_exists(None))
def test_get_land_omschrijving(self, mock_code_resolver):
mock_code_resolver.get_land.return_value = 'any omschrijving'
self.assertEqual(MKSConverter.get_land_omschrijving("any land"),
'any omschrijving')
def test_dd(self):
self.assertEqual(MKSConverter._dd("20200422"), "22")
self.assertEqual(MKSConverter._dd("202004221"), None)