def testCantAffordTraits(self):
char = Character([human.BornNobility(), human.NobleCoeptir(), human.NobleArmiger()])
self.assertEquals(char.trait_points(), 1)
self.assertRaises(NotAllowed, char.buy_trait, trait.CalmDemeanor())
self.assertEquals(char.trait_points(), 1)
char.add_path(human.NobleLPAnvil())
self.assertEquals(char.trait_points(),2)
char.buy_trait(trait.CalmDemeanor())
self.assertEquals(char.traits(), [trait.MarkOfPrivilege(), trait.AnvilTrained(), trait.CorvusAndCrucis(), trait.CalmDemeanor()])
self.assertEquals(char.trait_points(),0)
def testRemoveTraits(self):
char = Character([human.BornNobility(), human.NobleCoeptir(), human.NobleArmiger(), human.NobleLPAnvil()])
char.buy_trait(trait.CharacterTrait('Trait 1'))
char.buy_trait(trait.IronTrained())
self.assertEquals(char.trait_points(), 0)
char.remove_trait(trait.IronTrained())
self.assertEquals(char.trait_points(), 1)
self.assertRaises(Exception, char.remove_trait, trait.CharacterTrait('Trait 2'))
char.remove_trait(trait.CharacterTrait('Trait 1'))
self.assertEquals(char.trait_points(), 2)
def testCreateInBatch(self):
char_series = Character().add_path(Lifepath(born=True)).add_path(Lifepath()).add_path(Lifepath())
char_batch = Character([Lifepath(born=True),Lifepath(),Lifepath()])
self.assertEquals(char_series.path_count(),char_batch.path_count())
self.assertEquals(char_series.age(),char_batch.age())
self.assertEquals(char_series.circles(),char_batch.circles())
self.assertEquals(char_series.resources(),char_batch.resources())
self.assertEquals(char_series.traits(),char_batch.traits())
self.assertEquals(char_series.lifepath_traits(),char_batch.lifepath_traits())
self.assertEquals(char_series.trait_points(),char_batch.trait_points())
def testTraitsGetCheaper(self):
"""A trait can be bought, after which a lifepath is added that puts that trait on the available list.
The difference in cost should be refunded
"""
char = Character([human.BornNobility(), human.Bastard(), human.TheocracyStudent(), human.Soldier(), human.Sergeant()])
self.assertEquals(char.trait_points(), 3)
char.buy_trait(trait.Tough())
self.assertEquals(char.trait_points(), 0)
char.add_path(human.NobleArmiger())
self.assertEquals(char.trait_points(), 2)
self.assertTrue(char.has_trait(trait.Tough()))
def testLoseBoughtTraits(self):
"""A trait can be bought, then a lifepath removed, causing either:
1. The loss of the points used to buy the trait
2. The trait becomes more expensive than the character can afford
In these cases, traits should be removed, starting with the most recently addded, until balance is restored
"""
char = Character([human.BornNobility(), human.Bastard(), human.Soldier(), human.Sergeant()])
self.assertEquals(char.trait_points(), 2)
char.add_path(human.NobleArmiger())
char.buy_trait(trait.Tough())
self.assertEquals(char.trait_points(), 1)
char.remove_path()
self.assertEquals(char.trait_points(), 2)
self.assertFalse(char.has_trait(trait.Tough()))
def testCheaperTraits(self):
"""All traits on the available list cost only one point
"""
char = Character([human.BornNobility(), human.NobleCoeptir(), human.NobleArmiger()])
char.buy_trait(trait.Tough())
self.assertEquals(char.traits(), [trait.MarkOfPrivilege(), trait.AnvilTrained(), trait.Tough()])
self.assertEquals(char.trait_points(), 0)
class CharacterTraitsTests(unittest.TestCase):
def setUp(self):
self.char = Character()
def testGainsRequiredTrait(self):
self.assertFalse(self.char.has_trait('Required Trait'))
self.char.add_path(Lifepath(born=True, traits=[trait.Trait(name='Required Trait'), trait.Trait(name='Optional Trait')]))
self.assertTrue(self.char.has_trait(trait.Trait(name='Required Trait')))
self.assertFalse(self.char.has_trait(trait.Trait(name='Optional Trait')))
def testGainsRequiredTraitsAfterMultiplePaths(self):
self.char.add_path(Lifepath(born=True, traits=[trait.Trait(name='First Trait'), trait.Trait(name='Second Trait')]))
self.assertTrue(self.char.has_trait(trait.Trait(name='First Trait')))
self.assertFalse(self.char.has_trait(trait.Trait(name='Second Trait')))
self.char.add_path(Lifepath(traits=[trait.Trait(name='First Trait'), trait.Trait(name='Second Trait')]))
self.assertTrue(self.char.has_trait(trait.Trait(name='Second Trait')))
def testCountTraitPoints(self):
"""Most paths give trait points. However, they also might give access to traits.
Every time a a path is taken:
the first trait in the list that the character does not have is bought for one trait point
The second time and later times a path is taken:
If there is no such trait, then the path awards one less trait point
I assume this is the case even with paths that never award traits
plan:
add path with no points or traits (0)
add path with 1 point and first trait (0)
add path with 2 points and second trait (1)
add path with 2 points and first trait (2)
add path with 1 point and second trait (2)
add path with 1 point and no traits (3)
add same path with 1 point and no traits (3)
"""
self.char.add_path(human.BornNobility())
self.assertEquals(self.char.trait_points(), 0)
self.char.add_path(human.NobleCoeptir())
self.assertEquals(self.char.trait_points(), 1)
self.char.add_path(human.NobleArmiger())
self.assertEquals(self.char.trait_points(), 1)
self.char.add_path(human.NobleLPAnvil())
self.assertEquals(self.char.trait_points(), 2)
self.char.add_path(human.NobleLPAnvil())
self.assertEquals(self.char.trait_points(), 3)
self.char.add_path(human.NobleLPAnvil())
self.assertEquals(self.char.trait_points(), 3)
self.char.remove_path(5)
self.assertEquals(self.char.trait_points(), 0)
self.char.add_path(human.Companion())
self.assertEquals(self.char.trait_points(), 2)
self.char.add_path(human.Lady())
self.assertEquals(self.char.trait_points(), 3)
self.char.add_path(human.Lady())
self.assertEquals(self.char.trait_points(), 3)
def testTraitList(self):
char = Character([human.BornNobility(), human.NobleCoeptir(), human.NobleArmiger()])
self.assertEquals(char.traits(), [trait.MarkOfPrivilege(), trait.AnvilTrained()])
char.add_path(human.NobleLPAnvil())
self.assertEquals(char.traits(), [trait.MarkOfPrivilege(), trait.AnvilTrained(), trait.CorvusAndCrucis()])
char.add_path(human.NobleLPAnvil())
self.assertEquals(char.traits(), [trait.MarkOfPrivilege(), trait.AnvilTrained(), trait.CorvusAndCrucis(), trait.IronTrained()])
def testLifepathTraits(self):
"""All traits on all the paths the character has taken are listed.
"""
char = Character()
char.add_path(human.BornNobility())
self.assertEquals(char.lifepath_traits(), [trait.MarkOfPrivilege(), trait.YourLordship(), trait.YourEminence(), trait.YourGrace(), trait.YourMajesty()])
def testAllowedTraits(self):
"""all traits the character has not bought and can currently afford
"""
char = human.Human()
self.assertEquals(char.allowed_traits(), [])
char.add_path(human.BornNobility())
self.assertEquals(char.allowed_traits(), [])
char.add_path(human.NobleCoeptir())
self.assertTrue(trait.Amorous() in char.allowed_traits())
self.assertTrue(trait.YourLordship() in char.allowed_traits())
self.assertTrue(trait.YourEminence() in char.allowed_traits())
self.assertTrue(trait.YourGrace() in char.allowed_traits())
self.assertTrue(trait.YourMajesty() in char.allowed_traits())
def testBuyTraits(self):
char = Character([human.BornNobility(), human.NobleCoeptir(), human.NobleArmiger()])
char.buy_trait(trait.CharacterTrait())
self.assertEquals(char.traits(), [trait.MarkOfPrivilege(), trait.AnvilTrained(), trait.CharacterTrait()])
self.assertEquals(self.char.trait_points(),0)
def testCantAffordTraits(self):
char = Character([human.BornNobility(), human.NobleCoeptir(), human.NobleArmiger()])
self.assertEquals(char.trait_points(), 1)
self.assertRaises(NotAllowed, char.buy_trait, trait.CalmDemeanor())
self.assertEquals(char.trait_points(), 1)
char.add_path(human.NobleLPAnvil())
self.assertEquals(char.trait_points(),2)
char.buy_trait(trait.CalmDemeanor())
self.assertEquals(char.traits(), [trait.MarkOfPrivilege(), trait.AnvilTrained(), trait.CorvusAndCrucis(), trait.CalmDemeanor()])
self.assertEquals(char.trait_points(),0)
def testRemoveTraits(self):
char = Character([human.BornNobility(), human.NobleCoeptir(), human.NobleArmiger(), human.NobleLPAnvil()])
char.buy_trait(trait.CharacterTrait('Trait 1'))
char.buy_trait(trait.IronTrained())
self.assertEquals(char.trait_points(), 0)
char.remove_trait(trait.IronTrained())
self.assertEquals(char.trait_points(), 1)
self.assertRaises(Exception, char.remove_trait, trait.CharacterTrait('Trait 2'))
char.remove_trait(trait.CharacterTrait('Trait 1'))
self.assertEquals(char.trait_points(), 2)
def testCheaperTraits(self):
"""All traits on the available list cost only one point
"""
char = Character([human.BornNobility(), human.NobleCoeptir(), human.NobleArmiger()])
char.buy_trait(trait.Tough())
self.assertEquals(char.traits(), [trait.MarkOfPrivilege(), trait.AnvilTrained(), trait.Tough()])
self.assertEquals(char.trait_points(), 0)
def testTraitsGetCheaper(self):
"""A trait can be bought, after which a lifepath is added that puts that trait on the available list.
The difference in cost should be refunded
"""
char = Character([human.BornNobility(), human.Bastard(), human.TheocracyStudent(), human.Soldier(), human.Sergeant()])
self.assertEquals(char.trait_points(), 3)
char.buy_trait(trait.Tough())
self.assertEquals(char.trait_points(), 0)
char.add_path(human.NobleArmiger())
self.assertEquals(char.trait_points(), 2)
self.assertTrue(char.has_trait(trait.Tough()))
def testLoseBoughtTraits(self):
"""A trait can be bought, then a lifepath removed, causing either:
1. The loss of the points used to buy the trait
2. The trait becomes more expensive than the character can afford
In these cases, traits should be removed, starting with the most recently addded, until balance is restored
"""
char = Character([human.BornNobility(), human.Bastard(), human.Soldier(), human.Sergeant()])
self.assertEquals(char.trait_points(), 2)
char.add_path(human.NobleArmiger())
char.buy_trait(trait.Tough())
self.assertEquals(char.trait_points(), 1)
char.remove_path()
self.assertEquals(char.trait_points(), 2)
self.assertFalse(char.has_trait(trait.Tough()))
class BasicCharacterTests(unittest.TestCase):
def setUp(self):
self.char = Character()
def testPathCountBlank(self):
self.assertEquals(self.char.path_count(), len(self.char.life_paths))
self.assertEquals(self.char.path_count(), 0)
def testAddPath(self):
self.char.add_path(Lifepath(born=True))
self.assertEquals(self.char.path_count(), 1)
self.assertEquals(self.char.path_count(), len(self.char.life_paths))
self.char.add_path(Lifepath())
self.assertEquals(self.char.path_count(), 2)
self.assertEquals(self.char.path_count(), len(self.char.life_paths))
self.char.add_path(Lifepath()).add_path(Lifepath())
self.assertEquals(self.char.path_count(), 4)
self.assertEquals(self.char.path_count(), len(self.char.life_paths))
def testCreateInBatch(self):
char_series = Character().add_path(Lifepath(born=True)).add_path(Lifepath()).add_path(Lifepath())
char_batch = Character([Lifepath(born=True),Lifepath(),Lifepath()])
self.assertEquals(char_series.path_count(),char_batch.path_count())
self.assertEquals(char_series.age(),char_batch.age())
self.assertEquals(char_series.circles(),char_batch.circles())
self.assertEquals(char_series.resources(),char_batch.resources())
self.assertEquals(char_series.traits(),char_batch.traits())
self.assertEquals(char_series.lifepath_traits(),char_batch.lifepath_traits())
self.assertEquals(char_series.trait_points(),char_batch.trait_points())
def testAddNotAllowed(self):
self.char.add_path(Lifepath(born=True))
self.assertRaises(NotAllowed, self.char.add_path, Lifepath(born=True))
def testHasTaken(self):
self.assertFalse(self.char.has_taken('Born Lifepath'))
self.char.add_path(Lifepath(name = 'Born Lifepath', born=True))
self.assertTrue(self.char.has_taken('Born Lifepath'))
self.assertFalse(self.char.has_taken('Other Lifepath'))
def testHasTakenError(self):
"""has_taken and all related functions expect a string and throw a type error otherwise
"""
self.assertRaises(TypeError, self.char.has_taken, 5)
self.assertRaises(TypeError, self.char.has_taken, ('Lifepath',))
self.assertRaises(TypeError, self.char.has_taken, ['Lifepath'])
def testHasTakenAny(self):
self.char.add_path(Lifepath(name = 'Born Lifepath', born=True))
self.assertTrue(self.char.has_taken_any(['Court Coeptir', 'Court Clerk', 'Born Lifepath']))
self.assertFalse(self.char.has_taken_any(['Court Coeptir', 'Court Clerk', 'Lord-Pilot Anvil']))
def testHasTakenAll(self):
self.char.add_path(Lifepath(name = 'Born Lifepath', born=True)).add_path(Lifepath('Lifepath'))
self.assertTrue(self.char.has_taken_all(['born lifepath']))
self.assertTrue(self.char.has_taken_all(['born lifepath', 'lifepath']))
self.assertFalse(self.char.has_taken_all(['born lifepath', 'lifepath', 'other lifepath']))
self.char.add_path(Lifepath(name='Other Lifepath'))
self.assertTrue(self.char.has_taken_all(['born lifepath', 'lifepath', 'other lifepath']))
def testTimesTaken(self):
self.char.add_path(Lifepath(name = 'Born Lifepath', born=True)).add_path(Lifepath('Lifepath')).add_path(Lifepath(name='Lifepath'))
self.assertEquals(self.char.times_taken('Lifepath'), 2)
self.assertEquals(self.char.times_taken('Born Lifepath'), 1)
self.assertEquals(self.char.times_taken('Anything Else'), 0)
def testHasTakenTwice(self):
self.char.add_path(Lifepath(born=True)).add_path(Lifepath('Lifepath')).add_path(Lifepath(name='Lifepath'))
self.assertTrue(self.char.has_taken_twice('Lifepath'))
self.assertFalse(self.char.has_taken_twice('Default'))
self.assertTrue(self.char.has_taken('Lifepath', 2))
self.assertFalse(self.char.has_taken('Default', 2))
def testHasTakenAny(self):
self.char.add_path(Lifepath(name = 'Born Lifepath', born=True)).add_path(Lifepath('Lifepath'))
self.assertTrue(self.char.has_taken_any(['Born Lifepath', 'Lifepath'], 2))
self.assertFalse(self.char.has_taken_any(['Born Lifepath'], 2))
self.char.add_path(Lifepath())
self.assertTrue(self.char.has_taken_any(['Default', 'Lifepath'], 2))
self.assertTrue(self.char.has_taken_any(['Default', 'Lifepath', 'Born Lifepath'], 3))
def testHasTakenAnyRepeating(self):
"""if the list has the same name on it multiple times, that should be ignored
"""
self.char.add_path(Lifepath(name = 'Born Lifepath', born=True))
self.assertFalse(self.char.has_taken_any(['Born Lifepath', 'Born Lifepath'], 2))
self.assertFalse(self.char.has_taken_any(['Born Lifepath', 'Something Else', 'Born Lifepath', 'born lifePath'], 2))
def testIgnoresCase(self):
"""lifepaths are identified by non-unique names. Upper- and lower-case letters shouldn't matter
"""
self.char.add_path(Lifepath(name = 'Born Lifepath', born=True))
self.assertTrue(self.char.has_taken('born lifepath'))
self.assertTrue(self.char.has_taken('BORN LIFEPATH'))
self.assertEquals(self.char.times_taken('born lifepath'), 1)
self.assertEquals(self.char.times_taken('BORN lIFEPATH'), 1)
self.char.add_path(Lifepath()).add_path(Lifepath())
self.assertTrue(self.char.has_taken('default', 2))
self.assertTrue(self.char.has_taken('DEFAULT', 2))
self.assertTrue(self.char.has_taken_any(['born lifepath']))
self.assertTrue(self.char.has_taken_any(['BORN LIFEPATH']))
self.assertTrue(self.char.has_taken_any(['DEFAULT'], 2))
self.assertTrue(self.char.has_taken_any(['default'], 2))
self.assertTrue(self.char.has_taken_any(['born lifepath', 'default'], 3))
self.assertTrue(self.char.has_taken_any(['BORN LIFEPATH', 'DEFAULT'], 3))
def testHasTakenAnyFromSetting(self):
"""Born Lifepaths never count for the purposes of this function.
"""
self.char.add_path(human.NobleLifepath(born=True)).add_path(human.HammerLifepath())
self.assertTrue(self.char.has_taken_any_from(human.HammerLifepath))
self.assertFalse(self.char.has_taken_any_from(human.TheocracyLifepath))
self.assertFalse(self.char.has_taken_any_from(human.NobleLifepath))
def testHasTakenAnyFromSettingTwice(self):
"""Born Lifepaths never count for the purposes of this function.
"""
self.char.add_path(human.NobleLifepath(born=True)).add_path(human.NobleLifepath())
self.assertFalse(self.char.has_taken_any_from(human.NobleLifepath, 2))
self.char.add_path(human.NobleLifepath())
self.assertTrue(self.char.has_taken_any_from(human.NobleLifepath, 2))
def testRemove(self):
self.char.add_path(Lifepath(born=True)).add_path(Lifepath()).add_path(Lifepath())
self.assertEquals(self.char.traits(), [])
self.assertEquals(self.char.trait_points(), 0)
self.char.remove_path()
self.assertEquals(self.char.path_count(), 2)
self.char.remove_path(3)
self.assertEquals(self.char.path_count(), 0)
def testClear(self):
self.char.add_path(Lifepath(born=True)).add_path(Lifepath()).clear()
self.assertEquals(self.char.path_count(), 0)
def testNoAge(self):
self.assertEquals(self.char.age(), 0)
def testBornAge(self):
self.char.add_path(Lifepath(born=True, years=8))
self.assertEquals(self.char.age(), 8)
self.char.remove_path()
self.assertEquals(self.char.age(), 0)
def testSameSettingAge(self):
character = Character([human.NobleLifepath(born=True, years=1),
human.NobleLifepath(years=1),
human.NobleLifepath(years=1)])
self.assertEquals(character.age()
,3)
def testMoveSettingsAge(self):
self.char.add_path(human.BornNobility()).add_path(human.CourtCoeptir())
self.assertEquals(self.char.age(), 13)
self.char.remove_path()
self.assertEquals(self.char.age(), 8)
