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)
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_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)
async def test_minimal(self): event = Event(None, Birth()) expected = 'Birth' async with self._render(data={ 'event': event, }) as (actual, _): self.assertEqual(expected, actual)
async def test_with_identifiable(self): event = Event('E0', Birth()) expected = '<a href="/event/E0/index.html">Birth</a>' async with self._render(data={ 'event': event, }) as (actual, _): self.assertEqual(expected, actual)
async def test_event_should_encode_minimal(self): event = Event('the_event', Birth()) expected = { '$schema': '/schema.json#/definitions/event', '@type': 'https://schema.org/Event', 'id': 'the_event', 'type': 'birth', 'presences': [], 'citations': [], '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', }, ], } await self.assert_encodes(expected, event, 'event')
def test_should_remove_citations(self) -> None: event = Event(None, Birth()) source = Source(None, 'The Source') citation = Citation(None, 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(None, Birth()) Presence(person, Subject(), event) anonymize_person(person) self.assertEquals(0, len(person.presences)) self.assertEquals(0, len(event.presences))
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_citation_should_encode_full(self): citation = Citation('the_citation', Source('the_source', 'The Source')) citation.description = 'The Source Description' citation.facts.append(Event('the_event', Birth())) expected = { '$schema': '/schema.json#/definitions/citation', '@type': 'https://schema.org/Thing', 'id': 'the_citation', 'source': '/en/source/the_source/index.json', 'facts': ['/en/event/the_event/index.json'], 'links': [ { 'url': '/en/citation/the_citation/index.json', 'relationship': 'canonical', 'mediaType': 'application/json', }, { 'url': '/nl/citation/the_citation/index.json', 'relationship': 'alternate', 'locale': 'nl-NL', }, { 'url': '/en/citation/the_citation/index.html', 'relationship': 'alternate', 'mediaType': 'text/html', }, ], } await self.assert_encodes(expected, citation, 'citation')
def test_clean_should_clean_event(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) event = Event('E0', Birth()) event.citations.append(citation) event.files.append(file) event.place = place ancestry.entities.append(event) clean(ancestry) self.assertNotIn(event.id, ancestry.entities[Event]) self.assertIsNone(event.place) self.assertNotIn(event, place.events) self.assertNotIn(place.id, ancestry.entities[Place]) self.assertNotIn(event, citation.facts) self.assertNotIn(citation.id, ancestry.entities[Citation]) self.assertNotIn(event, file.entities) self.assertNotIn(file.id, ancestry.entities[File])
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)
async def test_with_citation(self): event = Event(None, Birth()) event.citations.append(Citation(None, Source(None, '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_date(self): event = Event(None, Birth()) event.date = Date(1970) expected = '1970' async with self._render(data={ 'event': event, }) as (actual, _): self.assertEqual(expected, actual)
def test_with_private_event_should_anonymize(self, m_anonymize_event) -> None: event = Event('E0', Birth()) event.private = True ancestry = Ancestry() ancestry.entities.append(event) anonymize(ancestry, AnonymousCitation(AnonymousSource())) m_anonymize_event.assert_called_once_with(event)
async def test_with_start(self): person = Person('P0') Presence(person, Subject(), Event(None, Birth(), Date(1970))) expected = '<div class="meta person-meta"><dl><div><dt>Birth</dt><dd>1970</dd></div></dl></div>' async with self._render(data={ 'person': person, }) as (actual, _): self.assertEqual(expected, actual)
async def test_with_place(self): event = Event(None, 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_description(self): event = Event(None, Birth()) event.description = 'Something happened!' expected = 'Birth (Something happened!)' async with self._render(data={ 'event': event, }) as (actual, _): self.assertEqual(expected, actual)
def test_events(self) -> None: sut = Place('P1', [PlaceName('The Place')]) event = Event('1', Birth()) sut.events.append(event) self.assertIn(event, sut.events) self.assertEquals(sut, event.place) sut.events.remove(event) self.assertCountEqual([], sut.events) self.assertEquals(None, event.place)
async def test_embedded_with_identifiable(self): event = Event('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_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)
async def test_with_place_is_place_context(self): event = Event(None, 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)
async def test_post_parse(self) -> None: event = Event('E0', Birth()) with TemporaryDirectory() as output_directory_path: configuration = Configuration(output_directory_path, 'https://example.com') configuration.extensions.add(ExtensionConfiguration(Cleaner)) async with App(configuration) as app: app.ancestry.entities.append(event) await load(app) self.assertEquals([], list(app.ancestry.entities[Event]))
async def test_with_person_context_as_subject(self): event = Event(None, 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)
async def test_event(self): configuration = Configuration(self._output_directory.name, 'https://ancestry.example.com') app = App(configuration) async with app: event = Event('EVENT1', Birth()) app.ancestry.entities.append(event) await generate(app) self.assert_betty_html(app, '/event/%s/index.html' % event.id) self.assert_betty_json(app, '/event/%s/index.json' % event.id, 'event')
def test_presences(self) -> None: event = Event(None, 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_embedded(self): event = Event(None, Birth()) event.date = Date(1970) event.place = Place('P0', [PlaceName('The Place')]) event.citations.append(Citation(None, Source(None, 'The Source'))) expected = '1970 in <address><span>The Place</span></address>' async with self._render(data={ 'event': event, 'embedded': True, }) as (actual, _): self.assertEqual(expected, actual)
async def test_embedded(self): person = Person('P0') Presence(person, Subject(), Event(None, Birth(), Date(1970))) PersonName(person, 'Jane', 'Dough') name = PersonName(person, 'Janet', 'Doughnut') name.citations.append(Citation(None, Source(None, 'The Source'))) expected = '<div class="meta person-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><div><dt>Birth</dt><dd>1970</dd></div></dl></div>' async with self._render(data={ 'person': person, 'embedded': True, }) as (actual, _): self.assertEqual(expected, actual)
def test_privatize_event_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_file = File('F1', __file__) event = Event('E1', Birth()) event.private = True event.citations.append(citation) event.files.append(event_file) person = Person('P0') Presence(person, Subject(), event) ancestry = Ancestry() ancestry.entities.append(event) privatize(ancestry) self.assertTrue(event.private) self.assertTrue(event_file.private) self.assertTrue(citation.private) self.assertTrue(source.private) self.assertTrue(citation_file.private) self.assertTrue(source_file.private) self.assertIsNone(person.private)
def test_comes_before(self) -> None: self.assertIsInstance(Birth.comes_before(), set)