class TestPerson(unittest.TestCase):
def setUp(self):
# create a few Persons
self.child = Person('kid', 'f')
self.mom = Person('mom', 'f')
self.dad = Person('dad', 'm')
# make a deep family history
# use dict to store people for different generations
self.generations = 4
self.people = people = {}
self.root_child = Person('root_child', Gender.UNKNOWN)
people[0] = {self.root_child}
for i in range(1, self.generations):
people[i] = set()
def add_parents(child, depth, max_depth):
if depth + 1 < max_depth:
dad = Person(child.name + '_dad', Gender.MALE)
mom = Person(child.name + '_mom', Gender.FEMALE)
people[depth + 1].add(dad)
people[depth + 1].add(mom)
child.set_father(dad)
child.set_mother(mom)
add_parents(dad, depth + 1, max_depth)
add_parents(mom, depth + 1, max_depth)
add_parents(self.root_child, 0, self.generations)
def test_set_mother(self):
self.child.set_mother(self.mom)
self.assertEqual(self.child.mother, self.mom)
self.assertIn(self.child, self.mom.children)
self.mom.gender = Gender.MALE
with self.assertRaises(PersonError) as context:
self.child.set_mother(self.mom)
self.assertIn('is not female', str(context.exception))
def test_set_father(self):
self.child.set_father(self.dad)
self.assertEqual(self.child.father, self.dad)
self.assertIn(self.child, self.dad.children)
self.dad.gender = Gender.FEMALE
with self.assertRaises(PersonError) as context:
self.child.set_father(self.dad)
self.assertIn('is not male', str(context.exception))
def test_add_child(self):
self.assertNotIn(self.child, self.mom.children)
self.mom.add_child(self.child)
self.assertEqual(self.child.mother, self.mom)
self.assertIn(self.child, self.mom.children)
self.assertNotIn(self.child, self.dad.children)
self.dad.add_child(self.child)
self.assertEqual(self.child.father, self.dad)
self.assertIn(self.child, self.dad.children)
def test_add_child_error(self):
self.dad.gender = Gender.UNKNOWN
with self.assertRaises(PersonError) as context:
self.dad.add_child(self.child)
self.assertIn('cannot add child', str(context.exception))
self.assertIn('with unknown gender', str(context.exception))
def test_remove_father(self):
self.child.set_father(self.dad)
self.child.remove_father()
self.assertNotIn(self.child, self.dad.children)
self.assertEqual(self.child.father, None)
def test_remove_father_error(self):
self.child.father = None
with self.assertRaises(PersonError) as context:
self.child.remove_father()
self.assertIn('father is unknown', str(context.exception))
def test_remove_mother(self):
self.child.set_mother(self.mom)
self.child.remove_mother()
self.assertNotIn(self.child, self.mom.children)
self.assertEqual(self.child.mother, None)
def test_remove_mother_error(self):
self.child.mother = None
with self.assertRaises(PersonError) as context:
self.child.remove_mother()
self.assertIn('mother is unknown', str(context.exception))
def test_get_persons_name(self):
self.assertEqual(self.child.name, Person.get_persons_name(self.child))
self.child = None
self.assertEqual(Person.get_persons_name(self.child), 'NA')
def test_ancestor(self):
check = set()
mindepth = 1
maxdepth = 3
for i in range(mindepth, maxdepth + 1):
check = check.union(self.people[i])
self.assertCountEqual(self.root_child.ancestors(mindepth, maxdepth),
check)
def test_ancestor_error(self):
max_depth = 3
min_depth = 5
with self.assertRaises(PersonError) as context:
self.root_child.ancestors(min_depth, max_depth)
self.assertIn('less than min_depth', str(context.exception))
def test_grandparents(self):
check = set()
for i in range(2, 3):
check = check.union(self.people[i])
self.assertCountEqual(self.root_child.grandparents(), check)
def test_all_grandparents(self):
check = set()
for i in range(3, len(self.people)):
check = check.union(self.people[i])
self.assertCountEqual(self.root_child.all_grandparents(), check)
def test_all_ancestors(self):
check = set()
for i in range(1, len(self.people)):
check = check.union(self.people[i])
self.assertCountEqual(self.root_child.all_ancestors(), check)
class TestPerson(unittest.TestCase):
def setUp(self):
# create a few Persons
self.child = Person('kid', 'NA')
self.mom = Person('mom', 'f')
self.dad = Person('dad', 'm')
self.generations = 4
self.people = people = []
self.root_child = Person('root_child', Gender.UNKNOWN)
people.append(self.root_child)
def add_parents(child, depth, max_depth):
if depth + 1 < max_depth:
dad = Person(child.name + '_dad', Gender.MALE)
mom = Person(child.name + '_mom', Gender.FEMALE)
people.append(dad)
people.append(mom)
child.set_father(dad)
child.set_mother(mom)
add_parents(dad, depth + 1, max_depth)
add_parents(mom, depth + 1, max_depth)
add_parents(self.root_child, 0, self.generations)
self.head_father = self.root_child.father.father.father
def test_person_attrs(self):
teststr = str(self.dad)
self.assertIn("name: dad; gender: M>", teststr)
def test_set_mother(self):
self.child.set_mother(self.mom)
self.assertEqual(self.child.mother, self.mom)
self.assertIn(self.child, self.mom.children)
def test_set_mother_error(self):
self.mom.gender = Gender.MALE
with self.assertRaises(PersonError) as context:
self.child.set_mother(self.mom)
self.assertIn('is not female', str(context.exception))
def test_set_father(self):
self.child.set_father(self.dad)
self.assertEqual(self.child.father, self.dad)
self.assertIn(self.child, self.dad.children)
def test_set_father_error(self):
self.dad.gender = Gender.FEMALE
with self.assertRaises(PersonError) as context:
self.child.set_father(self.dad)
self.assertIn('is not male', str(context.exception))
def test_add_child(self):
self.assertNotIn(self.child, self.mom.children)
#FIXED BUG from unittests: we need to set the gender of the child too, right?
self.child.gender = Gender.MALE
self.mom.add_child(self.child)
self.assertEqual(self.child.mother, self.mom)
self.assertIn(self.child, self.mom.children)
self.assertNotIn(self.child, self.dad.children)
#FIXED BUG from unittests: we need to set the gender of the child too, right?
# might as well check both genders
self.child.gender = Gender.FEMALE
self.dad.add_child(self.child)
self.assertEqual(self.child.father, self.dad)
self.assertIn(self.child, self.dad.children)
def test_add_child_error(self):
#FIXED BUG from unittests: we need to set the gender of the child too, right?
self.dad.gender = Gender.UNKNOWN
self.child.gender = Gender.MALE
with self.assertRaises(PersonError) as context:
self.dad.add_child(self.child)
self.assertIn('cannot add child', str(context.exception))
self.assertIn('with unknown gender of parent', str(context.exception))
#adding more tests to cover all possible cases - father set on top of father
self.dad.gender = Gender.MALE
self.dad.add_child(self.child)
with self.assertRaises(PersonError) as context:
self.dad.add_child(self.child)
self.assertIn("already has father", str(context.exception))
#adding more tests to cover all possible cases - mother set on top of mother
self.mom.add_child(self.child)
with self.assertRaises(PersonError) as context:
self.mom.add_child(self.child)
self.assertIn("already has mother", str(context.exception))
#adding more tests to cover all possible cases - check for loops or impossibilities in graph
self.root_child.gender = Gender.MALE
#adding more tests to cover all possible cases - check for loops or impossibilities in graph
with self.assertRaises(PersonError) as context:
self.root_child.add_child(self.head_father)
self.assertIn("is an ancestor of person", str(context.exception))
def test_remove_father(self):
self.child.set_father(self.dad)
self.child.remove_father()
self.assertNotIn(self.child, self.dad.children)
def test_remove_mother(self):
self.child.set_mother(self.mom)
self.child.remove_mother()
#FIXED BUG from unittests: it's self.mom, not self.mother for our test cases
self.assertNotIn(self.child, self.mom.children)
def test_remove_father_error(self):
#FIXED BUG from unittests: self.child doesn't initially have any parents set
with self.assertRaises(PersonError) as context:
self.child.remove_father()
self.assertIn('father not set', str(context.exception))
self.child.set_father(self.dad)
self.dad.children.remove(self.child)
with self.assertRaises(PersonError) as context:
self.child.remove_father()
self.assertIn('father named', str(context.exception))
self.assertIn('does not have person named', str(context.exception))
self.assertIn('in children', str(context.exception))
def test_remove_mother_error(self):
with self.assertRaises(PersonError) as context:
self.child.remove_mother()
self.assertIn('mother not set', str(context.exception))
self.child.set_mother(self.mom)
self.mom.children.remove(self.child)
with self.assertRaises(PersonError) as context:
self.child.remove_mother()
self.assertIn('mother named', str(context.exception))
self.assertIn('does not have person named', str(context.exception))
self.assertIn('in children', str(context.exception))
def test_get_persons_name(self):
self.assertEqual(Person.get_persons_name(self.mom), "mom")
self.assertEqual(Person.get_persons_name(None), "NA")
def test_grandparents(self):
grandparents_names = set([
Person.get_persons_name(i) for i in self.root_child.grandparents()
])
true_grandparents = {
'root_child_mom_mom', 'root_child_dad_mom', 'root_child_mom_dad',
'root_child_dad_dad'
}
self.assertEqual(grandparents_names, true_grandparents)
def test_all_grandparents(self):
all_grandparents_names = set([
Person.get_persons_name(i)
for i in self.root_child.all_grandparents()
])
#FIXED BUG: all grandparents returns all grandparents + great-grands, etc...
true_all_grandparents = {
'root_child_dad_mom_dad', 'root_child_dad_dad_dad',
'root_child_dad_mom_mom', 'root_child_mom_dad_dad',
'root_child_mom_dad_mom', 'root_child_mom_mom_dad',
'root_child_mom_mom_mom', 'root_child_dad_dad_mom',
'root_child_mom_mom', 'root_child_dad_mom', 'root_child_mom_dad',
'root_child_dad_dad'
}
self.assertEqual(all_grandparents_names, true_all_grandparents)
def test_all_ancestors(self):
all_ancestors = set([
Person.get_persons_name(i)
for i in self.root_child.all_ancestors()
])
true_all_ancestors = {
'root_child_mom_dad', 'root_child_mom_dad_mom',
'root_child_mom_mom', 'root_child_dad_dad_dad',
'root_child_dad_mom', 'root_child_mom', 'root_child_mom_dad_dad',
'root_child_dad_mom_dad', 'root_child_dad_dad',
'root_child_mom_mom_mom', 'root_child_dad_mom_mom',
'root_child_dad', 'root_child_mom_mom_dad',
'root_child_dad_dad_mom'
}
self.assertEqual(all_ancestors, true_all_ancestors)
def test_parents(self):
parents = set(
[Person.get_persons_name(i) for i in self.root_child.parents()])
true_parents = {'root_child_dad', 'root_child_mom'}
self.assertEqual(parents, true_parents)
def test_ancestors(self):
'''ancestors code has already been 100% covered
in other unittests (multiple levels and depths)'''
pass
def test_ancestors_error(self):
with self.assertRaises(PersonError) as context:
self.root_child.ancestors(min_depth=2, max_depth=1)
self.assertIn('max_depth (1) cannot be less than min_depth (2)',
str(context.exception))
def test_descendants(self):
children = set([
Person.get_persons_name(i) for i in self.head_father.descendants()
])
true_children = {'root_child_dad_dad'}
self.assertEqual(children, true_children)
all_descendants = set([
Person.get_persons_name(i)
for i in self.head_father.descendants(min_depth=1,
max_depth=float('inf'))
])
true_descendants = {
'root_child_dad_dad', 'root_child_dad', 'root_child'
}
self.assertEqual(all_descendants, true_descendants)
def test_descendants_error(self):
with self.assertRaises(PersonError) as context:
self.head_father.descendants(min_depth=2, max_depth=1)
self.assertIn('max_depth (1) cannot be less than min_depth (2)',
str(context.exception))
class TestFamily(unittest.TestCase):
# Function to first contruct the family tree and store the root as Shan
def setUp(self):
main_class = MainClass()
self.shan = Person("Shan", MALE)
self.obj = Person()
commands = main_class.read_input_file(POPULATE_FAMILY_TREE_FILE)
main_class.call_fam_funcs(self.shan,
commands,
populate_family_tree=True)
def test_find_person_positive(self):
answers_retrieved_obj = self.obj.find_person(self.shan, "Kriya")
self.assertEqual("Kriya", answers_retrieved_obj.name)
def test_find_person_negative(self):
answers_retrieved_obj = self.obj.find_person(self.shan, "abc")
self.assertEqual(None, answers_retrieved_obj)
def test_paternal_uncles_positive(self):
correct_answer = ['Chit', 'Ish', 'Vich']
answers_retrieved_obj = self.obj.get_paternal_uncles(self.shan, "Jnki")
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_paternal_uncles_negative_none(self):
correct_answer = 0
answers_retrieved_obj = self.obj.get_paternal_uncles(
self.shan, "Satvy")
self.assertEqual(len(answers_retrieved_obj), correct_answer)
def test_maternal_uncles_positive(self):
correct_answer = ['Ahit']
answers_retrieved_obj = self.obj.get_maternal_uncles(
self.shan, "Lavnya")
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_maternal_uncles_negative_none(self):
correct_answer = 0
answers_retrieved_obj = self.obj.get_maternal_uncles(self.shan, "Vila")
self.assertEqual(len(answers_retrieved_obj), correct_answer)
def test_paternal_aunts_positive(self):
correct_answer = ['Atya']
answers_retrieved_obj = self.obj.get_paternal_aunts(self.shan, "Vasa")
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_paternal_aunts_negative_none(self):
correct_answer = 0
answers_retrieved_obj = self.obj.get_paternal_aunts(self.shan, "Krpi")
self.assertEqual(len(answers_retrieved_obj), correct_answer)
def test_maternal_aunts_positive(self):
correct_answer = ['Tritha']
answers_retrieved_obj = self.obj.get_maternal_aunts(
self.shan, "Yodhan")
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_maternal_aunts_negative_none(self):
correct_answer = 0
answers_retrieved_obj = self.obj.get_maternal_aunts(
self.shan, "Krithi")
self.assertEqual(len(answers_retrieved_obj), correct_answer)
def test_sisters_in_laws_positive(self):
correct_answer = ['Amba', 'Lika', 'Chitra']
answers_retrieved_obj = self.obj.get_sisters_in_law(self.shan, "Satya")
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_sisters_in_laws_negative_none(self):
correct_answer = 0
answers_retrieved_obj = self.obj.get_sisters_in_law(self.shan, "Jnki")
self.assertEqual(len(answers_retrieved_obj), correct_answer)
def test_brothers_in_laws_positive(self):
correct_answer = ['Ahit']
answers_retrieved_obj = self.obj.get_brothers_in_law(self.shan, "Arit")
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_brothers_in_laws_negative_none(self):
correct_answer = 0
answers_retrieved_obj = self.obj.get_brothers_in_law(
self.shan, "Chika")
self.assertEqual(len(answers_retrieved_obj), correct_answer)
def test_sons_positive(self):
correct_answer = ['Chit', 'Ish', 'Vich', 'Aras']
answers_retrieved_obj = self.obj.get_sons(self.shan, "Anga")
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_sons_negative(self):
correct_answer = 0
answers_retrieved_obj = self.obj.get_sons(self.shan, "Vich")
self.assertEqual(len(answers_retrieved_obj), correct_answer)
def test_daughters_positive(self):
correct_answer = ['Dritha', 'Tritha']
answers_retrieved_obj = self.obj.get_daughters(self.shan, "Chit")
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_daughters_negative(self):
correct_answer = 0
answers_retrieved_obj = self.obj.get_daughters(self.shan, "Asva")
self.assertEqual(len(answers_retrieved_obj), correct_answer)
def test_siblings_positive(self):
correct_answer = ['Chit', 'Ish', 'Aras', 'Satya']
answers_retrieved_obj = self.obj.get_siblings(self.shan, "Vich")
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_siblings_negative(self):
correct_answer = 0
answers_retrieved_obj = self.obj.get_siblings(self.shan, "Jaya")
self.assertEqual(len(answers_retrieved_obj), correct_answer)
def test_brothers_positive(self):
correct_answer = ['Chit', 'Ish', 'Vich', 'Aras']
person = self.obj.find_person(self.shan, "Satya")
answers_retrieved_obj = self.obj.get_brothers(person)
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_brothers_negative(self):
correct_answer = 0
person = self.obj.find_person(self.shan, "Yodhan")
answers_retrieved_obj = self.obj.get_brothers(person)
self.assertEqual(len(answers_retrieved_obj), correct_answer)
def test_sisters_positive(self):
correct_answer = ['Dritha', 'Tritha']
person = self.obj.find_person(self.shan, "Vritha")
answers_retrieved_obj = self.obj.get_sisters(person)
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_sisters_negative(self):
correct_answer = 0
person = self.obj.find_person(self.shan, "Lavnya")
answers_retrieved_obj = self.obj.get_sisters(person)
self.assertEqual(len(answers_retrieved_obj), correct_answer)
def test_add_child_daughter(self):
mother = self.obj.find_person(self.shan, "Jnki")
self.obj.add_child(mother, Person("Rohini", FEMALE))
correct_answer = ["Lavnya", "Rohini"]
answers_retrieved_obj = self.obj.get_daughters(self.shan, "Jnki")
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
father = self.obj.find_person(self.shan, "Arit")
answers_retrieved_obj = self.obj.get_daughters(self.shan,
father.wife.name)
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_add_child_son(self):
mother = self.obj.find_person(self.shan, "Dritha")
self.obj.add_child(mother, Person("Arjun", MALE))
correct_answer = ["Yodhan", "Arjun"]
answers_retrieved_obj = self.obj.get_sons(self.shan, "Dritha")
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
father = self.obj.find_person(self.shan, "Jaya")
answers_retrieved_obj = self.obj.get_sons(self.shan, father.wife.name)
answers_retrieved_lst = list()
for answer in answers_retrieved_obj:
answers_retrieved_lst.append(answer.name)
self.assertEqual(answers_retrieved_lst, correct_answer)
def test_add_spouse_husband(self):
wife = self.obj.find_person(self.shan, "Chika")
husband_to_be_added = Person("Chetan", MALE)
self.obj.add_spouse(wife, husband_to_be_added)
husband = self.obj.find_person(self.shan, "Chetan")
self.assertEqual(husband.name, "Chetan")
def test_add_spouse_wife(self):
husband = self.obj.find_person(self.shan, "Ahit")
wife_to_be_added = Person("Deepa", FEMALE)
self.obj.add_spouse(husband, wife_to_be_added)
wife = self.obj.find_person(self.shan, "Deepa")
self.assertEqual(wife.name, "Deepa")
class TestPerson(unittest.TestCase):
def setUp(self):
# create a Person
self.child = Person('kid', 'NA')
self.mom = Person('mom', 'f')
self.dad = Person('dad', 'm')
# make a deep family history
self.generations = 4
self.people = people = []
self.root_child = Person('root_child', Gender.UNKNOWN)
people.append(self.root_child)
def add_parents(child, depth, max_depth):
if depth + 1 < max_depth:
dad = Person(child.name + '_dad', Gender.MALE)
mom = Person(child.name + '_mom', Gender.FEMALE)
people.append(dad)
people.append(mom)
child.set_father(dad)
child.set_mother(mom)
add_parents(dad, depth + 1, max_depth)
add_parents(mom, depth + 1, max_depth)
add_parents(self.root_child, 0, self.generations)
def test_set_mother(self):
'''Testing set_mother'''
self.child.set_mother(self.mom)
self.assertEqual(self.child.mother, self.mom)
self.assertIn(self.child, self.mom.children)
self.mom.gender = Gender.MALE
with self.assertRaises(PersonError) as context:
self.child.set_mother(self.mom)
self.assertIn("is not female", str(context.exception))
def test_set_father(self):
'''Testing set_father'''
self.child.set_father(self.dad)
self.assertEqual(self.child.father, self.dad)
self.assertIn(self.child, self.dad.children)
self.dad.gender = Gender.FEMALE
with self.assertRaises(PersonError) as context:
self.child.set_father(self.dad)
self.assertIn('is not male', str(context.exception))
def test_remove_father(self):
'''Testing function remove_father'''
with self.assertRaises(Exception) as context:
self.child.remove_father()
self.assertIn('is not known', str(context.exception))
self.child.set_father(self.dad)
self.dad.children.remove(self.child)
with self.assertRaises(Exception) as context:
self.child.remove_father()
self.assertIn('is not a child of father', str(context.exception))
self.child.set_father(self.dad)
self.child.remove_father()
self.assertNotEqual(self.dad, self.child.father)
self.assertNotIn(self.child, self.dad.children)
def test_remove_mother(self):
'''Testing function remove_mother'''
with self.assertRaises(Exception) as context:
self.child.remove_mother()
self.assertTrue('is not know', str(context.exception))
self.child.set_mother(self.mom)
self.mom.children.remove(self.child)
with self.assertRaises(Exception) as context:
self.child.remove_mother()
self.assertTrue('is not a child of mother', str(context.exception))
self.child.set_mother(self.mom)
self.child.remove_mother()
self.assertNotEqual(self.mom, self.child.mother)
self.assertNotIn(self.child,
self.mom.children) # self.mom noted in setUp
def test_add_child(self):
''' Testing add_child '''
self.assertNotIn(self.child, self.mom.children)
self.mom.add_child(self.child)
self.assertEqual(self.child.mother, self.mom)
self.assertIn(self.child, self.mom.children)
self.assertNotIn(self.child, self.dad.children)
self.dad.add_child(self.child)
self.assertEqual(self.child.father, self.dad)
self.assertIn(self.child, self.dad.children)
def test_add_child_error(self):
''' Test add_child_error '''
self.dad.gender = Gender.UNKNOWN
with self.assertRaises(PersonError) as context:
self.dad.add_child(self.child)
self.assertIn('cannot add child',
str(context.exception)) # added the str to test
self.assertIn('with unknown gender',
str(context.exception)) # added the str to test
'''def test_remove_father(self):
self.child.set_father(self.dad)
self.child.remove_father()
self.assertNotIn(self.child, self.dad.children)
'''
def test_get_persons_name(self):
'''Testing get_persons_name '''
self.assertEqual('root_child',
self.root_child.get_persons_name(self.root_child))
self.assertEqual(Person.get_persons_name(self.child), self.child.name)
self.assertEqual(Person.get_persons_name(None), 'NA')
self.assertIs(Person.get_persons_name(self.child), self.child.name)
self.assertTrue(Person.get_persons_name(self.child), self.child.name)
def test_grandparents(self):
'''Testing grandparents '''
self.assertIn(self.root_child.father.father,
self.root_child.grandparents())
self.assertIn(self.root_child.father.mother,
self.root_child.grandparents())
self.assertIn(self.root_child.mother.father,
self.root_child.grandparents())
self.assertIn(self.root_child.mother.mother,
self.root_child.grandparents())
def test_all_grandparents(self):
''' Testing all_grandparents '''
self.assertIn(self.root_child.father.father.father,
self.root_child.all_grandparents())
self.assertIn(self.root_child.father.father.mother,
self.root_child.all_grandparents())
self.assertIn(self.root_child.father.mother.father,
self.root_child.all_grandparents())
self.assertIn(self.root_child.father.mother.father,
self.root_child.all_grandparents())
self.assertIn(self.root_child.mother.mother.mother,
self.root_child.all_grandparents())
self.assertIn(self.root_child.mother.mother.father,
self.root_child.all_grandparents())
self.assertIn(self.root_child.mother.father.father,
self.root_child.all_grandparents())
self.assertIn(self.root_child.mother.father.mother,
self.root_child.all_grandparents())
self.assertIn(self.root_child.mother.mother.father,
self.root_child.all_grandparents())
self.assertIn(self.root_child.mother.father.father,
self.root_child.all_grandparents())
self.assertIsNot(self.root_child.mother.father.father,
self.root_child.all_grandparents())
self.assertIsNotNone(self.root_child.mother.father.father,
self.root_child.all_grandparents())
self.assertIsNot(self.root_child, self.root_child.all_grandparents())
self.assertIn(self.root_child.mother.mother.mother,
self.root_child.all_grandparents())
def test_all_ancestors(self):
''' Testing all_ancestors '''
self.assertNotEqual(self.root_child.father,
self.root_child.all_ancestors())
self.assertIn(self.root_child.father.father.father,
self.root_child.all_ancestors())
self.assertIn(self.root_child.mother.mother.mother,
self.root_child.all_ancestors())
self.assertIn(self.root_child.father.mother.mother,
self.root_child.all_ancestors())
self.assertIn(self.root_child.mother.father.mother,
self.root_child.all_ancestors())
self.assertIn(self.root_child.mother, self.root_child.all_ancestors())
self.assertIn(self.root_child.mother.mother,
self.root_child.all_ancestors())
self.assertIn(self.root_child.mother.father,
self.root_child.all_ancestors())
self.assertIsNot(self.root_child.mother.father.father.father,
self.root_child.all_ancestors())
self.assertIsNot(self.root_child.mother.mother.mother.mother,
self.root_child.all_ancestors())
self.assertIn(self.root_child.father, self.root_child.all_ancestors())
self.assertIn(self.root_child.father.father,
self.root_child.all_ancestors())
self.assertNotIn(self.root_child, self.root_child.all_ancestors())
self.assertIn(self.root_child.mother.mother.mother,
self.root_child.all_ancestors())
def test_ancestors(self):
''' Testing ancestors '''
self.assertIn(self.root_child.father, self.root_child.ancestors(1))
self.assertIn(self.root_child.father.father,
self.root_child.ancestors(2))
self.assertIn(self.root_child.father.mother,
self.root_child.ancestors(2))
self.assertIn(self.root_child.mother.father,
self.root_child.ancestors(2))
self.assertIn(self.root_child.mother.mother,
self.root_child.ancestors(2))
self.assertIn(self.root_child.father.father.father,
self.root_child.ancestors(3))
self.assertIn(self.root_child.father.father.mother,
self.root_child.ancestors(3))
self.assertIn(self.root_child.father.mother.father,
self.root_child.ancestors(3))
self.assertIn(self.root_child.father.mother.mother,
self.root_child.ancestors(3))
self.assertIn(self.root_child.mother.mother.father,
self.root_child.ancestors(3))
self.assertIn(self.root_child.mother.mother.mother,
self.root_child.ancestors(3))
self.assertIn(self.root_child.mother.father.mother,
self.root_child.ancestors(3))
self.assertIn(self.root_child.mother.father.mother,
self.root_child.ancestors(3))
self.assertIn(self.root_child.mother, self.root_child.ancestors(1))
self.assertIn(self.root_child.mother.mother,
self.root_child.ancestors(2))
self.assertIn(self.root_child.mother.mother.mother,
self.root_child.ancestors(3))
#self.assertIn(self.root_child.father.father.father.father,self.root_child.ancestors(4)) # not present
self.assertNotIn(self.root_child.father, self.root_child.ancestors(0))
with self.assertRaises(PersonError) as context:
self.root_child.ancestors(min_depth=2, max_depth=1)
self.assertIn('max_depth (1) cannot be less than min_depth (2)',
str(context.exception))
def test_parent(self):
self.assertEqual(self.root_child.father, self.root_child.father)
self.assertEqual(self.root_child.mother, self.root_child.mother)
