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_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)
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)
async def test_with_resource(self):
event = Event(Birth())
expected = 'Birth'
async with self._render(data={
'resource': event,
}) as (actual, _):
self.assertEqual(expected, actual)
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_should_remove_citations(self) -> None:
event = Event(Event.Type.BIRTH)
source = Source('S0', 'The Source')
citation = Citation('C0', source)
event.citations.append(citation)
anonymize_event(event)
self.assertEquals(0, len(event.citations))
class DelegatingUrlGeneratorTest(TestCase):
@parameterized.expand([
('/index.html', '/index.html'),
('/index.html', '<front>'),
('/person/index.html', '<person>'),
('/person/P1/index.html', Person('P1')),
('/event/index.html', '<event>'),
('/event/E1/index.html', Event('E1', Event.Type.DEATH)),
('/place/index.html', '<place>'),
('/place/P1/index.html', Place('P1', 'Place 1')),
('/file/index.html', '<file>'),
('/file/F1/index.html', File('F1', '/tmp')),
('/source/index.html', '<source>'),
('/source/S1/index.html', Source('S1', 'Source 1')),
('/citation/index.html', '<citation>'),
('/citation/C1/index.html', Citation('C1')),
])
def test_generate(self, expected: str, resource: Any):
configuration = Configuration('/tmp', 'https://example.com')
sut = DelegatingUrlGenerator(configuration)
self.assertEquals(expected, sut.generate(resource))
def test_generate_with_invalid_value(self):
configuration = Configuration('/tmp', 'https://example.com')
sut = DelegatingUrlGenerator(configuration)
with self.assertRaises(ValueError):
sut.generate(9)
def test_should_remove_citations(self) -> None:
event = Event(Birth())
source = Source('The Source')
citation = Citation(source)
event.citations.append(citation)
anonymize_event(event)
self.assertEquals(0, len(event.citations))
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))
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_minimal(self):
event = Event(Birth())
expected = 'Birth'
async with self._render(data={
'event': event,
}) as (actual, _):
self.assertEqual(expected, actual)
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 setUpClass(cls):
cls._outputDirectory = TemporaryDirectory()
configuration = Configuration(cls._outputDirectory.name,
'https://ancestry.example.com')
cls.site = Site(configuration)
place1 = Place('PLACE1', 'one')
event1 = Event('EVENT1', Event.Type.BIRTH)
event1.place = place1
event1_person_1_presence = Presence(Presence.Role.SUBJECT)
event1_person_1_presence.event = event1
person1 = Person('PERSON1', 'Janet', 'Dough')
person1.presences.add(event1_person_1_presence)
source1 = Source('SOURCE1', 'A Little Birdie')
places = [place1]
cls.site.ancestry.places.update({place.id: place for place in places})
events = [event1]
cls.site.ancestry.events.update({event.id: event for event in events})
people = [person1]
cls.site.ancestry.people.update(
{person.id: person
for person in people})
sources = [source1]
cls.site.ancestry.sources.update(
{source.id: source
for source in sources})
render(cls.site)
async def test_with_place(self):
event = Event(Birth())
event.place = Place('P0', [PlaceName('The Place')])
expected = 'in <address><a href="/place/P0/index.html"><span>The Place</span></a></address>'
async with self._render(data={
'event': event,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_with_date(self):
event = Event(Birth())
event.date = Date(1970)
expected = '1970'
async with self._render(data={
'event': event,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_with_citation(self):
event = Event(Birth())
event.citations.append(Citation(Source('The Source')))
expected = '<a href="#reference-1" class="citation">[1]</a>'
async with self._render(data={
'event': event,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_with_description(self):
event = Event(Birth())
event.description = 'Something happened!'
expected = 'Birth (Something happened!)'
async with self._render(data={
'event': event,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_with_witnesses(self):
event = Event(Birth())
Presence(Person('P0'), Witness(), event)
expected = 'Birth'
async with self._render(data={
'event': event,
}) as (actual, _):
self.assertEqual(expected, actual)
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)
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)
def test_place(self) -> None:
place = Place('1', [PlaceName('one')])
sut = Event(Mock(EventType))
sut.place = place
self.assertEquals(place, sut.place)
self.assertIn(sut, place.events)
sut.place = None
self.assertEquals(None, sut.place)
self.assertNotIn(sut, place.events)
def test_events_should_sync_references(self):
sut = Place('1', 'one')
event = Event('1', Event.Type.BIRTH)
sut.events.add(event)
self.assertIn(event, sut.events)
self.assertEquals(sut, event.place)
sut.events.remove(event)
self.assertCountEqual([], sut.events)
self.assertEquals(None, event.place)
def test_place_should_sync_references(self):
place = Place('1', 'one')
sut = Event('1', Event.Type.BIRTH)
sut.place = place
self.assertEquals(place, sut.place)
self.assertIn(sut, place.events)
sut.place = None
self.assertEquals(None, sut.place)
self.assertNotIn(sut, place.events)
def test_presence_should_sync_references(self):
presence = Presence(Presence.Role.SUBJECT)
sut = Event('1', Event.Type.BIRTH)
sut.presences.add(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_clean(self):
ancestry = Ancestry()
onymous_event = Event('E0', Event.Type.BIRTH)
onymous_event_presence = Presence(Presence.Role.SUBJECT)
onymous_event_presence.person = Person('P0')
onymous_event.presences.add(onymous_event_presence)
ancestry.events[onymous_event.id] = onymous_event
anonymous_event = Event('E1', Event.Type.BIRTH)
ancestry.events[anonymous_event.id] = anonymous_event
onymous_place = Place('P0', 'Amsterdam')
onymous_place.events.add(onymous_event)
ancestry.places[onymous_place.id] = onymous_place
anonymous_place = Place('P1', 'Almelo')
ancestry.places[anonymous_place.id] = anonymous_place
onmyous_place_because_encloses_onmyous_places = Place(
'P3', 'Netherlands')
onmyous_place_because_encloses_onmyous_places.encloses.add(
onymous_place)
onmyous_place_because_encloses_onmyous_places.encloses.add(
anonymous_place)
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)
async def test_with_place_is_place_context(self):
event = Event(Birth())
place = Place('P0', [PlaceName('The Place')])
event.place = place
expected = ''
async with self._render(data={
'event': event,
'place_context': place,
}) as (actual, _):
self.assertEqual(expected, actual)
def test_presence_should_sync_references(self):
event = Event(Event.Type.BIRTH)
sut = Person('1')
presence = Presence(sut, Presence.Role.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_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)
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)