def test_privatize_person_should_privatize_if_private(self):
source_file = File('F0', __file__)
source = Source('The Source')
source.files.append(source_file)
citation_file = File('F1', __file__)
citation = Citation('C0', source)
citation.files.append(citation_file)
event_as_subject = Event(None, Birth())
event_as_attendee = Event(None, Marriage())
person_file = File('F2', __file__)
person = Person('P0')
person.private = True
person.citations.append(citation)
person.files.append(person_file)
Presence(person, Subject(), event_as_subject)
Presence(person, Attendee(), event_as_attendee)
ancestry = Ancestry()
ancestry.entities.append(person)
privatize(ancestry)
self.assertTrue(person.private)
self.assertTrue(citation.private)
self.assertTrue(source.private)
self.assertTrue(person_file.private)
self.assertTrue(citation_file.private)
self.assertTrue(source_file.private)
self.assertTrue(event_as_subject.private)
self.assertIsNone(event_as_attendee.private)
async def test_private(self):
person = Person('P0')
person.private = True
expected = '<div class="meta person-meta"><p>This person\'s details are unavailable to protect their privacy.</p></div>'
async with self._render(data={
'person': person,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_private(self):
person = Person('P0')
person.private = True
expected = '<a href="/person/P0/index.html"><span class="private" title="This person\'s details are unavailable to protect their privacy.">private</span></a>'
async with self._render(data={
'person': person,
}) as (actual, _):
self.assertEqual(expected, actual)
def test_with_private_person_should_anonymize(self,
m_anonymize_person) -> None:
person = Person('P0')
person.private = True
ancestry = Ancestry()
ancestry.entities.append(person)
anonymize(ancestry, AnonymousCitation(AnonymousSource()))
m_anonymize_person.assert_called_once_with(person)
def test_children(self) -> None:
sut = Person('1')
child = Person('2')
sut.children.append(child)
self.assertCountEqual([child], sut.children)
self.assertCountEqual([sut], child.parents)
sut.children.remove(child)
self.assertCountEqual([], sut.children)
self.assertCountEqual([], child.parents)
def test_parents(self) -> None:
sut = Person('1')
parent = Person('2')
sut.parents.append(parent)
self.assertCountEqual([parent], sut.parents)
self.assertCountEqual([sut], parent.children)
sut.parents.remove(parent)
self.assertCountEqual([], sut.parents)
self.assertCountEqual([], parent.children)
async def test_with_subjects(self):
event = Event(None, Birth())
Presence(Person('P0'), Subject(), event)
Presence(Person('P1'), Subject(), event)
expected = 'Birth of <a href="/person/P0/index.html"><span class="nn" title="This person\'s name is unknown.">n.n.</span></a>, <a href="/person/P1/index.html"><span class="nn" title="This person\'s name is unknown.">n.n.</span></a>'
async with self._render(data={
'event': event,
}) as (actual, _):
self.assertEqual(expected, actual)
def test_privatize_person_without_relatives(self, expected, private,
event: Optional[Event]):
person = Person('P0')
person.private = private
if event is not None:
Presence(person, Subject(), event)
ancestry = Ancestry()
ancestry.entities.append(person)
privatize(ancestry)
self.assertEquals(expected, person.private)
def test_clean_should_not_clean_person_if_public(self):
ancestry = Ancestry()
person = Person('P0')
person.private = False
ancestry.entities.append(person)
clean(ancestry)
self.assertEqual(person, ancestry.entities[Person][person.id])
def test_privatize_person_with_child(self, expected, private,
event: Optional[Event]):
person = Person('P0')
person.private = private
child = Person('P1')
if event is not None:
Presence(child, Subject(), event)
person.children.append(child)
ancestry = Ancestry()
ancestry.entities.append(person)
privatize(ancestry)
self.assertEquals(expected, person.private)
async def test_post_parse(self) -> None:
person = Person('P0')
person.private = True
PersonName(person, 'Jane', 'Dough')
with TemporaryDirectory() as output_directory_path:
configuration = Configuration(output_directory_path,
'https://example.com')
configuration.extensions.add(ExtensionConfiguration(Anonymizer))
async with App(configuration) as app:
app.ancestry.entities.append(person)
await load(app)
self.assertEquals(0, len(person.names))
async def test_with_person_context_and_other_as_subject(self):
event = Event(None, Marriage())
person = Person('P0')
other_person = Person('P1')
Presence(person, Subject(), event)
Presence(other_person, Subject(), event)
expected = 'Marriage with <a href="/person/P1/index.html"><span class="nn" title="This person\'s name is unknown.">n.n.</span></a>'
async with self._render(data={
'event': event,
'person_context': person,
}) as (actual, _):
self.assertEqual(expected, actual)
def test_privatize_person_with_grandparent(self, expected, private,
event: Optional[Event]):
person = Person('P0')
person.private = private
parent = Person('P1')
person.parents.append(parent)
grandparent = Person('P2')
if event is not None:
Presence(grandparent, Subject(), event)
parent.parents.append(grandparent)
ancestry = Ancestry()
ancestry.entities.append(person)
privatize(ancestry)
self.assertEquals(expected, person.private)
def test_should_not_remove_parents_with_public_descendants(self) -> None:
person = Person('P0')
person.private = True
child = Person('P1')
child.private = False
person.children.append(child)
parent = Person('P2')
parent.private = True
person.parents.append(parent)
anonymize_person(person)
self.assertCountEqual([parent], person.parents)
def _load_person(loader: _Loader, element: ElementTree.Element):
person_handle = element.get('handle')
person = Person(element.get('id'))
name_elements = sorted(_xpath(element, './ns:name'),
key=lambda x: x.get('alt') == '1')
names = []
for name_element in name_elements:
is_alternative = name_element.get('alt') == '1'
individual_name_element = _xpath1(name_element, './ns:first')
individual_name = None if individual_name_element is None else individual_name_element.text
surname_elements = [
surname_element
for surname_element in _xpath(name_element, './ns:surname')
if surname_element.text is not None
]
if surname_elements:
for surname_element in surname_elements:
if not is_alternative:
is_alternative = surname_element.get('prim') == '0'
affiliation_name = surname_element.text
surname_prefix = surname_element.get('prefix')
if surname_prefix is not None:
affiliation_name = '%s %s' % (surname_prefix,
affiliation_name)
person_name = PersonName(None, individual_name,
affiliation_name)
_load_citationref(loader, person_name, name_element)
names.append((person_name, is_alternative))
elif individual_name is not None:
person_name = PersonName(None, individual_name)
_load_citationref(loader, person_name, name_element)
names.append((person_name, is_alternative))
for person_name, _ in sorted(names, key=lambda x: x[1]):
loader.add_entity(person_name)
loader.add_association(Person, person_handle, 'names', PersonName,
person_name.id)
_load_eventrefs(loader, person_handle, element)
if element.get('priv') == '1':
person.private = True
flattened_person = FlattenedEntity(person, person_handle)
_load_citationref(loader, flattened_person, element)
_load_objref(loader, flattened_person, element)
_load_urls(person, element)
_load_attribute_privacy(person, element, 'attribute')
loader.add_entity(flattened_person)
def test_should_remove_presences(self) -> None:
person = Person('P0')
event = Event(None, Birth())
Presence(person, Subject(), event)
anonymize_person(person)
self.assertEquals(0, len(person.presences))
self.assertEquals(0, len(event.presences))
def test_clean(self) -> None:
ancestry = Ancestry()
onymous_event = Event('E0', Birth())
Presence(Person('P0'), Subject(), onymous_event)
ancestry.entities.append(onymous_event)
anonymous_event = Event('E1', Birth())
ancestry.entities.append(anonymous_event)
onymous_place = Place('P0', [PlaceName('Amsterdam')])
onymous_place.events.append(onymous_event)
ancestry.entities.append(onymous_place)
anonymous_place = Place('P1', [PlaceName('Almelo')])
ancestry.entities.append(anonymous_place)
onmyous_place_because_encloses_onmyous_places = Place(
'P3', [PlaceName('Netherlands')])
Enclosure(onymous_place, onmyous_place_because_encloses_onmyous_places)
Enclosure(anonymous_place,
onmyous_place_because_encloses_onmyous_places)
ancestry.entities.append(onmyous_place_because_encloses_onmyous_places)
clean(ancestry)
self.assertEquals([onymous_event], list(ancestry.entities[Event]))
self.assertEquals(
[onymous_place, onmyous_place_because_encloses_onmyous_places],
list(ancestry.entities[Place]))
self.assertNotIn(
anonymous_place,
onmyous_place_because_encloses_onmyous_places.encloses)
async def test_without_meta(self):
person = Person('P0')
expected = '<div class="meta person-meta"></div>'
async with self._render(data={
'person': person,
}) as (actual, _):
self.assertEqual(expected, actual)
def test_should_remove_citations(self) -> None:
person = Person('P0')
source = Source('The Source')
citation = Citation(None, source)
person.citations.append(citation)
anonymize_person(person)
self.assertEquals(0, len(person.citations))
async def test_post_load(self):
person = Person('P0')
Presence(person, Subject(), Event(None, Birth()))
source_file = File('F0', __file__)
source = Source('S0', 'The Source')
source.private = True
source.files.append(source_file)
citation_file = File('F0', __file__)
citation_source = Source('The Source')
citation = Citation('C0', citation_source)
citation.private = True
citation.files.append(citation_file)
with TemporaryDirectory() as output_directory_path:
configuration = Configuration(output_directory_path,
'https://example.com')
configuration.extensions.add(ExtensionConfiguration(Privatizer))
async with App(configuration) as app:
app.ancestry.entities.append(person)
app.ancestry.entities.append(source)
app.ancestry.entities.append(citation)
await load(app)
self.assertTrue(person.private)
self.assertTrue(source_file.private)
self.assertTrue(citation_file.private)
def test_clean_should_not_clean_event_with_presences_with_people(
self) -> None:
ancestry = Ancestry()
source = Source('S1', 'The Source')
ancestry.entities.append(source)
citation = Citation('C1', source)
ancestry.entities.append(citation)
file = File('F1', __file__)
ancestry.entities.append(file)
place = Place('P0', [PlaceName('The Place')])
ancestry.entities.append(place)
person = Person('P0')
event = Event('E0', Birth())
event.citations.append(citation)
event.files.append(file)
event.place = place
ancestry.entities.append(event)
Presence(person, Subject(), event)
clean(ancestry)
self.assertEqual(event, ancestry.entities[Event][event.id])
self.assertIn(event, place.events)
self.assertEqual(place, ancestry.entities[Place][place.id])
self.assertIn(event, citation.facts)
self.assertEqual(citation, ancestry.entities[Citation][citation.id])
self.assertIn(event, file.entities)
self.assertEqual(file, ancestry.entities[File][file.id])
async def test_without_name(self):
person = Person('P0')
expected = '<a href="/person/P0/index.html"><span class="nn" title="This person\'s name is unknown.">n.n.</span></a>'
async with self._render(data={
'person': person,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_with_name(self):
person = Person('P0')
PersonName(person, 'Jane', 'Dough')
expected = '<a href="/person/P0/index.html"><span class="person-label" typeof="foaf:Person"><span property="foaf:individualName">Jane</span> <span property="foaf:familyName">Dough</span></span></a>'
async with self._render(data={
'person': person,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_with_end(self):
person = Person('P0')
Presence(person, Subject(), Event(None, Death(), Date(1970)))
expected = '<div class="meta person-meta"><dl><div><dt>Death</dt><dd>1970</dd></div></dl></div>'
async with self._render(data={
'person': person,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_person_is_context(self):
person = Person('P0')
expected = '<span class="nn" title="This person\'s name is unknown.">n.n.</span>'
async with self._render(data={
'person': person,
'person_context': person,
}) as (actual, _):
self.assertEqual(expected, actual)
def test_names(self) -> None:
sut = Person('1')
name = PersonName(sut, 'Janet', 'Not a Girl')
self.assertCountEqual([name], sut.names)
self.assertEquals(sut, name.person)
sut.names.remove(name)
self.assertCountEqual([], sut.names)
self.assertIsNone(name.person)
async def test_with_affiliation_name(self):
person = Person(None)
name = PersonName(person, None, 'Dough')
expected = '<span class="person-label" typeof="foaf:Person">… <span property="foaf:familyName">Dough</span></span>'
async with self._render(data={
'name': name,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_with_full_name(self):
person = Person(None)
name = PersonName(person, 'Jane', 'Dough')
expected = '<span class="person-label" typeof="foaf:Person"><span property="foaf:individualName">Jane</span> <span property="foaf:familyName">Dough</span></span>'
async with self._render(data={
'name': name,
}) as (actual, _):
self.assertEqual(expected, actual)
def test_person(self) -> None:
person = Person('1')
sut = PersonName(person, 'Janet', 'Not a Girl')
self.assertEquals(person, sut.person)
self.assertCountEqual([sut], person.names)
sut.person = None
self.assertIsNone(sut.person)
self.assertCountEqual([], person.names)
async def test_with_witnesses(self):
event = Event(None, Birth())
Presence(Person('P0'), Witness(), event)
expected = 'Birth'
async with self._render(data={
'event': event,
}) as (actual, _):
self.assertEqual(expected, actual)