Ejemplo n.º 1
0
class TestCharacterControllerIsOwner(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

    def test_is_owner(self):
        username = "******"
        character = "character"

        mock_char = Mock(name=character, owner=username)
        MockObject = Mock()
        MockObject.get_objects = Mock(return_value=mock_char)

        with patch.object(zoneserver, 'Object', MockObject):
            result = self.character_controller.is_owner(username, character)

        self.assertTrue(result)

    def test_is_owner_no_char(self):
        username = "******"
        character = "character"

        MockObject = Mock(name="NoChar")
        from elixir_models import Object
        MockObject.DoesNotExist = Object.DoesNotExist
        MockObject.get_objects = Mock(side_effect=Object.DoesNotExist(''))

        with patch.object(zoneserver, 'Object', MockObject):
            result = self.character_controller.is_owner(username, character)

        self.assertEqual(result, None)
Ejemplo n.º 2
0
class TestCharacterControllerIsOwner(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

    def test_is_owner(self):
        username = "******"
        character = "character"

        MockCharacter = Mock()
        MockCharacter.objects().first().owner = username
        with patch.object(zoneserver, 'Character', MockCharacter):
            result = self.character_controller.is_owner(username, character)

        self.assertTrue(result)

    def test_is_owner_no_char(self):
        username = "******"
        character = "character"

        MockCharacter = Mock()
        MockCharacter.objects().first = Mock(return_value=None)
        with patch.object(zoneserver, 'Character', MockCharacter):
            result = self.character_controller.is_owner(username, character)

        self.assertEqual(result, None)
Ejemplo n.º 3
0
class TestCharacterControllerIsOwner(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

    def test_is_owner(self):
        username = "******"
        character = "character"

        mock_char = Mock(name=character, owner=username)
        MockObject = Mock()
        MockObject.get_objects = Mock(return_value=mock_char)

        with patch.object(zoneserver, 'Object', MockObject):
            result = self.character_controller.is_owner(username, character)

        self.assertTrue(result)

    def test_is_owner_no_char(self):
        username = "******"
        character = "character"

        MockObject = Mock(name="NoChar")
        from elixir_models import Object
        MockObject.DoesNotExist = Object.DoesNotExist
        MockObject.get_objects = Mock(side_effect=Object.DoesNotExist(''))

        with patch.object(zoneserver, 'Object', MockObject):
            result = self.character_controller.is_owner(username, character)

        self.assertEqual(result, None)
Ejemplo n.º 4
0
class TestCharacterControllerGetCharacter(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

    def test_get_character(self):
        mock_char = Mock()
        MockCharacter = Mock()
        MockCharacter.get_objects = Mock(return_value=mock_char)

        with patch.object(zoneserver, 'Object', MockCharacter):
            result = self.character_controller.get_character("character")

        self.assertNotEqual(result, False)
        self.assertEqual(mock_char, result)

    def test_get_character_non_existent_no_states(self):
        from elixir_models import Object
        MockCharacter = Mock()
        MockCharacter.get_objects = Mock(side_effect=Object.DoesNotExist(''))
        MockCharacter.DoesNotExist = Object.DoesNotExist

        with patch.object(zoneserver, 'Object', MockCharacter):
            result = self.character_controller.get_character("character")

        self.assertFalse(result)
Ejemplo n.º 5
0
class TestCharacterControllerGetCharacter(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

    def test_get_character(self):
        mock_char = Mock(spec=['states'])
        MockCharacter = Mock()
        MockCharacter.objects().first = Mock(return_value=mock_char)

        with patch.object(zoneserver, 'Character', MockCharacter):
            result = self.character_controller.get_character("character")
        self.assertEqual(mock_char, result)

    def test_get_character_non_existent_empty_states(self):
        mock_char = Mock()
        mock_char.states = []
        MockCharacter = Mock()
        MockCharacter.objects().first = Mock(return_value=mock_char)

        with patch.object(zoneserver, 'Character', MockCharacter):
            result = self.character_controller.get_character("character")

        self.assertFalse(result)

    def test_get_character_non_existent_no_states(self):
        mock_char = Mock(name="char", spec=[])
        MockCharacter = Mock(name="Character")
        MockCharacter.objects().first = Mock(name="first", return_value=mock_char)

        with patch.object(zoneserver, 'Character', MockCharacter):
            result = self.character_controller.get_character("character")

        self.assertFalse(result)
Ejemplo n.º 6
0
class TestCharacterControllerGetCharacter(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

    def test_get_character(self):
        mock_char = Mock()
        MockCharacter = Mock()
        MockCharacter.get_objects = Mock(return_value=mock_char)

        with patch.object(zoneserver, 'Object', MockCharacter):
            result = self.character_controller.get_character("character")

        self.assertNotEqual(result, False)
        self.assertEqual(mock_char, result)

    def test_get_character_non_existent_no_states(self):
        from elixir_models import Object
        MockCharacter = Mock()
        MockCharacter.get_objects = Mock(side_effect=Object.DoesNotExist(''))
        MockCharacter.DoesNotExist = Object.DoesNotExist

        with patch.object(zoneserver, 'Object', MockCharacter):
            result = self.character_controller.get_character("character")

        self.assertFalse(result)
Ejemplo n.º 7
0
    def setUp(self):
        self.character_controller = CharacterController()

        self.MockObject = Mock(name="Object")
        self.MockObject.get_objects = Mock(return_value=list())
        self.character_patch = patch.object(zoneserver, 'Object',
                                            self.MockObject)
        self.character_patch.start()
Ejemplo n.º 8
0
class TestCharacterControllerSetMovement(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

        self.MockObject = Mock(name="Object")
        self.MockObject.get_objects = Mock(return_value=list())
        self.character_patch = patch.object(zoneserver, 'Object', self.MockObject)
        self.character_patch.start()

    def tearDown(self):
        self.character_patch.stop()

    def test_set_movement(self):
        mock_char = Mock(speed=1, loc_x=0, loc_y=0, loc_z=0)

        with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
            result = self.character_controller.set_movement("character", 1, 2, 3)

        self.assertEqual(result.loc_x, 1)
        self.assertEqual(result.loc_y, 2)
        self.assertEqual(result.loc_z, 3)

    def test_set_movement_existing_loc(self):
        mock_char = Mock(speed=1, loc_x=0, loc_y=0, loc_z=0)

        with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
            result = self.character_controller.set_movement("character", 1, 2, 3)

        self.assertGreater(result.loc_x, 0)

    def test_set_movement_physics_collision(self):
        mock_char = Mock(speed=1, loc_x=0, loc_y=0, loc_z=0)

        self.MockObject.get_objects = Mock(return_value=[mock_char])

        from copy import deepcopy
        with patch.object(zoneserver, 'Object', self.MockObject):
            with patch.object(self.character_controller, 'create_character', Mock(return_value=deepcopy(mock_char))):
                result = self.character_controller.set_movement("character", 1, 1, 3)

        self.assertFalse(result)

    def test_set_movement_physics_no_collision(self):
        mock_char = Mock(speed=1, loc_x=0, loc_y=0, loc_z=0)
        mock_otherchar = Mock(speed=1, loc_x=4, loc_y=4, loc_z=4)

        self.MockObject.get_objects = Mock(return_value=[mock_otherchar])

        with patch.object(zoneserver, 'Object', self.MockObject):
            with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
                result = self.character_controller.set_movement("character", 1, 2, 3)

        self.assertEqual(result, mock_char)
Ejemplo n.º 9
0
    def setUp(self):
        self.character_controller = CharacterController()

        self.MockObject = Mock(name="Object")
        self.MockObject.get_objects = Mock(return_value=list())
        self.character_patch = patch.object(zoneserver, 'Object', self.MockObject)
        self.character_patch.start()
Ejemplo n.º 10
0
class TestCharacterControllerCreateCharacter(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

    def test_create_character(self):
        expected = Mock()

        with patch.object(self.character_controller, 'get_character', Mock(return_value=expected)):
            result = self.character_controller.create_character("character")

        self.assertEqual(result, expected)

    def test_create_character_with_new_charobj(self):

        mock_char = Mock()
        MockObject = Mock(return_value=mock_char)
        with patch.object(zoneserver, 'Object', MockObject):
            with patch.object(self.character_controller, 'get_character', Mock(return_value=None)):
                result = self.character_controller.create_character("character")

        self.assertEqual(result, mock_char)
Ejemplo n.º 11
0
class TestCharacterControllerCreateCharacter(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

    def test_create_character(self):
        expected = Mock()

        with patch.object(self.character_controller, 'get_character',
                          Mock(return_value=expected)):
            result = self.character_controller.create_character("character")

        self.assertEqual(result, expected)

    def test_create_character_with_new_charobj(self):

        mock_char = Mock()
        MockObject = Mock(return_value=mock_char)
        with patch.object(zoneserver, 'Object', MockObject):
            with patch.object(self.character_controller, 'get_character',
                              Mock(return_value=None)):
                result = self.character_controller.create_character(
                    "character")

        self.assertEqual(result, mock_char)
Ejemplo n.º 12
0
class TestCharacterControllerSetCharacterStatus(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

    def test_set_char_status(self):
        mock_char = Mock(name='char', states=['alive'])

        with patch.object(self.character_controller, 'create_character',
                          Mock(return_value=mock_char)):
            result = self.character_controller.set_char_status(
                "character", 'alive')

        self.assertEqual(result, mock_char)

    def test_set_char_status_with_new_state(self):
        mock_char = Mock(name='char', states=[])

        with patch.object(self.character_controller, 'create_character',
                          Mock(return_value=mock_char)):
            self.character_controller.set_char_status("character", 'alive')

        self.assertTrue('alive' in mock_char.states)

    def test_set_char_status_mutually_exclusive(self):
        mock_char = Mock(name='char', states=[])

        with patch.object(self.character_controller, 'create_character',
                          Mock(return_value=mock_char)):
            self.character_controller.set_char_status("character", 'online')

        self.assertTrue('online' in mock_char.states)

    def test_set_char_status_mutually_exclusive_flip(self):
        mock_char = Mock(name='char', states=['online'])

        with patch.object(self.character_controller, 'create_character',
                          Mock(return_value=mock_char)):
            self.character_controller.set_char_status("character", 'offline')

        self.assertTrue('offline' in mock_char.states)
        self.assertTrue('online' not in mock_char.states)
Ejemplo n.º 13
0
class TestCharacterControllerSetCharacterStatus(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

    def test_set_char_status(self):
        mock_char = Mock(name="char")
        mock_char.states = ['alive']

        with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
            result = self.character_controller.set_char_status("character", 'alive')

        self.assertEqual(result, mock_char)

    def test_set_char_status_with_new_state(self):
        mock_char = Mock(name="char")
        mock_char.states = []

        with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
            self.character_controller.set_char_status("character", 'alive')

        self.assertTrue('alive' in mock_char.states)

    def test_set_char_status_mutually_exclusive(self):
        mock_char = Mock(name="char")
        mock_char.states = []

        with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
            self.character_controller.set_char_status("character", 'online')

        self.assertTrue('online' in mock_char.states)

    def test_set_char_status_mutually_exclusive_flip(self):
        mock_char = Mock(name="char")
        mock_char.states = ['online']

        with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
            self.character_controller.set_char_status("character", 'offline')

        self.assertTrue('offline' in mock_char.states)
        self.assertTrue('online' not in mock_char.states)
Ejemplo n.º 14
0
class TestCharacterControllerSetMovement(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

        self.MockObject = Mock(name="Object")
        self.MockObject.objects = Mock(return_value=list())
        self.character_patch = patch.object(zoneserver, 'Object', self.MockObject)
        self.character_patch.start()

    def tearDown(self):
        self.character_patch.stop()

    def test_set_movement(self):
        mock_char = Mock(name="char", spec=['speed', 'save'])
        mock_char.speed = 1

        with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
            result = self.character_controller.set_movement("character", 1, 2, 3)

        self.assertEqual(result.loc['x'], 0)

    def test_set_movement_existing_loc(self):
        mock_char = Mock(name="char")
        mock_char.speed = 1
        mock_char.loc = {'x': 0, 'y': 0, 'z': 0}

        with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
            result = self.character_controller.set_movement("character", 1, 2, 3)

        self.assertGreater(result.loc['x'], 0)

    def test_set_movement_loc_is_none(self):
        mock_char = Mock(name="char")
        mock_char.speed = 1
        mock_char.loc = None

        with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
            result = self.character_controller.set_movement("character", 1, 2, 3)

        self.assertEqual(result.loc['x'], 0)

    def test_set_movement_other_loc_is_none(self):
        '''When another object's loc is None,
        set_movement should not die horribly.'''
        mock_char = Mock(name="char")
        mock_char.speed = 1
        mock_char.loc = {'x': 0, 'y': 0, 'z': 0}

        mock_bad_obj = Mock()
        mock_bad_obj.loc = None

        MockObject = Mock()
        MockObject.objects = Mock(return_value=[mock_bad_obj])

        with patch.object(zoneserver, 'Object', MockObject):
            with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
                result = self.character_controller.set_movement("character", 1, 2, 3)

        self.assertEqual(result.loc['x'], 1)

    def test_set_movement_physics_collision(self):
        mock_char = Mock(name="char")
        mock_char.speed = 1
        mock_char.loc = {'x': 0, 'y': 0, 'z': 0}

        self.MockObject.objects = Mock(return_value=[mock_char])

        with patch.object(zoneserver, 'Object', self.MockObject):
            with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
                result = self.character_controller.set_movement("character", 1, 2, 3)

        self.assertFalse(result)

    def test_set_movement_physics_no_collision(self):
        mock_char = Mock(name="char")
        mock_char.speed = 1
        mock_char.loc = {'x': 0, 'y': 0, 'z': 0}

        mock_otherchar = Mock(name="other char")
        mock_otherchar.loc = {'x': 4, 'y': 4, 'z': 0}

        self.MockObject.objects = Mock(return_value=[mock_otherchar])

        with patch.object(zoneserver, 'Object', self.MockObject):
            with patch.object(self.character_controller, 'create_character', Mock(return_value=mock_char)):
                result = self.character_controller.set_movement("character", 1, 2, 3)

        self.assertEqual(result, mock_char)
Ejemplo n.º 15
0
 def setUp(self):
     self.character_controller = CharacterController()
Ejemplo n.º 16
0
class TestCharacterControllerSetMovement(unittest.TestCase):
    def setUp(self):
        self.character_controller = CharacterController()

        self.MockObject = Mock(name="Object")
        self.MockObject.get_objects = Mock(return_value=list())
        self.character_patch = patch.object(zoneserver, 'Object',
                                            self.MockObject)
        self.character_patch.start()

    def tearDown(self):
        self.character_patch.stop()

    def test_set_movement(self):
        mock_char = Mock(speed=1, loc_x=0, loc_y=0, loc_z=0)

        with patch.object(self.character_controller, 'create_character',
                          Mock(return_value=mock_char)):
            result = self.character_controller.set_movement(
                "character", 1, 2, 3)

        self.assertEqual(result.loc_x, 1)
        self.assertEqual(result.loc_y, 2)
        self.assertEqual(result.loc_z, 3)

    def test_set_movement_existing_loc(self):
        mock_char = Mock(speed=1, loc_x=0, loc_y=0, loc_z=0)

        with patch.object(self.character_controller, 'create_character',
                          Mock(return_value=mock_char)):
            result = self.character_controller.set_movement(
                "character", 1, 2, 3)

        self.assertGreater(result.loc_x, 0)

    def test_set_movement_physics_collision(self):
        mock_char = Mock(speed=1, loc_x=0, loc_y=0, loc_z=0)

        self.MockObject.get_objects = Mock(return_value=[mock_char])

        from copy import deepcopy
        with patch.object(zoneserver, 'Object', self.MockObject):
            with patch.object(self.character_controller, 'create_character',
                              Mock(return_value=deepcopy(mock_char))):
                result = self.character_controller.set_movement(
                    "character", 1, 1, 3)

        self.assertFalse(result)

    def test_set_movement_physics_no_collision(self):
        mock_char = Mock(speed=1, loc_x=0, loc_y=0, loc_z=0)
        mock_otherchar = Mock(speed=1, loc_x=4, loc_y=4, loc_z=4)

        self.MockObject.get_objects = Mock(return_value=[mock_otherchar])

        with patch.object(zoneserver, 'Object', self.MockObject):
            with patch.object(self.character_controller, 'create_character',
                              Mock(return_value=mock_char)):
                result = self.character_controller.set_movement(
                    "character", 1, 2, 3)

        self.assertEqual(result, mock_char)
Ejemplo n.º 17
0
 def setUp(self):
     self.character_controller = CharacterController()