class TestGroupEvent(unittest.TestCase):
def setUp(self):
self.fact = EventFactory()
self.group = self.fact.new(objects.GROUP)
self.inform = self.fact.new(objects.INFORM)
self.event = self.fact.new(objects.EVENT)
self.group.add(self.event)
self.group.add(self.inform)
def test_add(self):
self.assertIn(self.inform, self.group.events)
def test_add_raises(self):
with self.assertRaises(exceptions.InvalidParameterError):
self.group.add(self.event)
def test_execute(self):
res = self.group.execute(None)
self.assertEqual(res, "Get it while it's hot")
def test_execute_has_message(self):
self.group.message = 'What just happend?'
res = self.group.execute(None)
self.assertEqual(res, "What just happend?\nGet it while it's hot")
def test_accept(self):
visitor = fakes.FakeEventVisitor()
self.group.accept(visitor)
self.assertEqual(visitor.result, self.group.id)
def setUp(self):
self.fact = EventFactory()
self.group = self.fact.new(objects.GROUP)
self.inform = self.fact.new(objects.INFORM)
self.event = self.fact.new(objects.EVENT)
self.group.add(self.event)
self.group.add(self.inform)
def setUp(self):
self.fact = EventFactory()
self.conditional = self.fact.new(objects.CONDITIONAL)
self.success = self.fact.new(objects.INFORM)
self.failure = self.fact.new(objects.EVENT)
self.failure.message = 'Not a chance!'
self.will_pass = fakes.FakeCondition(True)
self.will_fail = fakes.FakeCondition(False)
def setUp(self):
self.fact = EventFactory()
self.ordered = self.fact.new(objects.ORDERED)
self.inform = self.fact.new(objects.INFORM)
self.event = self.fact.new(objects.EVENT)
self.event.message = 'How dare you!'
self.ordered.add(self.event)
self.ordered.add(self.inform)
def setUp(self):
self.evt_fact = EventFactory()
self.event = self.evt_fact.new(objects.EVENT)
self.inform = self.evt_fact.new(objects.INFORM)
self.move = self.evt_fact.new(objects.MOVE)
self.ent_fact = EntityFactory()
self.room = self.ent_fact.new(objects.ROOM)
self.world = World()
self.world.add_event(self.event)
self.world.add_event(self.inform)
self.world.add_event(self.move)
self.world.add_entity(self.room)
def setUp(self):
self.ent_fact = EntityFactory()
self.evt_fact = EventFactory()
self.json_objs = [
objects.ENTITY, objects.CONTAINER, objects.PLAYER, objects.ROOM
]
self.world = World()
self.entity = self.ent_fact.new(objects.ENTITY)
self.container = self.ent_fact.new(objects.CONTAINER)
self.player = self.ent_fact.new(objects.PLAYER)
self.npc = self.ent_fact.new(objects.NPC)
self.room = self.ent_fact.new(objects.ROOM)
self.world.add_entity(self.entity)
self.world.add_entity(self.container)
self.world.add_entity(self.room)
self.world.add_entity(self.player)
self.world.add_entity(self.npc)
self.world.add_event(self.evt_fact.new(objects.INFORM))
class TestOrderedGroup(unittest.TestCase):
def setUp(self):
self.fact = EventFactory()
self.ordered = self.fact.new(objects.ORDERED)
self.inform = self.fact.new(objects.INFORM)
self.event = self.fact.new(objects.EVENT)
self.event.message = 'How dare you!'
self.ordered.add(self.event)
self.ordered.add(self.inform)
def test_add(self):
self.assertIn(self.inform, self.ordered.events)
self.assertTrue(self.event.only_once)
def test_execute(self):
res = self.ordered.execute(None)
self.assertEqual(res, 'How dare you!')
res = self.ordered.execute(None)
self.assertEqual(res, "Get it while it's hot")
res = self.ordered.execute(None)
self.assertEqual(res, "Get it while it's hot")
def test_execute_has_message(self):
self.ordered.message = 'Why?'
res = self.ordered.execute(None)
self.assertEqual(res, 'Why?\nHow dare you!')
res = self.ordered.execute(None)
self.assertEqual(res, "Why?\nGet it while it's hot")
def test_execute_only_message(self):
self.ordered.message = 'Stop bothering me!'
self.inform.message = None
self.event.message = None
res = self.ordered.execute(None)
self.assertEqual(res, 'Stop bothering me!')
def test_execute_all_only_once(self):
self.inform.only_once = True
self.event.only_once = True
self.ordered.execute(None)
self.ordered.execute(None)
res = self.ordered.execute(None)
self.assertEqual(res, '')
self.assertTrue(self.ordered.is_done)
class TestEntityConnector(unittest.TestCase):
def setUp(self):
self.ent_fact = EntityFactory()
self.evt_fact = EventFactory()
self.json_objs = [
objects.ENTITY, objects.CONTAINER, objects.PLAYER, objects.ROOM
]
self.world = World()
self.entity = self.ent_fact.new(objects.ENTITY)
self.container = self.ent_fact.new(objects.CONTAINER)
self.player = self.ent_fact.new(objects.PLAYER)
self.npc = self.ent_fact.new(objects.NPC)
self.room = self.ent_fact.new(objects.ROOM)
self.world.add_entity(self.entity)
self.world.add_entity(self.container)
self.world.add_entity(self.room)
self.world.add_entity(self.player)
self.world.add_entity(self.npc)
self.world.add_event(self.evt_fact.new(objects.INFORM))
def test_connect_entity(self):
connector = visitor.EntityConnector(objects.ENTITY, self.world)
connector.connect(self.entity)
self.assertTrue(self.entity.events.has_event('use'))
def test_connect_container(self):
connector = visitor.EntityConnector(objects.ROOM, self.world)
connector.connect(self.room)
self.assertTrue(self.room.events.has_event('use'))
self.assertTrue(self.room.inventory.has_item(self.entity.spec.id))
self.assertTrue(self.room.inventory.has_item(self.player.spec.id))
self.assertTrue(self.room.inventory.has_item(self.npc.spec.id))
self.assertTrue(self.room.inventory.has_item(self.container.spec.id))
def test_connect_player(self):
connector = visitor.EntityConnector(objects.PLAYER, self.world)
connector.connect(self.player)
self.assertTrue(self.player.events.has_event('use'))
def test_connect_npc(self):
connector = visitor.EntityConnector(objects.NPC, self.world)
connector.connect(self.npc)
self.assertTrue(self.npc.events.has_event('use'))
class TestConditionalEvent(unittest.TestCase):
def setUp(self):
self.fact = EventFactory()
self.conditional = self.fact.new(objects.CONDITIONAL)
self.success = self.fact.new(objects.INFORM)
self.failure = self.fact.new(objects.EVENT)
self.failure.message = 'Not a chance!'
self.will_pass = fakes.FakeCondition(True)
self.will_fail = fakes.FakeCondition(False)
def test_execute_success(self):
self.conditional.condition = self.will_pass
self.conditional.success = self.success
res = self.conditional.execute(None)
self.assertEqual(res, "Get it while it's hot")
self.assertFalse(self.conditional.is_done)
res = self.conditional.execute(None)
self.assertEqual(res, "Get it while it's hot")
def test_execute_success_only_once(self):
self.conditional.condition = self.will_pass
self.conditional.success = self.success
self.conditional.only_once = True
res = self.conditional.execute(None)
self.assertEqual(res, "Get it while it's hot")
self.assertTrue(self.conditional.is_done)
def test_execute_failure(self):
self.conditional.condition = self.will_fail
self.conditional.failure = self.failure
res = self.conditional.execute(None)
self.assertEqual(res, 'Not a chance!')
def test_execute_fail_no_failure(self):
self.conditional.condition = self.will_fail
res = self.conditional.execute(None)
self.assertEqual(res, '')
def test_execute_with_message_success(self):
self.conditional.condition = self.will_pass
self.conditional.message = 'Come back anytime!'
self.conditional.success = self.success
res = self.conditional.execute(None)
self.assertEqual(res, "Come back anytime!\nGet it while it's hot")
def test_execute_with_message_failure(self):
self.conditional.condition = self.will_fail
self.conditional.message = 'Come back anytime!'
self.conditional.failure = self.failure
res = self.conditional.execute(None)
self.assertEqual(res, "Come back anytime!\nNot a chance!")
def test_execute_only_message(self):
self.conditional.condition = self.will_pass
self.conditional.message = 'Come back anytime!'
self.conditional.success = self.success
self.success.message = ''
res = self.conditional.execute(None)
self.assertEqual(res, "Come back anytime!")
def test_accept(self):
visitor = fakes.FakeEventVisitor()
self.conditional.accept(visitor)
self.assertEqual(visitor.result, self.conditional.id)
class TestEventConnector(unittest.TestCase):
def setUp(self):
self.evt_fact = EventFactory()
self.event = self.evt_fact.new(objects.EVENT)
self.inform = self.evt_fact.new(objects.INFORM)
self.move = self.evt_fact.new(objects.MOVE)
self.ent_fact = EntityFactory()
self.room = self.ent_fact.new(objects.ROOM)
self.world = World()
self.world.add_event(self.event)
self.world.add_event(self.inform)
self.world.add_event(self.move)
self.world.add_entity(self.room)
def test_connect_event(self):
connector = visitor.EventConnector(objects.INFORM, self.world, {})
connector.connect(self.inform)
self.assertIn(self.event, self.inform.subjects)
def test_connect_move(self):
connector = visitor.EventConnector(objects.MOVE, self.world, {})
connector.connect(self.move)
self.assertIn(self.inform, self.move.subjects)
self.assertIs(self.move.destination, self.room)
def test_connect_give(self):
give = self.evt_fact.new(objects.GIVE)
cont = self.ent_fact.new(objects.NPC)
self.world.add_entity(cont)
connector = visitor.EventConnector(objects.GIVE, self.world, {})
connector.connect(give)
self.assertEqual(give.item_owner, cont)
def test_connect_take(self):
take = self.evt_fact.new(objects.TAKE)
cont = self.ent_fact.new(objects.NPC)
self.world.add_entity(cont)
connector = visitor.EventConnector(objects.TAKE, self.world, {})
connector.connect(take)
self.assertEqual(take.new_owner, cont)
def test_connect_toggle(self):
toggle = self.evt_fact.new(objects.TOGGLE_ACTIVE)
cont = self.ent_fact.new(objects.NPC)
self.world.add_entity(cont)
connector = visitor.EventConnector(objects.TOGGLE_ACTIVE, self.world,
{})
connector.connect(toggle)
self.assertEqual(toggle.target, cont)
def test_connect_group(self):
group = self.evt_fact.new(objects.GROUP)
connector = visitor.EventConnector(objects.GROUP, self.world, {})
connector.connect(group)
self.assertIn(self.event, group.events)
self.assertIn(self.inform, group.events)
def test_connect_conditional(self):
conditional = self.evt_fact.new(objects.CONDITIONAL)
connector = visitor.EventConnector(
objects.CONDITIONAL, self.world,
{objects.QUESTION['id']: objects.QUESTION})
connector.connect(conditional)
self.assertEqual(conditional.condition.question,
objects.QUESTION['question'])
self.assertIs(conditional.success, self.event)
self.assertIs(conditional.failure, self.inform)
# this test is badly broken. But the symptom is that the world editor
# changed the way that the json is represented and the json_objects are
# no longer proper. I have hacked them together to keep things working, but
# this one could not be fixed. I need to rewrite how the tests work to fix
# these issues.
@unittest.skip
def test_connect_interaction(self):
interaction = self.evt_fact.new(objects.INTERACTION)
connector = visitor.EventConnector(
objects.INTERACTION, self.world, {
objects.QUESTION['id']:
objects.QUESTION,
objects.INTERACTION['options'][0]['id']:
objects.INTERACTION['options'][0],
objects.INTERACTION['options'][1]['id']:
objects.INTERACTION['options'][1]
})
connector.connect(interaction)
opt_1 = interaction.options[0]
opt_2 = interaction.options[1]
self.assertIs(opt_1.event, self.event)
self.assertIs(opt_2.event, self.inform)