def run():
"""main function
"""
file_data = None
filename = ""
validation_msgs = ValidationMessages()
tags = Tags()
peeps = People(validation_msgs)
fam = Families(peeps, validation_msgs)
peeps.set_families(fam)
if len(sys.argv) < 2:
sys.exit("Usage: " + sys.argv[0] + " path-to-gedom-file")
filename = sys.argv[1]
try:
file_data = open(filename)
except IOError:
sys.exit("ERROR: file " + sys.argv[1] + "was not found!")
for line in file_data:
try:
data = tags.processline(line)
if data["valid"] == "Y":
fam.process_line_data(data)
peeps.process_line_data(data)
except TagsError as err:
sys.exit("ERROR: ", err)
fam.validate()
peeps.validate()
if validation_msgs.get_messages():
print("Validation Messages")
validation_msgs.print_all()
print("")
print("Individuals")
peeps.print_all()
peeps.us29_print_deceased()
peeps.us31_print_single()
peeps.us35_print_recent_births()
peeps.us36_print_recent_deaths()
peeps.us_38_print_upcoming_birthdays()
print("")
print("Families")
fam.print_all()
fam.us30_print_married()
fam.us32_print_multiple_births()
fam.us33_print_orphans()
fam.us34_print_big_age_diff()
fam.us_39_print_upcoming_anniversaries()
print("")
class TestPeople(unittest.TestCase):
"""test cases for families class
Attributes:
fam (Families): Family test object
"""
def setUp(self):
"""creates setup objects
"""
self.msgs = ValidationMessages()
self.peeps = People(self.msgs)
self.fam = Families(self.peeps, self.msgs)
def tearDown(self):
"""delete setup objects
"""
del self.peeps
del self.fam
del self.msgs
def test_default_init(self):
"""make sure the object is empty on init
"""
self.assertEqual(0, len(self.peeps.individuals))
def test_ignore_bad_tags(self):
"""ensure bad tags aren't being processed
"""
# raw line:
# 1 BLAH sdfsd
data = {"level": 1, "tag": "BLAH", "args": "sdfsd", "valid": "N"}
with self.assertRaises(ValueError):
self.peeps.process_line_data(data)
# ensure nothing got added
self.assertEqual(0, len(self.peeps.individuals))
def test_add_individual(self):
"""test cases for detecting the person tag and adding it to the list of individuals
"""
# raw line:
# 0 @I6@ INDI
data = {"level": 0, "tag": "INDI", "args": "@I6@", "valid": "Y"}
self.peeps.process_line_data(data)
# add a person
self.assertEqual(1, len(self.peeps.individuals))
# test person dict setup
test_person = Person(data["args"])
result = self.peeps.individuals[data["args"]]
self.assertEqual(test_person.get_person_id(), result.get_person_id())
def test_unique_id(self):
"""US22 unique ID for people
"""
person1 = {"level": 0, "tag": "INDI", "args": "@I1@", "valid": "Y"}
self.peeps.process_line_data(person1)
person2 = {"level": 0, "tag": "INDI", "args": "@I1@", "valid": "Y"}
self.peeps.process_line_data(person2)
self.assertEqual(1, len(self.peeps.individuals))
def test_correct_individual_tag(self):
"""Ensuring the INDI tag can only be used to add a person
"""
# raw line:
# 0 @I8@ FAM
data = {"level": 0, "tag": "FAM", "args": "@I8@", "valid": "Y"}
self.peeps.process_line_data(data)
# add a person
self.assertEqual(0, len(self.peeps.individuals))
def test_add_multiple_people(self):
"""adding mulitiple people to make sure they are both read in
"""
# raw lines:
# 0 @I9@ INDI
# 0 @A6@ INDI
person1 = {"level": 0, "tag": "INDI", "args": "@I9@", "valid": "Y"}
self.peeps.process_line_data(person1)
person2 = {"level": 0, "tag": "INDI", "args": "@A6@", "valid": "Y"}
self.peeps.process_line_data(person2)
# add a family
self.assertEqual(2, len(self.peeps.individuals))
# test family exist
result1 = self.peeps.individuals[person1["args"]]
self.assertEqual(person1["args"], result1.get_person_id())
result2 = self.peeps.individuals[person2["args"]]
self.assertEqual(person2["args"], result2.get_person_id())
def test_name(self):
"""name test for people
"""
# raw lines:
# 0 @I6@ INDI
# 1 NAME Joe /Smith/
person = {"level": 0, "tag": "INDI", "args": "@I6@", "valid": "Y"}
self.peeps.process_line_data(person)
person_name = {
"level": 1,
"tag": "NAME",
"args": "Joe /Smith/",
"valid": "Y"
}
self.peeps.process_line_data(person_name)
self.assertEqual(person_name["args"],
self.peeps.individuals[person["args"]].get_name())
def test_gender(self):
"""gender tests for people
"""
# raw lines:
# 0 @I6@ INDI
# 1 SEX M
person = {"level": 0, "tag": "INDI", "args": "@I6@", "valid": "Y"}
self.peeps.process_line_data(person)
gender = {"level": 1, "tag": "SEX", "args": "M", "valid": "Y"}
self.peeps.process_line_data(gender)
self.assertEqual(gender["args"],
self.peeps.individuals[person["args"]].get_gender())
def test_birth_date(self):
"""able to read the birth date for a person and their age
"""
# raw lines:
# 0 @A9@ INDI
# 1 BIRT
# 2 DATE 15 JUN 1970
data = {"level": 0, "tag": "INDI", "args": "@A9@", "valid": "Y"}
self.peeps.process_line_data(data)
birth_tag = {"level": 1, "tag": "BIRT", "args": "", "valid": "Y"}
self.peeps.process_line_data(birth_tag)
birth_date = {
"level": 2,
"tag": "DATE",
"args": "15 JUN 1970",
"valid": "Y"
}
self.peeps.process_line_data(birth_date)
date_obj = datetime.strptime(birth_date["args"], '%d %b %Y')
self.assertEqual(date_obj,
self.peeps.individuals[data["args"]].get_birth_date())
age = int((datetime.now().date() - date_obj.date()).days / 365.2425)
self.assertEqual(age, self.peeps.individuals[data["args"]].get_age())
def test_death_date_no_birth(self):
"""test death date no birth and no age should be set
"""
# raw lines:
# 0 @A9@ INDI
# 1 DEAT
# 2 DATE 1 APR 1980
data = {"level": 0, "tag": "INDI", "args": "@A9@", "valid": "Y"}
self.peeps.process_line_data(data)
death_tag = {"level": 1, "tag": "DEAT", "args": "", "valid": "Y"}
self.peeps.process_line_data(death_tag)
death_date = {
"level": 2,
"tag": "DATE",
"args": "1 APR 1980",
"valid": "Y"
}
self.peeps.process_line_data(death_date)
date_obj = datetime.strptime(death_date["args"], '%d %b %Y')
self.assertEqual(date_obj,
self.peeps.individuals[data["args"]].get_death_date())
self.assertIsNone(self.peeps.individuals[data["args"]].get_age())
def test_birth_then_death_date(self):
"""test birth then death date with age of 9 years 9 months so 9
"""
# raw lines:
# 0 @A9@ INDI
# 1 BIRT
# 2 DATE 15 JUN 1970
# 1 DEAT
# 2 DATE 1 APR 1980
data = {"level": 0, "tag": "INDI", "args": "@A9@", "valid": "Y"}
self.peeps.process_line_data(data)
birth_tag = {"level": 1, "tag": "BIRT", "args": "", "valid": "Y"}
self.peeps.process_line_data(birth_tag)
birth_date = {
"level": 2,
"tag": "DATE",
"args": "15 JUN 1970",
"valid": "Y"
}
self.peeps.process_line_data(birth_date)
death_tag = {"level": 1, "tag": "DEAT", "args": "", "valid": "Y"}
self.peeps.process_line_data(death_tag)
death_date = {
"level": 2,
"tag": "DATE",
"args": "1 APR 1980",
"valid": "Y"
}
self.peeps.process_line_data(death_date)
self.assertEqual(9, self.peeps.individuals[data["args"]].get_age())
def test_death_then_birth_date(self):
"""test death then birth date with age of 9 years 9 months so 9
"""
# raw lines:
# 0 @A9@ INDI
# 1 DEAT
# 2 DATE 1 APR 1980
# 1 BIRT
# 2 DATE 15 JUN 1970
data = {"level": 0, "tag": "INDI", "args": "@A9@", "valid": "Y"}
self.peeps.process_line_data(data)
death_tag = {"level": 1, "tag": "DEAT", "args": "", "valid": "Y"}
self.peeps.process_line_data(death_tag)
death_date = {
"level": 2,
"tag": "DATE",
"args": "1 APR 1980",
"valid": "Y"
}
self.peeps.process_line_data(death_date)
birth_tag = {"level": 1, "tag": "BIRT", "args": "", "valid": "Y"}
self.peeps.process_line_data(birth_tag)
birth_date = {
"level": 2,
"tag": "DATE",
"args": "15 JUN 1970",
"valid": "Y"
}
self.peeps.process_line_data(birth_date)
self.assertEqual(9, self.peeps.individuals[data["args"]].get_age())
def test_child_of_family(self):
"""test person being a child in a family
"""
# raw lines:
# 0 @I6@ INDI
# 1 FAMC @F09@
# 1 FAMC @F10@
person = {"level": 0, "tag": "INDI", "args": "@I6@", "valid": "Y"}
self.peeps.process_line_data(person)
child1 = {"level": 1, "tag": "FAMC", "args": "@F09@", "valid": "Y"}
self.peeps.process_line_data(child1)
self.assertEqual(
child1["args"], self.peeps.individuals[
person["args"]].get_children_of_families()[0])
child2 = {"level": 1, "tag": "FAMC", "args": "@F10@", "valid": "Y"}
self.peeps.process_line_data(child2)
self.assertEqual(
child2["args"], self.peeps.individuals[
person["args"]].get_children_of_families()[1])
def test_spouse_of_family(self):
"""test person being a spouse in a family
"""
# raw lines:
# 0 @I6@ INDI
# 1 FAMS @F09@
# 1 FAMS @F10@
person = {"level": 0, "tag": "INDI", "args": "@I6@", "valid": "Y"}
self.peeps.process_line_data(person)
fam1 = {"level": 1, "tag": "FAMS", "args": "@F09@", "valid": "Y"}
self.peeps.process_line_data(fam1)
self.assertEqual(
fam1["args"],
self.peeps.individuals[person["args"]].get_spouse_of_families()[0])
fam2 = {"level": 1, "tag": "FAMS", "args": "@F10@", "valid": "Y"}
self.peeps.process_line_data(fam2)
self.assertEqual(
fam2["args"],
self.peeps.individuals[person["args"]].get_spouse_of_families()[1])
def test_print_all(self):
"""test print all persons
"""
# raw lines:
# 0 @A9@ INDI
# 1 NAME Joe /Smith/
# 1 SEX M
# 1 BIRT
# 2 DATE 15 JUN 1970
# 1 DEAT
# 2 DATE 1 APR 1980
# 1 FAMC @F02@
# 1 FAMS @F09@
data = {"level": 0, "tag": "INDI", "args": "@A9@", "valid": "Y"}
self.peeps.process_line_data(data)
name_tag = {
"level": 1,
"tag": "NAME",
"args": "Joe /Smith/",
"valid": "Y"
}
self.peeps.process_line_data(name_tag)
sex_tag = {"level": 1, "tag": "SEX", "args": "M", "valid": "Y"}
self.peeps.process_line_data(sex_tag)
birth_tag = {"level": 1, "tag": "BIRT", "args": "", "valid": "Y"}
self.peeps.process_line_data(birth_tag)
birth_date = {
"level": 2,
"tag": "DATE",
"args": "15 JUN 1970",
"valid": "Y"
}
self.peeps.process_line_data(birth_date)
death_tag = {"level": 1, "tag": "DEAT", "args": "", "valid": "Y"}
self.peeps.process_line_data(death_tag)
death_date = {
"level": 2,
"tag": "DATE",
"args": "1 APR 1980",
"valid": "Y"
}
self.peeps.process_line_data(death_date)
child_data = {"level": 1, "tag": "FAMC", "args": "@F02@", "valid": "Y"}
self.peeps.process_line_data(child_data)
spouse_data = {
"level": 1,
"tag": "FAMS",
"args": "@F09@",
"valid": "Y"
}
self.peeps.process_line_data(spouse_data)
# capture the output
output = io.StringIO()
sys.stdout = output
self.peeps.print_all()
sys.stdout = sys.__stdout__
test_output = """+------+-------------+--------+------------+-----+-------+------------+-----------+-----------+
| ID | Name | Gender | Birthday | Age | Alive | Death | Child | Spouse |
+------+-------------+--------+------------+-----+-------+------------+-----------+-----------+
| @A9@ | Joe /Smith/ | M | 1970-06-15 | 9 | False | 1980-04-01 | ['@F02@'] | ['@F09@'] |
+------+-------------+--------+------------+-----+-------+------------+-----------+-----------+
"""
self.assertEqual(test_output, output.getvalue())
def test_print_all_no_dates(self):
"""test print all persons
"""
# raw lines:
# 0 @A9@ INDI
# 1 NAME Joe /Smith/
# 1 SEX M
# 1 FAMC @F02@
# 1 FAMS @F09@
data = {"level": 0, "tag": "INDI", "args": "@A9@", "valid": "Y"}
self.peeps.process_line_data(data)
name_tag = {
"level": 1,
"tag": "NAME",
"args": "Joe /Smith/",
"valid": "Y"
}
self.peeps.process_line_data(name_tag)
sex_tag = {"level": 1, "tag": "SEX", "args": "M", "valid": "Y"}
self.peeps.process_line_data(sex_tag)
child_data = {"level": 1, "tag": "FAMC", "args": "@F02@", "valid": "Y"}
self.peeps.process_line_data(child_data)
spouse_data = {
"level": 1,
"tag": "FAMS",
"args": "@F09@",
"valid": "Y"
}
self.peeps.process_line_data(spouse_data)
# capture the output
output = io.StringIO()
sys.stdout = output
self.peeps.print_all()
sys.stdout = sys.__stdout__
test_output = """+------+-------------+--------+----------+------+-------+-------+-----------+-----------+
| ID | Name | Gender | Birthday | Age | Alive | Death | Child | Spouse |
+------+-------------+--------+----------+------+-------+-------+-----------+-----------+
| @A9@ | Joe /Smith/ | M | NA | None | True | NA | ['@F02@'] | ['@F09@'] |
+------+-------------+--------+----------+------+-------+-------+-----------+-----------+
"""
self.assertEqual(test_output, output.getvalue())
def test_print_all_in_order(self):
"""test print all persons in order
"""
# raw lines:
# 0 @A9@ INDI
# 1 NAME Joe /Smith/
# 1 SEX M
# 0 @A3@ INDI
# 1 NAME Jane /Doe/
# 1 SEX F
# 1 BIRT
# 2 DATE 10 AUG 1960
# 1 DEAT
# 2 DATE 20 DEC 1990
# 1 FAMC @F04@
# 1 FAMS @F10@
# person 1
data1 = {"level": 0, "tag": "INDI", "args": "@A9@", "valid": "Y"}
self.peeps.process_line_data(data1)
name_tag1 = {
"level": 1,
"tag": "NAME",
"args": "Joe /Smith/",
"valid": "Y"
}
self.peeps.process_line_data(name_tag1)
sex_tag1 = {"level": 1, "tag": "SEX", "args": "M", "valid": "Y"}
self.peeps.process_line_data(sex_tag1)
# person 2
data2 = {"level": 0, "tag": "INDI", "args": "@A3@", "valid": "Y"}
self.peeps.process_line_data(data2)
name_tag2 = {
"level": 1,
"tag": "NAME",
"args": "Jane /Doe/",
"valid": "Y"
}
self.peeps.process_line_data(name_tag2)
sex_tag2 = {"level": 1, "tag": "SEX", "args": "F", "valid": "Y"}
self.peeps.process_line_data(sex_tag2)
birth_tag2 = {"level": 1, "tag": "BIRT", "args": "", "valid": "Y"}
self.peeps.process_line_data(birth_tag2)
birth_date2 = {
"level": 2,
"tag": "DATE",
"args": "10 AUG 1960",
"valid": "Y"
}
self.peeps.process_line_data(birth_date2)
death_tag2 = {"level": 1, "tag": "DEAT", "args": "", "valid": "Y"}
self.peeps.process_line_data(death_tag2)
death_date2 = {
"level": 2,
"tag": "DATE",
"args": "20 DEC 1990",
"valid": "Y"
}
self.peeps.process_line_data(death_date2)
child_data2 = {
"level": 1,
"tag": "FAMC",
"args": "@F04@",
"valid": "Y"
}
self.peeps.process_line_data(child_data2)
spouse_data2 = {
"level": 1,
"tag": "FAMS",
"args": "@F10@",
"valid": "Y"
}
self.peeps.process_line_data(spouse_data2)
# capture the output
output = io.StringIO()
sys.stdout = output
self.peeps.print_all()
sys.stdout = sys.__stdout__
test_output = """+------+-------------+--------+------------+------+-------+------------+-----------+-----------+
| ID | Name | Gender | Birthday | Age | Alive | Death | Child | Spouse |
+------+-------------+--------+------------+------+-------+------------+-----------+-----------+
| @A3@ | Jane /Doe/ | F | 1960-08-10 | 30 | False | 1990-12-20 | ['@F04@'] | ['@F10@'] |
| @A9@ | Joe /Smith/ | M | NA | None | True | NA | [] | [] |
+------+-------------+--------+------------+------+-------+------------+-----------+-----------+
"""
self.assertEqual(test_output, output.getvalue())
def test_us03_is_valid_birth_date(self):
"""US03 test case for valid birth dates
"""
valid_person = Person("@I3@")
valid_person.set_name("Margo /Hemmingway/")
valid_person.set_gender("F")
valid_person.set_date("8 APR 1954", "birth")
valid_person.set_date("5 NOV 2011", "death")
self.peeps.individuals[valid_person.get_person_id()] = valid_person
self.peeps.validate()
self.assertEqual(0, len(self.msgs.get_messages()))
invalid_person = Person("@I4@")
invalid_person.set_gender("F")
invalid_person.set_name("Gergina /Hemmingway/")
invalid_person.set_date("8 APR 1954", "death")
invalid_person.set_date("5 NOV 2011", "birth")
self.peeps.individuals[invalid_person.get_person_id()] = invalid_person
self.peeps.validate()
test_messages = self.msgs.get_messages()
self.assertEqual(1, len(test_messages))
valid_error_message = {
'error_id': People.CLASS_IDENTIFIER,
'user_story': 'US03',
'user_id': invalid_person.get_person_id(),
'name': invalid_person.get_name(),
'message': 'Birth date should occur before death of an individual'
}
self.assertDictEqual(valid_error_message, test_messages[0])
def test_us07_not_too_old(self):
"""US07: test is the person's age is less than 150
"""
valid_person = Person("@I3@")
valid_person.set_name("Bubbles /Bambi/")
valid_person.set_date("1 JAN 1960", "birth")
self.peeps.individuals[valid_person.get_person_id()] = valid_person
invalid_person = Person("@I4@")
invalid_person.set_name("Margo /Hemmingway/")
invalid_person.set_date("1 JAN 2000", "death") # 151 years old
invalid_person.set_date("1 JAN 1849", "birth")
self.peeps.individuals[invalid_person.get_person_id()] = invalid_person
invalid_person2 = Person("@I5@")
invalid_person2.set_name("Betty /Hemmingway/")
invalid_person2.set_date("2 JAN 2000", "death") # 150 years old
invalid_person2.set_date("1 JAN 1850", "birth")
self.peeps.individuals[
invalid_person2.get_person_id()] = invalid_person2
invalid_person3 = Person("@I6@")
invalid_person3.set_name("Moses /Hemmingway/")
invalid_person3.set_date("1 JAN 2000", "death") # 200 years old
invalid_person3.set_date("1 JAN 1800", "birth")
self.peeps.individuals[
invalid_person3.get_person_id()] = invalid_person3
valid_person2 = Person("@I7@")
valid_person2.set_name("Salty /Hemmingway/")
valid_person2.set_date("1 JAN 2000", "death") # 149 years old
valid_person2.set_date("1 JAN 1851", "birth")
self.peeps.individuals[valid_person2.get_person_id()] = valid_person2
self.peeps.validate()
output = self.msgs.get_messages()
self.assertEqual(3, len(output))
error1 = {
"error_id": "INDIVIDUAL",
"message": "Age should be less than 150",
"name": invalid_person.get_name(),
"user_id": invalid_person.get_person_id(),
"user_story": "US07"
}
self.assertDictEqual(error1, output[0])
error2 = {
"error_id": "INDIVIDUAL",
"message": "Age should be less than 150",
"name": invalid_person2.get_name(),
"user_id": invalid_person2.get_person_id(),
"user_story": "US07"
}
self.assertDictEqual(error2, output[1])
error3 = {
"error_id": "INDIVIDUAL",
"message": "Age should be less than 150",
"name": invalid_person3.get_name(),
"user_id": invalid_person3.get_person_id(),
"user_story": "US07"
}
self.assertDictEqual(error3, output[2])
def test_us01_dates_before_current_date(self):
"""US01: test that all dates are before the current date
"""
curr = datetime.now()
date_before_current = Person("@I10@")
date_before_current.set_name("Link /Tiger/")
date_before_current.set_date("7 OCT 1940", "birth")
self.peeps.individuals[
date_before_current.get_person_id()] = date_before_current
date_before_current1 = Person("@I11@")
date_before_current1.set_name("Zelda /Tiger/")
date_before_current1.set_date("7 OCT 1942", "birth")
self.peeps.individuals[
date_before_current1.get_person_id()] = date_before_current1
date_notbefore_current1 = Person("@I3@")
date_notbefore_current1.set_name("Ernest /Hemmingway/")
date_notbefore_current1.set_date("4 AUG 1861", "birth")
date_notbefore_current1.set_date("5 NOV " + str(curr.year + 4),
"death")
self.peeps.individuals[
date_notbefore_current1.get_person_id()] = date_notbefore_current1
date_notbefore_current2 = Person("@I5@")
date_notbefore_current2.set_name("Rodney /Dangerfield/")
date_notbefore_current2.set_date("9 OCT " + str(curr.year + 2),
"birth")
self.peeps.individuals[
date_notbefore_current2.get_person_id()] = date_notbefore_current2
self.peeps.validate()
output = self.msgs.get_messages()
self.assertEqual(3, len(output))
error1 = {
"error_id": "INDIVIDUAL",
"user_story": "US01",
"user_id": date_notbefore_current1.get_person_id(),
"name": date_notbefore_current1.get_name(),
"message": "Death date should occur before current date"
}
self.assertDictEqual(error1, output[1])
error2 = {
"error_id": "INDIVIDUAL",
"user_story": "US01",
"user_id": date_notbefore_current2.get_person_id(),
"name": date_notbefore_current2.get_name(),
"message": "Birth date should occur before current date"
}
self.assertDictEqual(error2, output[2])
def test_us18_is_valid_sibling(self):
husband = Person("@I3@")
husband.set_name("Steve /Bambi/")
husband.add_children_of_family("@F4@")
husband.add_spouse_of_family("@F4@")
self.peeps.individuals[husband.get_person_id()] = husband
wife = Person("@I3@")
wife.set_name("Bubbles /Bambi/")
wife.add_children_of_family("@F4@")
wife.add_spouse_of_family("@F4@")
self.peeps.individuals[husband.get_person_id()] = wife
self.assertFalse(self.peeps._us18_is_valid_sibling(wife))
self.assertFalse(self.peeps._us18_is_valid_sibling(husband))
wife.remove_children_of_family("@F4@")
husband.remove_children_of_family("@F4@")
self.assertTrue(self.peeps._us18_is_valid_sibling(wife))
self.assertTrue(self.peeps._us18_is_valid_sibling(husband))
def test_us31_print_single(self):
""" US31 Unit tests
"""
single_person = Person("@I3@")
single_person.set_name("Margo /Hemmingway/")
single_person.set_gender("F")
single_person.set_date("8 APR 1954", "birth")
self.peeps.individuals[single_person.get_person_id()] = single_person
married_person = Person("@I4@")
married_person.set_name("David /Hemmingway/")
married_person.set_gender("M")
married_person.set_date("8 APR 1939", "birth")
married_person.add_spouse_of_family("@F1@")
self.peeps.individuals[married_person.get_person_id()] = married_person
# Not over 30
single_person1 = Person("@I5@")
single_person1.set_name("Dodge /Hemmingway/")
single_person1.set_gender("M")
single_person1.set_date("8 APR 1987", "birth")
self.peeps.individuals[single_person1.get_person_id()] = single_person1
# Not over 30
single_person2 = Person("@I6@")
single_person2.set_name("Dingo /Hemmingway/")
single_person2.set_gender("M")
single_person2.set_date("8 APR 1990", "birth")
self.peeps.individuals[single_person2.get_person_id()] = single_person2
# Not alive
single_person3 = Person("@I7@")
single_person3.set_name("Draftie /Hemmingway/")
single_person3.set_gender("M")
single_person3.set_date("8 APR 1967", "birth")
single_person3.set_date("8 APR 1990", "death")
self.peeps.individuals[single_person3.get_person_id()] = single_person3
# No age
single_person4 = Person("@I8@")
single_person4.set_name("Dirty /Hemmingway/")
single_person4.set_gender("M")
self.peeps.individuals[single_person4.get_person_id()] = single_person4
# capture the output
output = io.StringIO()
sys.stdout = output
self.peeps.us31_print_single()
sys.stdout = sys.__stdout__
test_output = """Single Individuals
+------+--------------------+-------+-----+---------+
| ID | Name | Alive | Age | Spouses |
+------+--------------------+-------+-----+---------+
| @I3@ | Margo /Hemmingway/ | True | 63 | [] |
+------+--------------------+-------+-----+---------+
"""
self.assertEqual(test_output, output.getvalue())
def test_us29_print_deceased(self):
""" US29 Unit tests
"""
deceased_person = Person("@I3@")
deceased_person.set_name("Margo /Hemmingway/")
deceased_person.set_gender("F")
deceased_person.set_date("8 APR 1954", "birth")
deceased_person.set_date("5 NOV 2011", "death")
self.peeps.individuals[
deceased_person.get_person_id()] = deceased_person
alive_person = Person("@I4@")
alive_person.set_name("David /Hemmingway/")
alive_person.set_gender("M")
alive_person.set_date("8 APR 1954", "birth")
self.peeps.individuals[alive_person.get_person_id()] = alive_person
# capture the output
output = io.StringIO()
sys.stdout = output
self.peeps.us29_print_deceased()
sys.stdout = sys.__stdout__
test_output = """Deceased Individuals
+------+--------------------+-------+
| ID | Name | Alive |
+------+--------------------+-------+
| @I3@ | Margo /Hemmingway/ | False |
+------+--------------------+-------+
"""
self.assertEqual(test_output, output.getvalue())
def test_us35_print_recent_births(self):
""" US35 unit test testing recent births
"""
# valid - pass
recent_birth = Person("@I11@")
recent_birth.set_name("Kyrie /Irving/")
recent_birth.set_gender("M")
recent_birth.set_date("30 OCT 2017", "birth")
self.peeps.individuals[recent_birth.get_person_id()] = recent_birth
# invalid - fail
not_recent_birth = Person("@I38@")
not_recent_birth.set_name("LaBron /James/")
not_recent_birth.set_gender("M")
not_recent_birth.set_date("30 OCT 1977", "birth")
self.peeps.individuals[
not_recent_birth.get_person_id()] = not_recent_birth
# capture the output
output = io.StringIO()
sys.stdout = output
self.peeps.us35_print_recent_births()
sys.stdout = sys.__stdout__
test_output = """Recent Births
+-------+----------------+---------------------+
| ID | Name | Birthdate |
+-------+----------------+---------------------+
| @I11@ | Kyrie /Irving/ | 2017-10-30 00:00:00 |
+-------+----------------+---------------------+
"""
def test_us36_print_recent_deaths(self):
""" US36 unit test testing recent deaths
"""
# valid - pass
recent_death = Person("@I49@")
recent_death.set_name("Mike /Jack/")
recent_death.set_gender("M")
recent_death.set_date("31 OCT 2017", "death")
self.peeps.individuals[recent_death.get_person_id()] = recent_death
# invalid - fail
not_recent_death = Person("@I38@")
not_recent_death.set_name("Maya /Angelou/")
not_recent_death.set_gender("M")
not_recent_death.set_date("30 OCT 1977", "death")
self.peeps.individuals[
not_recent_death.get_person_id()] = not_recent_death
# capture the output
output = io.StringIO()
sys.stdout = output
self.peeps.us36_print_recent_deaths()
sys.stdout = sys.__stdout__
test_output = """Recent Deaths
+-------+----------------+---------------------+
| ID | Name | Birthdate |
+-------+----------------+---------------------+
| @I49@ | Mike / Jack / | 2017-10-31 00:00:00 |
+-------+----------------+---------------------+
"""
def test_us_38_print_upcoming_birthdays(self):
""" US38 Unit tests
"""
recent_birthday_person = Person("@I3@")
recent_birthday_person.set_name("Margo /Hemmingway/")
recent_birthday_person.set_gender("F")
recent_birthday_person.set_date("20 NOV 1954", "birth")
self.peeps.individuals[
recent_birthday_person.get_person_id()] = recent_birthday_person
past_birthday_person = Person("@I4@")
past_birthday_person.set_name("Marge /Hemmingway/")
past_birthday_person.set_gender("F")
past_birthday_person.set_date("1 NOV 1960", "birth")
self.peeps.individuals[
past_birthday_person.get_person_id()] = past_birthday_person
deceased_person = Person("@I5@")
deceased_person.set_name("David /Hemmingway/")
deceased_person.set_gender("M")
deceased_person.set_date("8 APR 1954", "birth")
deceased_person.set_date("31 OCT 2017", "death")
self.peeps.individuals[
deceased_person.get_person_id()] = deceased_person
# capture the output
output = io.StringIO()
sys.stdout = output
self.peeps.us_38_print_upcoming_birthdays()
sys.stdout = sys.__stdout__
test_output = """Upcoming Birthdays
+------+--------------------+---------------------+
| ID | Name | Birthday |
+------+--------------------+---------------------+
| @I3@ | Margo /Hemmingway/ | 1954-11-20 00:00:00 |
+------+--------------------+---------------------+
"""
self.assertEqual(test_output, output.getvalue())