From e9148bc0f6d93b8bb8e0601778660442956ec40d Mon Sep 17 00:00:00 2001 From: Griatch Date: Sat, 26 Sep 2015 09:26:22 +0200 Subject: [PATCH] Added unittests for rplanguage and rpsystem contribs. --- evennia/contrib/rplanguage.py | 11 ++- evennia/contrib/rpsystem.py | 39 +++++---- evennia/contrib/tests.py | 144 ++++++++++++++++++++++++++++++++++ 3 files changed, 168 insertions(+), 26 deletions(-) create mode 100644 evennia/contrib/tests.py diff --git a/evennia/contrib/rplanguage.py b/evennia/contrib/rplanguage.py index 8b26d67851..679d9d6c23 100644 --- a/evennia/contrib/rplanguage.py +++ b/evennia/contrib/rplanguage.py @@ -158,8 +158,8 @@ class LanguageHandler(DefaultScript): def add(self, key="default", phonemes=_PHONEMES, grammar=_GRAMMAR, word_length_variance=0, noun_prefix="", - noun_postfix="", vowels=_VOWELS, manual_translation=None, - auto_translations="word_frequency.txt", force=False): + noun_postfix="", vowels=_VOWELS, manual_translations=None, + auto_translations=None, force=False): """ Add a new language. Note that you generally only need to do this once per language and that adding an existing language @@ -185,7 +185,7 @@ class LanguageHandler(DefaultScript): in this language (if any, usually best to avoid combining with `noun_prefix` or language becomes very wordy). vowels (str, optional): Every vowel allowed in this language. - manual_translation (dict, optional): This allows for custom-setting + manual_translations (dict, optional): This allows for custom-setting certain words in the language to mean the same thing. It is on the form `{real_word: fictional_word}`, for example `{"the", "y'e"}` . @@ -253,9 +253,9 @@ class LanguageHandler(DefaultScript): new_word += choice(grammar2phonemes[match.group()]) translation[word.lower()] = new_word.lower() - if manual_translation: + if manual_translations: # update with manual translations - translation.update(dict((key.lower(), value.lower()) for key, value in manual_translation.items())) + translation.update(dict((key.lower(), value.lower()) for key, value in manual_translations.items())) # store data storage = {"translation" : translation, @@ -293,7 +293,6 @@ class LanguageHandler(DefaultScript): if word.istitle(): # capitalized word we don't have a translation for - # treat as a name (don't translate) - print "noun ..." new_word = "%s%s%s" % (self.language["noun_prefix"], word, self.language["noun_postfix"]) else: # make up translation on the fly. Length can diff --git a/evennia/contrib/rpsystem.py b/evennia/contrib/rpsystem.py index b24ba541c2..79d7e01c15 100644 --- a/evennia/contrib/rpsystem.py +++ b/evennia/contrib/rpsystem.py @@ -175,11 +175,11 @@ def ordered_permutation_regex(sentence): """ # escape {#nnn} markers from sentence, replace with nnn - sentence = _RE_REF.sub("\1", sentence) + sentence = _RE_REF.sub(r"\1", sentence) # escape {##nnn} markers, replace with nnn - sentence = _RE_REF_LANG.sub("\1", sentence) + sentence = _RE_REF_LANG.sub(r"\1", sentence) # escape self-ref marker from sentence - sentence = _RE_SELF_REF.sub("", sentence) + sentence = _RE_SELF_REF.sub(r"", sentence) # ordered permutation algorithm words = sentence.split() @@ -233,7 +233,7 @@ def parse_language(speaker, emote): """ # escape mapping syntax on the form {##id} if it exists already in emote, # if so it is replaced with just "id". - emote = _RE_REF_LANG.sub("\1", emote) + emote = _RE_REF_LANG.sub(r"\1", emote) errors = [] mapping = {} @@ -308,7 +308,7 @@ def parse_sdescs_and_recogs(sender, candidates, string, search_mode=False): # escape mapping syntax on the form {#id} if it exists already in emote, # if so it is replaced with just "id". - string = _RE_REF.sub("\1", string) + string = _RE_REF.sub(r"\1", string) # we now loop over all references and analyze them mapping = {} @@ -744,11 +744,11 @@ class SdescHandler(object): """ # strip emote components from sdesc - sdesc = _RE_REF.sub("\1", - _RE_REF_LANG.sub("\1", - _RE_SELF_REF.sub("", - _RE_LANGUAGE.sub("", - _RE_OBJ_REF_START.sub("", sdesc))))) + sdesc = _RE_REF.sub(r"\1", + _RE_REF_LANG.sub(r"\1", + _RE_SELF_REF.sub(r"", + _RE_LANGUAGE.sub(r"", + _RE_OBJ_REF_START.sub(r"", sdesc))))) # make an sdesc clean of ANSI codes cleaned_sdesc = ansi.strip_ansi(sdesc) @@ -836,11 +836,11 @@ class RecogHandler(object): """ # strip emote components from recog - recog = _RE_REF.sub("\1", - _RE_REF_LANG.sub("\1", - _RE_SELF_REF.sub("", - _RE_LANGUAGE.sub("", - _RE_OBJ_REF_START.sub("", recog))))) + recog = _RE_REF.sub(r"\1", + _RE_REF_LANG.sub(r"\1", + _RE_SELF_REF.sub(r"", + _RE_LANGUAGE.sub(r"", + _RE_OBJ_REF_START.sub(r"", recog))))) # make an recog clean of ANSI codes cleaned_recog = ansi.strip_ansi(recog) @@ -849,7 +849,6 @@ class RecogHandler(object): # mapping #dbref:obj key = "#%i" % obj.id - print "self.obj:", self.obj, self.obj.db._ref2recog self.obj.db._recog_ref2recog[key] = recog self.obj.db._recog_obj2recog[obj] = recog regex = ordered_permutation_regex(cleaned_recog) @@ -880,10 +879,10 @@ class RecogHandler(object): Args: obj (Object): The object for which to remove recog. """ - if obj in self.db.obj2recog: - del self.db._recog_obj2recog[obj] - del self.db._recog_obj2regex[obj] - del self.db._recog_ref2regex["#%i" % obj.id] + if obj in self.obj2recog: + del self.obj.db._recog_obj2recog[obj] + del self.obj.db._recog_obj2regex[obj] + del self.obj.db._recog_ref2recog["#%i" % obj.id] self._cache() def get_regex_tuple(self, obj): diff --git a/evennia/contrib/tests.py b/evennia/contrib/tests.py new file mode 100644 index 0000000000..e696f1579c --- /dev/null +++ b/evennia/contrib/tests.py @@ -0,0 +1,144 @@ +""" +Testing suite for contrib folder + +""" + +from evennia.utils.test_resources import EvenniaTest + +# testing of rplanguage module + +from evennia.contrib import rplanguage + +mtrans = {"testing":"1", "is": "2", "a": "3", "human": "4"} +atrans = ["An", "automated", "advantageous", "repeatable", "faster"] + +text = "Automated testing is advantageous for a number of reasons:" \ + "tests may be executed Continuously without the need for human " \ + "intervention, They are easily repeatable, and often faster." + +class TestLanguage(EvenniaTest): + def setUp(self): + super(TestLanguage, self).setUp() + rplanguage.add_language(key="testlang", + word_length_variance=1, + noun_prefix="bara", + noun_postfix="'y", + manual_translations=mtrans, + auto_translations=atrans, + force=True) + def tearDown(self): + super(TestLanguage, self).tearDown() + rplanguage._LANGUAGE_HANDLER.delete() + rplanguage._LANGUAGE_HANDLER = None + + def test_obfuscate_language(self): + result0 = rplanguage.obfuscate_language(text, level=0.0, language="testlang") + self.assertEqual(result0, text) + result1 = rplanguage.obfuscate_language(text, level=1.0, language="testlang") + result2 = rplanguage.obfuscate_language(text, level=1.0, language="testlang") + self.assertNotEqual(result1, text) + result1, result2 = result1.split(), result2.split() + self.assertEqual(result1[:4], result2[:4]) + self.assertEqual(result1[1], "1") + self.assertEqual(result1[2], "2") + self.assertEqual(result2[-1], result2[-1]) + + def test_available_languages(self): + self.assertEqual(rplanguage.available_languages(), ["testlang"]) + + def test_obfuscate_whisper(self): + self.assertEqual(rplanguage.obfuscate_whisper(text, level=0.0), text) + assert (rplanguage.obfuscate_whisper(text, level=0.1).startswith( + '-utom-t-d t-sting is -dv-nt-g-ous for - numb-r of r--sons:t-sts m-y b- -x-cut-d Continuously')) + assert(rplanguage.obfuscate_whisper(text, level=0.5).startswith( + '--------- --s---- -s -----------s f-- - ------ -f ---s--s:--s-s ')) + self.assertEqual(rplanguage.obfuscate_whisper(text, level=1.0), "...") + +# testing of emoting / sdesc / recog system + +from evennia import create_object +from evennia.contrib import rpsystem + +sdesc0 = "A nice sender of emotes" +sdesc1 = "The first receiver of emotes." +sdesc2 = "Another nice colliding sdesc-guy for tests" +recog01 = "Mr Receiver" +recog02 = "Mr Receiver2" +recog10 = "Mr Sender" +emote = "With a flair, /me looks at /first and /colliding. She says \"This is a test.\"" + +class TestRPSystem(EvenniaTest): + def setUp(self): + super(TestRPSystem, self).setUp() + self.room = create_object(rpsystem.RPRoom, key="Location") + self.speaker = create_object(rpsystem.RPCharacter, key="Sender", location=self.room) + self.receiver1 = create_object(rpsystem.RPCharacter, key="Receiver1", location=self.room) + self.receiver2 = create_object(rpsystem.RPCharacter, key="Receiver2", location=self.room) + + def test_ordered_permutation_regex(self): + self.assertEqual(rpsystem.ordered_permutation_regex(sdesc0), + '/[0-9]*-*A nice sender of emotes|/[0-9]*-*nice sender of emotes|/[0-9]*-*sender ' \ + 'of emotes|/[0-9]*-*A nice sender of|/[0-9]*-*nice sender of|/[0-9]*-*A nice ' \ + 'sender|/[0-9]*-*nice sender|/[0-9]*-*of emotes|/[0-9]*-*sender of|/[0-9]*-*emotes|/[0-9]*-*' \ + 'A nice|/[0-9]*-*sender|/[0-9]*-*nice|/[0-9]*-*of|/[0-9]*-*A') + + def test_sdesc_handler(self): + self.speaker.sdesc.add(sdesc0) + self.assertEqual(self.speaker.sdesc.get(), sdesc0) + self.speaker.sdesc.add("This is {#324} ignored") + self.assertEqual(self.speaker.sdesc.get(), "This is 324 ignored") + self.speaker.sdesc.add("Testing three words") + self.assertEqual(self.speaker.sdesc.get_regex_tuple()[0].pattern, + '/[0-9]*-*Testing three words|/[0-9]*-*Testing three|/[0-9]' \ + '*-*three words|/[0-9]*-*Testing|/[0-9]*-*words|/[0-9]*-*three') + + def test_recog_handler(self): + self.speaker.sdesc.add(sdesc0) + self.receiver1.sdesc.add(sdesc1) + self.speaker.recog.add(self.receiver1, recog01) + self.speaker.recog.add(self.receiver2, recog02) + self.assertEqual(self.speaker.recog.get(self.receiver1), recog01) + self.assertEqual(self.speaker.recog.get(self.receiver2), recog02) + self.assertEqual(self.speaker.recog.get_regex_tuple(self.receiver1)[0].pattern, + '/[0-9]*-*Mr Receiver|/[0-9]*-*Receiver|/[0-9]*-*Mr') + self.speaker.recog.remove(self.receiver1) + self.assertEqual(self.speaker.recog.get(self.receiver1), sdesc1) + + def test_parse_language(self): + self.assertEqual(rpsystem.parse_language(self.speaker, emote), + ('With a flair, /me looks at /first and /colliding. She says {##0}', + {'##0': (None, '"This is a test."')}) ) + + def parse_sdescs_and_recogs(self): + speaker = self.speaker + speaker.sdesc.add(sdesc0) + self.receiver1.sdesc.add(sdesc1) + self.receiver2.sdesc.add(sdesc2) + candidates = (self.receiver1, self.receiver2) + result = ('With a flair, {#9} looks at {#10} and {#11}. She says "This is a test."', + {'#11': 'Another nice colliding sdesc-guy for tests', '#10': + 'The first receiver of emotes.', '#9': 'A nice sender of emotes'}) + self.assertEqual(rpsystem.parse_sdescs_and_recogs(speaker, candidates, emote), result) + self.speaker.recog.add(self.receiver1, recog01) + self.assertEqual(rpsystem.parse_sdescs_and_recogs(speaker, candidates, emote), result) + + def send_emote(self): + speaker = self.speaker + receiver1 = self.receiver1 + receiver2 = self.receiver2 + receivers = [speaker, receiver1, receiver2] + speaker.sdesc.add(sdesc0) + receiver1.sdesc.add(sdesc1) + receiver2.sdesc.add(sdesc2) + speaker.msg = lambda text, **kwargs: setattr(self, "out0", text) + receiver1.msg = lambda text, **kwargs: setattr(self, "out1", text) + receiver2.msg = lambda text, **kwargs: setattr(self, "out2", text) + rpsystem.send_emote(speaker, receivers, emote) + self.assertEqual(self.out0, 'With a flair, {bSender{n looks at {bThe first receiver of emotes.{n ' \ + 'and {bAnother nice colliding sdesc-guy for tests{n. She says {b{w"This is a test."{n{n') + self.assertEqual(self.out1, 'With a flair, {bA nice sender of emotes{n looks at {bReceiver1{n and ' \ + '{bAnother nice colliding sdesc-guy for tests{n. She says {b{w"This is a test."{n{n') + self.assertEqual(self.out2, 'With a flair, {bA nice sender of emotes{n looks at {bThe first ' \ + 'receiver of emotes.{n and {bReceiver2{n. She says {b{w"This is a test."{n{n') + +