def test_new_anonymous_name(family):
assert (family.new_anonymous_name() == '?')
assert (family.new_anonymous_name() == '?')
assert (family.new_anonymous_name() == '?')
p = pedigree_lib.Person(name='?', gender='female')
family.add_person(p)
assert (family.new_anonymous_name() == '??')
assert (family.new_anonymous_name() == '??')
q = pedigree_lib.Person(name='??????', gender='female')
family.add_person(q)
assert (family.new_anonymous_name() == '???????')
assert (family.new_anonymous_name() == '???????')
def test_family_change_name(family, persons_dict, names):
# Change person b's name to boo
newly_named = pedigree_lib.Person(name='boo', gender='female')
new_names = list(names)
new_names[2] = 'boo'
new_family = pedigree_lib.Family()
new_family.add_children(persons_dict['a'],
[persons_dict['b'], newly_named])
new_family.add_child(persons_dict['d'], persons_dict['e'])
new_family.add_child(persons_dict['d'], persons_dict['k'])
new_family.add_child(persons_dict['i'], persons_dict['j'])
new_family.add_child(persons_dict['i'], newly_named)
new_family.add_children(persons_dict['f'],
[persons_dict['g'], persons_dict['h']])
new_family.add_spouses(persons_dict['k'],
[persons_dict['l'], persons_dict['m']])
new_family.add_spouse(persons_dict['l'], persons_dict['k'])
new_family.add_spouse(persons_dict['m'], persons_dict['k'])
new_family.add_spouse(persons_dict['n'], persons_dict['o'])
new_family.add_spouse(persons_dict['o'], persons_dict['n'])
new_family.notes[persons_dict['a']] = ["This guy is named a"]
new_family.notes[persons_dict['d']] = ["This guy is named d"]
assert family != new_family
assert family.names() != new_names
family.change_name(persons_dict['c'], 'boo')
assert family == new_family
assert set(family.names()) == set(new_names)
def test_family_add_mother(family, fathers, mothers, spouses, persons_dict,
persons):
boo = pedigree_lib.Person(name='boo', gender='female')
with pytest.raises(pedigree_lib.GenealogicalError):
family.add_mother(persons_dict['g'], boo)
with pytest.raises(pedigree_lib.GenealogicalError):
family.add_mother(persons_dict['h'], boo)
with pytest.raises(pedigree_lib.GenealogicalError):
family.add_mother(persons_dict['j'], boo)
with pytest.raises(pedigree_lib.GenealogicalError):
family.add_mother(persons_dict['a'], persons_dict['a'])
family.add_mother(persons_dict['f'], boo)
# Becomes
# fathers: a -> b, c d -> e, k
# mothers: i -> j, c f -> g, h boo -> f
# spouses: k <-> l, m n <-> o
assert set(family.mothers()) == set(mothers + [boo])
assert set(family.persons()) == set(persons + [boo])
assert set(family.fathers()) == set(fathers)
assert set(family.spouses()) == set(spouses)
family.add_mother(persons_dict['e'], persons_dict['i'])
# Becomes
# fathers: a -> b, c d -> e, k
# mothers: i -> j, c, e f -> g, h boo -> f
# spouses: k <-> l, m n <-> o
assert set(family.mothers()) == set(mothers + [boo])
assert set(family.persons()) == set(persons + [boo])
assert set(family.fathers()) == set(fathers)
assert set(family.spouses()) == set(spouses)
assert set(family.children(persons_dict['i'])) == \
set([persons_dict['j'], persons_dict['c'], persons_dict['e']])
assert set(family.children(persons_dict['d'])) == \
set([persons_dict['e'], persons_dict['k']])
def p():
p = pedigree_lib.Person(name='p', gender='female')
def persons_dict():
to_return = {}
to_return['a'] = pedigree_lib.Person(name='a', gender="male")
to_return['b'] = pedigree_lib.Person(name='b', gender="female")
to_return['c'] = pedigree_lib.Person(name='c', gender="female")
to_return['d'] = pedigree_lib.Person(name='d', gender="male")
to_return['e'] = pedigree_lib.Person(name='e', gender="female")
to_return['f'] = pedigree_lib.Person(name='f', gender="female")
to_return['g'] = pedigree_lib.Person(name='g', gender="female")
to_return['h'] = pedigree_lib.Person(name='h', gender="female")
to_return['i'] = pedigree_lib.Person(name='i', gender="female")
to_return['j'] = pedigree_lib.Person(name='j', gender="female")
to_return['k'] = pedigree_lib.Person(name='k', gender="male")
to_return['l'] = pedigree_lib.Person(name='l', gender="male")
to_return['m'] = pedigree_lib.Person(name='m', gender="female")
to_return['n'] = pedigree_lib.Person(name='n', gender="female")
to_return['o'] = pedigree_lib.Person(name='o', gender="male")
return to_return
def test_family_add_full_sibling(family, persons, fathers, mothers,
persons_dict, names):
# Add one sibling
p = pedigree_lib.Person(name='p', gender='female')
family.add_full_sibling(persons_dict['b'], p)
# Becomes
# fathers: a -> b, c, p d -> e, k
# mothers: i -> j, c f -> g, h ? -> b, p
# spouses: k <-> l, m n <-> o
mom = pedigree_lib.Person(name='?', gender="female")
assert sorted(family.persons()) == sorted(persons + [p, mom])
assert set(family.fathers()) == set(fathers)
assert sorted(family.mothers()) == sorted(mothers + [mom])
assert set(family.children(persons_dict['a'])) == \
set([persons_dict['b'], persons_dict['c'], p])
assert set(family.children(mom)) == set([persons_dict['b'], p])
# Leaves spouses alone
family.spouses == spouses
# Add another sibling
q = pedigree_lib.Person(name='q', gender="male")
family.add_full_sibling(persons_dict['j'], q)
# Becomes
# fathers: a -> b, c, p d -> e, k ?? -> j, q
# mothers: i -> j, c, q f -> g, h ? -> b, p
# spouses: k <-> l, m n <-> o
dad = pedigree_lib.Person(name='??', gender="male")
# Creates the sibling and a father
assert sorted(family.persons()) == \
sorted(persons + [p, q, mom, dad])
assert sorted(family.fathers()) == sorted(fathers + [dad])
assert sorted(family.mothers()) == sorted(mothers + [mom])
assert sorted(family.children(persons_dict['a'])) == \
sorted([persons_dict['b'], persons_dict['c'], p])
assert sorted(family.children(persons_dict['i'])) == \
sorted([persons_dict['j'], persons_dict['c'], q])
assert sorted(family.children(mom)) == sorted([persons_dict['b'], p])
assert sorted(family.children(dad)) == sorted([persons_dict['j'], q])
# Add a full sibling to an existing nuclear family
r = pedigree_lib.Person(name='r', gender='female')
family.add_full_sibling(persons_dict['c'], r)
# Becomes
# fathers: a -> b, c, p, r d -> e, k ?? -> j, q
# mothers: i -> j, c, q, r f -> g, h ? -> b, p
# spouses: k <-> l, m n <-> o
assert sorted(family.persons()) == \
sorted(persons + [p, q, r, mom, dad])
assert sorted(family.fathers()) == sorted(fathers + [dad])
assert sorted(family.mothers()) == sorted(mothers + [mom])
assert sorted(family.children(persons_dict['a'])) == \
sorted([persons_dict['b'], persons_dict['c'], p, r])
assert sorted(family.children(persons_dict['i'])) == \
sorted([persons_dict['j'], persons_dict['c'], q, r])
assert sorted(family.children(mom)) == sorted([persons_dict['b'], p])
assert sorted(family.children(dad)) == sorted([persons_dict['j'], q])