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 = 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)
def test_privatize_source_should_privatize_if_private(self):
file = File('F0', __file__)
source = IdentifiableSource('S0', 'The Source')
source.private = True
source.files.append(file)
ancestry = Ancestry()
ancestry.sources[source.id] = source
privatize(ancestry)
self.assertTrue(source.private)
self.assertTrue(file.private)
def test_privatize_source_should_not_privatize_if_public(self):
file = File('F0', __file__)
source = Source('S0', 'The Source')
source.private = False
source.files.append(file)
ancestry = Ancestry()
ancestry.entities.append(source)
privatize(ancestry)
self.assertEqual(False, source.private)
self.assertIsNone(file.private)
def test_privatize_source_should_privatize_if_private(self):
file = File('F0', __file__)
source = Source('S0', 'The Source')
source.private = True
source.files.append(file)
ancestry = Ancestry()
ancestry.entities.append(source)
privatize(ancestry)
self.assertTrue(source.private)
self.assertTrue(file.private)
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_privatize_file_should_privatize_if_private(self):
source = Source('The Source')
citation = Citation(source)
file = File('F0', __file__)
file.private = True
file.citations.append(citation)
ancestry = Ancestry()
ancestry.files[file.id] = file
privatize(ancestry)
self.assertTrue(True, file.private)
self.assertTrue(citation.private)
def test_privatize_file_should_privatize_if_private(self):
source = Source(None, 'The Source')
citation = Citation(None, source)
file = File('F0', __file__)
file.private = True
file.citations.append(citation)
ancestry = Ancestry()
ancestry.entities.append(file)
privatize(ancestry)
self.assertTrue(True, file.private)
self.assertTrue(citation.private)
def test_privatize_file_should_not_privatize_if_public(self):
source = Source(None, 'The Source')
citation = Citation(None, source)
file = File('F0', __file__)
file.private = False
file.citations.append(citation)
ancestry = Ancestry()
ancestry.entities.append(file)
privatize(ancestry)
self.assertEqual(False, file.private)
self.assertIsNone(citation.private)
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)
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)
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_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)
def test_privatize_citation_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.private = True
citation.files.append(citation_file)
ancestry = Ancestry()
ancestry.entities.append(citation)
privatize(ancestry)
self.assertTrue(citation.private)
self.assertTrue(source.private)
self.assertTrue(citation_file.private)
self.assertTrue(source_file.private)
def test_privatize_citation_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 = Citation('C0', source)
citation.private = False
citation.files.append(citation_file)
ancestry = Ancestry()
ancestry.entities.append(citation)
privatize(ancestry)
self.assertEqual(False, citation.private)
self.assertIsNone(source.private)
self.assertIsNone(citation_file.private)
self.assertIsNone(source_file.private)
def test_privatize_event_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_file = File('F1', __file__)
event = IdentifiableEvent('E1', Birth())
event.private = False
event.citations.append(citation)
event.files.append(event_file)
person = Person('P0')
Presence(person, Subject(), event)
ancestry = Ancestry()
ancestry.events[event.id] = event
privatize(ancestry)
self.assertEqual(False, event.private)
self.assertIsNone(event_file.private)
self.assertIsNone(citation.private)
self.assertIsNone(source.private)
self.assertIsNone(citation_file.private)
self.assertIsNone(source_file.private)
self.assertIsNone(person.private)
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)
