class applyEffect(unittest.TestCase): """ Test cases of applyEffect """ def setUp(self): """ Build the Pkmn and Delegate for the test """ self.user = BuildPokemonBattleWrapper() self.target = BuildPokemonBattleWrapper() self.delegate = ConfuseDelegate(1) def alreadyConfused(self): """ Test that confusion is not applied when the target is already confused """ self.user.secondaryEffects = [Confusion()] message = self.user.getHeader() + Confusion.already messages = self.delegate.applyEffect(self.user, self.target, None) assert len(messages) == 1, "Should get one message" assert messages[ 0] == message, "Should say that the Pkmn is already confused" assert len(self.user.secondaryEffects ) == 1, "Pkmn should not get another confusion effect" def notConfused(self): """ Test that confusion is applied when the target is not confused """ self.user.secondaryEffects = [] message = self.user.getHeader() + Confusion.start messages = self.delegate.applyEffect(self.user, self.target, None) assert len(messages) == 1, "Should get one message" assert messages[ 0] == message, "Should say that the Pkmn is now confused" assert len(self.user.secondaryEffects ) == 1, "Pkmn should get a confusion effect" assert self.delegate.isConfused( self.user), "The Pkmn should now be confused"
class applyEffect(unittest.TestCase): """ Test cases of applyEffect """ def setUp(self): """ Build the Pkmn, Abilities and Effect for the test """ self.user = BuildPokemonBattleWrapper() self.target = BuildPokemonBattleWrapper() self.userAbility = Ability(None) self.targetAbility = Ability(None) self.user.setAbility(self.userAbility) self.target.setAbility(self.targetAbility) self.delegate = SwapAbilityDelegate() def swapped(self): """ Test that the abilities are swapped """ self.delegate.applyEffect(self.user, self.target, None) assert self.user.getAbility() is self.targetAbility, "User should have target's ability" assert self.target.getAbility() is self.userAbility, "Target should have user's ability" def message(self): """ Test message is returned correctly """ messages = self.delegate.applyEffect(self.user, self.target, None) assert messages == [SwapAbilityDelegate.message % (self.user.getHeader(), self.target.getHeader())], "Should have the Effect's message"
class applyEffect(unittest.TestCase): """ Test cases of applyEffect """ def setUp(self): """ Build the Pkmn and Delegate for the test """ self.user = BuildPokemonBattleWrapper() self.target = BuildPokemonBattleWrapper() self.delegate = ConfuseDelegate(1) def alreadyConfused(self): """ Test that confusion is not applied when the target is already confused """ self.user.secondaryEffects = [Confusion()] message = self.user.getHeader() + Confusion.already messages = self.delegate.applyEffect(self.user, self.target, None) assert len(messages) == 1, "Should get one message" assert messages[0] == message, "Should say that the Pkmn is already confused" assert len(self.user.secondaryEffects) == 1, "Pkmn should not get another confusion effect" def notConfused(self): """ Test that confusion is applied when the target is not confused """ self.user.secondaryEffects = [] message = self.user.getHeader() + Confusion.start messages = self.delegate.applyEffect(self.user, self.target, None) assert len(messages) == 1, "Should get one message" assert messages[0] == message, "Should say that the Pkmn is now confused" assert len(self.user.secondaryEffects) == 1, "Pkmn should get a confusion effect" assert self.delegate.isConfused(self.user), "The Pkmn should now be confused"
class checkOver(unittest.TestCase): """ Test cases of checkOver """ def setUp(self): """ Build the Confusion for the test """ self.user = BuildPokemonBattleWrapper() self.confusion = Confusion() self.turns = 2 def overCured(self): """ Test that the Confusion is cured when it is over """ messages = [] self.confusion.turns = 0 self.user.secondaryEffects = [self.confusion] self.confusion.checkOver(self.user, messages) assert self.user.secondaryEffects == [], "Should be cured" def overMessage(self): """ Test that the Message is correct when it is over """ messages = [] self.confusion.turns = 0 self.user.secondaryEffects = [self.confusion] message = self.user.getHeader() + Confusion.over self.confusion.checkOver(self.user, messages) assert len(messages) == 1, "Should receive one message" assert messages[0] == message, "Should receive a message that the confusion is over" def notOverStillConfused(self): """ Test that thePkmn is still confused when it isn't over """ messages = [] self.confusion.turns = self.turns self.user.secondaryEffects = [self.confusion] self.confusion.checkOver(self.user, messages) assert self.user.secondaryEffects == [self.confusion], "Should still be confused" def notOverTurnsDecremented(self): """ Test that the Turns is decremented when it isn't over """ messages = [] self.confusion.turns = self.turns self.confusion.checkOver(self.user, messages) assert self.confusion.turns == self.turns-1, "Should have turns decremented" def notOverMessage(self): """ Test that the Message is correct when it isn't over """ messages = [] self.confusion.turns = self.turns message = self.user.getHeader() + Confusion.start self.confusion.checkOver(self.user, messages) assert len(messages) == 1, "Should receive one message" assert messages[0] == message, "Should receive a message that the Pkmn is still confusion"
class checkCharging(unittest.TestCase): """ Test cases of checkCharging """ def setUp(self): """ Build the Pkmn and Precondition Checker for the test """ self.user = BuildPokemonBattleWrapper() self.target = BuildPokemonBattleWrapper() self.environment = BattleEnvironment() self.attack = AttackFactory.getAttackAsNew("DIG") self.preconditionChecker = PreconditionChecker(self.user, self.target, self.environment, self.attack) attack2 = AttackFactory.getAttackAsNew("TACKLE") self.preconditionChecker2 = PreconditionChecker(self.user, self.target, self.environment, attack2) def charging(self): """ Test that check charging returns correctly when the user is charging """ stop, messages = self.preconditionChecker.checkCharging() message = [self.user.getHeader() + self.attack.effectDelegates[0].message] assert stop, "Should stop if the user is charging" assert messages == message, "Should have charging message" def notCharging(self): """ Test that check charging returns correctly when the user is not charging """ stop, messages = self.preconditionChecker2.checkCharging() assert not stop, "Should not stop if the user isn't charging" assert messages == [], "Should not receive any messages"
class checkFlinch(unittest.TestCase): """ Test cases of checkFlinch """ def setUp(self): """ Build the Pkmn and Precondition Checker for the test """ self.user = BuildPokemonBattleWrapper() self.target = BuildPokemonBattleWrapper() self.environment = BattleEnvironment() attack = AttackFactory.getAttackAsNew("TACKLE") self.preconditionChecker = PreconditionChecker(self.user, self.target, self.environment, attack) def flinching(self): """ Test that check flinch returns correctly when the user has is flinching """ self.user.flinching = True stop, messages = self.preconditionChecker.checkFlinch() message = [self.user.getHeader() + " flinched."] assert stop, "Should stop if the user flinches" assert messages == message, "Should have flinching message" def notFlinching(self): """ Test that check flinch returns correctly when the user is not flinching """ self.user.flinching = False stop, messages = self.preconditionChecker.checkLock() assert not stop, "Should not stop if the user isn't flinching" assert messages == [], "Should not receive any messages"
class applyEffect(unittest.TestCase): """ Test cases of applyEffect """ def setUp(self): """ Build the Effect and Pkmn for the test """ self.stat1 = "ATK" self.stat2 = "DEF" self.val1 = 50 self.val2 = 20 self.user = BuildPokemonBattleWrapper() self.delegate = SwapStatDelegate(self.stat1, self.stat2) def swapped(self): """ Test that the stats are swapped """ self.user.setStat(self.stat1, self.val1) self.user.setStat(self.stat2, self.val2) self.delegate.applyEffect(self.user, None, None) assert self.user.getStat( self.stat1) == self.val2, "Stat 1 should get Stat 2's value" assert self.user.getStat( self.stat2) == self.val1, "Stat 2 should get Stat 1's value" def message(self): """ Test that the message is returned correctly """ messages = self.delegate.applyEffect(self.user, None, None) message = SwapStatDelegate.message % (self.user.getHeader(), self.stat1, self.stat2) assert messages == [ message ], "Message should say the user had its two stats swapped"
class applyEffect(unittest.TestCase): """ Test that isCharging returns the correct values """ def setUp(self): """ Grabs the message dictionary from StatModDelegate """ self.user = BuildPokemonBattleWrapper() self.target = BuildPokemonBattleWrapper() self.delegate = SwapStatModsDelegate() self.statMods1 = {"ATK":1, "DEF":0, "SPD":0, "SATK":0, "SDEF":0, "ACC":0, "EVAS":0, "CRT":1} self.user.statMods = self.statMods1 self.statMods2 = {"ATK":0, "DEF":0, "SPD":1, "SATK":1, "SDEF":1, "ACC":0, "EVAS":0, "CRT":0} self.target.statMods = self.statMods2 def statModsSwitched(self): """ Tests if ithe stat mods are swapped """ self.delegate.applyEffect(self.user, self.target, None) assert self.user.statMods == self.statMods2, "Pkmn 1 should have stats from Pkmn 2" assert self.target.statMods == self.statMods1, "Pkmn 2 should have stats from Pkmn 1" def message(self): """ Test the message returned is correct """ messages = self.delegate.applyEffect(self.user, self.target, None) message = self.user.getHeader() + SwapStatModsDelegate.message assert len(messages) == 1, "Should get 1 message" assert messages[0] == message, "Should be Pkmn's header and the Delegate's message"
class applyEffect(unittest.TestCase): """ Test cases of applyEffect """ def setUp(self): """ Build the Effect and Pkmn for the test """ self.stat1 = "ATK" self.stat2 = "DEF" self.val1 = 50 self.val2 = 20 self.user = BuildPokemonBattleWrapper() self.delegate = SwapStatDelegate(self.stat1, self.stat2) def swapped(self): """ Test that the stats are swapped """ self.user.setStat(self.stat1, self.val1) self.user.setStat(self.stat2, self.val2) self.delegate.applyEffect(self.user, None, None) assert self.user.getStat(self.stat1) == self.val2, "Stat 1 should get Stat 2's value" assert self.user.getStat(self.stat2) == self.val1, "Stat 2 should get Stat 1's value" def message(self): """ Test that the message is returned correctly """ messages = self.delegate.applyEffect(self.user, None, None) message = SwapStatDelegate.message % (self.user.getHeader(), self.stat1, self.stat2) assert messages == [message], "Message should say the user had its two stats swapped"
class checkLock(unittest.TestCase): """ Test cases of checkLock """ def setUp(self): """ Build the Pkmn, Lock, and Precondition Checker for the test """ self.user = BuildPokemonBattleWrapper() self.target = BuildPokemonBattleWrapper() self.environment = BattleEnvironment() self.actionLock = BuildActionLock(user = self.user) self.attack = AttackFactory.getAttackAsNew("TACKLE") self.preconditionChecker = PreconditionChecker(self.user, self.target, self.environment, self.attack) def hasLock(self): """ Test that check lock returns correctly when the user has a lock """ self.user.actionLock = self.actionLock stop, messages = self.preconditionChecker.checkLock() message = "{0} USED {1}".format(self.user.getHeader(), self.actionLock.action.attack.name) assert stop, "Should stop if the user has a lock" assert len(messages) > 0, "Should receive the messages for the actual attack" assert messages[0] == message, "Should use the actionLock attack" def usingLock(self): """ Test that check lock returns correctly when the user is using its lock attack """ self.preconditionChecker.attack = self.actionLock.action.attack self.user.actionLock = self.actionLock stop, messages = self.preconditionChecker.checkLock() message = "{0} USED {1}".format(self.user.getHeader(), self.actionLock.action.attack.name) assert not stop, "Should not stop if the user is using its lock" assert messages == [], "Should not receive any messages" def noLock(self): """ Test that check lock returns correctly when the user has no lock """ self.user.actionLock = None stop, messages = self.preconditionChecker.checkLock() assert not stop, "Should not stop if the user has no lock" assert messages == [], "Should not receive any messages"
class effectOnMiss(unittest.TestCase): """ Test cases of effectOnMiss """ def setUp(self): """ Build the Pkmn and Delegate for the test """ self.pkmn = BuildPokemonBattleWrapper() self.attack = BuildAttack() self.damage, messages = self.attack.damageDelegate.damage(self.pkmn, self.pkmn) self.ratio = 2 self.delegate = CrashDelegate(self.attack, self.ratio) def recoil(self): """ Test that recoil damage is done """ self.pkmn.setCurrHP(self.damage*2) self.delegate.effectOnMiss(self.pkmn, self.pkmn, None) damageDone = self.damage*2 - self.pkmn.getCurrHP() damage = self.damage/self.ratio assert damageDone == damage or damageDone == 2*damage, "Should do damage over ratio as damage" def message(self): """ Test that the message returned is correct """ self.pkmn.setCurrHP(self.damage) self.delegate.damage = self.damage messages = self.delegate.effectOnMiss(self.pkmn, self.pkmn, None) message = CrashDelegate.message % self.pkmn.getHeader() assert len(messages) == 1, "Should get one message" assert messages[0] == message, "Message should be Pkmn's header and the Delegate's message" def faints(self): """ Test that the message is correct when the Pkmn faints """ self.pkmn.setCurrHP(1) self.delegate.damage = self.damage messages = self.delegate.effectOnMiss(self.pkmn, self.pkmn, None) faintMessage = self.pkmn.getHeader() + Faint.start assert len(messages) == 2, "Should get 2 messages" assert messages[1] == faintMessage, "Message should be that the Pkmn Fainted"
class applyEffect(unittest.TestCase): """ Test cases of applyEffect """ def setUp(self): """ Build the Pkmn and Delegate for the test """ self.pkmn = BuildPokemonBattleWrapper() self.ratio = 2 self.damage = 50 self.delegate = RecoilDelegate(self.ratio) def recoil(self): """ Test that recoil damage is done """ self.pkmn.setCurrHP(self.damage) self.delegate.damage = self.damage self.delegate.applyEffect(self.pkmn, None, None) damageDone = self.damage - self.pkmn.getCurrHP() damage = self.damage / self.ratio assert damageDone == damage, "Should do damage over ratio as damage" def message(self): """ Test that the message returned is correct """ self.pkmn.setCurrHP(self.damage) self.delegate.damage = self.damage messages = self.delegate.applyEffect(self.pkmn, None, None) message = RecoilDelegate.message % self.pkmn.getHeader() assert len(messages) == 1, "Should get one message" assert messages[ 0] == message, "Message should be Pkmn's header and the Delegate's message" def faints(self): """ Test that the message is correct when the Pkmn faints """ self.pkmn.setCurrHP(1) self.delegate.damage = self.damage messages = self.delegate.applyEffect(self.pkmn, None, None) faintMessage = self.pkmn.getHeader() + Faint.start assert len(messages) == 2, "Should get 2 messages" assert messages[ 1] == faintMessage, "Message should be that the Pkmn Fainted"
class applyEffect(unittest.TestCase): """ Test cases of applyEffect """ def setUp(self): """ Build the Pkmn and Delegate for the test """ self.user = BuildPokemonBattleWrapper() self.delegate = SelfDestructDelegate() def selfDestructed(self): """ Test that the user self destructs (aka dies) """ self.delegate.applyEffect(self.user, None, None) assert self.user.getCurrHP() == 0, "Pkmn should have fainted" def message(self): """ Test that the user self destructs (aka dies) """ messages = self.delegate.applyEffect(self.user, None, None) message = self.user.getHeader() + SelfDestructDelegate.message faintMessage = self.user.getHeader() + Faint.start assert len(messages) == 2, "Should get 1 message" assert messages[0] == message, "Should get the Pkmn's header and the Delegate's message" assert messages[1] == faintMessage, "Should have the Pkmn faint"
class applyEffect(unittest.TestCase): """ Test cases of applyEffect """ def setUp(self): """ Build the Pkmn and Delegate for the test """ self.user = BuildPokemonBattleWrapper() self.delegate = SelfDestructDelegate() def selfDestructed(self): """ Test that the user self destructs (aka dies) """ self.delegate.applyEffect(self.user, None, None) assert self.user.getCurrHP() == 0, "Pkmn should have fainted" def message(self): """ Test that the user self destructs (aka dies) """ messages = self.delegate.applyEffect(self.user, None, None) message = self.user.getHeader() + SelfDestructDelegate.message faintMessage = self.user.getHeader() + Faint.start assert len(messages) == 2, "Should get 1 message" assert messages[ 0] == message, "Should get the Pkmn's header and the Delegate's message" assert messages[1] == faintMessage, "Should have the Pkmn faint"
class afterTurn(unittest.TestCase): """ Test that afterTurn returns correctly """ def setUp(self): """ Builds the Pkmn and the Leech Effect """ self.pkmn = BuildPokemonBattleWrapper() self.message = " hurt." self.pkmn2 = BuildPokemonBattleWrapper() self.leech = Leech(self.pkmn2, self.message) def message(self): """ Test the message is correct """ message = self.leech.afterTurn(self.pkmn) assert message == [self.pkmn.getHeader() + self.message], "Message should be the pokemon's name and the message given to the Leech." def faint(self): """ Test that the messsages returned when the target faints """ self.pkmn.setCurrHP(self.leech.getAmount(self.pkmn)) messages = self.leech.afterTurn(self.pkmn) assert len(messages) == 2, "Should have 2 messages" assert messages[1] == self.pkmn.getHeader() + Faint.start, "Should have a faint message."
class immobilized(unittest.TestCase): """ Test that immobilized performs correctly """ def setUp(self): """ Builds the Sleep status""" self.status = Sleep() self.pkmn = BuildPokemonBattleWrapper() self.pkmn.setStatus(self.status) self.turns = 1 def notDone(self): """ Test if immobilized returns correctly when it is not done """ self.status.turns = self.turns immobilized, messages = self.status.immobilized(self.pkmn) assert immobilized, "Should be immobilized" assert messages == [self.pkmn.getHeader() + Sleep.intermittent],\ "Should return Sleep's intermittent message" assert self.status.turns == self.turns - 1, "Turns should be decremented" def done(self): """ Test if immobilized returns correctly when it is done """ self.status.turns = 0 assert self.pkmn.getStatus() == self.status, "Should have status to start" immobilized, messages = self.status.immobilized(self.pkmn) assert not immobilized, "Should not be immobilized" assert len(messages) == 2, "Should have two messages" assert messages[0] == self.pkmn.getHeader() + Sleep.intermittent,\ "Should return Sleep's intermittent message" assert messages[1] == self.pkmn.getHeader() + Sleep.done,\ "Should return Sleep's done message" assert self.pkmn.getStatus() != self.status, "Status should be removed"
class immobilized(unittest.TestCase): """ Test that immobilized performs correctly """ def setUp(self): """ Builds the Sleep status""" self.status = Sleep() self.pkmn = BuildPokemonBattleWrapper() self.pkmn.setStatus(self.status) self.turns = 1 def notDone(self): """ Test if immobilized returns correctly when it is not done """ self.status.turns = self.turns immobilized, messages = self.status.immobilized(self.pkmn) assert immobilized, "Should be immobilized" assert messages == [self.pkmn.getHeader() + Sleep.intermittent],\ "Should return Sleep's intermittent message" assert self.status.turns == self.turns - 1, "Turns should be decremented" def done(self): """ Test if immobilized returns correctly when it is done """ self.status.turns = 0 assert self.pkmn.getStatus( ) == self.status, "Should have status to start" immobilized, messages = self.status.immobilized(self.pkmn) assert not immobilized, "Should not be immobilized" assert len(messages) == 2, "Should have two messages" assert messages[0] == self.pkmn.getHeader() + Sleep.intermittent,\ "Should return Sleep's intermittent message" assert messages[1] == self.pkmn.getHeader() + Sleep.done,\ "Should return Sleep's done message" assert self.pkmn.getStatus() != self.status, "Status should be removed"
class afterTurn(unittest.TestCase): """ Test that afterTurn returns correctly """ def setUp(self): """ Build the Pkmn and Heal """ self.pkmn = BuildPokemonBattleWrapper() self.message = " hurt." self.heal = PeriodicHeal(self.message) def message(self): """ Test the message is correct """ message = self.heal.afterTurn(self.pkmn) assert message == [self.pkmn.getHeader() + self.message], "Message should be the pokemon's name and the message given to the Heal."
class applyEffect(unittest.TestCase): """ Test cases of applyEffect """ def setUp(self): """ Build the Pkmn and Delegate for the test """ self.pkmn = BuildPokemonBattleWrapper() self.delegate = HealByRatioDelegate(2) def message(self): """ Test that the message is returned properly """ messages = self.delegate.applyEffect(self.pkmn, None, None) message = self.pkmn.getHeader() + HealByRatioDelegate.message assert len(messages) == 1, "Should receive one message" assert messages[ 0] == message, "Should be the Pokmn's header and the Delegates message"
class afterTurn(unittest.TestCase): """ Test that afterTurn returns correctly """ def setUp(self): """ Build the Pkmn and Heal """ self.pkmn = BuildPokemonBattleWrapper() self.message = " hurt." self.heal = PeriodicHeal(self.message) def message(self): """ Test the message is correct """ message = self.heal.afterTurn(self.pkmn) assert message == [ self.pkmn.getHeader() + self.message ], "Message should be the pokemon's name and the message given to the Heal."
class afterTurn(unittest.TestCase): """ Test that afterTurn returns correctly """ def setUp(self): """ Builds the Pkmn and the Leech Effect """ self.pkmn = BuildPokemonBattleWrapper() self.message = " hurt." self.pkmn2 = BuildPokemonBattleWrapper() self.leech = Leech(self.pkmn2, self.message) def message(self): """ Test the message is correct """ message = self.leech.afterTurn(self.pkmn) assert message == [ self.pkmn.getHeader() + self.message ], "Message should be the pokemon's name and the message given to the Leech." def faint(self): """ Test that the messsages returned when the target faints """ self.pkmn.setCurrHP(self.leech.getAmount(self.pkmn)) messages = self.leech.afterTurn(self.pkmn) assert len(messages) == 2, "Should have 2 messages" assert messages[1] == self.pkmn.getHeader() + Faint.start, "Should have a faint message."
class applyEffect(unittest.TestCase): """ Test cases of applyEffect """ def setUp(self): """ Build the Pkmn and Delegate for the test """ self.pkmn = BuildPokemonBattleWrapper() self.delegate = HealByRatioDelegate(2) def message(self): """ Test that the message is returned properly """ messages = self.delegate.applyEffect(self.pkmn, None, None) message = self.pkmn.getHeader() + HealByRatioDelegate.message assert len(messages) == 1, "Should receive one message" assert messages[0] == message, "Should be the Pokmn's header and the Delegates message"
class takeDamage(unittest.TestCase): """ Test cases of takeDamage """ def setUp(self): """ Build the Pkmn """ self.pkmn = BuildPokemonBattleWrapper() def faints(self): """ Test that Faint Exception is thrown """ messages = self.pkmn.takeDamage(self.pkmn.getCurrHP()) assert messages == [self.pkmn.getHeader() + Faint.start], "The Pkmn should have fainted" def noFaint(self): """ Test that Faint Exception is not thrown if the pkmn doesn't faint """ messages = self.pkmn.takeDamage(self.pkmn.getCurrHP()-1) assert messages == [], "Should receive any empty list when the Pkmn has not fainted"
class afterTurn(unittest.TestCase): """ Test that afterTurn works correctly """ def setUp(self): """ Builds the Paralysis status""" self.status = Burn() self.pkmn = BuildPokemonBattleWrapper() def damage(self): """ Test that the damage is done correctly """ self.pkmn.setStat("HP", 32) self.pkmn.setCurrHP(32) self.status.afterTurn(self.pkmn) damage = self.pkmn.getStat("HP") - self.pkmn.getCurrHP() assert damage == self.pkmn.getRatioOfHealth(Burn.ratio), "Damage should be Burn Ratio of Health" def message(self): """ Test that the message is returned correctly """ messages = self.status.afterTurn(self.pkmn) message = self.pkmn.getHeader() + Burn.intermittent assert len(messages) == 1, "Should get one message" assert messages[0] == message, "Message should be that the Pkmn was damaged by the Burn"
class stopAttack(unittest.TestCase): """ Test cases of stopAttack """ def setUp(self): """ Build the Ability and Pkmn for the test """ self.ability = SkipTurnAbility(None) self.pkmn = BuildPokemonBattleWrapper() def stop(self): """ Test that the ability returns correctly when it should stop """ self.ability.stop = 0 stop, messages = self.ability.stopAttack(self.pkmn) assert stop, "Should stop" assert messages == [self.pkmn.getHeader() + SkipTurnAbility.message], "Should receive message that the Pkmn is loafing" def noStop(self): """ Test that the ability returns correctly when it should not stop """ self.ability.stop = 1 stop, messages = self.ability.stopAttack(self.pkmn) assert not stop, "Should not stop" assert messages == [], "Should not receive any messages"
class afterTurn(unittest.TestCase): """ Test that afterTurn works correctly """ def setUp(self): """ Builds the Paralysis status""" self.status = Burn() self.pkmn = BuildPokemonBattleWrapper() def damage(self): """ Test that the damage is done correctly """ self.pkmn.setStat("HP", 32) self.pkmn.setCurrHP(32) self.status.afterTurn(self.pkmn) damage = self.pkmn.getStat("HP") - self.pkmn.getCurrHP() assert damage == self.pkmn.getRatioOfHealth( Burn.ratio), "Damage should be Burn Ratio of Health" def message(self): """ Test that the message is returned correctly """ messages = self.status.afterTurn(self.pkmn) message = self.pkmn.getHeader() + Burn.intermittent assert len(messages) == 1, "Should get one message" assert messages[ 0] == message, "Message should be that the Pkmn was damaged by the Burn"
class stopAttack(unittest.TestCase): """ Test cases of stopAttack """ def setUp(self): """ Build the Ability and Pkmn for the test """ self.ability = SkipTurnAbility(None) self.pkmn = BuildPokemonBattleWrapper() def stop(self): """ Test that the ability returns correctly when it should stop """ self.ability.stop = 0 stop, messages = self.ability.stopAttack(self.pkmn) assert stop, "Should stop" assert messages == [ self.pkmn.getHeader() + SkipTurnAbility.message ], "Should receive message that the Pkmn is loafing" def noStop(self): """ Test that the ability returns correctly when it should not stop """ self.ability.stop = 1 stop, messages = self.ability.stopAttack(self.pkmn) assert not stop, "Should not stop" assert messages == [], "Should not receive any messages"
class checkEncore(unittest.TestCase): """ Test cases of checkEncore """ def setUp(self): """ Build the Pkmn and Precondition Checker for the test """ self.user = BuildPokemonBattleWrapper() self.target = BuildPokemonBattleWrapper() self.environment = BattleEnvironment() self.attack = AttackFactory.getAttackAsNew("DIG") self.preconditionChecker = PreconditionChecker(self.user, self.target, self.environment, self.attack) attack2 = AttackFactory.getAttackAsNew("TACKLE") self.preconditionChecker2 = PreconditionChecker(self.user, self.target, self.environment, attack2) def encore(self): """ Test that check encore returns correctly when the user has an encore """ encoreCount = 1 self.user.encore = encoreCount stop, messages = self.preconditionChecker.checkEncore() message = [self.user.getHeader() + self.attack.effectDelegates[0].message] assert self.user.encore == encoreCount-1, "Encore should be decremented" assert not stop, "Should never stop if have an encore" assert messages == [], "Should not receive any messages" def noEncore(self): """ Test that check encore returns correctly when the user has no encore """ encoreCount = 0 self.user.encore = encoreCount stop, messages = self.preconditionChecker2.checkEncore() assert self.user.encore == encoreCount, "Encore should not decrement when there is no encore" assert not stop, "Should never stop if have an encore" assert messages == [], "Should not receive any messages"
class afterTurn(unittest.TestCase): """ Test that afterTurn returns correctly """ def setUp(self): """ Builds the side and trap """ self.source = BuildPokemonBattleWrapper() self.pkmn = BuildPokemonBattleWrapper() self.message = " hurt." self.doneMessage = " done." self.trap = Trap(None, self.message, self.doneMessage) def turnDecreases(self): """ Test the turn counter decreases """ self.trap.turns = 5 turns = self.trap.turns self.trap.afterTurn(self.pkmn) assert self.trap.turns == turns - 1, "Turns should decrement" def effectIsRemoved(self): """ Test that the effect is removed when the turn count is reduced to zero """ self.trap.turns = 1 self.pkmn.secondaryEffects.append(self.trap) self.trap.afterTurn(self.pkmn) assert self.trap.turns == 0, "Turns should be zero" assert not self.trap in self.pkmn.secondaryEffects def message(self): """ Test the message is correct """ message = self.trap.afterTurn(self.pkmn) assert message == [self.pkmn.getHeader() + self.message], "Message should be the pokemon's name and the message given to the Trap." def doneMessage(self): """ Test the done message is correct """ self.trap.turns = 1 self.pkmn.secondaryEffects.append(self.trap) messages = self.trap.afterTurn(self.pkmn) assert len(messages) == 2, "Should have two messages" assert messages[1] == self.pkmn.getHeader() + self.doneMessage, "Done message should be returned." def faintMessage(self): """ Test the faint message appears if the Pkmn faints """ self.trap.turns = 3 self.pkmn.setCurrHP(self.trap.getDamage(self.pkmn)) self.pkmn.secondaryEffects.append(self.trap) messages = self.trap.afterTurn(self.pkmn) assert len(messages) == 2, "Should have two messages" assert messages[1] == self.pkmn.getHeader() + Faint.start, "Pkmn should have fainted." def faintAndDoneMessage(self): """ Test the done message is correct """ self.trap.turns = 1 self.pkmn.setCurrHP(self.trap.getDamage(self.pkmn)) self.pkmn.secondaryEffects.append(self.trap) messages = self.trap.afterTurn(self.pkmn) assert len(messages) == 2, "Should have two messages" assert messages[1] == self.pkmn.getHeader() + Faint.start, "Pkmn should have fainted."