# evennia.utils.test_resources

Various helper resources for writing unittests.

Classes for testing Evennia core:

- BaseEvenniaTestCase - no default objects, only enforced default settings

- BaseEvenniaTest - all default objects, enforced default settings

- BaseEvenniaCommandTest - for testing Commands, enforced default settings

Classes for testing game folder content:

- EvenniaTestCase - no default objects, using gamedir settings (identical to

    standard Python TestCase)

- EvenniaTest - all default objects, using gamedir settings

- EvenniaCommandTest - for testing game folder commands, using gamedir settings

Other:

- EvenniaTestMixin - A class mixin for creating the test environment objects, for making custom tests.

- EvenniaCommandMixin - A class mixin that adds support for command testing with the .call() helper. Used by the command-test classes, but can be used for making a customt test class.

`evennia.utils.test_resources.``mockdelay`(timedelay, callback, *args, **kwargs)

`evennia.utils.test_resources.``mockdeferLater`(reactor, timedelay, callback, *args, **kwargs)

`evennia.utils.test_resources.``unload_module`(module)

  Reset import so one can mock global constants.

  Parameters

    module (module, object or str) – The module will be removed so it will have to be imported again. If given an object, the module in which that object sits will be unloaded. A string should directly give the module pathname to unload.

  Example

      # (in a test method)
      unload_module(foo)
      with mock.patch("foo.GLOBALTHING", "mockval"):
          import foo
          ... # test code using foo.GLOBALTHING, now set to 'mockval'

  This allows for mocking constants global to the module, since otherwise those would not be mocked (since a module is only loaded once).

class `evennia.utils.test_resources.``EvenniaTestMixin`

  Bases: `object`

  Evennia test environment mixin

  `account_typeclass`

    alias of `evennia.accounts.accounts.DefaultAccount`

  `object_typeclass`

    alias of `evennia.objects.objects.DefaultObject`

  `character_typeclass`

    alias of `evennia.objects.objects.DefaultCharacter`

  `exit_typeclass`

    alias of `evennia.objects.objects.DefaultExit`

  `room_typeclass`

    alias of `evennia.objects.objects.DefaultRoom`

  `script_typeclass`

    alias of `evennia.scripts.scripts.DefaultScript`

  `create_accounts`()
  `teardown_accounts`()
  `create_rooms`()
  `create_objs`()
  `create_chars`()
  `create_script`()
  `setup_session`()
  `teardown_session`()
  `setUp`()

    Sets up testing environment

  `tearDown`()

class `evennia.utils.test_resources.``EvenniaCommandTestMixin`

  Bases: `object`

  Mixin to add to a test in order to provide the .call helper for testing the execution and returns of a command.

  Tests a Command by running it and comparing what messages it sends with expected values. This tests without actually spinning up the cmdhandler for every test, which is more controlled.

  Example:

      from commands.echo import CmdEcho

      class MyCommandTest(EvenniaTest, CommandTestMixin):

          def test_echo(self):
              '''
              Test that the echo command really returns
              what you pass into it.
              '''
              self.call(MyCommand(), "hello world!",
                        "You hear your echo: 'Hello world!'")

  `call`(cmdobj, input_args, msg=None, cmdset=None, noansi=True, caller=None, receiver=None, cmdstring=None, obj=None, inputs=None, raw_string=None)

    Test a command by assigning all the needed properties to a cmdobj and running the sequence. The resulting .msg calls will be mocked and the text= calls to them compared to a expected output.

    Parameters

      - cmdobj (Command) – The command object to use.

      - input_args (str) – This should be the full input the Command should see, such as ‘look here’. This will become .args for the Command instance to parse.

      - msg (str or dict, optional) – This is the expected return value(s) returned through caller.msg(text=…) calls in the command. If a string, the receiver is controlled with the receiver kwarg (defaults to caller). If this is a dict, it is a mapping {receiver1: “expected1”, receiver2: “expected2”,…} and receiver is ignored. The message(s) are compared with the actual messages returned to the receiver(s) as the Command runs. Each check uses .startswith, so you can choose to only include the first part of the returned message if that’s enough to verify a correct result. EvMenu decorations (like borders) are stripped and should not be included. This should also not include color tags unless noansi=False. If the command returns texts in multiple separate .msg- calls to a receiver, separate these with | if noansi=True (default) and || if noansi=False. If no msg is given (None), then no automatic comparison will be done.

      - cmdset (str, optional) – If given, make .cmdset available on the Command instance as it runs. While .cmdset is normally available on the Command instance by default, this is usually only used by commands that explicitly operates/displays cmdsets, like examine.

      - noansi (str, optional) – By default the color tags of the msg is ignored, this makes them significant. If unset, msg must contain the same color tags as the actual return message.

      - caller (Object or Account, optional) – By default self.char1 is used as the command-caller (the .caller property on the Command). This allows to execute with another caller, most commonly an Account.

      - receiver (Object or Account, optional) – This is the object to receive the return messages we want to test. By default this is the same as caller (which in turn defaults to is self.char1). Note that if msg is a dict, this is ignored since the receiver is already specified there.

      - cmdstring (str, optional) – Normally this is the Command’s key. This allows for tweaking the .cmdname property of the Command**. This isb used for commands with multiple aliases, where the command explicitly checs which alias was used to determine its functionality.

      - obj (str, optional) – This sets the .obj property of the Command - the object on which the Command ‘sits’. By default this is the same as caller. This can be used for testing on-object Command interactions.

      - inputs (list, optional) – A list of strings to pass to functions that pause to take input from the user (normally using @interactive and ret = yield(question) or evmenu.get_input). Each element of the list will be passed into the command as if the user answered each prompt in that order.

      - raw_string (str, optional) – Normally the .raw_string property is set as a combination of your key/cmdname and input_args. This allows direct control of what this is, for example for testing edge cases or malformed inputs.

    Returns

      str or dict –

      The message sent to receiver, or a dict of

        {receiver: “msg”, …} if multiple are given. This is usually only used with msg=None to do the validation externally.

    Raises

      AssertionError – If the returns of .msg calls (tested with .startswith) does not match expected_input.

    Notes

    As part of the tests, all methods of the Command will be called in the proper order:

    - cmdobj.at_pre_cmd()

    - cmdobj.parse()

    - cmdobj.func()

    - cmdobj.at_post_cmd()

class `evennia.utils.test_resources.``BaseEvenniaTestCase`(methodName='runTest')

  Bases: `django.test.testcases.TestCase`

  Base test (with no default objects) but with enforced default settings.

class `evennia.utils.test_resources.``EvenniaTestCase`(methodName='runTest')

  Bases: `django.test.testcases.TestCase`

  For use with gamedir settings; Just like the normal test case, only for naming consistency.

class `evennia.utils.test_resources.``BaseEvenniaTest`(methodName='runTest')

  Bases: `evennia.utils.test_resources.EvenniaTestMixin`, `django.test.testcases.TestCase`

  This class parent has all default objects and uses only default settings.

class `evennia.utils.test_resources.``EvenniaTest`(methodName='runTest')

  Bases: `evennia.utils.test_resources.EvenniaTestMixin`, `django.test.testcases.TestCase`

  This test class is intended for inheriting in mygame tests. It helps ensure your tests are run with your own objects and settings from your game folder.

  `account_typeclass` = 'typeclasses.accounts.Account'
  `object_typeclass` = 'typeclasses.objects.Object'
  `character_typeclass` = 'typeclasses.characters.Character'
  `exit_typeclass` = 'typeclasses.exits.Exit'
  `room_typeclass` = 'typeclasses.rooms.Room'
  `script_typeclass` = 'typeclasses.scripts.Script'

class `evennia.utils.test_resources.``BaseEvenniaCommandTest`(methodName='runTest')

  Bases: `evennia.utils.test_resources.BaseEvenniaTest`, `evennia.utils.test_resources.EvenniaCommandTestMixin`

  Commands only using the default settings.

class `evennia.utils.test_resources.``EvenniaCommandTest`(methodName='runTest')

  Bases: `evennia.utils.test_resources.EvenniaTest`, `evennia.utils.test_resources.EvenniaCommandTestMixin`

  Parent class to inherit from - makes tests use your own classes and settings in mygame.