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)
class ApiTest(TestCase):
"""
API tests for kingdom projects.
This is not complete. It only checks the main api returns, and does not check the other API endpoints.
The rationale here is the endpoints only do glue code, and all the logic is done at the signal level.
"""
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.c = Client()
self.c.login(username=self.u.username, password="******")
def test_api_is_up(self):
"""
Check API calls returns with status 200
"""
r = self.c.get(reverse('kingdom.views.api.api'))
self.assertEqual(200, r.status_code)
class ScriptTest(TestCase):
"""
Unit tests for event app
"""
def setUp(self):
self.k = Kingdom()
self.k.save()
self.c = EventCategory(
frequency=1,
timeout=1,
)
self.c.save()
self.e = Event(
name="Event 1",
slug="event_1",
category=self.c,
text="Event 1",
on_fire=""
)
self.e.save()
self.a = EventAction(
event=self.e,
text="some text",
on_fire="",
)
self.a.save()
def test_kingdom_create_pending_event(self):
"""
Check the pending event is created and not started
"""
pe = self.k.create_pending_event("event_1")
self.assertIsNone(pe.started)
self.assertEqual(pe.event_id, self.e.pk)
self.assertEqual(self.k.pendingevent_set.count(), 1)
def test_kingdom_start_pending_event(self):
"""
Check the pending event is created and started
"""
pe = self.k.start_pending_event("event_1")
self.assertIsNotNone(pe.started)
self.assertEqual(pe.event_id, self.e.pk)
self.assertEqual(self.k.pendingevent_set.count(), 1)
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_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_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)
class UnitTest(TestCase): def setUp(self): self.k = Kingdom() self.k.save() @override_settings(DEBUG=True) def test_scriptlog(self): """ Scriptlog store all relevant datas. We need to override_settings with DEBUG=True as the test runner automatically deactivate this option. """ f = Function( slug="create_lastname", ) f.on_fire = """ # Does one direct query LastName(name="la veuve des sept lieux").save() """ f.save() f2 = Function( slug="count_and_create_lastname", ) f2.on_fire = """ # Does 2 direct queries, 1 indirect LastName.objects.count() create_lastname.fire() LastName.objects.count() """ f2.save() # Sanity check self.assertEqual(0, ScriptLog.objects.count()) # Do 3 queries f2.fire(create_lastname=f) self.assertEqual(2, ScriptLog.objects.count()) # First log is the innermost function self.assertEqual(1, ScriptLog.objects.all()[0].direct_queries) self.assertEqual(1, ScriptLog.objects.all()[0].queries) self.assertEqual(2, ScriptLog.objects.all()[1].direct_queries) self.assertEqual(3, ScriptLog.objects.all()[1].queries)
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_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_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_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_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_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_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_token_pending_event_sanity(self): """ Check kingdoms in token and pending_event are similar """ pe = PendingEvent( event=self.e, kingdom=self.k, started=None ) pe.save() k2 = Kingdom() k2.save() pet = PendingEventToken( kingdom=k2, pending_event=pe, category=self.c ) self.assertRaises(IntegrityError, pet.save)
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')
class ViewTest(TestCase):
"""
Views tests for kingdom projects.
This is not complete. It only checks the return code.
"""
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.c = Client()
self.c.login(username=self.u.username, password="******")
def test_app_require_login(self):
"""
Check app returns with status 200
"""
r = Client().get(reverse('kingdom.views.index.app'))
self.assertEqual(302, r.status_code)
def test_login_is_up(self):
"""
Check app returns with status 200
"""
r = self.c.get(reverse('django.contrib.auth.views.login'))
self.assertEqual(200, r.status_code)
def test_app_is_up(self):
"""
Check app returns with status 200
"""
r = self.c.get(reverse('kingdom.views.index.app'))
self.assertEqual(200, r.status_code)
def test_errors_require_enabling(self):
"""
Check app returns with status 200
"""
r = self.c.get(reverse('kingdom.views.index.errors'))
self.assertEqual(404, r.status_code)
@override_settings(ERROR_FILE=__file__)
def test_errors_is_up(self):
"""
Check app returns with status 200
"""
r = self.c.get(reverse('kingdom.views.index.errors'))
self.assertEqual(200, r.status_code)
def test_dependencies_is_up(self):
"""
Check app returns with status 200
"""
r = self.c.get(reverse('kingdom.views.index.dependencies', args=('dot',)))
self.assertEqual(200, r.status_code)
def test_admin_is_up(self):
"""
Check admin returns with status 200
"""
r = self.c.get('/admin/')
self.assertEqual(200, r.status_code)
def test_admin_subpage_is_up(self):
"""
Check admin returns with status 200
"""
qc = QualityCategory(
name="category"
)
qc.save()
q = Quality(
category = qc,
slug="quality",
name="quality"
)
q.save()
r = self.c.get('/admin/kingdom/quality/1/')
self.assertEqual(200, r.status_code)
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): 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 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 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 TemplateTest(TestCase):
def setUp(self):
self.k = Kingdom()
self.k.save()
self.c = EventCategory(
frequency=1,
timeout=1,
)
self.c.save()
self.e = Event(
name="Event 1",
slug="event_1",
category=self.c,
text="Event 1",
on_fire=""
)
self.e.save()
self.a = EventAction(
event=self.e,
text="some text",
on_fire="",
)
self.a.save()
def test_templates_missing_var(self):
"""
Display missing values
"""
self.e.text = "{{undefined}}"
self.e.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
self.assertTrue(pe.text, "<tt style='color:red'>{{undefined}}</tt>")
def test_templates_and_variables(self):
"""
Check templating works on event and EventAction.
"""
self.e.on_fire = """
kingdom.money=666
kingdom.save()
param.set_value("value", "test")
param.set_value("kingdom", kingdom)
"""
self.e.text = "EVENT:{{ value }}-{{ kingdom.money}}"
self.e.save()
self.a.text = "ACTION:{{ value }}-{{ kingdom.money}}"
self.a.message = "ACTIONLOG:{{ value }}-{{ kingdom.money}}"
self.a.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
pea = pe.pendingeventaction_set.all()[0]
self.assertEqual(pe.text, "EVENT:test-666")
self.assertEqual(pea.text, "ACTION:test-666")
self.assertEqual(pea.message, "ACTIONLOG:test-666")
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_templates_and_kingdom_context(self):
"""
Check templating works on event and EventAction with default context title.
"""
self.k.set_value('mate', 'Angie')
self.e.text = "{{ kingdom.values.mate }}"
self.e.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
self.assertEqual(pe.text, "Angie")
def test_templates_and_dynasty_context(self):
"""
Check templating works on event and EventAction with default context dynasty.
"""
from django.contrib.auth.models import User
u = User(username="******")
u.save()
self.k.user = u
self.k.save()
self.e.text = "{{ dynasty }}"
self.e.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
self.assertEqual(pe.text, "hello")
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_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_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_templates_and_number_templatetags(self):
"""
Check number templatetags
"""
self.e.text = "{{ 5|number }}, {{ 15|number }}, {{ 50|number }}, {{ -2|number }}"
self.e.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
self.assertEqual(pe.text, 'cinq, quinze, 50, -2')
def test_templates_and_elide_templatetags(self):
"""
Check elide template_tags
"""
self.e.text = '{{"ambassadeur"|elide:"le,l\'"}}, {{"chatelain"|elide:"le,l\'"}}'
self.e.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
self.assertEqual(pe.text, "l'ambassadeur, le chatelain")
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): """ 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 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 UnitTest(TestCase):
def setUp(self):
self.k = Kingdom()
self.k.save()
self.c = EventCategory(
frequency=1,
timeout=1,
)
self.c.save()
self.e = Event(
name="Event 1",
slug="event_1",
category=self.c,
text="Event 1",
on_fire=""
)
self.e.save()
self.a = EventAction(
event=self.e,
text="some text",
on_fire="",
)
self.a.save()
def test_references_coherence(self):
"""
Check the pending_event and the event_action always refers to the same event.
"""
e2 = Event(
name="Event 2",
slug="event_2",
category=self.c,
text="Event 2",
)
e2.save()
pe = PendingEvent(
event=e2,
kingdom=self.k,
)
pe.save()
pea = PendingEventAction(
pending_event=pe,
event_action=self.a,
)
self.assertRaises(IntegrityError, pea.save)
def test_condition_event(self):
"""
Check condition is triggered.
"""
self.e.condition = """
status="notAllowed"
"""
self.e.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
self.assertRaises(ValidationError, pe.save)
def test_on_fire_event(self):
"""
Check the on-fire code (for event initialisation)
"""
self.e.on_fire = """
kingdom.population = 10
kingdom.save()
"""
self.e.save()
# Sanity check
self.assertEqual(self.k.population, 0)
pe = PendingEvent(
event=self.e,
kingdom=self.k,
text="some text"
)
pe.save()
self.assertEqual(self.k.population, 10)
def test_on_fire_event_creates_action(self):
"""
Check the on_fire code creates pending event action.
"""
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
self.assertEqual(len(pe.pendingeventaction_set.all()), 1)
self.assertEqual(pe.pendingeventaction_set.all()[0].event_action, self.a)
def test_pendingevent_future_created(self):
"""
Test the cron launches PendingEvent in the future
"""
self.e.on_fire = "param.set_value('has_been_called', True)"
self.e.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
started=datetime.now()+timedelta(milliseconds=5)
)
pe.save()
# Sanity check : not started yet
self.assertFalse(pe.is_started)
self.assertFalse(pe.has_value('has_been_called'))
# Wait until completion
time.sleep(0.005)
cron_minute.send(self, counter=1000)
# PE has been executed
self.assertTrue(pe.get_value('has_been_called'))
self.assertTrue(PendingEvent.objects.get(pk=pe.id).is_started)
def test_pendingevent_future_cancelled(self):
"""
Test the cron launches PendingEvent in the future, and gracefully handles cancellation if the event asks not to be displayed.
"""
self.e.condition = "status='no'"
self.e.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
started=datetime.now()+timedelta(milliseconds=5)
)
pe.save()
# Sanity check : not started yet
self.assertFalse(pe.is_started)
# Wait until completion
time.sleep(0.005)
cron_minute.send(self, counter=1000)
# PE has been deleted (status=no)
self.assertRaises(PendingEvent.DoesNotExist, (lambda: PendingEvent.objects.get(pk=pe.id)))
def test_on_fire_event_action_condition(self):
"""
Check the on_fire code creates pending event action according to their conditions.
"""
self.a.condition = "status='no'"
self.a.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
self.assertEqual(len(pe.pendingeventaction_set.all()), 0)
def test_on_fire_event_twice(self):
"""
Check the on-fire code is only ran once.
"""
self.e.on_fire = """
kingdom.population += 10
kingdom.save()
"""
self.e.save()
# Sanity check
self.assertEqual(self.k.population, 0)
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
self.assertEqual(self.k.population, 10)
# Save again : no action
pe.save()
self.assertEqual(self.k.population, 10)
def test_on_fire_action(self):
"""
Check the on_fire event_action (when an action is selected)
"""
self.a.on_fire = """
kingdom.money=50
kingdom.save()
"""
self.a.save()
# Sanity check
self.assertEqual(self.k.money, 0)
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
pea = pe.pendingeventaction_set.all()[0]
pea.fire()
self.assertEqual(Kingdom.objects.get(pk=self.k.pk).money, 50)
def test_resolution_delete_pending_event(self):
"""
Pending event must be deleted after event resolution.
"""
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
pea = pe.pendingeventaction_set.all()[0]
pea.fire()
self.assertRaises(PendingEvent.DoesNotExist, (lambda: PendingEvent.objects.get(pk=pe.pk)))
self.assertRaises(PendingEventAction.DoesNotExist, (lambda: PendingEventAction.objects.get(pk=pea.pk)))
def test_resolution_create_message(self):
"""
Pending event must be deleted after event resolution.
"""
self.a.message = "get lucky!"
self.a.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
# Sanity check
self.assertEqual(0, len(self.k.message_set.all()))
pea = pe.pendingeventaction_set.all()[0]
pea.fire()
self.assertEqual(1, len(self.k.message_set.all()))
self.assertEqual(self.a.message, self.k.message_set.all()[0].content)
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_pendingevent_savecontext(self):
"""
Test the saving context mechanism in post_save signal on PendingEvent
"""
self.e.on_fire = "param.set_value('beastnum', 666)"
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
self.assertEqual(pe.get_value("beastnum"), 666)
def test_context_restored_on_action(self):
"""
Check the context defined in the Event.on_fire is available to EventAction.on_fire.
"""
self.e.on_fire = """
param.set_value('beastnum', 666)
"""
self.e.save()
self.a.on_fire = """
if param.get_value('beastnum') != 666:
raise ValidationError("Unable to retrieve pending value.")
"""
self.a.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
pea = pe.pendingeventaction_set.all()[0]
# No exception should be raised.
pea.fire()
def test_context_action_setter(self):
"""
Check the pendingeventaction can set values too
"""
self.a.on_fire = """
param.set_value('angelnum', 666)
"""
self.a.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
pea = pe.pendingeventaction_set.all()[0]
# No exception should be raised.
pea.fire()
def test_pendingevent_delayed_add_context_postsave(self):
"""
Test you can create a pending event, store values on it and condition is fired after with this context.
"""
e2 = Event(
name="Event 2",
slug="event_2",
category=self.c,
text="Event 2",
)
e2.condition = """
if param.get_value("ok") != 1:
status = "abort this"
"""
e2.save()
self.e.on_fire = """
pe2 = PendingEvent(
event=Event.objects.get(slug="event_2"),
kingdom=kingdom,
started=None
)
pe2.save()
pe2.set_value("ok", 1)
pe2.start()
"""
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
pea = pe.pendingeventaction_set.all()[0]
pea.fire()
def test_pendingevent_delayed(self):
"""
Tests if ou can create a pending event in the future, and condition is not checked yet.
"""
pe = PendingEvent(
event=self.e,
kingdom=self.k,
started=datetime.now()+timedelta(days=2)
)
pe.save()
# No pending event action created
self.assertEqual(0, pe.pendingeventaction_set.count())
#If started updated :
pe.started = datetime.now()
pe.save()
# Pending event actions created
self.assertEqual(1, pe.pendingeventaction_set.count())
def test_start_pendingevent_twice_fail(self):
"""
Tests if we can't start twice a pendingevent
"""
self.pe = PendingEvent(
event=self.e,
kingdom=self.k,
started=None
)
self.pe.save()
self.pe.start()
self.assertRaises(ValidationError, (lambda: self.pe.start()))
def test_next_event(self):
"""
Tests if the new event is created with the old context
"""
pe = PendingEvent(
event=self.e,
kingdom=self.k,
started=None
)
pe.save()
pe.set_value("valeur", 10)
e2 = Event(
name="Event 2",
slug="event_2",
category=self.c,
text="Event 2",
)
e2.save()
pe.next_event(e2).start()
pe2 = PendingEvent.objects.get(kingdom=self.k, event=e2)
self.assertEqual(10, pe2.get_value("valeur"))
def test_next_event_slug(self):
"""
Tests we can create from event slug too.
"""
pe = PendingEvent(
event=self.e,
kingdom=self.k,
started=None
)
pe.save()
pe.set_value("valeur", 10)
e2 = Event(
name="Event 2",
slug="event_2",
category=self.c,
text="Event 2",
)
e2.save()
pe.next_event("event_2").start()
pe2 = PendingEvent.objects.get(kingdom=self.k, event=e2)
self.assertEqual(10, pe2.get_value("valeur"))
def test_delete(self):
"""
Tests if the event is deleted
"""
e3 = Event(
name="Event 3",
slug="event_3",
category=self.c,
text="Event 3",
)
e3.on_fire = """
status="stop"
"""
e3.save()
pe2 = PendingEvent(
event=e3,
kingdom=self.k,
started=None
)
pe2.save()
pe2.start()
self.assertRaises(PendingEvent.DoesNotExist, (lambda: PendingEvent.objects.get(kingdom=self.k, event=e3)))
def test_dealer_create_pendingeventtoken(self):
"""
Check token creation by the dealer when it is needed
"""
self.c.available_kingdoms.add(self.k)
cron_ten_minutes.send(self, counter=1000)
self.assertEquals(PendingEventToken.objects.count(), 1)
def test_dealer_no_create_pendingeventtoken(self):
"""
Check token creation by the dealer when it is not needed
"""
cron_ten_minutes.send(self, counter=1000)
self.assertEquals(PendingEventToken.objects.count(), 0)
def test_token_pending_event_sanity(self):
"""
Check kingdoms in token and pending_event are similar
"""
pe = PendingEvent(
event=self.e,
kingdom=self.k,
started=None
)
pe.save()
k2 = Kingdom()
k2.save()
pet = PendingEventToken(
kingdom=k2,
pending_event=pe,
category=self.c
)
self.assertRaises(IntegrityError, pet.save)
def test_token_pending_event_not_started(self):
"""
Check kingdoms in token and pending_event are similar
"""
pe = PendingEvent(
event=self.e,
kingdom=self.k,
)
pe.save()
pet = PendingEventToken(
kingdom=self.k,
pending_event=pe,
category=self.c
)
self.assertRaises(IntegrityError, pet.save)
def test_token_to_pending_event_from_pending_event(self):
"""
Check token is made into specified pending_event
"""
pe = PendingEvent(
event=self.e,
kingdom=self.k,
started=None
)
pe.save()
pet = PendingEventToken(
kingdom=self.k,
pending_event=pe,
category=self.c
)
pet.save()
self.assertEqual(pet.to_event(), pe)
def test_token_to_pending_event_from_invalid_pending_event(self):
"""
Check token validates condition for specified pending_event
"""
self.e.condition = "stop('nope')"
self.e.save()
e2 = Event(
name="Event 2",
slug="event_2",
category=self.c,
text="Event 2",
on_fire=""
)
e2.save()
pe = PendingEvent(
event=self.e,
kingdom=self.k,
started=None
)
pe.save()
pet = PendingEventToken(
kingdom=self.k,
pending_event=pe,
category=self.c
)
pet.save()
# Should fallback to other events in the category
ret = pet.to_event()
self.assertEquals(ret.event, e2)
# Check pe has been deleted
self.assertIsNone(pe.pk)
def test_token_to_pending_event_from_category(self):
"""
Check token validates condition for specified pending_event
"""
pet = PendingEventToken(
kingdom=self.k,
category=self.c
)
pet.save()
# Should fallback to other events in the category
ret = pet.to_event()
self.assertEquals(ret.event, self.e)
def test_token_to_pending_event_from_invalid_category(self):
"""
Check token validates condition for specified pending_event
"""
self.e.condition = "stop('nope')"
self.e.save()
pet = PendingEventToken(
kingdom=self.k,
category=self.c
)
pet.save()
# Should fallback to other events in the category
self.assertRaises(ValidationError, pet.to_event)
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 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 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))
