def correctSeq(self):
individuals = {
"HUSB1":
Individual("HUSB1",
name=None,
sex=None,
birth=None,
death=date(2015, 11, 6),
famc=None,
fams="TEST1"),
"WIFE1":
Individual("WIFE1",
name=None,
sex=None,
birth=None,
death=date(2015, 11, 6),
famc=None,
fams="TEST1")
}
families = {
"TEST1": Family("TEST1", [], "HUSB1", "WIFE1", date(2014, 10, 5),
None)
}
parser = TestParser(individuals, families)
self.assertEqual(len(US05.marriage_before_death(parser)), 0)
def male_last_names(self):
individuals = {
"HUSB":
Individual(id="HUSB", name="Jim Halpert", sex="M", fams="FAM1"),
"WIFE":
Individual(id="WIFE", name="Pam Halpert", sex="F", fams="FAM2"),
"CHILD":
Individual(id="CHILD",
name="Michael Halpert",
sex="M",
famc="FAM1",
fams="FAM2"),
"CHILD2":
Individual(id="CHILD2",
name="Angela Halpert",
sex="F",
famc="FAM1",
fams="FAM2")
}
families = {
"FAM1":
Family(id="FAM",
child_ids=["CHILD", "CHILD2"],
husband_id="HUSB",
wife_id="WIFE")
}
parser = TestParser(individuals, families)
error_count = len(US16.male_last_name(parser))
self.assertEqual(error_count, 0)
pass
def no_name_birthdate(self):
individuals = {
'I01':
Individual('I01',
name=None,
sex=None,
birth=None,
death=None,
famc=None,
fams=None),
'I02':
Individual('I02',
name=None,
sex=None,
birth=None,
death=None,
famc=None,
fams=None),
'I03':
Individual('I03',
name=None,
sex=None,
birth=None,
death=None,
famc=None,
fams=None)
}
families = {}
parser = TestParser(individuals, families)
self.assertEqual(len(US23.unique_names_and_birth_date(parser)), 2)
def living_married(self):
individuals = {
"HUSB1": Individual(id="HUSB1", fams="FAM1"),
"WIFE1": Individual(id="WIFE1", fams="FAM1"),
"HUSB2": Individual(id="HUSB2", fams="FAM2"),
"WIFE2": Individual(id="WIFE2", fams="FAM2"),
"WIFE3": Individual(id="WIFE3", famc="FAM3"),
}
families = {
"FAM1":
Family(id="FAM1",
married=date(2012, 11, 12),
divorced=None,
husband_id="HUSB1",
wife_id="WIFE1"),
"FAM2":
Family(id="FAM2",
married=date(2012, 10, 16),
divorced=None,
husband_id="HUSB2",
wife_id="WIFE2"),
}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US30.list_living_married(parser, db)
#print(pt_list)
self.assertGreater(TableHelpers.get_row_count(pt_list[0]), 0)
def incorrect_divorces(self):
individuals = {
"HUSB1":
Individual("HUSB1",
name=None,
sex=None,
birth=None,
death=date(2013, 11, 6),
famc=None,
fams="TEST1"),
"WIFE1":
Individual("WIFE1",
name=None,
sex=None,
birth=None,
death=date(2015, 11, 6),
famc=None,
fams="TEST1")
}
families = {
"TEST1": Family("TEST1", [], "HUSB1", "WIFE1", None,
date(2014, 10, 5))
}
parser = TestParser(individuals, families)
self.assertGreater(len(US06.divorce_before_death(parser)), 0)
def correct_individuals(self):
individuals = {
"TEST1":
Individual("TEST1",
name=None,
sex=None,
birth=None,
death=date(2001, 11, 6),
famc=None,
fams=None),
"TEST2":
Individual("TEST2",
name=None,
sex=None,
birth=date(1985, 11, 6),
death=None,
famc=None,
fams=None),
"TEST3":
Individual("TEST3",
name=None,
sex=None,
birth=None,
death=None,
famc=None,
fams=None)
}
parser = TestParser(individuals, {})
self.assertEqual(len(US01.dates_before_current_date(parser)), 0)
def marriage_after_14(self):
individuals = {
"DAD":
Individual("DAD",
name=None,
sex=None,
birth=date(1995, 11, 13),
death=None,
famc=None,
fams="FAM"),
"MOM":
Individual("MOM",
name=None,
sex=None,
birth=date(1997, 6, 20),
death=None,
famc=None,
fams="FAM")
}
families = {
"FAM":
Family("FAM",
child_ids=[],
husband_id="DAD",
wife_id="MOM",
married=date(2016, 8, 15),
divorced=None)
}
parser = TestParser(individuals, families)
self.assertEqual(len(US10.marriage_after_14(parser)), 0)
def all_unique(self):
individuals = {
'I01':
Individual('I01',
name='John 1',
sex=None,
birth=date(2013, 4, 14),
death=None,
famc=None,
fams=None),
'I02':
Individual('I02',
name='John 2',
sex=None,
birth=date(1994, 5, 16),
death=None,
famc=None,
fams=None),
'I03':
Individual('I03',
name='John 3',
sex=None,
birth=date(2014, 6, 7),
death=None,
famc=None,
fams=None)
}
families = {}
parser = TestParser(individuals, families)
self.assertEqual(len(US23.unique_names_and_birth_date(parser)), 0)
def three_not_unique(self):
individuals = {
'I01':
Individual('I01',
name='John',
sex=None,
birth=date(1994, 5, 16),
death=None,
famc=None,
fams=None),
'I02':
Individual('I02',
name='John',
sex=None,
birth=date(1994, 5, 16),
death=None,
famc=None,
fams=None),
'I03':
Individual('I03',
name='John',
sex=None,
birth=date(1994, 5, 16),
death=None,
famc=None,
fams=None)
}
families = {}
parser = TestParser(individuals, families)
self.assertEqual(len(US23.unique_names_and_birth_date(parser)), 2)
def child_birth_at_marriage(self):
individuals = {
"DAD":
Individual("DAD",
name=None,
sex=None,
birth=None,
death=None,
famc=None,
fams="FAM"),
"MOM":
Individual("MOM",
name=None,
sex=None,
birth=None,
death=None,
famc=None,
fams="FAM"),
"SON":
Individual("SON",
name=None,
sex=None,
birth=date(2010, 11, 6),
death=None,
famc="FAM",
fams=None),
}
families = {
"FAM": Family("FAM", ["SON"], None, None, date(2010, 11, 6), None)
}
parser = TestParser(individuals, families)
self.assertEqual(len(US02.birth_before_marriage(parser)), 1)
def no_siblings(self):
individuals = {
"WIFE": Individual(id="WIFE", fams="FAM"),
"HUSB": Individual(id="HUSB", fams="FAM"),
}
families = {"FAM": Family(id="FAM")}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US28.older_siblings_by_age(parser, db)
self.assertEqual(len(pt_list), 0)
def noneRecent(self):
individuals = {
"OLD1": Individual(id="OLD1", death=date(1990,2,22)),
"OLD2": Individual(id="OLD2", death=date(1991,6,16))
}
parser = TestParser(individuals, {})
db = TestDatabase(individuals, {})
pt_list = US36.list_recent_deaths(parser, db)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 0)
def recent(self):
individuals = {
"RECENT": Individual(id="RECENT", death=date.today()),
"OLD": Individual(id="OLD", death=date(1989,7,31))
}
parser = TestParser(individuals, {})
db = TestDatabase(individuals, {})
pt_list = US36.list_recent_deaths(parser, db)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 1)
def one_table(self):
individuals = {
"PERSON1": Individual(id="PERSON1", death=date(2019, 10, 1)),
"PERSON2": Individual(id="PERSON2", death=date(2019, 5, 4)),
"PERSON3": Individual(id="PERSON3", death=date(2019, 4, 3)),
}
families = {}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US29.list_deceased(parser, db)
self.assertEqual(len(pt_list), 1)
def all_deceased(self):
individuals = {
"PERSON1": Individual(id="PERSON1", death=date(2005, 10, 5)),
"PERSON2": Individual(id="PERSON2", death=date(2005, 10, 15)),
"PERSON3": Individual(id="PERSON3", death=date(2006, 9, 5)),
}
families = {}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US29.list_deceased(parser, db)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 3)
def no_siblings(self):
individuals = {
"DAD": Individual("DAD", name=None, sex=None, birth=None, death=None, famc=None, fams="FAM"),
"MOM": Individual("MOM", name=None, sex=None, birth=None, death=None, famc=None, fams="FAM"),
"CHILD1": Individual("CHILD1", name=None, sex=None, birth=date(2013, 4, 14), death=None, famc="FAM", fams=None)
}
families = {
"FAM": Family("FAM", child_ids=["CHILD1"], husband_id="DAD", wife_id="MOM", married=None, divorced=None)
}
parser = TestParser(individuals, families)
self.assertEqual(len(US13.sibling_spacing(parser)), 0)
def nullDadBirth(self):
individuals = {
"DAD": Individual("DAD", name=None, sex=None, birth=None, death=None, famc=None, fams="FAM"),
"MOM": Individual("MOM", name=None, sex=None, birth=date(1985, 10, 6), death=None, famc=None, fams="FAM"),
"CHILD": Individual("CHILD", name=None, sex=None, birth=date(2015, 10, 6), death=None, famc=None, fams="FAM")
}
families = {
"FAM": Family("FAM", child_ids=["CHILD"], husband_id="DAD", wife_id="MOM", married=None, divorced=None)
}
parser = TestParser(individuals, families)
self.assertEqual(len(US12.parents_not_too_old(parser)), 0)
def correct_gender_for_role(self):
individuals = {
"HUSB": Individual(id="HUSB", name="Jim", sex="M", fams="FAM1"),
"WIFE": Individual(id="WIFE", name="Pam", sex="F", fams="FAM2"),
"CHILD": Individual(id="CHILD", name="Dwight", sex="M", famc="FAM1", fams="FAM2"),
}
families = {
"FAM1": Family(id="FAM", child_ids=["CHILD"], husband_id="HUSB", wife_id="WIFE")
}
parser = TestParser(individuals, families)
self.assertEqual(len(US21.correct_gender_for_role(parser)), 0)
def correct(self):
individuals = {
"DAD": Individual("DAD", name=None, sex=None, birth=None, death=date(2017, 10, 6), famc=None, fams="FAM"),
"MOM": Individual("MOM", name=None, sex=None, birth=None, death=date(2018, 10, 6), famc=None, fams="FAM"),
"CHILD": Individual("CHILD", name=None, sex=None, birth=date(2015, 10, 6), death=None, famc=None, fams="FAM")
}
families = {
"FAM": Family("FAM", child_ids=["CHILD"], husband_id="DAD", wife_id="MOM", married=None, divorced=None)
}
parser = TestParser(individuals, families)
self.assertEqual(len(US09.birth_before_parent_death(parser)), 0)
def none_deceased(self):
individuals = {
"PERSON1": Individual(id="PERSON1"),
"PERSON2": Individual(id="PERSON2"),
"PERSON3": Individual(id="PERSON3"),
}
families = {}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US29.list_deceased(parser, db)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 0)
def nonUniqueIndiv(self):
individuals = {
"HUSB": Individual(id="SPOUSE", fams="FAM1", duplicates=1),
"WIFE": Individual(id="SPOUSE", fams="FAM1"),
}
families = {
"FAM1": Family(id="FAM1", married=date(2012,11,12), divorced=None, husband_id="HUSB", wife_id="WIFE1"),
"FAM2": Family(id="FAM2", married=date(2012,10,16), divorced=None, husband_id="HUSB", wife_id="WIFE2"),
}
parser = TestParser(individuals, families)
error_count = len(US22.unique_ids(parser))
self.assertEqual(error_count, 1)
def large_age_differences(self):
individuals = {
"HUSB1": Individual(id="HUSB1", birth=date(1967,9,30),fams="FAM1"),
"WIFE1": Individual(id="WIFE1", birth=date(1989,7,31),fams="FAM1")
}
families = {
"FAM1": Family(id="FAM1", married=date(2009,10,31), divorced=None, husband_id="HUSB1", wife_id="WIFE1")
}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US34.list_large_age_differences(parser, db)
#print(pt_list[0])
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 2)
def not_large_age_differences(self):
individuals = {
"HUSB2": Individual(id="HUSB2", birth=date(1990,2,22),fams="FAM2"),
"WIFE2": Individual(id="WIFE2", birth=date(1991,6,16),fams="FAM2")
}
families = {
"FAM2": Family(id="FAM2", married=date(2012,10,16), divorced=None, husband_id="HUSB2", wife_id="WIFE2")
}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US34.list_large_age_differences(parser, db)
#print(pt_list[0])
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 0)
def living_single(self):
individuals = {
"HUSB": Individual(id="HUSB", birth=date(1900, 2, 11), famc="FAM1"),
"WIFE": Individual(id="WIFE", birth=date(1930, 4, 18), famc="FAM2"),
"HUSB2": Individual(id="HUSB2", birth=date(2000, 8, 17), fams="FAM2"),
"WIFE2": Individual(id="WIFE2", birth=date(1990, 9, 26), fams="FAM2"),
}
families = {
"FAM2": Family(id="FAM2", married=date(2012,10,16), divorced=None, husband_id="HUSB2", wife_id="WIFE2")
}
parser = TestParser(individuals, families)
db = TestDatabase(individuals, families)
pt_list = US31.list_living_single(parser, db)
#print(pt_list)
self.assertGreater(TableHelpers.get_row_count(pt_list[0]), 0)
def correct_order(self):
individuals = {
"TEST1":
Individual("TEST1", None, None, date(1998, 2, 16),
date(2015, 10, 6), None, None)
}
parser = TestParser(individuals, {})
self.assertEqual(len(US03.birth_before_death(parser)), 0)
def incorrect_birth_null(self):
individuals = {
"TEST1":
Individual("TEST1", None, None, None, date(1998, 2, 16), None,
None)
}
parser = TestParser(individuals, {})
self.assertGreater(len(US03.birth_before_death(parser)), 0)
def incorrect_age(self):
individuals = {
"TEST1":
Individual("TEST1", None, None, date(1800, 2, 16),
date(2015, 10, 6), None, None)
}
parser = TestParser(individuals, {})
self.assertGreater(len(US07.less_than_150_years_old(parser)), 0)
def one_table(self):
birthday = date(2001, self.today.month, self.today.day)
individuals = {
"PERSON1":
Individual(id="PERSON1",
birth=DateHelpers.add_time(birthday, 15, "days")),
"PERSON2":
Individual(id="PERSON2",
birth=DateHelpers.add_time(birthday, 16, "days")),
"PERSON3":
Individual(id="PERSON3",
birth=DateHelpers.add_time(birthday, 1, "days")),
}
families = {}
parser = TestParser(individuals, families)
pt_list = US38.upcoming_birthdays(parser)
self.assertEqual(len(pt_list), 1)
def two_birthdays(self):
birthday = date(2001, self.today.month, self.today.day)
individuals = {
"PERSON1":
Individual(id="PERSON1",
birth=DateHelpers.add_time(birthday, 25, "days")),
"PERSON2":
Individual(id="PERSON2",
birth=DateHelpers.add_time(birthday, 70, "days")),
"PERSON3":
Individual(id="PERSON3",
birth=DateHelpers.add_time(birthday, 15, "days")),
}
families = {}
parser = TestParser(individuals, families)
pt_list = US38.upcoming_birthdays(parser)
self.assertEqual(TableHelpers.get_row_count(pt_list[0]), 2)
def no_married_siblings(self):
individuals = {
'I01':
Individual('I01',
name='John',
sex=None,
birth=None,
death=None,
famc=None,
fams=None),
'I02':
Individual('I02',
name='Marie',
sex=None,
birth=None,
death=None,
famc=None,
fams=None),
'I03':
Individual('I03',
name='Robert',
sex=None,
birth=None,
death=None,
famc=None,
fams=None)
}
families = {
'FAM1':
Family('FAM1',
child_ids=['I01', 'I03'],
husband_id=None,
wife_id=None,
married=None,
divorced=None),
'FAM2':
Family('FAM2',
child_ids=[],
husband_id='I01',
wife_id='I02',
married=None,
divorced=None)
}
parser = TestParser(individuals, families)
self.assertEqual(len(US18.no_married_siblings(parser)), 0)
