def test_templates_and_feminize_templatetags(self):
"""
Check feminize template_tags.
"""
f = Folk(first_name="septon", sex=Folk.MALE, kingdom=self.k)
f.save()
f2 = Folk(first_name="cersei", sex=Folk.FEMALE, kingdom=self.k)
f2.save()
self.e.text = "batard{{ septon|feminize }}, batard{{ cersei|feminize }}"
self.e.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
started=None
)
pe.save()
pe.set_value("septon", f)
pe.set_value("cersei", f2)
pe.started = datetime.now()
pe.save()
self.assertEqual(pe.text, "batard, batarde")
def test_grid_length(self): """ Check grid length constraint. """ self.mg.length = 1 self.mg.save() f2 = Folk( kingdom=self.k, first_name="Cersei", last_name="Lannister" ) f2.save() pma2 = PendingMissionAffectation( pending_mission=self.pm, mission_grid=self.mg, folk=f2 ) # Too many people self.assertRaises(ValidationError, pma2.save) # Update length, now can be saved self.mg.length = 2 self.mg.save() pma2.save()
def test_pendingmission_set_get_value(self):
"""
Test that setting and retrieving a context value through a PendingMission works
"""
f = Folk(
kingdom=self.k,
first_name="Theon",
last_name="Greyjoy"
)
f.save()
self.pm.set_value("peon", f)
self.assertEqual(f, self.pm.get_value("peon"))
self.pm.set_value("Narnia", self.k)
self.assertEqual(self.k, self.pm.get_value("Narnia"))
self.pm.set_value("nompourri", "Kevin")
self.assertEqual(self.pm.get_value("nompourri"), "Kevin")
self.pm.set_value("beastnum", 666)
self.assertEqual(self.pm.get_value("beastnum"), 666)
self.pm.set_value("void", None)
self.assertEqual(self.pm.get_value("void"), None)
def test_templates_and_folk_details_templatetags(self):
"""
Check folk_details template_tags.
"""
folk = Folk(first_name="septon", sex=Folk.MALE, kingdom=self.k)
cat = QualityCategory(name="boa",description="so")
cat.save()
quality = Quality(slug="lol",name="sdf",category=cat)
quality.save()
folk.save()
folk.quality_set.add(quality)
self.e.text = "{{ septon|folk_details }}"
self.e.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
started=None
)
pe.save()
pe.set_value("septon", folk)
pe.started = datetime.now()
pe.save()
self.assertTrue(quality.name in pe.text)
self.assertTrue(str(folk.fight) in pe.text)
self.assertTrue("<table>" in pe.text)
def test_pendingevent_set_get_value(self):
"""
Test that setting and retrieving a context value through a Pending Event works
"""
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
f = Folk(
kingdom=self.k,
first_name="Theon",
last_name="Greyjoy"
)
f.save()
pe.set_value("peon", f)
self.assertEqual(f, pe.get_value("peon"))
pe.set_value("Narnia", self.k)
self.assertEqual(self.k, pe.get_value("Narnia"))
pe.set_value("nompourri", "Kevin")
self.assertEqual(pe.get_value("nompourri"), "Kevin")
pe.set_value("beastnum", 666)
self.assertEqual(pe.get_value("beastnum"), 666)
pe.set_value("void", None)
self.assertEqual(pe.get_value("void"), None)
def test_auto_name_for_folk(self): """ The name is automatically filled. """ FirstName(name="Gendry", sex=Folk.MALE).save() LastName(name="Baratheon").save() f2 = Folk(kingdom=self.k) f2.save() self.assertEqual(f2.first_name, "Gendry") self.assertEqual(f2.last_name, "Baratheon")
def test_kingdom_value_store_list_fk(self):
"""
Store list of fk values on the kingdom
"""
f2 = Folk(kingdom=self.k)
f2.save()
datas = [self.f, f2, True, 0, "trololol"]
self.k.set_value("foo", datas)
stored_datas = self.k.get_value("foo")
for r, s in zip(datas, stored_datas):
self.assertEqual(r, s)
def test_sanity_folk_in_kingdoms(self): """ The folk in PendingBargainSharedMissionAffectation must be owned by one of the sides of the negotiation. """ k3 = Kingdom() k3.save() f2 = Folk(kingdom=k3) f2.save() pbsma = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=f2 ) # folk.kingdom != pbk.kingdom self.assertRaises(IntegrityError, pbsma.save)
def test_title_affect_defect(self): """ Test affect AND defect code are run """ self.t.on_affect = """ folk.loyalty = 80 folk.save() """ self.t.on_defect = """ folk.loyalty = 20 folk.save() """ self.t.save() f2 = Folk( first_name="Robb", last_name="Stark", kingdom=self.k ) f2.save() # Sanity check self.assertEqual(self.f.loyalty, 0) self.assertEqual(f2.loyalty, 0) at = AvailableTitle( title=self.t, kingdom=self.k, folk=self.f ) at.save() self.assertEqual(self.f.loyalty, 80) at.folk = f2 at.save() self.assertEqual(self.f.loyalty, 20) self.assertEqual(f2.loyalty, 80)
def test_folk_deletion(self): """ Deleted people do not CASCADE on their family, only set to None. """ son = Folk(kingdom=self.k) son.father = self.f son.save() pupil = Folk(kingdom=self.k) pupil.mentor = self.f pupil.save() wife = Folk(kingdom=self.k) wife.spouse = self.f wife.save() # Sanity check self.assertEqual(4, Folk.objects.count()) self.assertEqual(son.father, self.f) self.assertEqual(pupil.mentor, self.f) self.assertEqual(wife.spouse, self.f) self.f.delete() self.assertEqual(3, Folk.objects.count()) self.assertIsNone(Folk.objects.get(pk=son.pk).father) self.assertIsNone(Folk.objects.get(pk=pupil.pk).mentor) self.assertIsNone(Folk.objects.get(pk=wife.pk).spouse)
def test_templates_and_title_context(self):
"""
Check templating works on event and EventAction with default context title.
"""
from title.models import Title, AvailableTitle
t = Title(name="Maître espion", slug="maitre_espion", description=" ")
t.save()
f = Folk(first_name="septon", kingdom=self.k)
f.save()
at = AvailableTitle(kingdom=self.k, title=t, folk=f)
at.save()
self.e.text = "{{ title.maitre_espion.first_name }}"
self.e.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
self.assertEqual(pe.text, "septon")
def test_state_reverted_on_affectation_changed(self): """ PendingBargainKingdom states are reverted if an affectation is updated. """ pbsma = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=self.f ) pbsma.save() # Kingdom1 is OK. self.pbk1.state = PendingBargainKingdom.OK self.pbk1.save() # Deal breaker f2 = Folk(kingdom=self.k2) f2.save() pbsma.folk = f2 pbsma.save() self.assertEqual(PendingBargainKingdom.PENDING, PendingBargainKingdom.objects.get(pk=self.pbk1.pk).state)
def test_templates_and_folks_list_templatetags(self):
"""
Check folks_list template_tags.
"""
f = Folk(first_name="septon", kingdom=self.k)
f.save()
f2 = Folk(first_name="cersei", kingdom=self.k)
f2.save()
self.e.text = "{{ folks|folks_list:'short' }}"
self.e.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
started=None
)
pe.save()
pe.set_value("folks", [f, f2])
pe.started = datetime.now()
pe.save()
self.assertEqual(pe.text, "septon et cersei")
def test_cant_affect_after_mission_start(self): """ A folk can't be affected to a mission after it started. """ # Start the pendingmission self.pm.started = datetime.now() self.pm.save() f2 = Folk( first_name="Hot", last_name="Pie", kingdom=self.k ) f2.save() pma2 = PendingMissionAffectation( pending_mission=self.pm, mission_grid=self.mg, folk=f2 ) # Can't affect after start self.assertRaises(ValidationError, pma2.save)
class UnitTest(TestCase):
"""
Unit tests for kingdom.
"""
def setUp(self):
self.k = Kingdom()
self.k.save()
self.f = Folk(
kingdom=self.k,
)
self.f.save()
self.qc = QualityCategory(
name="Stub quality category",
description="A stub."
)
self.qc.save()
def test_money_threshold(self):
"""
Money should be positive
"""
self.k.money = 20
self.k.save()
self.assertEqual(self.k.money, 20)
self.k.money = -1
self.k.save()
self.assertEqual(self.k.money, 0)
def test_prestige_threshold(self):
"""
Prestige should be positive
"""
self.k.prestige = 20
self.k.save()
self.assertEqual(self.k.prestige, 20)
self.k.prestige = -1
self.k.save()
self.assertEqual(self.k.prestige, 0)
def test_population_threshold(self):
"""
Population should be positive
"""
self.k.population = 20
self.k.save()
self.assertEqual(self.k.population, 20)
self.k.population = -1
self.k.save()
self.assertEqual(self.k.population, 0)
def test_death_after_birth(self):
"""
Should raise an ValidationError if death < birth
"""
self.f.death = datetime(year=2000, month=1, day=1)
self.assertRaises(ValidationError, self.f.save)
def test_folk_sex(self):
"""
Sex should be MALE or FEMALE
"""
self.f.sex = Folk.MALE
self.f.save()
self.f.sex = Folk.FEMALE
self.f.save()
self.f.sex = 't'
self.assertRaises(ValidationError, self.f.save)
def test_mother_sex(self):
"""
Mother should be a woman
"""
self.f.sex = Folk.FEMALE
self.f.save()
# Sanity check
Folk(
kingdom=self.k,
mother=self.f,
first_name="My mother is a female",
last_name="---"
).save()
# Insanity check
self.f.sex = Folk.MALE
self.f.save()
weirdos = Folk(
kingdom=self.k,
mother=self.f,
first_name="My mother is a male",
last_name="---"
)
self.assertRaises(ValidationError, weirdos.save)
def test_father_sex(self):
"""
Father should be a male
"""
self.f.sex = Folk.MALE
self.f.save()
# Sanity check
Folk(
kingdom=self.k,
father=self.f,
first_name="My mother is a male",
last_name="---"
).save()
# Insanity check
self.f.sex = Folk.FEMALE
self.f.save()
weirdos = Folk(
kingdom=self.k,
father=self.f,
first_name="My mother is a female",
last_name="---"
)
self.assertRaises(ValidationError, weirdos.save)
def test_fight_threshold(self):
"""
Fight should be restricted within [0, 20]
"""
self.f.fight = 21
self.f.save()
self.assertEqual(self.f.fight, 20)
self.f.fight = -1
self.f.save()
self.assertEqual(self.f.fight, 1)
def test_diplomacy_threshold(self):
"""
Diplomacy should be restricted within [0, 20]
"""
self.f.diplomacy = 21
self.f.save()
self.assertEqual(self.f.diplomacy, 20)
self.f.diplomacy = -1
self.f.save()
self.assertEqual(self.f.diplomacy, 1)
def test_plot_threshold(self):
"""
Plot should be restricted within [0, 20]
"""
self.f.plot = 21
self.f.save()
self.assertEqual(self.f.plot, 20)
self.f.plot = -1
self.f.save()
self.assertEqual(self.f.plot, 1)
def test_scholarship_threshold(self):
"""
Scholarship should be restricted within [0, 20]
"""
self.f.scholarship = 21
self.f.save()
self.assertEqual(self.f.scholarship, 20)
self.f.scholarship = -1
self.f.save()
self.assertEqual(self.f.scholarship, 1)
def test_loyalty_threshold(self):
"""
Loyalty should be restricted within [0, 20]
"""
self.f.loyalty = 101
self.f.save()
self.assertEqual(self.f.loyalty, 100)
self.f.loyalty = -1
self.f.save()
self.assertEqual(self.f.loyalty, 0)
def test_folk_deletion(self):
"""
Deleted people do not CASCADE on their family, only set to None.
"""
son = Folk(kingdom=self.k)
son.father = self.f
son.save()
pupil = Folk(kingdom=self.k)
pupil.mentor = self.f
pupil.save()
wife = Folk(kingdom=self.k)
wife.spouse = self.f
wife.save()
# Sanity check
self.assertEqual(4, Folk.objects.count())
self.assertEqual(son.father, self.f)
self.assertEqual(pupil.mentor, self.f)
self.assertEqual(wife.spouse, self.f)
self.f.delete()
self.assertEqual(3, Folk.objects.count())
self.assertIsNone(Folk.objects.get(pk=son.pk).father)
self.assertIsNone(Folk.objects.get(pk=pupil.pk).mentor)
self.assertIsNone(Folk.objects.get(pk=wife.pk).spouse)
def test_claim_level(self):
"""
Claim level should be REACHABLE, CLAIM or VENDETTA.
"""
k2 = Kingdom()
k2.save()
c = Claim(offender=self.k, offended=k2)
c.save()
c.level = c.REACHABLE
c.save()
c.level = c.CLAIM
c.save()
c.level = c.VENDETTA
c.save()
c.level = 10
self.assertRaises(ValidationError, c.save)
def test_claim_unicity(self):
"""
You can't have two claims on the same kingdom.
"""
k2 = Kingdom()
k2.save()
Claim(
offender=self.k,
offended=k2
).save()
c = Claim(
offender=self.k,
offended=k2
)
self.assertRaises(IntegrityError, c.save)
def test_incompatible_qualities(self):
"""
You can't have two incompatible qualities.
"""
q = Quality(
category=self.qc,
name="Avare",
slug="avare",
description="Jamais donner argent !")
q.save()
q2 = Quality(
category=self.qc,
name="Généreux",
slug="genereux",
description="Toujours donner argent !")
q2.save()
q.incompatible_qualities.add(q2)
self.f.quality_set.add(q)
self.assertRaises(ValidationError, (lambda: self.f.quality_set.add(q2)))
def test_quality_on_affect(self):
"""
Test on affect code is executed.
"""
q = Quality(
category=self.qc,
name="Avare",
slug="avare",
description="Jamais donner argent !")
q.on_affect = """
folk.kingdom.money = 15
folk.kingdom.save()
"""
q.save()
# Sanity check
self.assertEqual(self.k.money, 0)
self.f.quality_set.add(q)
self.assertEqual(self.k.money, 15)
def test_quality_on_defect(self):
"""
Test on_defect code is executed.
"""
q = Quality(
category=self.qc,
name="Avare",
slug="avare",
description="Jamais donner argent !")
q.on_defect = """
folk.kingdom.money = 15
folk.kingdom.save()
"""
q.save()
self.f.quality_set.add(q)
# Sanity check
self.assertEqual(self.k.money, 0)
self.f.quality_set.remove(q)
self.assertEqual(self.k.money, 15)
def test_quality_name_for(self):
q = Quality(
category=self.qc,
name="male",
female_name="female"
)
q.save()
self.f.sex = Folk.MALE
self.assertEqual("male", q.name_for(self.f))
self.f.sex = Folk.FEMALE
self.assertEqual("female", q.name_for(self.f))
class UnitTest(TestCase): def setUp(self): self.k1 = Kingdom() self.k1.save() self.k2 = Kingdom() self.k2.save() self.f = Folk(kingdom=self.k1) self.f.save() self.m = Mission( name="Stub mission", slug="stub", on_resolution="", ) self.m.save() self.mg = MissionGrid( mission=self.m, allow_empty=True, ) self.mg.save() self.pb = PendingBargain() self.pb.save() self.pbk1 = PendingBargainKingdom( pending_bargain=self.pb, kingdom=self.k1 ) self.pbk1.save() self.pbk2 = PendingBargainKingdom( pending_bargain=self.pb, kingdom=self.k2 ) self.pbk2.save() self.pm = PendingMission( kingdom=self.k1, mission=self.m ) self.pm.save() self.pbsm = PendingBargainSharedMission( pending_mission=self.pm, pending_bargain=self.pb ) self.pbsm.save() def test_no_pending_bargain_with_yourself(self): """ Can't bargain with yourself. """ self.pbk2.kingdom = self.k1 self.assertRaises(IntegrityError, self.pbk2.save) def test_only_two_kingdoms_per_pending_bargain(self): """ Can't have more than two kingdoms on the same bargain """ k3 = Kingdom() k3.save() pbk3 = PendingBargainKingdom( pending_bargain=self.pb, kingdom=k3 ) self.assertRaises(ValidationError, pbk3.save) def test_sanity_pending_mission_in_kingdoms(self): """ A PendingBargainSharedMission must be owned by one of the sides of the negotiation """ k3 = Kingdom() k3.save() pm = PendingMission( kingdom=k3, mission=self.m ) pm.save() pbsm2 = PendingBargainSharedMission( pending_mission=pm, pending_bargain=self.pb ) # pm.kingdom != pbk.kingdom self.assertRaises(IntegrityError, pbsm2.save) def test_sanity_folk_in_kingdoms(self): """ The folk in PendingBargainSharedMissionAffectation must be owned by one of the sides of the negotiation. """ k3 = Kingdom() k3.save() f2 = Folk(kingdom=k3) f2.save() pbsma = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=f2 ) # folk.kingdom != pbk.kingdom self.assertRaises(IntegrityError, pbsma.save) def test_sanity_folk_in_one_affectation(self): """ The folk in PendingBargainSharedMissionAffectation must be owned by one of the sides of the negotiation. """ pbsma = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=self.f ) pbsma.save() pbsma2 = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=self.f ) # Can't be affected twice self.assertRaises(IntegrityError, pbsma2.save) def test_autoremove_pending_bargain_on_kingdom_deletion(self): """ When a kingdom is removed, all PendingBargain it was part of are deleted """ self.pbk1.delete() self.assertRaises(PendingBargain.DoesNotExist, lambda: PendingBargain.objects.get(pk=self.pb.pk)) def test_cant_share_started_pending_mission(self): """ A PendingBargainSharedMission must not be started """ self.pm.started = datetime.now() self.pm.save() pbsm = PendingBargainSharedMission( pending_mission=self.pm, pending_bargain=self.pb ) self.assertRaises(ValidationError, pbsm.save) def test_pending_mission_removed_on_start(self): """ PendingBargainSharedMission are deleted when the PendingMission is started. """ self.pm.started = datetime.now() self.pm.save() # PBSM must be deleted self.assertRaises(PendingBargainSharedMission.DoesNotExist, (lambda: PendingBargainSharedMission.objects.get(pk=self.pbsm.pk))) def test_affectation_is_checked(self): """ The affectation must trigger the PendingMissionAffectation code (as a dry run of course, since the affectation is at this point purely virtual) """ self.mg.length = 0 self.mg.save() pbsma = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=self.f ) # This grid is full self.assertRaises(ValidationError, pbsma.save) def test_cant_affect_if_in_mission(self): """ The affectation must check you're not already in a mission. """ # Create a pending mission, not shared pm2 = PendingMission(kingdom=self.k1, mission=self.m) pm2.save() pma = PendingMissionAffectation(pending_mission=pm2, mission_grid=self.mg, folk=self.f) pma.save() pbsma = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=self.f ) self.assertRaises(ValidationError, pbsma.save) def test_kingdom_state(self): """ PendingBargainKingdom states values are constrained. """ self.pbk1.state = PendingBargainKingdom.PENDING self.pbk1.save() self.pbk1.state = PendingBargainKingdom.OK self.pbk1.save() self.pbk1.state = PendingBargainKingdom.OK_NO_MATTER_WHAT self.pbk1.save() self.pbk1.state = 15 self.assertRaises(ValidationError, self.pbk1.save) def test_validation(self): """ PendingBargain are committed when everyone is OK. """ pbsma = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=self.f ) pbsma.save() # Sanity check: folk is not in MissionGrid self.assertEqual(0, PendingMissionAffectation.objects.filter(pending_mission=self.pm, mission_grid=self.mg).count()) self.pbk1.state = PendingBargainKingdom.OK self.pbk1.save() self.pbk2.state = PendingBargainKingdom.OK self.pbk2.save() self.assertEqual(1, PendingMissionAffectation.objects.filter(pending_mission=self.pm, mission_grid=self.mg).count()) self.assertEqual(self.f, PendingMissionAffectation.objects.filter(pending_mission=self.pm, mission_grid=self.mg)[0].folk) # PendingBargain has been deleted self.assertRaises(PendingBargain.DoesNotExist, (lambda: PendingBargain.objects.get(pk=self.pb.pk))) def test_validation_failing(self): """ PendingBargain can raise ValidationError, and forbid saving last state to OK. """ pbsma = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=self.f ) pbsma.save() # Fake case. # In reality, the Exception may be triggered by some code on the grid depending on various contexts. self.mg.length = 0 self.mg.save() self.pbk1.state = PendingBargainKingdom.OK self.pbk1.save() self.pbk2.state = PendingBargainKingdom.OK # This grid is full self.assertRaises(ValidationError, self.pbk2.save) # Assert exists (has not been deleted) PendingBargain.objects.get(pk=self.pb.pk) def test_state_reverted_on_affectation_delete(self): """ PendingBargainKingdom states are reverted if an affectation is deleted. """ pbsma = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=self.f ) pbsma.save() # Kingdom1 is OK. self.pbk1.state = PendingBargainKingdom.OK self.pbk1.save() # Deal breaker pbsma.delete() self.assertEqual(PendingBargainKingdom.PENDING, PendingBargainKingdom.objects.get(pk=self.pbk1.pk).state) def test_state_reverted_on_affectation_changed(self): """ PendingBargainKingdom states are reverted if an affectation is updated. """ pbsma = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=self.f ) pbsma.save() # Kingdom1 is OK. self.pbk1.state = PendingBargainKingdom.OK self.pbk1.save() # Deal breaker f2 = Folk(kingdom=self.k2) f2.save() pbsma.folk = f2 pbsma.save() self.assertEqual(PendingBargainKingdom.PENDING, PendingBargainKingdom.objects.get(pk=self.pbk1.pk).state) def test_state_reverted_on_affectation_created(self): """ PendingBargainKingdom states are reverted if an affectation is created. """ # Kingdom1 is OK. self.pbk1.state = PendingBargainKingdom.OK self.pbk1.save() # Deal breaker pbsma = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=self.f ) pbsma.save() self.assertEqual(PendingBargainKingdom.PENDING, PendingBargainKingdom.objects.get(pk=self.pbk1.pk).state) def test_state_reverted_on_shared_mission_deleted(self): """ PendingBargainKingdom states are reverted if a shared mission with affectations is removed. """ pbsma = PendingBargainSharedMissionAffectation( pending_bargain_shared_mission=self.pbsm, mission_grid=self.mg, folk=self.f ) pbsma.save() # Kingdom1 is OK. self.pbk1.state = PendingBargainKingdom.OK self.pbk1.save() # Deal breaker self.pbsm.delete() self.assertEqual(PendingBargainKingdom.PENDING, PendingBargainKingdom.objects.get(pk=self.pbk1.pk).state)
class ScriptTest(TestCase):
def setUp(self):
self.k = Kingdom()
self.k.save()
self.f = Folk(
kingdom=self.k,
first_name="Robert",
last_name="Baratheon"
)
self.f.save()
def test_function_calls(self):
"""
Test calls to function from inside a script
"""
self.k.money = 0
self.k.save()
f1 = Function(
slug="first_function",
)
f1.on_fire = """
foo += 50
param = call_function("second_function", foo=foo)
"""
f1.save()
f2 = Function(
slug="second_function",
)
f2.on_fire = """
foo += 30
param = foo
"""
f2.save()
param = call_function("first_function", foo=0)
self.assertEqual(param, 80)
def test_constant_shortcut(self):
"""
Test constant values can be directly accessed
"""
c = Constant(
name="MAJORITY",
description="Age to come of age",
value=18
)
c.save()
self.assertEqual(C.MAJORITY, 18)
self.assertRaises(Constant.DoesNotExist, lambda: C.SOME_CONSTANT)
def test_status_shortcut(self):
"""
Test status values can be directly accessed
"""
s = Status(
name="TOO_YOUNG",
value="You're too young for this, kiddo."
)
s.save()
self.assertEqual(S.TOO_YOUNG, s.value)
self.assertRaises(Status.DoesNotExist, lambda: S.SOME_STATUS)
class UnitTest(TestCase): """ Unit tests for title app """ def setUp(self): self.k = Kingdom() self.k.save() self.f = Folk( kingdom=self.k, ) self.f.save() self.t = Title( name="Dummy title", slug="dummy_title", description="Nothing to say." ) self.t.save() def test_folk_unicity(self): """ A folk can only be affected in one Title at a time. """ at = AvailableTitle( title=self.t, kingdom=self.k, folk=self.f ) at.save() t2 = Title( name="Dummy title2", slug="dummy_title2", description="Nothing to say." ) t2.save() at2 = AvailableTitle( title=t2, kingdom=self.k, folk=self.f ) self.assertRaises(IntegrityError, at2.save) def test_title_kingdom_unicity(self): """ The same title can't appear twice in the same kingdom """ at = AvailableTitle( title=self.t, kingdom=self.k, ) at.save() at2 = AvailableTitle( title=self.t, kingdom=self.k, ) self.assertRaises(IntegrityError, at2.save) def test_folk_kingdom_change(self): """ When you change kingdom, you're disaffected from your title. """ at = AvailableTitle( title=self.t, kingdom=self.k, folk=self.f ) at.save() k2 = Kingdom() k2.save() self.f.kingdom = k2 self.f.save() # Reload the title, folk should now be empty at = AvailableTitle.objects.get(pk=at.pk) self.assertIsNone(at.folk) def test_folk_death(self): """ When you change kingdom, you're disaffected from your title. """ at = AvailableTitle( title=self.t, kingdom=self.k, folk=self.f ) at.save() self.f.die() # Reload the title, folk should now be empty at = AvailableTitle.objects.get(pk=at.pk) self.assertIsNone(at.folk) def test_title_unlock(self): """ The on_unlock code is executed """ self.t.on_unlock = """ kingdom.prestige = 50 kingdom.save() """ # Sanity check self.assertEqual(self.k.prestige, 0) at = AvailableTitle( title=self.t, kingdom=self.k, ) at.save() self.assertEqual(self.k.prestige, 50) def test_title_unlock_fail(self): """ The on_unlock code is executed, and can stop the title creation. """ self.t.on_unlock = """ status="no" """ # Sanity check self.assertEqual(self.k.prestige, 0) at = AvailableTitle( title=self.t, kingdom=self.k, ) self.assertRaises(ValidationError, at.save) def test_title_condition(self): """ The condition can abort an affection """ self.t.condition = 'status="not_possible"' self.t.save() at = AvailableTitle( title=self.t, kingdom=self.k, folk=self.f ) self.assertRaises(ValidationError, at.save) def test_title_folk_kingdom(self): """ Folk must be in the AvailableTitle kingdom. """ k2 = Kingdom() k2.save() at = AvailableTitle( title=self.t, kingdom=k2, folk=self.f ) self.assertRaises(ValidationError, at.save) def test_title_affect_direct(self): """ You can create and affect in the same time. """ self.t.on_affect = """ folk.loyalty = 50 folk.save() """ self.t.save() # Sanity check self.assertNotEquals(self.f.loyalty, 50) at = AvailableTitle( title=self.t, kingdom=self.k, folk=self.f ) at.save() self.assertEqual(self.f.loyalty, 50) def test_title_affect(self): """ Test affect code is run """ self.t.on_affect = """ folk.loyalty = 50 folk.save() """ self.t.save() # Sanity check self.assertNotEquals(self.f.loyalty, 50) at = AvailableTitle( title=self.t, kingdom=self.k, ) at.save() # Sanity check self.assertNotEquals(self.f.loyalty, 50) at.folk = self.f at.save() self.assertEqual(self.f.loyalty, 50) def test_title_defect(self): """ Test defect code is run """ self.t.on_defect = """ folk.loyalty = 50 folk.save() """ self.t.save() at = AvailableTitle( title=self.t, kingdom=self.k, folk=self.f ) at.save() # Sanity check self.assertNotEquals(self.f.loyalty, 50) at = AvailableTitle.objects.get(pk=at.pk) at.folk = None at.save() self.assertEqual(Folk.objects.get(pk=self.f.pk).loyalty, 50) def test_title_affect_defect(self): """ Test affect AND defect code are run """ self.t.on_affect = """ folk.loyalty = 80 folk.save() """ self.t.on_defect = """ folk.loyalty = 20 folk.save() """ self.t.save() f2 = Folk( first_name="Robb", last_name="Stark", kingdom=self.k ) f2.save() # Sanity check self.assertEqual(self.f.loyalty, 0) self.assertEqual(f2.loyalty, 0) at = AvailableTitle( title=self.t, kingdom=self.k, folk=self.f ) at.save() self.assertEqual(self.f.loyalty, 80) at.folk = f2 at.save() self.assertEqual(self.f.loyalty, 20) self.assertEqual(f2.loyalty, 80)
class UnitTest(TestCase):
def setUp(self):
self.k = Kingdom()
self.k.save()
self.f = Folk(
kingdom=self.k,
)
self.f.save()
self.t = Title(
name="Stub title",
description="My description.")
self.t.save()
self.at = AvailableTitle(
title=self.t,
kingdom=self.k,
folk=self.f
)
self.at.save()
self.m = Mission(
name="Stub mission",
slug="stub",
on_resolution="",
title=self.t,
)
self.m.save()
self.mg = MissionGrid(
mission=self.m,
slug='stub_grid'
)
self.mg.save()
self.pm = PendingMission(
mission=self.m,
kingdom=self.k
)
self.pm.save()
self.pma = PendingMissionAffectation(
pending_mission=self.pm,
mission_grid=self.mg,
folk=self.f
)
self.pma.save()
def test_cant_affect_twice(self):
"""
A folk can't be affected twice to a mission.
"""
pma2 = PendingMissionAffectation(
pending_mission=self.pm,
mission_grid=self.mg,
folk=self.f
)
self.assertRaises(IntegrityError, pma2.save)
def test_cant_affect_disabled(self):
"""
By default, grids do not allow disabled to be affected.
"""
self.pma.delete()
self.f.disabled = True
self.f.save()
pma = PendingMissionAffectation(
pending_mission=self.pm,
mission_grid=self.mg,
folk=self.f
)
self.assertRaises(ValidationError, pma.save)
def test_grid_allow_disabled(self):
"""
Specific grids allows disabled folks.
"""
self.pma.delete()
self.f.disabled = True
self.f.save()
self.mg.allow_disabled = True
self.mg.save()
pma = PendingMissionAffectation(
pending_mission=self.pm,
mission_grid=self.mg,
folk=self.f
)
pma.save()
def test_cant_affect_dead(self):
"""
A folk can't be affected when he is dead.
"""
self.pma.delete()
self.f.die()
pma = PendingMissionAffectation(
pending_mission=self.pm,
mission_grid=self.mg,
folk=self.f
)
self.assertRaises(ValidationError, pma.save)
def test_auto_remove_on_death(self):
"""
Dead peoples are removed from their affectations
"""
self.f.die()
self.assertRaises(PendingMissionAffectation.DoesNotExist, lambda: PendingMissionAffectation.objects.get(pk=self.pma.pk))
def test_cant_remove_after_mission_start(self):
"""
A folk can't be removed from a mission after it started.
"""
# Start the pendingmission
self.pm.started = datetime.now()
self.pm.save()
# Can't remove affectation
self.assertRaises(ValidationError, self.pma.delete)
def test_cant_affect_after_mission_start(self):
"""
A folk can't be affected to a mission after it started.
"""
# Start the pendingmission
self.pm.started = datetime.now()
self.pm.save()
f2 = Folk(
first_name="Hot",
last_name="Pie",
kingdom=self.k
)
f2.save()
pma2 = PendingMissionAffectation(
pending_mission=self.pm,
mission_grid=self.mg,
folk=f2
)
# Can't affect after start
self.assertRaises(ValidationError, pma2.save)
def test_cant_update_target_after_mission_start(self):
"""
The target can't be changed after mission start.
"""
self.m.has_target = True
self.m.save()
k2 = Kingdom()
k2.save()
k3 = Kingdom()
k3.save()
# Sanity check
self.pm.target = k2
self.pm.save()
self.pm.target = k3
self.pm.save()
self.pm.started = datetime.now()
self.pm.save()
# Can't change target
self.pm.target = k2
self.assertRaises(ValidationError, self.pm.save)
def test_cant_update_value_after_mission_start(self):
"""
The value can't be changed after mission start.
"""
self.m.has_value = True
self.m.save()
# Sanity check
self.pm.value = 10
self.pm.save()
self.pm.started = datetime.now()
self.pm.save()
# Can't change value
self.pm.value = 20
self.assertRaises(ValidationError, self.pm.save)
def test_grid_condition(self):
"""
Check condition is triggered.
"""
self.pma.delete()
self.mg.condition = """
status="not_allowed"
"""
self.mg.save()
self.pma = PendingMissionAffectation(
pending_mission=self.pm,
mission_grid=self.mg,
folk=self.f
)
# Can't affect folk
self.assertRaises(ValidationError, self.pma.save)
def test_grid_length(self):
"""
Check grid length constraint.
"""
self.mg.length = 1
self.mg.save()
f2 = Folk(
kingdom=self.k,
first_name="Cersei",
last_name="Lannister"
)
f2.save()
pma2 = PendingMissionAffectation(
pending_mission=self.pm,
mission_grid=self.mg,
folk=f2
)
# Too many people
self.assertRaises(ValidationError, pma2.save)
# Update length, now can be saved
self.mg.length = 2
self.mg.save()
pma2.save()
def test_emptygrids_not_allowed(self):
"""
Check that a grid with argument allow_empty to False (default) raises an error if no one is in it
"""
self.pma.delete()
self.pm.started = datetime.now()
self.assertRaises(ValidationError, self.pm.save)
def test_emptygrids_allowed(self):
"""
Check that a grid with argument allow_empty can have no one in it
"""
self.mg.allow_empty = True
self.mg.save()
self.pma.delete()
self.pm.started = datetime.now()
self.pm.save()
def test_sanity_grid_is_from_mission(self):
"""
Check the grid is part of the current mission.
"""
m2 = Mission(
name="Stub mission2",
on_resolution="",
title=self.t,
)
m2.save()
pm2 = PendingMission(
mission=m2,
kingdom=self.k
)
pm2.save()
# pending_mission refers to mission2,
# mission_grid refers to mission
pma2 = PendingMissionAffectation(
pending_mission=pm2,
mission_grid=self.mg,
folk=self.f
)
self.assertRaises(IntegrityError, pma2.save)
def test_mission_target_list_code(self):
"""
Check the target_list code is runned on affectation
"""
self.m.has_target = True
self.m.target_list = "param = Kingdom.objects.filter(money__gte=10000)"
self.m.save()
# Check : no kingdom matches.
self.assertEqual(len(self.pm.targets()), 0)
k2 = Kingdom(
money=50000
)
k2.save()
# Check : k2 matches
self.assertEqual(len(self.pm.targets()), 1)
self.assertEqual(self.pm.targets()[0], k2)
def test_mission_target_in_list(self):
"""
Check the target is in target_list
"""
self.m.has_target = True
self.m.target_list = "param = Kingdom.objects.filter(money__gte=10000)"
self.m.save()
# Invalid assignment, our kingdom does not match condition
self.pm.target = self.k
self.assertRaises(ValidationError, self.pm.save)
def test_mission_target_default(self):
"""
Check the target with default code (all kingdom but mine)
"""
k2 = Kingdom(
money=50000
)
k2.save()
self.m.has_target = True
self.m.save()
# Assert noRaises
self.pm.target = k2
self.pm.save()
# Our kingdom is forbidden by default
self.pm.target = self.k
self.assertRaises(ValidationError, self.pm.save)
def test_mission_target_allowed(self):
"""
Check the target is allowed on affectation.
"""
# Invalid assignment, self.m does not define has_target=True
self.pm.target = self.k
self.assertRaises(ValidationError, self.pm.save)
def test_mission_value_allowed(self):
"""
Check the value is allowed on affectation.
"""
# Invalid assignment, self.m does not define has_value=True
self.pm.value = 100
self.assertRaises(ValidationError, self.pm.save)
def test_mission_target_provided(self):
"""
Check target is not None if mission has_target
"""
self.m.has_target = True
self.m.save()
self.pm.started = datetime.now()
self.assertRaises(ValidationError, self.pm.save)
def test_mission_on_init(self):
"""
Check the on_init code can cancel the mission before it is launched.
"""
m2 = Mission(
name="Stub mission2",
slug="stub_2",
on_resolution="",
on_init="status='Abort Mission'",
title=self.t
)
m2.save()
pm2 = PendingMission(
mission=m2,
kingdom=self.k
)
self.assertRaises(ValidationError, pm2.save)
def test_mission_on_start_title(self):
"""
Check you can't start without a folk in associated title.
"""
self.at.folk = None
self.at.save()
self.pm.started = datetime.now()
self.assertRaises(ValidationError, self.pm.save)
def test_mission_on_start(self):
"""
Check the on_start code.
"""
m2 = Mission(
name="Stub mission2",
slug="stub_2",
on_resolution="",
on_start="""
Kingdom().save()
""",
title=self.t,
)
m2.save()
# Sanity check
self.assertEqual(Kingdom.objects.count(), 1)
pm2 = PendingMission(
mission=m2,
kingdom=self.k,
started=datetime.now()
)
pm2.save()
self.assertEqual(Kingdom.objects.count(), 2)
def test_mission_on_start_aborted(self):
"""
Check the on_start code, aborting the mission.
"""
m2 = Mission(
name="Stub mission2",
slug="stub_2",
on_resolution="",
on_start="""
status='abort'
""",
title=self.t,
)
m2.save()
pm2 = PendingMission(
mission=m2,
kingdom=self.k,
started=datetime.now()
)
self.assertRaises(ValidationError, pm2.save)
def test_mission_start_again(self):
"""
Can't start twice the same mission.
"""
self.pm.started = datetime.now()
self.pm.save()
self.assertRaises(ValidationError, self.pm.start)
def test_mission_resolution_before_start(self):
"""
Can't resolve unstarted mission
"""
self.assertRaises(ValidationError, self.pm.resolve)
def test_mission_resolution(self):
"""
Check the on_resolution code.
"""
self.m.on_resolution = """
status='mission_solved'
"""
self.m.save()
self.pm.started = datetime.now()
self.pm.save()
status = self.pm.resolve()
self.assertEqual(status, 'mission_solved')
def test_mission_resolution_with_target(self):
"""
Check the on_resolution code works with a target.
"""
k2 = Kingdom()
k2.save()
self.m.has_target = True
self.m.on_resolution = """
if target.pk == %s:
status='mission_solved'
""" % k2.pk
self.m.save()
self.pm.target = k2
self.pm.save()
self.pm.started = datetime.now()
self.pm.save()
status = self.pm.resolve()
self.assertEqual(status, 'mission_solved')
def test_mission_resolution_with_value(self):
"""
Check the on_resolution code works with a value.
"""
self.m.has_value = True
self.m.on_resolution = """
if value == 15:
status='mission_solved'
"""
self.m.save()
self.pm.value = 15
self.pm.save()
self.pm.started = datetime.now()
self.pm.save()
status = self.pm.resolve()
self.assertEqual(status, 'mission_solved')
def test_mission_resolution_delete_pending_mission(self):
"""
Pendingmission must be deleted after resolution.
"""
self.pm.started = datetime.now()
self.pm.save()
self.pm.resolve()
self.assertTrue(self.pm.is_finished)
self.assertRaises(PendingMission.DoesNotExist, (lambda: PendingMission.objects.get(pk=self.pm.pk)))
def test_mission_not_cancellable(self):
"""
Check the is_cancellable flag.
"""
self.m.is_cancellable = False
self.m.save()
self.assertRaises(ValidationError, self.pm.delete)
def test_mission_finished_not_cancellable(self):
"""
Check the is_cancellable flag combined with is_finished.
"""
self.m.is_cancellable = False
self.m.save()
# Fake resolution
self.pm.is_started = True
self.pm.is_finished = True
self.pm.save()
# AssertNoRaise
self.pm.delete()
def test_mission_cancellable(self):
"""
Check the inactive is_cancellable flag.
"""
# AssertNoRaise
self.pm.delete()
def test_mission_on_cancel(self):
"""
Check the on_cancel code.
"""
self.m.on_cancel = """
kingdom.prestige = 50
kingdom.save()
"""
# Sanity check
self.assertEqual(0, Kingdom.objects.get(pk=self.k.pk).prestige)
self.pm.delete()
self.assertEqual(50, Kingdom.objects.get(pk=self.k.pk).prestige)
def test_mission_on_cancel_status(self):
"""
Check the on_cancel code can stop deletion
"""
self.m.on_cancel = """
kingdom.prestige = 50
kingdom.save()
"""
# Sanity check
self.assertEqual(0, Kingdom.objects.get(pk=self.k.pk).prestige)
self.pm.delete()
self.assertEqual(50, Kingdom.objects.get(pk=self.k.pk).prestige)
def test_grid_with_two_people(self):
"""
Check if folks are well put in the grid
"""
self.m.on_resolution = """
status = grids['stub_grid'][0].first_name + " " + grids['stub_grid'][1].first_name
"""
self.m.save()
self.f.first_name = "a"
self.f.save()
self.f2 = Folk(
kingdom=self.k,
first_name="b"
)
self.f2.save()
self.mg.length = 2
self.mg.save()
self.pma2 = PendingMissionAffectation(
pending_mission=self.pm,
mission_grid=self.mg,
folk=self.f2
)
self.pma2.save()
self.pm.start()
status = self.pm.resolve()
self.assertEqual(status, 'a b')
def test_grid_with_two_grids(self):
"""
Check if folks are well put in the grid
"""
mg2 = MissionGrid(
mission=self.m,
slug='stub_grid2'
)
mg2.save()
self.m.on_resolution = """
status = grids['stub_grid'][0].first_name + " " + grids['stub_grid2'][0].first_name
"""
self.m.save()
self.f.first_name = "a"
self.f.save()
self.f2 = Folk(
kingdom=self.k,
first_name="b"
)
self.f2.save()
self.pma2 = PendingMissionAffectation(
pending_mission=self.pm,
mission_grid=mg2,
folk=self.f2
)
self.pma2.save()
self.pm.start()
status = self.pm.resolve()
self.assertEqual(status, 'a b')
def test_pendingmission_set_get_value(self):
"""
Test that setting and retrieving a context value through a PendingMission works
"""
f = Folk(
kingdom=self.k,
first_name="Theon",
last_name="Greyjoy"
)
f.save()
self.pm.set_value("peon", f)
self.assertEqual(f, self.pm.get_value("peon"))
self.pm.set_value("Narnia", self.k)
self.assertEqual(self.k, self.pm.get_value("Narnia"))
self.pm.set_value("nompourri", "Kevin")
self.assertEqual(self.pm.get_value("nompourri"), "Kevin")
self.pm.set_value("beastnum", 666)
self.assertEqual(self.pm.get_value("beastnum"), 666)
self.pm.set_value("void", None)
self.assertEqual(self.pm.get_value("void"), None)
def test_pendingmission_context_start(self):
"""
Test the context access in on_start.
"""
self.m.on_start = """
param.set_value('beastnum', 666)
"""
self.m.save()
# Internal machinery works to delete.
self.pm.start()
self.assertEqual(self.pm.get_value("beastnum"), 666)
def test_pendingmission_context_resolve(self):
"""
Test the context access in on_resolve.
"""
self.m.on_start = """
param.set_value('beastnum', 666)
"""
self.m.on_resolve = """
if param.get_value('beastnum') != 666:
from django.core.exceptions import ValidationError
raise ValidationError("HUM")
"""
self.m.save()
# Internal machinery works to delete.
self.pm.start()
self.pm.resolve()
def test_pendingmission_cron_timeout(self):
"""
Test the cron timeouts pendingmission.
"""
self.m.timeout = 10
self.m.save()
self.pm.created = datetime.now() - timedelta(minutes=15)
self.pm.save()
pm2 = PendingMission(kingdom=self.k, mission=self.m)
pm2.save()
cron_minute.send(self, counter=1000)
self.assertRaises(PendingMission.DoesNotExist, (lambda: PendingMission.objects.get(pk=self.pm.id)))
# Assert no raises
PendingMission.objects.get(pk=pm2.id)
def test_pendingmission_cron_notimeout(self):
"""
Test the cron does not timeout pendingmission without timeout.
"""
self.m.timeout = None
self.m.save()
self.pm.created = datetime.now() - timedelta(minutes=15)
self.pm.save()
cron_minute.send(self, counter=1000)
# assertNoRaises
PendingMission.objects.get(pk=self.pm.id)
def test_pendingmission_cron_timeout_cancel_code(self):
"""
Test the cron triggers the on_cancel code.
"""
self.m.timeout = 10
self.m.on_cancel = """
kingdom.set_value('pm_deleted', param.pk)
"""
self.m.save()
self.pm.created = datetime.now() - timedelta(minutes=15)
self.pm.save()
cron_minute.send(self, counter=1000)
self.assertEqual(self.k.get_value('pm_deleted'), self.pm.id)
def test_pendingmission_cron_duration(self):
"""
Test the cron resolves pendingmission and deletes them.
"""
self.m.duration = 10
self.m.save()
self.pm.started = datetime.now() - timedelta(minutes=15)
self.pm.save()
pm2 = PendingMission(kingdom=self.k, mission=self.m)
pm2.started = datetime.now()
pm2.save()
cron_minute.send(self, counter=1000)
self.assertRaises(PendingMission.DoesNotExist, (lambda: PendingMission.objects.get(pk=self.pm.id)))
# Assert no raises
PendingMission.objects.get(pk=pm2.id)
def test_pendingmission_cron_duration_resolution_code(self):
"""
Test the cron resolves pendingmission and execute the code.
"""
self.m.duration = 10
self.m.on_resolution = """
kingdom.set_value('pm_resolved', param.pk)
"""
self.m.save()
self.pm.started = datetime.now() - timedelta(minutes=15)
self.pm.save()
cron_minute.send(self, counter=1000)
self.assertEqual(self.k.get_value('pm_resolved'), self.pm.id)
def test_team_cant_start(self):
"""
Test teams can't be started
"""
self.m.is_team = True
self.m.save()
self.pm.started = datetime.now()
self.assertRaises(ValidationError, self.pm.save)
class StoredValueTest(TestCase):
"""
Unit tests for stored values
"""
def setUp(self):
self.k = Kingdom()
self.k.save()
self.f = Folk(
kingdom=self.k,
)
self.f.save()
def test_kingdom_value_store_string(self):
"""
Store string values on the kingdom
"""
self.k.set_value("foo", "bar")
self.assertEqual(self.k.get_value("foo"), "bar")
def test_kingdom_value_store_int(self):
"""
Store int values on the kingdom
"""
self.k.set_value("foo", 2)
self.assertEqual(self.k.get_value("foo"), 2)
def test_kingdom_value_store_float(self):
"""
Store float values on the kingdom
"""
self.k.set_value("foo", 1.25)
self.assertEqual(self.k.get_value("foo"), 1.25)
def test_kingdom_value_store_boolean(self):
"""
Store int values on the kingdom
"""
self.k.set_value("foo", True)
self.k.set_value("foo2", False)
self.assertEqual(self.k.get_value("foo"), True)
self.assertEqual(self.k.get_value("foo2"), False)
def test_kingdom_value_store_fk(self):
"""
Store foreign keys values on the kingdom
"""
self.k.set_value("foo", self.f)
self.assertEqual(self.k.get_value("foo"), self.f)
def test_kingdom_value_store_fk_unsaved(self):
"""
Can't store unsaved models.
"""
f2 = Folk(kingdom=self.k)
self.assertRaises(ValidationError, (lambda: self.k.set_value("foo", f2)))
def test_kingdom_value_store_fk_deletion(self):
"""
Deleted values yields None
"""
self.k.set_value("foo", self.f)
self.f.delete()
self.assertEqual(self.k.get_value("foo"), None)
def test_kingdom_value_store_empty_list(self):
"""
Store empty array values on the kingdom
"""
datas = []
self.k.set_value("foo", datas)
self.assertEqual(self.k.get_value("foo"), datas)
def test_kingdom_value_store_mixed_list(self):
"""
Store array values on the kingdom
"""
datas = [1, 2, "lol", True]
self.k.set_value("foo", datas)
self.assertEqual(self.k.get_value("foo"), datas)
def test_kingdom_value_store_nested_list(self):
"""
Store nested array values on the kingdom
"""
datas = [[self.f, 1, 2], [self.k, 1, 2]]
self.k.set_value("foo", datas)
self.assertEqual(self.k.get_value("foo"), datas)
def test_kingdom_value_store_nested_dict(self):
"""
Store nested dict values on the kingdom
"""
datas = {
'man': "himself",
'woman': {
"lol": "herself"
}
}
self.k.set_value("foo", datas)
self.assertEqual(self.k.get_value("foo"), datas)
def test_kingdom_value_store_queryset_fk(self):
"""
Store queryset values on the kingdom
"""
Folk(kingdom=self.k).save()
Folk(kingdom=self.k).save()
Folk(kingdom=self.k).save()
datas = Folk.objects.all()
self.k.set_value("foo", datas)
real_folks = Folk.objects.all()
stored_folks = self.k.get_value("foo")
for r, s in zip(real_folks, stored_folks):
self.assertEqual(r, s)
def test_kingdom_value_store_list_fk(self):
"""
Store list of fk values on the kingdom
"""
f2 = Folk(kingdom=self.k)
f2.save()
datas = [self.f, f2, True, 0, "trololol"]
self.k.set_value("foo", datas)
stored_datas = self.k.get_value("foo")
for r, s in zip(datas, stored_datas):
self.assertEqual(r, s)
def test_kingdom_value_store_mixin(self):
"""
Mixin values.
"""
datas = {
'string': "string",
'array': [1, 2, 3],
'fk': self.k,
'none': None,
'bool': True,
'mixed_array': [1, None, self.f],
'nested_arrays': [1, 2, [3, 4, [5, 6]]],
'nested_object': {
'outofidea': True
}
}
self.k.set_value("foo", datas)
self.assertEqual(self.k.get_value("foo"), datas)
def test_kingdom_value_retrieve_undefined(self):
"""
Non existing values returns default value, or None
"""
self.assertEqual(self.k.get_value("foo"), None)
self.assertEqual(self.k.get_value("foo", "bar"), "bar")
def test_kingdom_value_retrieve_all(self):
"""
get_values retrieve all values.
"""
obj = {
'val1': 1,
'val2': "Hello",
'val3': True,
'val4': self.k
}
for k, v in obj.items():
self.k.set_value(k, v)
self.assertEqual(self.k.get_values(), obj)
def test_kingdom_has_value(self):
"""
Test has_value code
"""
self.assertFalse(self.k.has_value("foo"))
self.k.set_value('foo', 'bar')
self.assertTrue(self.k.has_value("foo"))
def test_kingdom_value_overwrite(self):
"""
Test we can write to the same value multiple time.
"""
self.k.set_value('foo', 'bar')
self.assertEqual(self.k.get_value("foo"), 'bar')
self.k.set_value('foo', 223)
self.assertEqual(self.k.get_value("foo"), 223)
self.k.set_value('foo', self.k)
self.assertEqual(self.k.get_value("foo"), self.k)
self.k.set_value('foo', self.f)
self.assertEqual(self.k.get_value("foo"), self.f)
class UnitTest(TestCase):
def setUp(self):
self.k = Kingdom()
self.k.save()
self.f = Folk(
kingdom=self.k,
first_name="Robert",
last_name="Baratheon"
)
self.f.save()
self.t = Trigger(
slug='Trigger_internal_test',
name='Trigger_internal_test',
prestige_threshold=10,
population_threshold=10,
money_threshold=10,
)
self.t.save()
def test_threshold(self):
"""
Check that thresholds are properly handled
"""
self.t.on_fire = """
Folk(
kingdom=kingdom,
first_name="Balon",
last_name="Greyjoy"
).save()
"""
self.t.save()
# Sanity check
self.assertEqual(Folk.objects.count(), 1)
# Do not fire
self.k.prestige = 2
self.k.population = 2
self.k.money_threshold = 2
# triggers are executed on save from kingdoms
self.k.save()
self.assertEqual(Folk.objects.count(), 1)
# Do not fire if only one value is ok
self.k.prestige = 15
self.k.population = 0
self.k.money = 0
self.k.save()
self.assertEqual(Folk.objects.count(), 1)
# Test also the case when only the second one is ok
self.k.prestige = 0
self.k.population = 15
self.k.money = 0
self.k.save()
self.assertEqual(Folk.objects.count(), 1)
# Test also the case when only the third one is ok
self.k.prestige = 0
self.k.population = 0
self.k.money = 15
self.k.save()
self.assertEqual(Folk.objects.count(), 1)
# Test also the case when only two are ok
self.k.prestige = 15
self.k.population = 15
self.k.money = 0
self.k.save()
self.assertEqual(Folk.objects.count(), 1)
# Test case when two are okay (#1)
self.k.prestige = 15
self.k.population = 0
self.k.money = 15
self.k.save()
self.assertEqual(Folk.objects.count(), 1)
# Test case when two are okay (#2)
self.k.prestige = 0
self.k.population = 15
self.k.money = 15
self.k.save()
self.assertEqual(Folk.objects.count(), 1)
# Test case when two are okay (#3)
self.k.prestige = 0
self.k.population = 0
self.k.money = 15
self.k.save()
self.assertEqual(Folk.objects.count(), 1)
# Fire!
self.k.prestige = 15
self.k.population = 15
self.k.money = 15
# Kingdom save to launch the triggers
self.k.save()
self.assertEqual(Folk.objects.count(), 2)
def test_trigger_only_once(self):
"""
Check that a trigger cannot be activated more than once
"""
self.t.on_fire = """
Folk(
kingdom=kingdom,
first_name="Catelyn",
last_name="Stark",
sex=Folk.FEMALE
).save()
"""
self.t.save()
# Sanity check
self.assertEqual(Folk.objects.count(), 1)
# Fire!
self.k.prestige = 15
self.k.population = 15
self.k.money = 15
self.k.save()
self.assertEqual(Folk.objects.count(), 2)
# No Fire again!
self.t.on_fire = """
from django.core.exceptions import ValidationError
raise ValidationError("Can't call twice.")
"""
self.t.save()
self.k.prestige = 20
self.k.population = 20
self.k.money = 20
self.k.save()
def test_trigger_condition_success(self):
"""
Check that a successful condition activates the corresponding trigger
"""
self.t.on_fire = """
Folk(
kingdom=kingdom,
first_name="Joffrey",
last_name="Lannister"
).save()
"""
self.t.save()
# Sanity check
self.assertEqual(Folk.objects.count(), 1)
# Fire !
self.k.prestige = 20
self.k.population = 20
self.k.money = 20
self.k.save()
self.assertEqual(Folk.objects.count(), 2)
def test_trigger_condition_failure(self):
"""
Check that an unsusccessful condition does not activate the corresponding trigger
"""
self.t.on_fire = """
Folk(
kingdom=kingdom,
name="New user from trigger"
).save()
"""
# return None in param(minimal failure condition)
self.t.condition = """
status = "NotPossible"
"""
self.t.save()
# Sanity check
self.assertEqual(Folk.objects.count(), 1)
# No Fire
self.k.prestige = 20
self.k.population = 20
self.k.money = 20
self.k.save()
self.assertEqual(Folk.objects.count(), 1)
def test_recurring_kingdoms(self):
"""
Test recurring returns a list of kingdoms on which to run
"""
r = Recurring(
kingdom_list="""
param = Kingdom.objects.filter(prestige__lte=50)
"""
)
r.save()
kingdoms = r.kingdoms()
self.assertEqual(len(kingdoms), 1)
self.k.prestige = 500
self.k.save()
kingdoms = r.kingdoms()
self.assertEqual(len(kingdoms), 0)
def test_recurring_code(self):
"""
Test recurring condition code.
"""
r = Recurring(
on_fire="""
status = "foo"
kingdom.money = 15
kingdom.save()
"""
)
r.save()
status = r.fire(self.k)
self.assertEqual(status, "foo")
self.assertEqual(Kingdom.objects.get(pk=self.k.pk).money, 15)
def test_recurring_cron(self):
"""
Test recurring runs within the cron signal
"""
r = Recurring(
delay=10,
on_fire="""
kingdom.money = 500
kingdom.save()
"""
)
r.save()
# Sanity check
self.assertEqual(Kingdom.objects.get(pk=self.k.pk).money, 0)
cron_ten_minutes.send(self, counter=5)
self.assertEqual(Kingdom.objects.get(pk=self.k.pk).money, 0)
cron_ten_minutes.send(self, counter=10)
self.assertEqual(Kingdom.objects.get(pk=self.k.pk).money, 500)
def test_execution_order(self):
"""
Test that simultaneous triggers are executed in their creation order
"""
t1 = Trigger(
slug="trigger1_internal_test",
name="Trigger1 internal test",
prestige_threshold=10,
population_threshold=10,
money_threshold=10,
)
t1.on_fire = """
kingdom.money = 111
"""
t1.save()
t2 = Trigger(
slug="trigger2_internal_test",
name="Trigger2 internal test",
prestige_threshold=10,
population_threshold=10,
money_threshold=10,
)
t2.on_fire = """
kingdom.money = 42
kingdom.save()
"""
t2.save()
# Fire!
self.k.prestige = 15
self.k.population = 15
self.k.money = 15
# Kingdom save to launch the triggers
self.k.save()
self.assertEqual(self.k.money, 42)
def test_function(self):
"""
Test function code.
"""
f = Function(
slug="test_function",
)
f.on_fire = """
param = "foo"
"""
f.save()
param = f.fire()
self.assertEqual(param, "foo")
def test_function_params(self):
"""
Test function code.
"""
f = Function(
slug="test_function",
)
f.on_fire = """
param = foo * bar
"""
f.save()
param = f.fire(foo=2, bar=3)
self.assertEqual(param, 6)
def test_function_params_check_provided(self):
"""
Test mandatory params are provided
"""
f = Function(
slug="test_function",
)
f.params = """
foo:int
bar:int
"""
f.on_fire = """
param = foo * bar
"""
f.save()
# Missing bar parameter
self.assertRaises(NameError, lambda: f.fire(foo=2))
def test_function_params_check_provided_type(self):
"""
Test mandatory params are provided with good type
"""
f = Function(
slug="test_function",
)
f.params = """
foo:int
bar:int
"""
f.save()
# Bar parameter must be int
self.assertRaises(TypeError, lambda: f.fire(foo=2, bar="3"))
def test_function_params_check_provided_types(self):
"""
Test mandatory params are provided with good type, and multiple types are allowed with a | separator.
"""
f = Function(
slug="test_function",
)
f.params = """
foo:list|QuerySet
"""
f.save()
# Foo parameter must be list or QuerySet
self.assertRaises(TypeError, lambda: f.fire(foo=2))
# assertNoRaises
f.fire(foo=[1,2,3])
f.fire(foo=Function.objects.all())
def test_function_params_check_none(self):
"""
Test mandatory params are provided with good type, or None is OK.
"""
f = Function(
slug="test_function",
)
f.params = """
foo:int
bar:int
"""
f.save()
# assertNoRaise
f.fire(foo=2, bar=None)
def test_auto_name_for_folk(self):
"""
The name is automatically filled.
"""
FirstName(name="Gendry", sex=Folk.MALE).save()
LastName(name="Baratheon").save()
f2 = Folk(kingdom=self.k)
f2.save()
self.assertEqual(f2.first_name, "Gendry")
self.assertEqual(f2.last_name, "Baratheon")
def test_freeze_no_access(self):
"""
Test freeze is only available to super user.
"""
u = User(username="******")
u.save()
self.k.user = u
freeze = Freeze(kingdom=self.k)
self.assertRaises(ValidationError, freeze.save)
def test_freeze_access(self):
"""
Test freeze is only available to super user.
"""
u = User(username="******", is_staff=True)
u.save()
self.k.user = u
freeze = Freeze(kingdom=self.k)
# AssertNoRaises
freeze.save()
def test_freeze_on_values(self):
"""
Test freeze mechanism : value restored.
"""
freezed_prestige = self.k.prestige
freezed_folk_first_name = self.f.first_name
freeze = Freeze(kingdom=self.k)
freeze.save()
# Change values
self.k.prestige += 50
self.k.save()
self.f.first_name = "Raymondie"
self.f.save()
# Unfreeze
freeze.restore()
# Check values are restored
self.assertEqual(Kingdom.objects.get(pk=self.k.pk).prestige, freezed_prestige)
self.assertEqual(Folk.objects.get(pk=self.f.pk).first_name, freezed_folk_first_name)
def test_freeze_destroyed(self):
"""
Test freeze mechanism : objects deleted post-freeze are recreated
"""
freezed_folk_pk = self.f.pk
freeze = Freeze(kingdom=self.k)
freeze.save()
# Delete folk
self.f.delete()
# Unfreeze
freeze.restore()
# Check folk is restored
self.assertEqual(Folk.objects.get(pk=freezed_folk_pk).first_name, self.f.first_name)
def test_freeze_created(self):
"""
Test freeze mechanism : objects created post-freeze are deleted
"""
freezed_folk_pk = self.f.pk
self.f.delete()
freeze = Freeze(kingdom=self.k)
freeze.save()
# Create new folk
self.f.save()
# Unfreeze
freeze.restore()
# Check folk has been removed
self.assertRaises(Folk.DoesNotExist, lambda: Folk.objects.get(pk=freezed_folk_pk))
def test_freeze_advanced(self):
"""
Test advanced freeze mechanism : pending_event_variable are restored (this is "second level restoration" since this Variable has nothing to do with the kingdom)
"""
from event.models import Event, PendingEvent
e = Event(
name="Event 1",
slug="event_1",
category=None,
text="Event 1",
on_fire=""
)
e.save()
pe = PendingEvent(
event=e,
kingdom=self.k
)
pe.save()
pe.set_value('foo', 'bar')
pe.set_value('folk', self.f)
freezed_pe_pk = pe.pk
freeze = Freeze(kingdom=self.k)
freeze.save()
# Terminate PendingEvent
pe.delete()
# Unfreeze
freeze.restore()
# Check variable has been restored
pe = PendingEvent.objects.get(pk=freezed_pe_pk)
self.assertEqual(pe.get_value('foo'), 'bar')
self.assertEqual(pe.get_value('folk'), self.f)
def test_freeze_nolock(self):
"""
Test freeze restoration is not bound to petty matter, such as "not leaving a mission before it ends".
"""
from mission.models import Mission, PendingMission, MissionGrid, PendingMissionAffectation
m = Mission(
name="Stub mission",
slug="stub",
title=None,
)
m.save()
mg = MissionGrid(
mission=m,
slug='stub_grid'
)
mg.save()
pm = PendingMission(
mission=m,
kingdom=self.k
)
pm.save()
pma = PendingMissionAffectation(
pending_mission=pm,
mission_grid=mg,
folk=self.f
)
pma.save()
# Create the freeze
freeze = Freeze(kingdom=self.k)
freeze.save()
pm.start()
# Sanity check
self.assertRaises(ValidationError, lambda: pm.delete())
# Unfreeze.
# No errors should be raised, even though the PendingMission is still deleted
freeze.restore()
self.assertFalse(PendingMission.objects.get(pk=pm.pk).is_started)
def test_freeze_m2m(self):
"""
Test freeze mechanism : m2m objects are restored
"""
freeze = Freeze(kingdom=self.k)
freeze.save()
# Launch trigger self.t
self.k.population = 15
self.k.prestige = 15
self.k.money = 15
self.k.save()
# Sanity check
self.assertEqual(1, self.k.trigger_set.count())
# Unfreeze
freeze.restore()
self.assertEqual(0, self.k.trigger_set.count())
def test_avatar_image_adult(self):
"""
Verify the good image is returned, depending on the age
"""
a = Avatar(
adult_threshold=20,
old_threshold=50,
adult=File(open(__file__), 'adult'),
old=File(open(__file__), 'old'),
)
a.save()
# Age between adult_threshold and old_threshold: adult
self.assertEqual(a.image(25), a.adult.url)
# Age after old_threshold
self.assertEqual(a.image(55), a.old.url)
# Age lower than adult_threshold: adult anyway
self.assertEqual(a.image(0), a.adult.url)
def test_avatar_image_child(self):
"""
Verify the good image is returned
"""
a = Avatar(
adult_threshold=20,
old_threshold=50,
child=File(open(__file__), 'child'),
)
a.save()
# Child image, no matter what.
self.assertEqual(a.image(1), a.child.url)
self.assertEqual(a.image(18), a.child.url)
self.assertEqual(a.image(100), a.child.url)
class ScriptTest(TestCase):
"""
Unit tests for mission script
"""
def setUp(self):
self.k = Kingdom()
self.k.save()
self.f = Folk(first_name="bob", kingdom=self.k)
self.f.save()
self.m = Mission(name="Stub mission", slug="stub", on_resolution="")
self.m.save()
def test_kingdom_unlock_mission(self):
"""
Check the available mission is created.
"""
self.k.unlock_mission("stub")
# AssertNoRaises
AvailableMission.objects.get(kingdom=self.k, mission=self.m)
def test_kingdom_create_pending_mission(self):
"""
Check the pending mission is created.
"""
self.k.create_pending_mission("stub")
self.assertEqual(self.k.pendingmission_set.count(), 1)
def test_kingdom_unlock_title_already_available(self):
"""
Check no error occurs if you unlock twice
"""
self.k.unlock_mission("stub")
# AssertNoRaises
self.k.unlock_mission("stub")
def test_kingdom_get_team(self):
"""
Check you can retrieve team datas
"""
# Sanity check
self.assertRaises(PendingMission.DoesNotExist, lambda: self.k.get_team("stub"))
self.m.is_team = True
self.m.save()
pm = PendingMission(kingdom=self.k, mission=self.m)
pm.save()
# AssertNoRaises
datas = self.k.get_team("stub")
self.assertEqual(datas["pendingmission"], pm)
self.assertEqual(len(datas["grids"]), 0)
class ApiTest(TestCase):
"""
API tests for missions
"""
def setUp(self):
self.u = User(username="******")
self.u.set_password("pwd")
self.u.save()
self.k = Kingdom(user=self.u)
self.k.save()
self.f = Folk(
kingdom=self.k,
)
self.f.save()
self.t = Title(
name="Stub title",
description="My description.")
self.t.save()
self.at = AvailableTitle(
title=self.t,
kingdom=self.k,
folk=self.f
)
self.at.save()
self.m = Mission(
name="Stub mission",
slug="stub",
on_resolution="",
title=self.t,
)
self.m.save()
self.mg = MissionGrid(
mission=self.m,
slug='stub_grid',
allow_empty=True
)
self.mg.save()
self.pm = PendingMission(
mission=self.m,
kingdom=self.k
)
self.pm.save()
self.c = Client()
self.c.login(username=self.u.username, password="******")
def test_grid_affect(self):
"""
A folk can be affected
"""
r = self.c.post(reverse('mission.views.pending_mission_grid_affect', args=(self.pm.pk, self.mg.pk)), {'folk': self.f.pk})
self.assertEqual(200, r.status_code)
self.assertEqual(PendingMissionAffectation.objects.all().count(), 1)
def test_grid_defect(self):
"""
A folk can be defected
"""
pma = PendingMissionAffectation(
pending_mission=self.pm,
mission_grid=self.mg,
folk=self.f
)
pma.save()
r = self.c.post(reverse('mission.views.pending_mission_grid_defect', args=(pma.pk,)))
self.assertEqual(200, r.status_code)
self.assertEqual(PendingMissionAffectation.objects.all().count(), 0)
def test_target(self):
"""
A target can be defined
"""
self.m.has_target = True
self.m.save()
k2 = Kingdom()
k2.save()
r = self.c.post(reverse('mission.views.pending_mission_set_target', args=(self.pm.pk,)), {'target': k2.pk})
self.assertEqual(200, r.status_code)
self.assertEqual(PendingMission.objects.get(pk=self.pm.pk).target, k2)
def test_value(self):
"""
A value can be defined
"""
self.m.has_value = True
self.m.save()
r = self.c.post(reverse('mission.views.pending_mission_set_value', args=(self.pm.pk,)), {'value': 100})
self.assertEqual(200, r.status_code)
self.assertEqual(PendingMission.objects.get(pk=self.pm.pk).value, 100)
def test_start(self):
"""
PendingMission can be started
"""
r = self.c.post(reverse('mission.views.pending_mission_start', args=(self.pm.pk,)))
self.assertEqual(200, r.status_code)
self.assertIsNotNone(PendingMission.objects.get(pk=self.pm.pk).started)
def test_cancel(self):
"""
PendingMission can be cancelled
"""
r = self.c.post(reverse('mission.views.pending_mission_cancel', args=(self.pm.pk,)))
self.assertEqual(200, r.status_code)
self.assertRaises(PendingMission.DoesNotExist, lambda: PendingMission.objects.get(pk=self.pm.pk))
def test_availablemission_start(self):
"""
AvailableMission can be started
"""
am = AvailableMission(
mission=self.m,
kingdom=self.k
)
am.save()
r = self.c.post(reverse('mission.views.available_mission_start', args=(am.pk,)))
self.assertEqual(200, r.status_code)
self.assertEqual(PendingMission.objects.all().count(), 2)
class ScriptTest(TestCase):
"""
Unit tests for title script
"""
def setUp(self):
self.k = Kingdom()
self.k.save()
self.f = Folk(
first_name="bob",
kingdom=self.k,
)
self.f.save()
self.t = Title(
name="Dummy title",
slug="dummy_title",
description="Nothing to say."
)
self.t.save()
def test_kingdom_get_folk_in_title(self):
"""
Check folk is returned
"""
at2 = AvailableTitle(
title=self.t,
kingdom=self.k,
folk=self.f
)
at2.save()
self.assertEqual(self.f, self.k.get_folk_in_title("dummy_title"))
def test_kingdom_get_folk_in_title_fail(self):
"""
Check None is returned
"""
at2 = AvailableTitle(
title=self.t,
kingdom=self.k,
folk=self.f
)
at2.save()
self.assertIsNone(self.k.get_folk_in_title("zerfzef"))
def test_kingdom_get_folk_in_title_empty(self):
"""
Check None is returned
"""
at2 = AvailableTitle(
title=self.t,
kingdom=self.k,
)
at2.save()
self.assertIsNone(self.k.get_folk_in_title("dummy_title"))
def test_kingdom_unlock_title(self):
"""
Check available title is created
"""
# Sanity check
self.assertRaises(AvailableTitle.DoesNotExist, (lambda: AvailableTitle.objects.get(kingdom=self.k, title=self.t)))
self.k.unlock_title("dummy_title")
# AssertNoRaises
AvailableTitle.objects.get(kingdom=self.k, title=self.t)
def test_kingdom_unlock_title_already_available(self):
"""
Check you can unlock twice
"""
self.k.unlock_title("dummy_title")
self.k.unlock_title("dummy_title")
def test_folk_add_title(self):
"""
Check the title is added
"""
self.assertRaises(AvailableTitle.DoesNotExist, self.k.get_folk_in_title("dummy_title"))
self.at = AvailableTitle(
title=self.t,
kingdom=self.k,
folk=self.f
)
self.at.save()
self.f.add_title("dummy_title")
self.assertEqual("bob", self.k.get_folk_in_title("dummy_title").first_name)
def test_folk_remove_title(self):
"""
Check the title is removed
"""
self.assertRaises(AvailableTitle.DoesNotExist, self.k.get_folk_in_title("dummy_title"))
self.at = AvailableTitle(
title=self.t,
kingdom=self.k,
folk=self.f
)
self.at.save()
self.f.add_title("dummy_title")
self.assertEqual("bob", self.k.get_folk_in_title("dummy_title").first_name)
self.f.remove_title()
self.assertEqual(None, self.k.get_folk_in_title("dummy_title"))
class ScriptTest(TestCase):
"""
Unit tests for kingdom's scripts.
"""
def setUp(self):
self.k = Kingdom()
self.k.save()
self.f = Folk(
kingdom=self.k,
)
self.f.save()
self.m = Message(
kingdom=self.k,
content="some content"
)
self.m.save()
def test_kingdom_message(self):
"""
Verify the message is created
"""
self.m.delete()
self.k.message("coucou")
self.assertEqual("coucou", Message.objects.get(kingdom=self.k).content)
def test_kingdom_add_claim(self):
"""
Verify if the claim is created
"""
self.k2 = Kingdom()
self.k2.save()
self.k.add_claim(self.k2, Claim.REACHABLE)
self.assertEqual(self.k, Claim.objects.get(offender=self.k2, level=Claim.REACHABLE).offended)
def test_folk_die(self):
"""
Verify the folk die
"""
self.assertIsNone(self.f.death)
self.f.die()
self.assertIsNotNone(self.f.death)
def test_folk_add_quality(self):
"""
Verify if the quality is added
"""
self.qc = QualityCategory(
name="Inherent qualities",
description="haha"
)
self.qc.save()
self.q = Quality(
category=self.qc,
slug="smart",
name="Smart",
description="Just like me."
)
self.q.save()
self.f.add_quality("smart")
self.f.save()
self.assertEqual(1, Folk.objects.get(kingdom=self.k).quality_set.count())
def test_folk_add_quality_fail(self):
"""
Can't affect non existing quality
"""
self.assertRaises(Quality.DoesNotExist, (lambda: self.f.add_quality("poor")))
def test_folk_remove_quality(self):
"""
Verify if the quality is removed
"""
self.qc = QualityCategory(
name="Inherent qualities",
description="haha"
)
self.qc.save()
self.q = Quality(
category=self.qc,
slug="smart",
name="Smart",
description="Just like me."
)
self.q.save()
self.f.add_quality("smart")
self.f.save()
self.f.remove_quality("smart")
self.assertEqual(0, Folk.objects.get(pk=self.f.pk).quality_set.count())
def test_folk_age(self):
"""
Verify if the good age is returned
"""
self.f.birth = datetime.now()-timedelta(days=10)
self.assertEqual(10, self.f.age())
def test_folk_has_quality(self):
"""
Verify if the folk has the quality
"""
self.qc = QualityCategory(
name="Inherent qualities",
description="haha"
)
self.qc.save()
self.q = Quality(
category=self.qc,
slug="smart",
name="Smart",
description="Just like me."
)
self.q.save()
self.f.add_quality("smart")
self.assertEqual(True, self.f.has_quality("smart"))
def test_sum_stats(self):
"""
Verify if sum is correct
"""
self.f2 = Folk(
kingdom=self.k,
fight=10,
first_name="aa",
last_name="bb"
)
self.f2.save()
self.f.fight = 5
self.f.save()
self.assertEqual(15, sum_stats([self.f, self.f2], "fight"))
def test_avg_stats(self):
"""
Verify if avg is correct
"""
self.f2 = Folk(
kingdom=self.k,
fight=10,
first_name="aa",
last_name="bb"
)
self.f2.save()
self.f.fight = 6
self.f.save()
# Average code
self.assertEqual(8, avg_stats([self.f, self.f2], "fight"))
# Empty list
self.assertEqual(0, avg_stats([], "fight"))
def test_has_claim(self):
"""
Checks if the has_claim works
"""
self.k3 = Kingdom()
self.k3.save()
self.assertIsNone(self.k.has_claim(self.k3))
self.k.add_claim(self.k3, Claim.REACHABLE)
self.assertEqual(Claim.REACHABLE, self.k.has_claim(self.k3))
