def test_us12(self):
""" us12 tests """
self.assertEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us12(
get_data_file_path('us12&15.ged'))), ['I20'])
self.assertNotEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us12(
get_data_file_path('us12&15.ged'))), ['F1', 'F3'])
self.assertNotEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us12(
get_data_file_path('us12&15.ged'))), [])
def test_us07(self):
""" us07 tests """
self.assertEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us07(
get_data_file_path('us07.ged'))), ['I1', 'I3'])
self.assertNotEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us07(
get_data_file_path('us07.ged'))), ['US0507I2', 'US0507I3'])
self.assertNotEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us07(
get_data_file_path('us07.ged'))), [])
def test_us25(self):
""" us25 tests """
self.assertEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us25(
get_data_file_path('US23&25.ged'))), ['F1', 'F3'])
self.assertNotEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us25(
get_data_file_path('US23&25.ged'))), ['F1'])
self.assertNotEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us25(
get_data_file_path('US23&25.ged'))), "")
def test_us23(self):
""" us23 tests """
self.assertEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us23(
get_data_file_path('US23&25.ged'))), ['I3', 'I5', 'I7', 'I9'])
self.assertNotEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us23(
get_data_file_path('US23&25.ged'))), ['I3', 'I5'])
self.assertNotEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us23(
get_data_file_path('US23&25.ged'))), [])
def test_us05(self):
""" us05 tests """
self.assertEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us05(
get_data_file_path('us05.ged'))), ['F1', 'F2'])
self.assertNotEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us05(
get_data_file_path('us05.ged'))), ['US0507F1', 'US0507F3'])
self.assertNotEqual(
UserStoriesDg().get_id_list(UserStoriesDg().us05(
get_data_file_path('us05.ged'))), [])
def run_sprint2():
error_list = []
fp = get_data_file_path('data_sprint_2.ged')
Sprint.logger.error(
'######################################## starting sprint 2 ... ########################################'
)
try:
Tree().grow(fp).pretty_print()
usny, usmsk, usam, usdg, usrk = UserStoriesNy(), UserStoriesMSK(
), UserStoriesAm(), UserStoriesDg(), UserStoriesRK()
error_list.extend(usny.us13(fp))
error_list.extend(usny.us19(fp))
error_list.extend(usdg.us15(fp))
error_list.extend(usdg.us12(fp))
error_list.extend(usrk.us14(fp))
error_list.extend(usrk.us21(fp))
error_list.extend(usam.us11(fp))
error_list.extend(usam.us16(fp))
error_list.extend(usmsk.us17(fp))
error_list.extend(usmsk.us18(fp))
TreeUtils.print_report('Sprint 2 Report', error_list)
except FileNotFoundError:
print(f'File not found: {fp}')
Sprint.logger.error(
'######################################## ending sprint 2 ... ########################################\n'
)
def run_sprint1():
error_list = []
fp = get_data_file_path('data_sprint_1.ged')
Sprint.logger.error(
'######################################## starting sprint 1 ... ########################################'
)
try:
tree = Tree().grow(fp).pretty_print()
usny, usmsk, usam, usdg, usrk = UserStoriesNy(), UserStoriesMSK(
), UserStoriesAm(), UserStoriesDg(), UserStoriesRK()
error_list.extend(usmsk.us09(fp))
error_list.extend(usmsk.us10(fp))
error_list.extend(usny.us01(fp))
error_list.extend(usny.us08(fp))
error_list.extend(usam.us02(fp))
error_list.extend(usam.us06(fp))
error_list.extend(usdg.us05(fp))
error_list.extend(usdg.us07(fp))
error_list.extend(usrk.us03(fp))
error_list.extend(usrk.us04(fp))
TreeUtils.print_report('Sprint 1 Report', error_list)
except FileNotFoundError:
print(f'File not found: {fp}')
Sprint.logger.error(
'######################################## ending sprint 1 ... ########################################\n'
)
def us08(self, file_path=None):
""" returns a list of individuals whose birth date is before parent's marriage date
or nine months after parent's divorce date
"""
# self.logger.error(TreeUtils.form_heading('Starting User Story 8', '#', 70))
file_path = file_path if file_path else get_data_file_path('us08.ged')
family_tree = TreeLine().process_data(file_path)
indi_list = family_tree.get_sorted_list(UserStoriesNy.INDI_TAG)
indi_list_us08_fail = []
for indi in indi_list:
birth_date = indi.get_birth_date()
parent_marr_date = indi.get_parent_marr_date(family_tree)
parent_div_date = indi.get_parent_div_date(family_tree)
# if birth date is on or before marriage date, add indi to failure list
# if birth_date and parent_marr_date and birth_date <= parent_marr_date:
if date_greater_than(parent_marr_date,
birth_date) or date_equal_to(
parent_marr_date, birth_date):
warn_msg = f'Birth date {birth_date.strftime(TreeUtils.OUTPUT_DATE_FORMAT)} ' \
f'is before or on parent\'s marriage date {parent_marr_date.strftime(TreeUtils.OUTPUT_DATE_FORMAT)}'
indi.err = TreeError(TreeError.TYPE_ERROR, TreeError.ON_INDI,
'US08', indi.id, warn_msg)
indi_list_us08_fail.append(indi)
if date_greater_than(birth_date,
add_to_date(parent_div_date, months=9)):
warn_msg = f'Birth date {birth_date.strftime(TreeUtils.OUTPUT_DATE_FORMAT)} ' \
f'is more than 9 months after parent\'s divorce date {parent_div_date.strftime(TreeUtils.OUTPUT_DATE_FORMAT)}'
indi.err = TreeError(TreeError.TYPE_ERROR, TreeError.ON_INDI,
'US08', indi.id, warn_msg)
indi_list_us08_fail.append(indi)
return indi_list_us08_fail
def test_us16(self):
""" us16 tests """
fp = get_data_file_path('US11and16.ged')
self.assertEqual(self.get_id_list(UserStoriesAm().us16(fp)), ['F1'])
self.assertNotEqual(self.get_id_list(UserStoriesAm().us16(fp)), [])
self.assertNotEqual(self.get_id_list(UserStoriesAm().us16(fp)), "")
def us06(self, file_path=None):
""" return a list of objects whose divorce date is after death date """
file_path = file_path if file_path else get_data_file_path('us06.ged')
family_tree = TreeLine().process_data(file_path)
fam_list = family_tree.get_fam_list()
indi_list_us06_fail = []
for fam in fam_list:
husband_death_date = family_tree.get(fam.husb).get_death_date() if family_tree.get(fam.husb) else None
wife_death_date = family_tree.get(fam.wife).get_death_date() if family_tree.get(fam.wife) else None
divorce_date = fam.get_div_date()
if divorce_date:
if husband_death_date and wife_death_date:
if divorce_date >= husband_death_date and divorce_date >= wife_death_date:
warn_msg = f"death date {family_tree.get(fam.husb).get_death_date(TreeUtils.OUTPUT_DATE_FORMAT)}, {family_tree.get(fam.wife).get_death_date(TreeUtils.OUTPUT_DATE_FORMAT)} is before the divorce date for both {fam.get_div_date(TreeUtils.OUTPUT_DATE_FORMAT)}"
fam.err = TreeError(TreeError.TYPE_ERROR, TreeError.ON_FAM, 'US06', fam.id, warn_msg)
indi_list_us06_fail.append(fam)
elif husband_death_date or wife_death_date:
if husband_death_date and divorce_date >= husband_death_date:
warn_msg = f"death date {family_tree.get(fam.husb).get_death_date(TreeUtils.OUTPUT_DATE_FORMAT)} of husband is before the divorce date {fam.get_div_date(TreeUtils.OUTPUT_DATE_FORMAT)}"
fam.err = TreeError(TreeError.TYPE_ERROR, TreeError.ON_FAM, 'US06', fam.id, warn_msg)
indi_list_us06_fail.append(fam)
if wife_death_date and divorce_date >= wife_death_date:
warn_msg = f"death date {family_tree.get(fam.wife).get_death_date(TreeUtils.OUTPUT_DATE_FORMAT)} of wife is before the divorce date {fam.get_div_date(TreeUtils.OUTPUT_DATE_FORMAT)}"
fam.err = TreeError(TreeError.TYPE_ERROR, TreeError.ON_FAM, 'US06', fam.id, warn_msg)
indi_list_us06_fail.append(fam)
else:
continue
# if indi_list_us06_fail:
# TreeUtils.print_report("US06 divorce date is after death date ", indi_list_us06_fail)
return indi_list_us06_fail
def test_us30(self):
""" us30 tests """
fp = get_data_file_path('US27and30.ged')
self.assertEqual(self.get_id_list(UserStoriesAm().us30(fp)),
['I1', 'I2', 'I4', 'I5', 'I6', 'I7'])
self.assertNotEqual(self.get_id_list(UserStoriesAm().us30(fp)), [])
self.assertNotEqual(self.get_id_list(UserStoriesAm().us30(fp)), "")
def test_us14(self):
""" testing us14"""
fp = get_data_file_path('US14.ged')
self.assertEqual(UserStoriesRK().get_id_list(UserStoriesRK().us14(fp)),
['F1'])
self.assertNotEqual(
UserStoriesRK().get_id_list(UserStoriesRK().us14(fp)),
['I01', 'I03'])
def us22(self, file_path=None):
""" All individual IDs should be unique and all family IDs should be unique """
file_path = file_path if file_path else get_data_file_path('us22.ged')
# file_path = get_data_file_path('us22.ged')
family_tree = Tree(file_path)
us22_fail = family_tree.duplicate_items
for item in us22_fail:
warn_msg = f'duplicate item [{item.id}], {item}'
err_on = TreeError.ON_INDI if item.tag_name == TreeUtils.INDI else TreeError.ON_FAM
item.err = TreeError(TreeError.TYPE_ERROR, err_on, 'US22', item.id,
warn_msg)
return us22_fail
def run_sprint_test():
error_list = []
# fp = os.path.join(os.path.realpath('.'), 'com', 'familytree', 'data', 'us10.ged')
fp = get_data_file_path('us26.ged')
try:
family_tree = Tree().grow(fp)
family_tree.pretty_print()
error_list.extend(UserStoriesNy().us26(fp))
TreeUtils.print_report('US 26', error_list)
except FileNotFoundError:
print(f'File not found: {fp}')
except Exception as e:
# print(f'Exception occurred: {str(e)}')
# e.print_exception()
traceback.print_exc(file=sys.stderr)
def test_us27(self):
""" us27 tests """
fp = get_data_file_path('US27and30.ged')
self.assertEqual(
UserStoriesAm().us27(fp), {
'I1': 44,
'I2': 39,
'I3': 19,
'I4': 19,
'I5': 17,
'I6': 16,
'I7': 16,
'I8': 17
})
self.assertNotEqual(UserStoriesAm().us27(fp), [])
self.assertNotEqual(UserStoriesAm().us27(fp), "")
def us26(self, file_path=None):
""" All family roles (spouse, child) specified in an individual record should have corresponding entries in
the corresponding family records. Likewise, all individual roles (spouse, child) specified in family records
should have corresponding entries in the corresponding individual's records. I.e. the information in the
individual and family records should be consistent. """
file_path = file_path if file_path else get_data_file_path('us26.ged')
family_tree = Tree().grow(file_path)
us26_fail = []
indi_list = family_tree.get_indi_list()
logger = self.logger
for indi in indi_list:
# TODO have to add handling for multiple errors on single indi/fam object
self.check_family_roles(indi, family_tree, us26_fail)
for fam in family_tree.get_fam_list():
self.check_indi_roles(fam, family_tree, us26_fail)
return us26_fail
def us19(self, file_path=None):
""" cousins should not marry """
file_path = file_path if file_path else get_data_file_path('us08.ged')
family_tree = TreeLine().process_data(file_path)
us19_fail = []
indi_list = family_tree.get_indi_list()
for indi in indi_list:
cousin_list = indi.get_cousins(family_tree)
spouse_list = indi.get_spouses(family_tree)
common_indi_list = set(cousin_list) & set(spouse_list)
if common_indi_list:
for cousin in common_indi_list:
warn_msg = f'{indi.name} married first cousin {cousin.name}'
# indi.err = TreeError(TreeError.TYPE_ERROR, TreeError.ON_INDI, 'US19', indi.id, warn_msg)
indi.add_err(TreeError.TYPE_ERROR, 'US19', warn_msg)
if indi.err or indi.err_list:
us19_fail.append(indi)
return us19_fail
def us02(self, file_path=None):
"""return a list of objects whose birth date is after or on their marriage date """
file_path = file_path if file_path else get_data_file_path('us02.ged')
family_tree = TreeLine().process_data(file_path)
indi_list = family_tree.get_sorted_list(UserStoriesAm.INDI_TAG)
indi_list_us02_fail = []
for indi in indi_list:
birth_date = indi.get_birth_date()
for spouse in indi.fams:
marriage_date = family_tree.get(spouse).get_marr_date() if family_tree.get(spouse) else None
if marriage_date and birth_date >= marriage_date:
warn_msg = f"birth date {indi.get_birth_date(TreeUtils.OUTPUT_DATE_FORMAT)} should not occur after or on marriage date {family_tree.get(spouse).get_marr_date(TreeUtils.OUTPUT_DATE_FORMAT)}"
indi.err = TreeError(TreeError.TYPE_ERROR, TreeError.ON_INDI, 'US02', indi.id, warn_msg)
indi_list_us02_fail.append(indi)
continue
# if indi_list_us02_fail:
# TreeUtils.print_report("US02 birth date is after marriage date ", indi_list_us02_fail)
# print('prining indi us02 failed:')
# for indi in indi_list_us02_fail:
# print(indi)
return indi_list_us02_fail
def us13(self, file_path=None):
""" sibling spacing, should be more than 8 months apart """
file_path = file_path if file_path else get_data_file_path('us13.ged')
family_tree = TreeLine().process_data(file_path)
indi_list = family_tree.get_indi_list()
us13_fail = []
for indi in indi_list:
sibling_list = indi.get_siblings(family_tree)
for sibling in sibling_list:
date_diff = indi.get_birth_date() - sibling.get_birth_date()
if 30.4 * 8 >= abs(date_diff.days) >= 2:
# TODO f"{today:%B %d, %Y}"
warn_msg = f'{indi.name} and {sibling.name} have birth dates {indi.get_birth_date(TreeUtils.OUTPUT_DATE_FORMAT)}' \
f', {sibling.get_birth_date(TreeUtils.OUTPUT_DATE_FORMAT)} less than 8 months and more than 1 day apart'
err_id_1 = indi.id
err_id_2 = sibling.id
# indi.err = TreeError(TreeError.TYPE_ERROR, TreeError.ON_INDI, 'US13', indi.id, warn_msg)
indi.add_err(TreeError.TYPE_ERROR, 'US13', warn_msg)
if indi.err or indi.err_list:
us13_fail.append(indi)
return us13_fail
def run_sprint3():
error_list = []
fp = get_data_file_path('data_sprint_3.ged')
Sprint.logger.error(
'######################################## starting sprint 3 ... ########################################'
)
Tree().grow(fp).pretty_print()
usny, usmsk, usam, usdg, usrk = UserStoriesNy(), UserStoriesMSK(
), UserStoriesAm(), UserStoriesDg(), UserStoriesRK()
error_list.extend(usny.us22(fp))
error_list.extend(usny.us26(fp))
usrk.us28(fp)
usrk.us29(fp)
usam.us27(fp)
usam.us30(fp)
error_list.extend(usdg.us23(fp))
error_list.extend(usdg.us25(fp))
error_list.extend(usmsk.us20(fp))
error_list.extend(usmsk.us31(fp))
TreeUtils.print_report('Sprint 3 Report', error_list)
Sprint.logger.error(
'######################################## ending sprint 3 ... ########################################\n'
)
def us01(self, file_path=None):
""" returns a list of objects containing dates after current date
"""
# self.logger.error(TreeUtils.form_heading("Starting User Story 1", "#", 70))
file_path = file_path if file_path else get_data_file_path('us01.ged')
family_tree = TreeLine().process_data(file_path)
indi_list, fam_list = family_tree.get_sorted_list(UserStoriesNy.INDI_TAG), \
family_tree.get_sorted_list(UserStoriesNy.FAM_TAG)
today_date = datetime.today()
indi_list_us01, fam_list_us01 = [], []
# if there is error in both birth and death criteria, only birth will be listed
for indi in indi_list:
if date_greater_than(indi.get_birth_date(), today_date):
warn_msg = f'Birthday {indi.get_birth_date(TreeUtils.OUTPUT_DATE_FORMAT)} occurs in future'
indi.err = TreeError(TreeError.TYPE_ERROR, TreeError.ON_INDI,
'US01', indi.id, warn_msg)
indi_list_us01.append(indi)
if date_greater_than(indi.get_death_date(), today_date):
warn_msg = f'Death day {indi.get_death_date(TreeUtils.OUTPUT_DATE_FORMAT)} occurs in future'
indi.err = TreeError(TreeError.TYPE_ERROR, TreeError.ON_INDI,
'US01', indi.id, warn_msg)
indi_list_us01.append(indi)
# if there is error in both marriage and divorce criteria, only marriage will be listed
for fam in fam_list:
if date_greater_than(fam.get_marr_date(), today_date):
warn_msg = f'Marriage date {fam.get_marr_date(TreeUtils.OUTPUT_DATE_FORMAT)} occurs in future'
fam.err = TreeError(TreeError.TYPE_ERROR, TreeError.ON_FAM,
'US01', fam.id, warn_msg)
fam_list_us01.append(fam)
if date_greater_than(fam.get_div_date(), today_date):
warn_msg = f'Divorce date {fam.get_div_date(TreeUtils.OUTPUT_DATE_FORMAT)} occurs in future'
fam.err = TreeError(TreeError.TYPE_ERROR, TreeError.ON_FAM,
'US01', fam.id, warn_msg)
fam_list_us01.append(fam)
return indi_list_us01 + fam_list_us01
def test_us13(self):
self.assertEqual(['I1', 'I10', 'I5', 'I7'], get_id_list(self.stories.us13(get_data_file_path('us13.ged'))))
def test_us20(self):
""" I10, I4 have failing criteria in US20.ged """
error_list = self.stories.us20(get_data_file_path('US20.ged'))
self.assertEqual(['I10', 'I4'], get_id_list(error_list))
def test_us31(self):
""" I1, I10, I6 have failing criteria in US31.ged """
error_list = self.stories.us31(get_data_file_path('US31.ged'))
self.assertEqual(['I1', 'I10', 'I6'], get_id_list(error_list))
def test_us22(self):
self.assertEqual(['I2', 'I5', 'F1'], get_id_list(self.stories.us22(get_data_file_path('us22.ged'))))
def test_us01(self):
""" I1, I5, F1 have failing criteria in us01.ged """
self.assertEqual(['I1', 'I5', 'F1'], get_id_list(self.stories.us01(get_data_file_path('us01.ged'))))
def test_us19(self):
self.assertEqual(['I12', 'I8'], get_id_list(self.stories.us19(get_data_file_path('us19.ged'))))
def test_us18(self):
""" I1, I2, I6, I8 have failing criteria in us18.ged """
error_list = self.stories.us18(get_data_file_path('us18.ged'))
self.assertEqual(['I1', 'I2', 'I6', 'I8'], get_id_list(error_list))
def test_us26(self):
self.assertEqual(['I2', 'I6', 'F1', 'F2', 'F3'], get_id_list(self.stories.us26(get_data_file_path('us26.ged'))))
def test_us08(self):
""" I5, I6, I7, I8 have failing criteria in us08.ged """
self.assertEqual(['I5', 'I6', 'I7', 'I8'], get_id_list(self.stories.us08(get_data_file_path('us08.ged'))))
