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)
