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_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_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_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_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_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_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_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_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_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 kingdom_start_pending_event(self, slug): """ Start a pending event on this kingdom. """ event = Event.objects.get(slug=slug) pe = PendingEvent( kingdom=self, event=event ) pe.save() return pe
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_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")
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_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 kingdom_create_pending_event(self, slug): """ Create a pending event on this kingdom. """ event = Event.objects.get(slug=slug) pe = PendingEvent( kingdom=self, event=event, started=None ) pe.save() return pe
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_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_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_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_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_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(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_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_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_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_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_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_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_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)))