async def test_with_subjects(self):
event = Event(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)
async def test_with_person_context_and_other_as_subject(self):
event = Event(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)
async def test_derive_update_derivable_event_without_reference_events(
self, event_type_type: Type[DerivableEventType]):
person = Person('P0')
Presence(person, Subject(), Event(Ignored()))
derivable_event = Event(event_type_type())
Presence(person, Subject(), derivable_event)
created, updated = derive(person, event_type_type)
self.assertEquals(0, created)
self.assertEquals(0, updated)
self.assertEquals(2, len(person.presences))
self.assertIsNone(derivable_event.date)
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)
privatize_person(person, 125)
self.assertEquals(expected, person.private)
def test_privatize_person_should_not_privatize_if_public(self):
source_file = File('F0', __file__)
source = Source('The Source')
source.files.append(source_file)
citation_file = File('F1', __file__)
citation = IdentifiableCitation('C0', source)
citation.files.append(citation_file)
event_as_subject = Event(Birth())
event_as_attendee = Event(Marriage())
person_file = File('F2', __file__)
person = Person('P0')
person.private = False
person.citations.append(citation)
person.files.append(person_file)
Presence(person, Subject(), event_as_subject)
Presence(person, Attendee(), event_as_attendee)
ancestry = Ancestry()
ancestry.people[person.id] = person
privatize(ancestry)
self.assertEqual(False, person.private)
self.assertIsNone(citation.private)
self.assertIsNone(source.private)
self.assertIsNone(person_file.private)
self.assertIsNone(citation_file.private)
self.assertIsNone(source_file.private)
self.assertIsNone(event_as_subject.private)
self.assertIsNone(event_as_attendee.private)
def test_clean_should_not_clean_event_with_presences_with_people(
self) -> None:
ancestry = Ancestry()
source = IdentifiableSource('S1', 'The Source')
ancestry.sources[source.id] = source
citation = IdentifiableCitation('C1', source)
ancestry.citations[citation.id] = citation
file = File('F1', __file__)
ancestry.files[file.id] = file
place = Place('P0', [PlaceName('The Place')])
ancestry.places[place.id] = place
person = Person('P0')
event = IdentifiableEvent('E0', Birth())
event.citations.append(citation)
event.files.append(file)
event.place = place
ancestry.events[event.id] = event
Presence(person, Subject(), event)
clean(ancestry)
self.assertEqual(event, ancestry.events[event.id])
self.assertIn(event, place.events)
self.assertEqual(place, ancestry.places[place.id])
self.assertIn(event, citation.facts)
self.assertEqual(citation, ancestry.citations[citation.id])
self.assertIn(event, file.resources)
self.assertEqual(file, ancestry.files[file.id])
async def test_derive_update_comes_after_derivable_event(
self, expected_datey: Optional[Datey],
after_datey: Optional[Datey], derivable_datey: Optional[Datey]):
expected_updates = 0 if expected_datey == derivable_datey else 1
person = Person('P0')
Presence(person, Subject(), Event(Ignored(), Date(0, 0, 0)))
Presence(person, Subject(), Event(ComesAfterReference(), after_datey))
derivable_event = Event(ComesAfterDerivable(), derivable_datey)
Presence(person, Subject(), derivable_event)
created, updated = derive(person, ComesAfterDerivable)
self.assertEquals(expected_datey, derivable_event.date)
self.assertEquals(0, created)
self.assertEquals(expected_updates, updated)
self.assertEquals(3, len(person.presences))
async def test_post_parse(self):
person = Person('P0')
Presence(person, Subject(), Event(Birth()))
source_file = File('F0', __file__)
source = IdentifiableSource('S0', 'The Source')
source.private = True
source.files.append(source_file)
citation_file = File('F0', __file__)
citation_source = Source('The Source')
citation = IdentifiableCitation('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.plugins[Privatizer] = None
async with Site(configuration) as site:
site.ancestry.people[person.id] = person
site.ancestry.sources[source.id] = source
site.ancestry.citations[citation.id] = citation
await parse(site)
self.assertTrue(person.private)
self.assertTrue(source_file.private)
self.assertTrue(citation_file.private)
def test_person_deletion_upon_event_set_to_none(self) -> None:
person = Person('P1')
event = Event(Birth())
sut = Presence(person, Subject(), event)
sut.event = None
self.assertIsNone(sut.person)
self.assertNotIn(sut, person.presences)
def test_should_remove_presences(self) -> None:
person = Person('P0')
event = Event(Birth())
Presence(person, Subject(), event)
anonymize_person(person)
self.assertEquals(0, len(person.presences))
self.assertEquals(0, len(event.presences))
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 = IdentifiableCitation('C0', source)
citation.files.append(citation_file)
event_as_subject = Event(Birth())
event_as_attendee = Event(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)
privatize_person(person, 125)
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)
def test_event_should_encode_full(self):
event = IdentifiableEvent('the_event', Birth())
event.date = DateRange(Date(2000, 1, 1), Date(2019, 12, 31))
event.place = Place('the_place', [PlaceName('The Place')])
Presence(Person('the_person'), Subject(), event)
event.citations.append(
IdentifiableCitation('the_citation', Source('The Source')))
expected = {
'$schema': '/schema.json#/definitions/event',
'@context': {
'place': 'https://schema.org/location',
},
'@type': 'https://schema.org/Event',
'id': 'the_event',
'type': 'birth',
'presences': [
{
'@context': {
'person': 'https://schema.org/actor',
},
'role': 'subject',
'person': '/en/person/the_person/index.json',
},
],
'citations': [
'/en/citation/the_citation/index.json',
],
'date': {
'start': {
'year': 2000,
'month': 1,
'day': 1,
},
'end': {
'year': 2019,
'month': 12,
'day': 31,
},
},
'place': '/en/place/the_place/index.json',
'links': [
{
'url': '/en/event/the_event/index.json',
'relationship': 'canonical',
'mediaType': 'application/json',
},
{
'url': '/nl/event/the_event/index.json',
'relationship': 'alternate',
'locale': 'nl-NL',
},
{
'url': '/en/event/the_event/index.html',
'relationship': 'alternate',
'mediaType': 'text/html',
},
],
}
self.assert_encodes(expected, event, 'event')
async def test_with_end(self):
person = Person('P0')
Presence(person, Subject(), Event(Death(), Date(1970)))
expected = '<div class="meta"><dl><dt>Death</dt><dd>1970</dd></dl></div>'
async with self._render(data={
'person': person,
}) as (actual, _):
self.assertEqual(expected, actual)
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)
privatize_person(person, 125)
self.assertEquals(expected, person.private)
def test_privatize_person_with_parent(self, expected, private, event: Optional[Event]):
person = Person('P0')
person.private = private
parent = Person('P1')
if event is not None:
Presence(parent, Subject(), event)
person.parents.append(parent)
privatize_person(person, 125)
self.assertEquals(expected, person.private)
async def test_embedded_with_identifiable(self):
event = IdentifiableEvent('E0', Birth())
Presence(Person('P0'), Subject(), event)
expected = 'Birth of <span class="nn" title="This person\'s name is unknown.">n.n.</span>'
async with self._render(data={
'event': event,
'embedded': True,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_with_person_context_as_subject(self):
event = Event(Birth())
person = Person('P0')
Presence(person, Subject(), event)
expected = 'Birth'
async with self._render(data={
'event': event,
'person_context': person,
}) as (actual, _):
self.assertEqual(expected, actual)
def test_presences(self) -> None:
person = Person('P1')
sut = Event(Mock(EventType))
presence = Presence(person, Subject(), sut)
sut.presences.append(presence)
self.assertCountEqual([presence], sut.presences)
self.assertEquals(sut, presence.event)
sut.presences.remove(presence)
self.assertCountEqual([], sut.presences)
self.assertIsNone(presence.event)
def test_presences(self) -> None:
event = Event(Birth())
sut = Person('1')
presence = Presence(sut, Subject(), event)
sut.presences.append(presence)
self.assertCountEqual([presence], sut.presences)
self.assertEquals(sut, presence.person)
sut.presences.remove(presence)
self.assertCountEqual([], sut.presences)
self.assertIsNone(presence.person)
def test_presence_should_sync_references(self):
person = Person('P1')
sut = IdentifiableEvent('1', Birth())
presence = Presence(person, Subject(), sut)
sut.presences.append(presence)
self.assertCountEqual([presence], sut.presences)
self.assertEquals(sut, presence.event)
sut.presences.remove(presence)
self.assertCountEqual([], sut.presences)
self.assertIsNone(presence.event)
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.people[person.id] = person
privatize(ancestry)
self.assertEquals(expected, person.private)
def test_privatize_person_with_parent(self, expected, private,
event: Optional[Event]):
person = Person('P0')
person.private = private
parent = Person('P1')
if event is not None:
Presence(parent, Subject(), event)
person.parents.append(parent)
ancestry = Ancestry()
ancestry.people[person.id] = person
privatize(ancestry)
self.assertEquals(expected, person.private)
async def test_embedded(self):
person = Person('P0')
Presence(person, Subject(), Event(Birth(), Date(1970)))
person.names.append(PersonName('Jane', 'Dough'))
name = PersonName('Janet', 'Doughnut')
name.citations.append(Citation(Source('The Source')))
person.names.append(name)
expected = '<div class="meta"><span class="aka">Also known as <span class="person-label" typeof="foaf:Person"><span property="foaf:individualName">Janet</span> <span property="foaf:familyName">Doughnut</span></span></span><dl><dt>Birth</dt><dd>1970</dd></dl></div>'
async with self._render(data={
'person': person,
'embedded': True,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_derive_create_comes_after_derivable_event(
self, expected_datey: Optional[Datey],
after_datey: Optional[Datey]):
expected_creations = 0 if expected_datey is None else 1
person = Person('P0')
Presence(person, Subject(), Event(Ignored(), Date(0, 0, 0)))
Presence(person, Subject(), Event(ComesAfterReference(), after_datey))
created, updated = derive(person, ComesAfterCreatableDerivable)
derived_presences = [
presence for presence in person.presences
if isinstance(presence.event.type, ComesAfterCreatableDerivable)
]
self.assertEquals(expected_creations, len(derived_presences))
if expected_creations:
derived_presence = derived_presences[0]
self.assertIsInstance(derived_presence.role, Subject)
self.assertEquals(expected_datey, derived_presence.event.date)
self.assertEquals(expected_creations, created)
self.assertEquals(0, updated)
self.assertEquals(2 + expected_creations, len(person.presences))
def test_privatize_person_with_grandchild(self, expected, private,
event: Optional[Event]):
person = Person('P0')
person.private = private
child = Person('P1')
person.children.append(child)
grandchild = Person('P2')
if event is not None:
Presence(grandchild, Subject(), event)
child.children.append(grandchild)
ancestry = Ancestry()
ancestry.people[person.id] = person
privatize(ancestry)
self.assertEquals(expected, person.private)
class TestSubjectRoleTest(TemplateTestCase):
@parameterized.expand([
('true', Subject()),
('false', Subject),
('false', Attendee()),
('false', 9),
])
@sync
async def test(self, expected, data) -> None:
template = '{% if data is subject_role %}true{% else %}false{% endif %}'
async with self._render(template_string=template, data={
'data': data,
}) as (actual, _):
self.assertEquals(expected, actual)
def derive(person: Person,
event_type_type: Type[DerivableEventType]) -> Tuple[int, int]:
# Gather any existing events that could be derived, or create a new derived event if needed.
derivable_events = list(_get_derivable_events(person, event_type_type))
if not derivable_events:
if list(
filter(lambda x: isinstance(x.event.type, event_type_type),
person.presences)):
return 0, 0
if issubclass(event_type_type, CreatableDerivableEventType):
derivable_events = [DerivedEvent(event_type_type())]
else:
return 0, 0
# Aggregate event type order from references and backreferences.
comes_before_event_type_types = event_type_type.comes_before()
comes_after_event_type_types = event_type_type.comes_after()
for other_event_type_type in EVENT_TYPE_TYPES:
if event_type_type in other_event_type_type.comes_before():
comes_after_event_type_types.add(other_event_type_type)
if event_type_type in other_event_type_type.comes_after():
comes_before_event_type_types.add(other_event_type_type)
created_derivations = 0
updated_derivations = 0
for derivable_event in derivable_events:
dates_derived = False
if derivable_event.date is None or derivable_event.date.end is None:
dates_derived = dates_derived or _ComesBeforeDateDeriver.derive(
person, derivable_event, comes_before_event_type_types)
if derivable_event.date is None or derivable_event.date.start is None:
dates_derived = dates_derived or _ComesAfterDateDeriver.derive(
person, derivable_event, comes_after_event_type_types)
if dates_derived:
if isinstance(derivable_event, DerivedEvent):
created_derivations += 1
Presence(person, Subject(), derivable_event)
else:
updated_derivations += 1
return created_derivations, updated_derivations
async def test_post_parse(self):
person = Person('P0')
reference_presence = Presence(person, Subject(), Event(Residence()))
reference_presence.event.date = Date(1970, 1, 1)
with TemporaryDirectory() as output_directory_path:
configuration = Configuration(output_directory_path,
'https://example.com')
configuration.plugins[Deriver] = None
async with Site(configuration) as site:
site.ancestry.people[person.id] = person
await parse(site)
self.assertEquals(3, len(person.presences))
self.assertEquals(
DateRange(None, Date(1970, 1, 1), end_is_boundary=True),
person.start.date)
self.assertEquals(DateRange(Date(1970, 1, 1), start_is_boundary=True),
person.end.date)
def test_associated_files(self) -> None:
file1 = Mock(File)
file2 = Mock(File)
file3 = Mock(File)
file4 = Mock(File)
file5 = Mock(File)
file6 = Mock(File)
sut = Person('1')
sut.files = [file1, file2, file1]
citation = Mock(Citation)
citation.associated_files = [file3, file4, file2]
name = PersonName()
name.citations = [citation]
sut.names = [name]
event = Mock(Event)
event.associated_files = [file5, file6, file4]
Presence(sut, Subject(), event)
self.assertEquals([file1, file2, file3, file4, file5, file6],
list(sut.associated_files))
def test_clean(self) -> None:
ancestry = Ancestry()
onymous_event = IdentifiableEvent('E0', Birth())
Presence(Person('P0'), Subject(), onymous_event)
ancestry.events[onymous_event.id] = onymous_event
anonymous_event = IdentifiableEvent('E1', Birth())
ancestry.events[anonymous_event.id] = anonymous_event
onymous_place = Place('P0', [PlaceName('Amsterdam')])
onymous_place.events.append(onymous_event)
ancestry.places[onymous_place.id] = onymous_place
anonymous_place = Place('P1', [PlaceName('Almelo')])
ancestry.places[anonymous_place.id] = 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.places[onmyous_place_because_encloses_onmyous_places.
id] = onmyous_place_because_encloses_onmyous_places
clean(ancestry)
self.assertDictEqual({
onymous_event.id: onymous_event,
}, ancestry.events)
self.assertDictEqual(
{
onymous_place.id:
onymous_place,
onmyous_place_because_encloses_onmyous_places.id:
onmyous_place_because_encloses_onmyous_places,
}, ancestry.places)
self.assertNotIn(
anonymous_place,
onmyous_place_because_encloses_onmyous_places.encloses)