From d55bee8905e824c2afba16453d92bfd4fc42e890 Mon Sep 17 00:00:00 2001 From: Griatch Date: Fri, 9 Nov 2012 23:17:10 +0100 Subject: [PATCH] Fixed a type - get_attribute_cache() should be get_attr_cache() --- src/commands/default/system.py | 46 +- src/commands/default/tests.py | 1007 ++++++++++++++++++-------------- src/typeclasses/models.py | 2 +- 3 files changed, 570 insertions(+), 485 deletions(-) diff --git a/src/commands/default/system.py b/src/commands/default/system.py index 76637c85d9..667825afb6 100644 --- a/src/commands/default/system.py +++ b/src/commands/default/system.py @@ -274,6 +274,9 @@ class CmdScripts(MuxCommand): else: # we want all scripts. scripts = ScriptDB.objects.get_all_scripts() + if not scripts: + caller.msg("No scripts are running.") + return if not scripts: string = "No scripts found with a key '%s', or on an object named '%s'." % (args, args) @@ -692,46 +695,3 @@ class CmdServerLoad(MuxCommand): string += "\n{w On-entity Property cache usage:{n %5.2f MB (%i props)" % (prop_cache_info[1], prop_cache_info[0]) caller.msg(string) - -# class CmdPs(MuxCommand): -# """ -# list processes - -# Usage -# @ps - -# Shows the process/event table. -# """ -# key = "@ps" -# locks = "cmd:perm(ps) or perm(Builders)" -# help_category = "System" - -# def func(self): -# "run the function." - -# nscripts = ScriptDB.objects.count() -# repeat_scripts = ScriptDB.objects.filter(db_interval__gt=0) -# nrepeat_scripts = ScriptDB.objects.filter(db_interval__le=0) - -# string = "\n{wNon-timed scripts:{n -- PID name desc --" -# if not nrepeat_scripts: -# string += "\n " -# for script in nrepeat_scripts: -# string += "\n {w%i{n %s %s" % (script.id, script.key, script.desc) - -# string += "\n{wTimed scripts:{n -- PID name [time/interval][repeats] desc --" -# if not repeat_scripts: -# string += "\n " -# for script in repeat_scripts: -# repeats = "[inf] " -# if script.repeats: -# repeats = "[%i] " % script.repeats -# time_next = "[inf/inf]" -# if script.time_until_next_repeat() != None: -# time_next = "[%d/%d]" % (script.time_until_next_repeat(), script.interval) -# string += "\n {w%i{n %s %s%s%s" % (script.id, script.key, -# time_next, repeats, script.desc) -# string += "\n{wTotal{n: %d scripts." % len(all_scripts) -# self.caller.msg(string) - - diff --git a/src/commands/default/tests.py b/src/commands/default/tests.py index 5bbfa1151d..03f147b646 100644 --- a/src/commands/default/tests.py +++ b/src/commands/default/tests.py @@ -12,470 +12,595 @@ main test suite started with """ -import re, time -try: - # this is a special optimized Django version, only available in current Django devel - from django.utils.unittest import TestCase -except ImportError: - from django.test import TestCase -from django.conf import settings -from src.utils import create, ansi -from src.server import serversession, sessionhandler -from src.locks.lockhandler import LockHandler -from src.server.models import ServerConfig -from src.comms.models import Channel, Msg, PlayerChannelConnection, ExternalChannelConnection -from django.contrib.auth.models import User -from src.players.models import PlayerDB -from src.objects.models import ObjectDB +#import re, time +#from django.conf import settings +#from src.utils import create, ansi +#from src.server import serversession, sessionhandler +#from src.locks.lockhandler import LockHandler +#from src.server.models import ServerConfig +#from src.comms.models import Channel, Msg, PlayerChannelConnection, ExternalChannelConnection +#from django.contrib.auth.models import User +#from src.players.models import PlayerDB +#from src.objects.models import ObjectDB + +from django.utils.unittest import TestCase +from src.players.player import Player +from src.utils import create, utils, ansi #------------------------------------------------------------ # Command testing # ------------------------------------------------------------ -# print all feedback from test commands (can become very verbose!) -VERBOSE = True -NOMANGLE = True # mangle command input for extra testing - -def cleanup(): - User.objects.all().delete() - PlayerDB.objects.all().delete() - ObjectDB.objects.all().delete() - Channel.objects.all().delete() - Msg.objects.all().delete() - PlayerChannelConnection.objects.all().delete() - ExternalChannelConnection.objects.all().delete() - ServerConfig.objects.all().delete() - -class FakeSessionHandler(sessionhandler.ServerSessionHandler): - """ - Fake sessionhandler, without an amp connection - """ - def portal_shutdown(self): - pass - def disconnect(self, session, reason=""): - pass - def login(self, session): - pass - def session_sync(self): - pass - def data_out(self, session, string="", data=""): - return string - -SESSIONS = FakeSessionHandler() - -class FakeSession(serversession.ServerSession): - """ - A fake session that - implements dummy versions of the real thing; this is needed to - mimic a logged-in player. - """ - protocol_key = "TestProtocol" - sessdict = {'protocol_key':'telnet', 'address':('0.0.0.0','5000'), 'sessid':2, 'uid':2, 'uname':None, - 'logged_in':False, 'cid':None, 'ndb':{}, 'encoding':'utf-8', - 'conn_time':time.time(), 'cmd_last':time.time(), 'cmd_last_visible':time.time(), 'cmd_total':1} - - def connectionMade(self): - self.load_sync_data(self.sessdict) - self.sessionhandler = SESSIONS - def disconnectClient(self): - pass - def lineReceived(self, raw_string): - pass - def msg(self, message, data=None): - global VERBOSE - if message.startswith("Traceback (most recent call last):"): - #retval = "Traceback last line: %s" % message.split('\n')[-4:] - raise AssertionError(message) - if self.player.character.ndb.return_string != None: - return_list = self.player.character.ndb.return_string - if hasattr(return_list, '__iter__'): - rstring = return_list.pop(0) - self.player.character.ndb.return_string = return_list - else: - rstring = return_list - self.player.character.ndb.return_string = None - message_noansi = ansi.parse_ansi(message, strip_ansi=True).strip() - rstring = rstring.strip() - if not message_noansi.startswith(rstring): - sep1 = "\n" + "="*30 + "Wanted message" + "="*34 + "\n" - sep2 = "\n" + "="*30 + "Returned message" + "="*32 + "\n" - sep3 = "\n" + "="*78 - retval = sep1 + rstring + sep2 + message_noansi + sep3 - raise AssertionError(retval) - if VERBOSE: - print message -# setting up objects +class TestPlayer(Player): + def msg(self, message, from_obj=None, data=None): + "test message" + #print "in testing msg():", message + if not self.ndb.stored_msg: + self.ndb.stored_msg = [] + self.ndb.stored_msg.append(message) class CommandTest(TestCase): """ - Sets up the basics of testing the default commands and the generic things - that should always be present in a command. - - Inherit new tests from this. + Tests a command """ - + CID = 0 def setUp(self): - "sets up the testing environment" - #ServerConfig.objects.conf("default_home", 2) - self.addCleanup(cleanup) - self.room1 = create.create_object(settings.BASE_ROOM_TYPECLASS, key="room1") - self.room2 = create.create_object(settings.BASE_ROOM_TYPECLASS, key="room2") - # create a faux player/character for testing. - self.char1 = create.create_player("TestChar", "testplayer@test.com", "testpassword", character_location=self.room1) - self.char1.player.user.is_superuser = True - self.char1.lock_storage = "" - self.char1.locks = LockHandler(self.char1) - self.char1.ndb.return_string = None - self.sess1 = FakeSession() - self.sess1.connectionMade() - self.sess1.session_login(self.char1.player) - # create second player - self.char2 = create.create_player("TestChar2", "testplayer2@test.com", "testpassword2", character_location=self.room1) - self.char2.player.user.is_superuser = False - self.char2.lock_storage = "" - self.char2.locks = LockHandler(self.char2) - self.char2.ndb.return_string = None - self.sess2 = FakeSession() - self.sess2.connectionMade() - self.sess2.session_login(self.char2.player) - # A non-player-controlled character - self.char3 = create.create_object(settings.BASE_CHARACTER_TYPECLASS, key="TestChar3", location=self.room1) - # create some objects - self.obj1 = create.create_object(settings.BASE_OBJECT_TYPECLASS, key="obj1", location=self.room1) - self.obj2 = create.create_object(settings.BASE_OBJECT_TYPECLASS, key="obj2", location=self.room1) - self.exit1 = create.create_object(settings.BASE_EXIT_TYPECLASS, key="exit1", location=self.room1) - self.exit2 = create.create_object(settings.BASE_EXIT_TYPECLASS, key="exit2", location=self.room2) + "sets up testing environment" + self.room1 = create.create_object("src.objects.objects.Room", key="Room%i"%self.CID) + self.room1.db.desc = "room_desc" + self.room2 = create.create_object("src.objects.objects.Room", key="Room%ib"%self.CID) + self.obj1 = create.create_object("src.objects.objects.Object", key="Obj%i"%self.CID, location=self.room1, home=self.room1) + self.obj2 = create.create_object("src.objects.objects.Object", key="Obj%ib"%self.CID, location=self.room1, home=self.room1) + self.player = create.create_player("TestPlayer%i"%self.CID, "test@test.com", "testpassword", typeclass=TestPlayer, create_character=False) + self.caller = create.create_player("Caller%i"%self.CID, "test@test.com", "testpassword", player_dbobj=self.player.dbobj, + character_typeclass="src.objects.objects.Character", + permissions=["Immortals"], character_home=self.room1, character_location=self.room1) + self.caller.player = self.player + self.char = create.create_player("Char%i"%self.CID, "test2@test.com", "testpassword2", typeclass=TestPlayer, + character_typeclass="src.objects.objects.Character", + permissions=["Immortals"], character_home=self.room1, character_location=self.room1) + self.char = create.create_script("src.scripts.scripts.Script", key="Script%i"%self.CID) - def get_cmd(self, cmd_class, argument_string=""): + def call(self, cmdobj, args, msg=None, cmdset=None, noansi=True): """ - Obtain a cmd instance from a class and an input string - Note: This does not make use of the cmdhandler functionality. + Test a command by assigning all the needed + properties to cmdobj and running + cmdobj.at_pre_cmd() + cmdobj.parse() + cmdobj.func() + cmdobj.at_post_cmd() + The msgreturn value is compared to eventual + output sent to caller.msg in the game """ - cmd = cmd_class() - cmd.caller = self.char1 - cmd.cmdstring = cmd_class.key - cmd.args = argument_string - cmd.cmdset = None - cmd.obj = self.char1 - return cmd - def execute_cmd(self, raw_string, wanted_return_string=None, nomangle=False): - """ - Creates the command through faking a normal command call; - This also mangles the input in various ways to test if the command - will be fooled. - """ - if not nomangle and not VERBOSE and not NOMANGLE: - # only mangle if not VERBOSE, to make fewer return lines - test1 = re.sub(r'\s', '', raw_string) # remove all whitespace inside it - test2 = "%s/åäö öäö;-:$£@*~^' 'test" % raw_string # inserting weird characters in call - test3 = "%s %s" % (raw_string, raw_string) # multiple calls - self.char1.execute_cmd(test1) - self.char1.execute_cmd(test2) - self.char1.execute_cmd(test3) - # actual call, we potentially check so return is ok. - self.char1.ndb.return_string = wanted_return_string - try: - self.char1.execute_cmd(raw_string) - except AssertionError, e: - self.fail(e) - self.char1.ndb.return_string = None - -class BuildTest(CommandTest): - """ - We need to turn of mangling for build commands since - it creates arbitrary objects that mess up tests later. - """ - NOMANGLE = True + cmdobj.caller = self.caller + cmdobj.cmdstring = cmdobj.key + cmdobj.args = args + cmdobj.cmdset = cmdset + cmdobj.raw_string = cmdobj.key + " " + args + cmdobj.obj = self.caller + # test + self.caller.player.ndb.stored_msg = [] + cmdobj.at_pre_cmd() + cmdobj.parse() + cmdobj.func() + cmdobj.at_post_cmd() + returned_msg = "|".join(self.caller.player.ndb.stored_msg) + returned_msg = ansi.parse_ansi(returned_msg, strip_ansi=noansi).strip() + if msg != None and not returned_msg.startswith(msg.strip()): + sep1 = "\n" + "="*30 + "Wanted message" + "="*34 + "\n" + sep2 = "\n" + "="*30 + "Returned message" + "="*32 + "\n" + sep3 = "\n" + "="*78 + retval = sep1 + msg.strip() + sep2 + returned_msg + sep3 + raise AssertionError(retval) -#------------------------------------------------------------ -# Default set Command testing -#------------------------------------------------------------ +# Individual module Tests -# # general.py tests +from src.commands.default import general +class TestGeneral(CommandTest): + CID = 1 + def test_cmds(self): + self.call(general.CmdLook(), "here", "Room1\n room_desc") + self.call(general.CmdHome(), "", "You are already home") + self.call(general.CmdPassword(), "testpassword = testpassword", "") + self.call(general.CmdInventory(), "", "You are not carrying anything.") + self.call(general.CmdPose(), "looks around", "Caller1 looks around") + self.call(general.CmdHome(), "", "You are already home") + self.call(general.CmdNick(), "testalias = testaliasedstring1", "Nick set:") + self.call(general.CmdNick(), "/player testalias = testaliasedstring2", "Nick set:") + self.call(general.CmdNick(), "/object testalias = testaliasedstring3", "Nick set:") + self.assertEqual(u"testaliasedstring1", self.caller.nicks.get("testalias")) + self.assertEqual(u"testaliasedstring2", self.caller.nicks.get("testalias", nick_type="player")) + self.assertEqual(u"testaliasedstring3", self.caller.nicks.get("testalias", nick_type="object")) + self.call(general.CmdGet(), "Obj1", "You pick up Obj1.") + self.call(general.CmdDrop(), "Obj1", "You drop Obj1.") + self.call(general.CmdWho(), "", "Player Name") + self.call(general.CmdSay(), "Testing", "You say, \"Testing\"") + self.call(general.CmdAccess(), "", "Permission Hierarchy (climbing):") + #self.call(general.CmdEncoding(), "", "Default encoding:") + #self.call(general.CmdQuit(), "", "You are already home") -class TestLook(CommandTest): - def test_call(self): - self.execute_cmd("look here") -class TestHome(CommandTest): - def test_call(self): - self.char1.location = self.room1 - self.char1.home = self.room2 - self.execute_cmd("home") - self.assertEqual(self.char1.location, self.room2) -class TestPassword(CommandTest): - def test_call(self): - self.execute_cmd("@password testpassword = newpassword") -class TestInventory(CommandTest): - def test_call(self): - self.execute_cmd("inv") -class TestQuit(CommandTest): - def test_call(self): - self.execute_cmd("@quit") -class TestPose(CommandTest): - def test_call(self): - self.execute_cmd("pose is testing","TestChar is testing") -class TestNick(CommandTest): - def test_call(self): - self.char1.player.user.is_superuser = False - self.execute_cmd("nickname testalias = testaliasedstring1") - self.execute_cmd("nickname/player testalias = testaliasedstring2") - self.execute_cmd("nickname/object testalias = testaliasedstring3") - self.assertEqual(u"testaliasedstring1", self.char1.nicks.get("testalias")) - self.assertEqual(u"testaliasedstring2", self.char1.nicks.get("testalias",nick_type="player")) - self.assertEqual(u"testaliasedstring3", self.char1.nicks.get("testalias",nick_type="object")) -class TestGet(CommandTest): - def test_call(self): - self.obj1.location = self.room1 - self.execute_cmd("get obj1", "You pick up obj1.") -class TestDrop(CommandTest): - def test_call(self): - self.obj1.location = self.char1 - self.execute_cmd("drop obj1", "You drop obj1.") -class TestWho(CommandTest): - def test_call(self): - self.execute_cmd("who") -class TestSay(CommandTest): - def test_call(self): - self.execute_cmd("say Hello", 'You say, "Hello') -class TestAccess(CommandTest): - def test_call(self): - self.execute_cmd("access") -class TestEncoding(CommandTest): - def test_call(self): - global NOMANGLE - NOMANGLE = True - self.char1.db.encoding="utf-8" - self.execute_cmd("@encoding", "Default encoding:") - NOMANGLE = False - -# help.py command tests - -class TestHelpSystem(CommandTest): - def test_call(self): - self.NOMANGLE = True +from src.commands.default import help +from src.commands.default.cmdset_default import DefaultCmdSet +class TestHelp(CommandTest): + CID = 2 + def test_cmds(self): sep = "-"*78 + "\n" - self.execute_cmd("@help/add TestTopic,TestCategory = Test1", ) - self.execute_cmd("help TestTopic",sep + "Help topic for Testtopic\nTest1" + "\n" + sep) - self.execute_cmd("@help/merge TestTopic = Test2", "Added the new text right after") - self.execute_cmd("help TestTopic", sep + "Help topic for Testtopic\nTest1 Test2") - self.execute_cmd("@help/append TestTopic = Test3", "Added the new text as a") - self.execute_cmd("help TestTopic",sep + "Help topic for Testtopic\nTest1 Test2\n\nTest3") - self.execute_cmd("@help/delete TestTopic","Deleted the help entry") - self.execute_cmd("help TestTopic","No help entry found for 'TestTopic'") + self.call(help.CmdHelp(), "", sep + " Command help entries", cmdset=DefaultCmdSet()) + self.call(help.CmdSetHelp(), "testhelp, General = This is a test", "Topic 'testhelp' was successfully created.") + self.call(help.CmdHelp(), "testhelp", sep + "Help topic for testhelp", cmdset=DefaultCmdSet()) -# system.py command tests -class TestPy(CommandTest): - def test_call(self): - self.execute_cmd("@py 1+2", [">>> 1+2", "<<< 3"]) -class TestScripts(CommandTest): - def test_call(self): - script = create.create_script(None, "test") - self.execute_cmd("@scripts", "id") -class TestObjects(CommandTest): - def test_call(self): - self.execute_cmd("@objects", "Database totals") -# Cannot be tested since we don't have an active server running at this point. -# class TestListService(CommandTest): -# def test_call(self): -# self.execute_cmd("@service/list", "---") -class TestVersion(CommandTest): - def test_call(self): - self.execute_cmd("@version", '---') -class TestTime(CommandTest): - def test_call(self): - self.execute_cmd("@time", "Current server uptime") -class TestServerLoad(CommandTest): - def test_call(self): - self.execute_cmd("@serverload", "Server load") -class TestPs(CommandTest): - def test_call(self): - self.execute_cmd("@ps","Non-timed scripts") -# admin.py command tests +from src.commands.default import system +class TestSystem(CommandTest): + CID = 3 + def test_cmds(self): + # we are not testing CmdReload, CmdReset and CmdShutdown, CmdService or CmdTime + # since the server is not running during these tests. + self.call(system.CmdPy(), "1+2", ">>> 1+2|<<< 3") + self.call(system.CmdScripts(), "", "id ") + self.call(system.CmdObjects(), "", "Database totals:") + self.call(system.CmdAbout(), "", None) + self.call(system.CmdServerLoad(), "", "Server load (1 min):") -class TestBoot(CommandTest): - def test_call(self): - self.execute_cmd("@boot TestChar2","You booted TestChar2.") -class TestDelPlayer(CommandTest): - def test_call(self): - self.execute_cmd("@delplayer TestChar2","Booting and informing player ...") -class TestEmit(CommandTest): - def test_call(self): - self.execute_cmd("@emit Test message", "Emitted to room1.") -class TestUserPassword(CommandTest): - def test_call(self): - self.execute_cmd("@userpassword TestChar2 = newpass", "TestChar2 - new password set to 'newpass'.") -class TestPerm(CommandTest): - def test_call(self): - self.execute_cmd("@perm TestChar2 = Builders", "Permission 'Builders' given to") -# cannot test this here; screws up the test suite -#class TestPuppet(CommandTest): + +from src.commands.default import admin +class TestAdmin(CommandTest): + CID = 4 + def test_cmds(self): + # not testing CmdBoot, CmdDelPlayer, CmdNewPassword + self.call(admin.CmdEmit(), "Char4 = Test", "Test|Emitted to Char4.") + self.call(admin.CmdPerm(), "Obj1 = Builders", "Permission 'Builders' given to Obj1.") + self.call(admin.CmdWall(), "Test", "Caller4 shouts \"Test\"") + + + + +## print all feedback from test commands (can become very verbose!) +#VERBOSE = True +#NOMANGLE = True # mangle command input for extra testing +# +#def cleanup(): +# User.objects.all().delete() +# PlayerDB.objects.all().delete() +# ObjectDB.objects.all().delete() +# Channel.objects.all().delete() +# Msg.objects.all().delete() +# PlayerChannelConnection.objects.all().delete() +# ExternalChannelConnection.objects.all().delete() +# ServerConfig.objects.all().delete() +# +#class FakeSessionHandler(sessionhandler.ServerSessionHandler): +# """ +# Fake sessionhandler, without an amp connection +# """ +# def portal_shutdown(self): +# pass +# def disconnect(self, session, reason=""): +# pass +# def login(self, session): +# pass +# def session_sync(self): +# pass +# def data_out(self, session, string="", data=""): +# return string +# +#SESSIONS = FakeSessionHandler() +# +#class FakeSession(serversession.ServerSession): +# """ +# A fake session that +# implements dummy versions of the real thing; this is needed to +# mimic a logged-in player. +# """ +# protocol_key = "TestProtocol" +# sessdict = {'protocol_key':'telnet', 'address':('0.0.0.0','5000'), 'sessid':2, 'uid':2, 'uname':None, +# 'logged_in':False, 'cid':None, 'ndb':{}, 'encoding':'utf-8', +# 'conn_time':time.time(), 'cmd_last':time.time(), 'cmd_last_visible':time.time(), 'cmd_total':1} +# +# def connectionMade(self): +# self.load_sync_data(self.sessdict) +# self.sessionhandler = SESSIONS +# def disconnectClient(self): +# pass +# def lineReceived(self, raw_string): +# pass +# def msg(self, message, data=None): +# global VERBOSE +# if message.startswith("Traceback (most recent call last):"): +# #retval = "Traceback last line: %s" % message.split('\n')[-4:] +# raise AssertionError(message) +# if self.player.character.ndb.return_string != None: +# return_list = self.player.character.ndb.return_string +# if hasattr(return_list, '__iter__'): +# rstring = return_list.pop(0) +# self.player.character.ndb.return_string = return_list +# else: +# rstring = return_list +# self.player.character.ndb.return_string = None +# message_noansi = ansi.parse_ansi(message, strip_ansi=True).strip() +# rstring = rstring.strip() +# if not message_noansi.startswith(rstring): +# sep1 = "\n" + "="*30 + "Wanted message" + "="*34 + "\n" +# sep2 = "\n" + "="*30 + "Returned message" + "="*32 + "\n" +# sep3 = "\n" + "="*78 +# retval = sep1 + rstring + sep2 + message_noansi + sep3 +# raise AssertionError(retval) +# if VERBOSE: +# print message +## setting up objects +# +#class CommandTest(TestCase): +# """ +# Sets up the basics of testing the default commands and the generic things +# that should always be present in a command. +# +# Inherit new tests from this. +# """ +# +# def setUp(self): +# "sets up the testing environment" +# #ServerConfig.objects.conf("default_home", 2) +# self.addCleanup(cleanup) +# self.room1 = create.create_object(settings.BASE_ROOM_TYPECLASS, key="room1") +# self.room2 = create.create_object(settings.BASE_ROOM_TYPECLASS, key="room2") +# # create a faux player/character for testing. +# self.char1 = create.create_player("TestChar", "testplayer@test.com", "testpassword", character_location=self.room1) +# self.char1.player.user.is_superuser = True +# self.char1.lock_storage = "" +# self.char1.locks = LockHandler(self.char1) +# self.char1.ndb.return_string = None +# self.sess1 = FakeSession() +# self.sess1.connectionMade() +# self.sess1.session_login(self.char1.player) +# # create second player +# self.char2 = create.create_player("TestChar2", "testplayer2@test.com", "testpassword2", character_location=self.room1) +# self.char2.player.user.is_superuser = False +# self.char2.lock_storage = "" +# self.char2.locks = LockHandler(self.char2) +# self.char2.ndb.return_string = None +# self.sess2 = FakeSession() +# self.sess2.connectionMade() +# self.sess2.session_login(self.char2.player) +# # A non-player-controlled character +# self.char3 = create.create_object(settings.BASE_CHARACTER_TYPECLASS, key="TestChar3", location=self.room1) +# # create some objects +# self.obj1 = create.create_object(settings.BASE_OBJECT_TYPECLASS, key="obj1", location=self.room1) +# self.obj2 = create.create_object(settings.BASE_OBJECT_TYPECLASS, key="obj2", location=self.room1) +# self.exit1 = create.create_object(settings.BASE_EXIT_TYPECLASS, key="exit1", location=self.room1) +# self.exit2 = create.create_object(settings.BASE_EXIT_TYPECLASS, key="exit2", location=self.room2) +# +# def get_cmd(self, cmd_class, argument_string=""): +# """ +# Obtain a cmd instance from a class and an input string +# Note: This does not make use of the cmdhandler functionality. +# """ +# cmd = cmd_class() +# cmd.caller = self.char1 +# cmd.cmdstring = cmd_class.key +# cmd.args = argument_string +# cmd.cmdset = None +# cmd.obj = self.char1 +# return cmd +# +# def execute_cmd(self, raw_string, wanted_return_string=None, nomangle=False): +# """ +# Creates the command through faking a normal command call; +# This also mangles the input in various ways to test if the command +# will be fooled. +# """ +# if not nomangle and not VERBOSE and not NOMANGLE: +# # only mangle if not VERBOSE, to make fewer return lines +# test1 = re.sub(r'\s', '', raw_string) # remove all whitespace inside it +# test2 = "%s/åäö öäö;-:$£@*~^' 'test" % raw_string # inserting weird characters in call +# test3 = "%s %s" % (raw_string, raw_string) # multiple calls +# self.char1.execute_cmd(test1) +# self.char1.execute_cmd(test2) +# self.char1.execute_cmd(test3) +# # actual call, we potentially check so return is ok. +# self.char1.ndb.return_string = wanted_return_string +# try: +# self.char1.execute_cmd(raw_string) +# except AssertionError, e: +# self.fail(e) +# self.char1.ndb.return_string = None +# +#class BuildTest(CommandTest): +# """ +# We need to turn of mangling for build commands since +# it creates arbitrary objects that mess up tests later. +# """ +# NOMANGLE = True +# +# +##------------------------------------------------------------ +## Default set Command testing +##------------------------------------------------------------ +# +## # general.py tests +# +#class TestLook(CommandTest): +# def test_call(self): +# self.execute_cmd("look here") +#class TestHome(CommandTest): +# def test_call(self): +# self.char1.location = self.room1 +# self.char1.home = self.room2 +# self.execute_cmd("home") +# self.assertEqual(self.char1.location, self.room2) +#class TestPassword(CommandTest): +# def test_call(self): +# self.execute_cmd("@password testpassword = newpassword") +#class TestInventory(CommandTest): +# def test_call(self): +# self.execute_cmd("inv") +#class TestQuit(CommandTest): +# def test_call(self): +# self.execute_cmd("@quit") +#class TestPose(CommandTest): +# def test_call(self): +# self.execute_cmd("pose is testing","TestChar is testing") +#class TestNick(CommandTest): +# def test_call(self): +# self.char1.player.user.is_superuser = False +# self.execute_cmd("nickname testalias = testaliasedstring1") +# self.execute_cmd("nickname/player testalias = testaliasedstring2") +# self.execute_cmd("nickname/object testalias = testaliasedstring3") +# self.assertEqual(u"testaliasedstring1", self.char1.nicks.get("testalias")) +# self.assertEqual(u"testaliasedstring2", self.char1.nicks.get("testalias",nick_type="player")) +# self.assertEqual(u"testaliasedstring3", self.char1.nicks.get("testalias",nick_type="object")) +#class TestGet(CommandTest): +# def test_call(self): +# self.obj1.location = self.room1 +# self.execute_cmd("get obj1", "You pick up obj1.") +#class TestDrop(CommandTest): +# def test_call(self): +# self.obj1.location = self.char1 +# self.execute_cmd("drop obj1", "You drop obj1.") +#class TestWho(CommandTest): +# def test_call(self): +# self.execute_cmd("who") +#class TestSay(CommandTest): +# def test_call(self): +# self.execute_cmd("say Hello", 'You say, "Hello') +#class TestAccess(CommandTest): +# def test_call(self): +# self.execute_cmd("access") +#class TestEncoding(CommandTest): +# def test_call(self): +# global NOMANGLE +# NOMANGLE = True +# self.char1.db.encoding="utf-8" +# self.execute_cmd("@encoding", "Default encoding:") +# NOMANGLE = False +# +## help.py command tests +# +#class TestHelpSystem(CommandTest): +# def test_call(self): +# self.NOMANGLE = True +# sep = "-"*78 + "\n" +# self.execute_cmd("@help/add TestTopic,TestCategory = Test1", ) +# self.execute_cmd("help TestTopic",sep + "Help topic for Testtopic\nTest1" + "\n" + sep) +# self.execute_cmd("@help/merge TestTopic = Test2", "Added the new text right after") +# self.execute_cmd("help TestTopic", sep + "Help topic for Testtopic\nTest1 Test2") +# self.execute_cmd("@help/append TestTopic = Test3", "Added the new text as a") +# self.execute_cmd("help TestTopic",sep + "Help topic for Testtopic\nTest1 Test2\n\nTest3") +# self.execute_cmd("@help/delete TestTopic","Deleted the help entry") +# self.execute_cmd("help TestTopic","No help entry found for 'TestTopic'") +# +## system.py command tests +#class TestPy(CommandTest): +# def test_call(self): +# self.execute_cmd("@py 1+2", [">>> 1+2", "<<< 3"]) +#class TestScripts(CommandTest): +# def test_call(self): +# script = create.create_script(None, "test") +# self.execute_cmd("@scripts", "id") +#class TestObjects(CommandTest): +# def test_call(self): +# self.execute_cmd("@objects", "Database totals") +## Cannot be tested since we don't have an active server running at this point. +## class TestListService(CommandTest): +## def test_call(self): +## self.execute_cmd("@service/list", "---") +#class TestVersion(CommandTest): +# def test_call(self): +# self.execute_cmd("@version", '---') +#class TestTime(CommandTest): +# def test_call(self): +# self.execute_cmd("@time", "Current server uptime") +#class TestServerLoad(CommandTest): +# def test_call(self): +# self.execute_cmd("@serverload", "Server load") +#class TestPs(CommandTest): +# def test_call(self): +# self.execute_cmd("@ps","Non-timed scripts") +# +## admin.py command tests +# +#class TestBoot(CommandTest): # def test_call(self): -# self.execute_cmd("@puppet TestChar3", "You now control TestChar3.") -# self.execute_cmd("@puppet TestChar", "You now control TestChar.") -class TestWall(CommandTest): - def test_call(self): - self.execute_cmd("@wall = This is a test message", "TestChar shouts") - - -# building.py command tests - -class TestObjAlias(BuildTest): - def test_call(self): - self.execute_cmd("@alias obj1 = obj1alias, obj1alias2", "Aliases for") - self.execute_cmd("look obj1alias2", "obj1") -class TestCopy(BuildTest): - def test_call(self): - self.execute_cmd("@copy obj1 = obj1_copy;alias1;alias2", "Copied obj1 to 'obj1_copy'") - self.execute_cmd("look alias2","obj1_copy") -class TestSet(BuildTest): - def test_call(self): - self.execute_cmd("@set obj1/test = value", "Created attribute obj1/test = value") - self.execute_cmd("@set obj1/test", "Attribute obj1/test = value") - self.assertEqual(self.obj1.db.test, u"value") -class TestCpAttr(BuildTest): - def test_call(self): - self.execute_cmd("@set obj1/test = value") - self.execute_cmd("@set obj2/test2 = value2") - #self.execute_cmd("@cpattr obj1/test = obj2/test") # can't be tested since instances changes - #self.assertEqual(self.obj2.db.test, u"value") -class TestMvAttr(BuildTest): - def test_call(self): - self.execute_cmd("@set obj1/test = value") - self.execute_cmd("@mvattr obj1/test = obj2") - #self.assertEqual(self.obj2.db.test, u"value") - #self.assertEqual(self.obj1.db.test, None) -class TestCreate(BuildTest): - def test_call(self): - self.execute_cmd("@create testobj;alias1;alias2") - self.execute_cmd("look alias1", "testobj") -class TestDebug(BuildTest): - def test_call(self): - self.execute_cmd("@debug/obj obj1") -class TestDesc(BuildTest): - def test_call(self): - self.execute_cmd("@desc obj1 = Test object", "The description was set on") - #self.assertEqual(self.obj1.db.desc, u"Test object") -class TestDestroy(BuildTest): - def test_call(self): - self.execute_cmd("@destroy obj1, obj2", "obj1 was destroyed.\nobj2 was destroyed.") -class TestFind(BuildTest): - def test_call(self): - self.execute_cmd("@find obj1", "One Match") -class TestDig(BuildTest): - def test_call(self): - self.execute_cmd("@dig room3;roomalias1;roomalias2 = north;n,south;s") - self.execute_cmd("@find room3", "One Match") - self.execute_cmd("@find roomalias1", "One Match") - self.execute_cmd("@find roomalias2", "One Match") - self.execute_cmd("@find/room roomalias2", "One Match") - self.execute_cmd("@find/exit south", "One Match") - self.execute_cmd("@find/exit n", "One Match") -class TestUnLink(BuildTest): - def test_call(self): - self.execute_cmd("@dig room3;roomalias1, north, south") - self.execute_cmd("@unlink north") -class TestLink(BuildTest): - def test_call(self): - self.execute_cmd("@dig room3;roomalias1, north, south") - self.execute_cmd("@unlink north") - self.execute_cmd("@link north = room3") -class TestHome(BuildTest): - def test_call(self): - self.obj1.db_home = self.obj2.dbobj - self.obj1.save() - self.execute_cmd("@home obj1") - self.assertEqual(self.obj1.db_home, self.obj2.dbobj) -class TestCmdSets(BuildTest): - def test_call(self): - self.execute_cmd("@cmdsets") - self.execute_cmd("@cmdsets obj1") -class TestName(BuildTest): - def test_call(self): - self.execute_cmd("@name obj1 = Test object", "Object's name changed to 'Test object'.") - #self.assertEqual(self.obj1.key, u"Test object") -class TestOpen(BuildTest): - def test_call(self): - self.execute_cmd("@dig room4;roomalias4") - self.execute_cmd("@open testexit4;aliasexit4 = roomalias4", "Created new Exit") -class TestTypeclass(BuildTest): - def test_call(self): - self.execute_cmd("@typeclass obj1 = src.objects.objects.Character", "obj's type is now") - #self.assertEqual(self.obj1.db_typeclass_path, u"src.objects.objects.Character") -class TestSet(BuildTest): - def test_call(self): - self.execute_cmd("@set box1/test = value") - self.execute_cmd("@wipe box1", "Wiped") - self.assertEqual(self.obj1.db.all, []) -class TestLock(BuildTest): - # lock functionality itseld is tested separately - def test_call(self): - self.char1.permissions = ["TestPerm"] - self.execute_cmd("@lock obj1 = test:perm(TestPerm)") - #self.assertEqual(True, self.obj1.access(self.char1, u"test")) -class TestExamine(BuildTest): - def test_call(self): - self.execute_cmd("examine obj1", "------------") -class TestTeleport(BuildTest): - def test_call(self): - self.execute_cmd("@tel obj1 = room1") - self.assertEqual(self.obj1.location.key, self.room1.key) -class TestScript(BuildTest): - def test_call(self): - self.execute_cmd("@script TestChar = examples.bodyfunctions.BodyFunctions", "Script successfully added") - -# Comms commands - -class TestChannelCreate(CommandTest): - def test_call(self): - self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") - self.execute_cmd("testchan1 Hello", "[testchannel1] TestChar: Hello") -class TestAddCom(CommandTest): - def test_call(self): - self.execute_cmd("@cdestroy testchannel1", "Channel 'testchannel1'") - self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") - self.execute_cmd("addcom chan1 = testchannel1") - self.execute_cmd("addcom chan2 = testchan1") - self.execute_cmd("delcom testchannel1") - self.execute_cmd("addcom testchannel1" "You now listen to the channel channel.") -class TestDelCom(CommandTest): - def test_call(self): - self.execute_cmd("@cdestroy testchannel1", "Channel 'testchannel1'") - self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") - self.execute_cmd("addcom chan1 = testchan1") - self.execute_cmd("addcom chan2 = testchan1b") - self.execute_cmd("addcom chan3 = testchannel1") - self.execute_cmd("delcom chan1", "Your alias 'chan1' for ") - self.execute_cmd("delcom chan2", "Your alias 'chan2' for ") - self.execute_cmd("delcom testchannel1" "You stop listening to") -class TestAllCom(CommandTest): - def test_call(self): - self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") - self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") - self.execute_cmd("allcom off") - self.execute_cmd("allcom on") - self.execute_cmd("allcom destroy") -class TestChannels(CommandTest): - def test_call(self): - self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") - self.execute_cmd("@cdestroy testchannel1", "Channel 'testchannel1'") -class TestCBoot(CommandTest): - def test_call(self): - self.execute_cmd("@cdestroy testchannel1", "Channel 'testchannel1'") - self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") - self.execute_cmd("addcom testchan = testchannel1") - self.execute_cmd("@cboot testchannel1 = TestChar", "TestChar boots TestChar from channel.") -class TestCemit(CommandTest): - def test_call(self): - self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") - self.execute_cmd("@cemit testchan1 = Testing!", "[testchannel1] Testing!") -class TestCwho(CommandTest): - def test_call(self): - self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") - self.execute_cmd("@cwho testchan1b", "Channel subscriptions") - +# self.execute_cmd("@boot TestChar2","You booted TestChar2.") +#class TestDelPlayer(CommandTest): +# def test_call(self): +# self.execute_cmd("@delplayer TestChar2","Booting and informing player ...") +#class TestEmit(CommandTest): +# def test_call(self): +# self.execute_cmd("@emit Test message", "Emitted to room1.") +#class TestUserPassword(CommandTest): +# def test_call(self): +# self.execute_cmd("@userpassword TestChar2 = newpass", "TestChar2 - new password set to 'newpass'.") +#class TestPerm(CommandTest): +# def test_call(self): +# self.execute_cmd("@perm TestChar2 = Builders", "Permission 'Builders' given to") +## cannot test this here; screws up the test suite +##class TestPuppet(CommandTest): +## def test_call(self): +## self.execute_cmd("@puppet TestChar3", "You now control TestChar3.") +## self.execute_cmd("@puppet TestChar", "You now control TestChar.") +#class TestWall(CommandTest): +# def test_call(self): +# self.execute_cmd("@wall = This is a test message", "TestChar shouts") +# +# +## building.py command tests +# +#class TestObjAlias(BuildTest): +# def test_call(self): +# self.execute_cmd("@alias obj1 = obj1alias, obj1alias2", "Aliases for") +# self.execute_cmd("look obj1alias2", "obj1") +#class TestCopy(BuildTest): +# def test_call(self): +# self.execute_cmd("@copy obj1 = obj1_copy;alias1;alias2", "Copied obj1 to 'obj1_copy'") +# self.execute_cmd("look alias2","obj1_copy") +#class TestSet(BuildTest): +# def test_call(self): +# self.execute_cmd("@set obj1/test = value", "Created attribute obj1/test = value") +# self.execute_cmd("@set obj1/test", "Attribute obj1/test = value") +# self.assertEqual(self.obj1.db.test, u"value") +#class TestCpAttr(BuildTest): +# def test_call(self): +# self.execute_cmd("@set obj1/test = value") +# self.execute_cmd("@set obj2/test2 = value2") +# #self.execute_cmd("@cpattr obj1/test = obj2/test") # can't be tested since instances changes +# #self.assertEqual(self.obj2.db.test, u"value") +#class TestMvAttr(BuildTest): +# def test_call(self): +# self.execute_cmd("@set obj1/test = value") +# self.execute_cmd("@mvattr obj1/test = obj2") +# #self.assertEqual(self.obj2.db.test, u"value") +# #self.assertEqual(self.obj1.db.test, None) +#class TestCreate(BuildTest): +# def test_call(self): +# self.execute_cmd("@create testobj;alias1;alias2") +# self.execute_cmd("look alias1", "testobj") +#class TestDebug(BuildTest): +# def test_call(self): +# self.execute_cmd("@debug/obj obj1") +#class TestDesc(BuildTest): +# def test_call(self): +# self.execute_cmd("@desc obj1 = Test object", "The description was set on") +# #self.assertEqual(self.obj1.db.desc, u"Test object") +#class TestDestroy(BuildTest): +# def test_call(self): +# self.execute_cmd("@destroy obj1, obj2", "obj1 was destroyed.\nobj2 was destroyed.") +#class TestFind(BuildTest): +# def test_call(self): +# self.execute_cmd("@find obj1", "One Match") +#class TestDig(BuildTest): +# def test_call(self): +# self.execute_cmd("@dig room3;roomalias1;roomalias2 = north;n,south;s") +# self.execute_cmd("@find room3", "One Match") +# self.execute_cmd("@find roomalias1", "One Match") +# self.execute_cmd("@find roomalias2", "One Match") +# self.execute_cmd("@find/room roomalias2", "One Match") +# self.execute_cmd("@find/exit south", "One Match") +# self.execute_cmd("@find/exit n", "One Match") +#class TestUnLink(BuildTest): +# def test_call(self): +# self.execute_cmd("@dig room3;roomalias1, north, south") +# self.execute_cmd("@unlink north") +#class TestLink(BuildTest): +# def test_call(self): +# self.execute_cmd("@dig room3;roomalias1, north, south") +# self.execute_cmd("@unlink north") +# self.execute_cmd("@link north = room3") +#class TestHome(BuildTest): +# def test_call(self): +# self.obj1.db_home = self.obj2.dbobj +# self.obj1.save() +# self.execute_cmd("@home obj1") +# self.assertEqual(self.obj1.db_home, self.obj2.dbobj) +#class TestCmdSets(BuildTest): +# def test_call(self): +# self.execute_cmd("@cmdsets") +# self.execute_cmd("@cmdsets obj1") +#class TestName(BuildTest): +# def test_call(self): +# self.execute_cmd("@name obj1 = Test object", "Object's name changed to 'Test object'.") +# #self.assertEqual(self.obj1.key, u"Test object") +#class TestOpen(BuildTest): +# def test_call(self): +# self.execute_cmd("@dig room4;roomalias4") +# self.execute_cmd("@open testexit4;aliasexit4 = roomalias4", "Created new Exit") +#class TestTypeclass(BuildTest): +# def test_call(self): +# self.execute_cmd("@typeclass obj1 = src.objects.objects.Character", "obj's type is now") +# #self.assertEqual(self.obj1.db_typeclass_path, u"src.objects.objects.Character") +#class TestSet(BuildTest): +# def test_call(self): +# self.execute_cmd("@set box1/test = value") +# self.execute_cmd("@wipe box1", "Wiped") +# self.assertEqual(self.obj1.db.all, []) +#class TestLock(BuildTest): +# # lock functionality itseld is tested separately +# def test_call(self): +# self.char1.permissions = ["TestPerm"] +# self.execute_cmd("@lock obj1 = test:perm(TestPerm)") +# #self.assertEqual(True, self.obj1.access(self.char1, u"test")) +#class TestExamine(BuildTest): +# def test_call(self): +# self.execute_cmd("examine obj1", "------------") +#class TestTeleport(BuildTest): +# def test_call(self): +# self.execute_cmd("@tel obj1 = room1") +# self.assertEqual(self.obj1.location.key, self.room1.key) +#class TestScript(BuildTest): +# def test_call(self): +# self.execute_cmd("@script TestChar = examples.bodyfunctions.BodyFunctions", "Script successfully added") +# +## Comms commands +# +#class TestChannelCreate(CommandTest): +# def test_call(self): +# self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") +# self.execute_cmd("testchan1 Hello", "[testchannel1] TestChar: Hello") +#class TestAddCom(CommandTest): +# def test_call(self): +# self.execute_cmd("@cdestroy testchannel1", "Channel 'testchannel1'") +# self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") +# self.execute_cmd("addcom chan1 = testchannel1") +# self.execute_cmd("addcom chan2 = testchan1") +# self.execute_cmd("delcom testchannel1") +# self.execute_cmd("addcom testchannel1" "You now listen to the channel channel.") +#class TestDelCom(CommandTest): +# def test_call(self): +# self.execute_cmd("@cdestroy testchannel1", "Channel 'testchannel1'") +# self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") +# self.execute_cmd("addcom chan1 = testchan1") +# self.execute_cmd("addcom chan2 = testchan1b") +# self.execute_cmd("addcom chan3 = testchannel1") +# self.execute_cmd("delcom chan1", "Your alias 'chan1' for ") +# self.execute_cmd("delcom chan2", "Your alias 'chan2' for ") +# self.execute_cmd("delcom testchannel1" "You stop listening to") +#class TestAllCom(CommandTest): +# def test_call(self): +# self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") +# self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") +# self.execute_cmd("allcom off") +# self.execute_cmd("allcom on") +# self.execute_cmd("allcom destroy") +#class TestChannels(CommandTest): +# def test_call(self): +# self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") +# self.execute_cmd("@cdestroy testchannel1", "Channel 'testchannel1'") +#class TestCBoot(CommandTest): +# def test_call(self): +# self.execute_cmd("@cdestroy testchannel1", "Channel 'testchannel1'") +# self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") +# self.execute_cmd("addcom testchan = testchannel1") +# self.execute_cmd("@cboot testchannel1 = TestChar", "TestChar boots TestChar from channel.") +#class TestCemit(CommandTest): +# def test_call(self): +# self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") +# self.execute_cmd("@cemit testchan1 = Testing!", "[testchannel1] Testing!") +#class TestCwho(CommandTest): +# def test_call(self): +# self.execute_cmd("@ccreate testchannel1;testchan1;testchan1b = This is a test channel") +# self.execute_cmd("@cwho testchan1b", "Channel subscriptions") +# # OOC commands #class TestOOC_and_IC(CommandTest): # can't be tested it seems, causes errors in other commands (?) diff --git a/src/typeclasses/models.py b/src/typeclasses/models.py index 70c6e9b2e1..b1ecc4fae1 100644 --- a/src/typeclasses/models.py +++ b/src/typeclasses/models.py @@ -1342,7 +1342,7 @@ class TypedObject(SharedMemoryModel): """ Get the actual attribute object named attribute_name """ - attrib_obj = get_attribute_cache(self, attribute_name) + attrib_obj = get_attr_cache(self, attribute_name) if not attrib_obj: attrib_obj = _GA(self, "_attribute_class").objects.filter( db_obj=self).filter(db_key__iexact=attribute_name)