def test_exits(self):
     hall = Location("hall")
     attic = Location("attic")
     exit1 = Exit("ladder1", attic, "The first ladder leads to the attic.")
     exit2 = Exit("up", attic, "Second ladder to attic.")
     exit3 = Exit("ladder3", attic, "Third ladder to attic.")
     exit4 = Exit("window", attic, "A window.", "A window, maybe if you open it you can get out?")
     hall.add_exits([exit1, exit2, exit3, exit4])
     self.assertTrue(hall.exits["up"] is exit2)
     self.assertTrue(hall.exits["ladder3"] is exit3)
     self.assertTrue(hall.exits["window"] is exit4)
     self.assertEqual(['[hall]', 'The first ladder leads to the attic. Third ladder to attic. Second ladder to attic. A window.'], strip_text_styles(hall.look()))
     self.assertEqual("Third ladder to attic.", exit3.description)
     self.assertEqual("A window, maybe if you open it you can get out?", exit4.description)
     with self.assertRaises(ActionRefused):
         exit1.activate(None)
     with self.assertRaises(ActionRefused):
         exit1.deactivate(None)
     with self.assertRaises(ActionRefused):
         exit1.close(None, None)
     with self.assertRaises(ActionRefused):
         exit1.open(None, None)
     with self.assertRaises(ActionRefused):
         exit1.lock(None, None)
     with self.assertRaises(ActionRefused):
         exit1.unlock(None, None)
     with self.assertRaises(ActionRefused):
         exit1.manipulate("frobnitz", None)
     with self.assertRaises(ActionRefused):
         exit1.read(None)

 def test_socialize(self):
     player = Player("fritz", "m")
     attic = Location("Attic", "A dark attic.")
     julie = NPC("julie", "f")
     julie.move(attic)
     player.move(attic)
     parsed = player.parse("wave all")
     self.assertEqual("wave", parsed.verb)
     self.assertEqual([julie], parsed.who_order)
     who, playermsg, roommsg, targetmsg = player.soul.process_verb_parsed(player, parsed)
     self.assertEqual({julie}, who)
     self.assertEqual("You wave happily at julie.", playermsg)
     with self.assertRaises(tale.soul.UnknownVerbException):
         player.parse("befrotzificate all and me")
     with self.assertRaises(NonSoulVerb) as x:
         player.parse("befrotzificate all and me", external_verbs={"befrotzificate"})
     parsed = x.exception.parsed
     self.assertEqual("befrotzificate", parsed.verb)
     self.assertEqual([julie, player], parsed.who_order)
     attic.add_exits([Exit("south", "target", "door")])
     try:
         player.parse("push south")
         self.fail("push south should throw a parse error because of the exit that is used")
     except ParseError:
         pass
     with self.assertRaises(NonSoulVerb):
         player.parse("fart south")
     parsed = player.parse("hug julie")
     player.validate_socialize_targets(parsed)

 def setUp(self):
     mud_context.driver = TestDriver()
     mud_context.config = DemoStory()._get_config()
     self.hall = Location("Main hall", "A very large hall.")
     self.attic = Location("Attic", "A dark attic.")
     self.street = Location("Street", "An endless street.")
     e1 = Exit("up", self.attic, "A ladder leads up.")
     e2 = Exit(["door", "east"], self.street, "A heavy wooden door to the east blocks the noises from the street outside.")
     self.hall.add_exits([e1, e2])
     self.table = Item("table", "oak table", "a large dark table with a lot of cracks in its surface")
     self.key = Item("key", "rusty key", "an old rusty key without a label", short_description="Someone forgot a key.")
     self.magazine = Item("magazine", "university magazine")
     self.magazine2 = Item("magazine", "university magazine")
     self.rat = NPC("rat", "n", race="rodent")
     self.rat2 = NPC("rat", "n", race="rodent")
     self.fly = NPC("fly", "n", race="insect", short_description="A fly buzzes around your head.")
     self.julie = NPC("julie", "f", title="attractive Julie", description="She's quite the looker.")
     self.julie.aliases = {"chick"}
     self.player = Player("player", "m")
     self.pencil = Item("pencil", title="fountain pen")
     self.pencil.aliases = {"pen"}
     self.bag = Container("bag")
     self.notebook_in_bag = Item("notebook")
     self.bag.insert(self.notebook_in_bag, self.player)
     self.player.insert(self.pencil, self.player)
     self.player.insert(self.bag, self.player)
     self.hall.init_inventory([self.table, self.key, self.magazine, self.magazine2, self.rat, self.rat2, self.julie, self.player, self.fly])

    def test_custom_verbs(self):
        player = Player("julie", "f")
        player.verbs["xywobble"] = "p1"
        room = Location("room")
        chair1 = Item("chair1")
        chair1.verbs["frobnitz"] = "c1"
        chair2 = Item("chair2")
        chair2.verbs["frobnitz"] = "c2"
        chair_in_inventory = Item("chair3")
        chair_in_inventory.verbs["kowabooga"] = "c3"
        room.init_inventory([chair1, player, chair2])

        # check inventory NOT affecting player custom verbs, but DOES affect location verbs
        self.assertEqual({"xywobble": "p1"}, player.verbs)
        self.assertEqual({"frobnitz": "c2", "xywobble": "p1"}, room.verbs)
        player.insert(chair_in_inventory, player)
        self.assertEqual({"xywobble": "p1"}, player.verbs)
        self.assertEqual({"frobnitz": "c2", "xywobble": "p1", "kowabooga": "c3"}, room.verbs)
        player.remove(chair_in_inventory, player)
        self.assertEqual({"frobnitz": "c2", "xywobble": "p1"}, room.verbs)

        player.insert(chair_in_inventory, player)
        self.assertEqual({"frobnitz": "c2", "xywobble": "p1", "kowabooga": "c3" }, room.verbs)
        room2 = Location("room2")
        self.assertEqual({}, room2.verbs)
        chair1.move(room2, player)
        self.assertEqual({"xywobble": "p1", "kowabooga": "c3" }, room.verbs)
        self.assertEqual({"frobnitz": "c1"}, room2.verbs)
        chair2.move(room2, player)
        self.assertEqual({"xywobble": "p1", "kowabooga": "c3"}, room.verbs)
        self.assertEqual({"frobnitz": "c2"}, room2.verbs)
        player.move(room2)
        self.assertEqual({}, room.verbs)
        self.assertEqual({"frobnitz": "c2", "xywobble": "p1", "kowabooga": "c3"}, room2.verbs)

 def test_move(self):
     hall = Location("hall")
     person = Living("person", "m", race="human")
     monster = NPC("dragon", "f", race="dragon")
     monster.aggressive = True
     key = Item("key")
     stone = Item("stone")
     hall.init_inventory([person, key])
     stone.move(hall, person)
     wiretap = Wiretap(hall)
     self.assertTrue(person in hall)
     self.assertTrue(key in hall)
     key.contained_in = person   # hack to force move to actually check the source container
     with self.assertRaises(KeyError):
         key.move(person, person)
     key.contained_in = hall   # put it back as it was
     key.move(person, person)
     self.assertFalse(key in hall)
     self.assertTrue(key in person)
     self.assertEqual([], wiretap.msgs, "item.move() should be silent")
     with self.assertRaises(ActionRefused) as x:
         key.move(monster, person)  # aggressive monster should fail
     self.assertTrue("not a good idea" in str(x.exception))
     monster.aggressive = False
     key.move(monster, person)   # non-aggressive should be ok

    def test_door_pair(self):
        loc1 = Location("room1", "room one")
        loc2 = Location("room2", "room two")
        key = Key("key")
        door_one_two = Door("two", loc2, "door to room two", locked=True, opened=False)
        door_two_one = door_one_two.reverse_door("one", loc1, "door to room one", reverse_open_msg="door one open", reverse_close_msg="door one close",
                                                 this_open_msg="door two open", this_close_msg="door two close")
        loc1.add_exits([door_one_two])
        loc2.add_exits([door_two_one])
        door_one_two.key_code = 555
        key.key_for(door_one_two)
        pubsub1 = PubsubCollector()
        pubsub2 = PubsubCollector()
        loc1.get_wiretap().subscribe(pubsub1)
        loc2.get_wiretap().subscribe(pubsub2)
        self.assertTrue(door_two_one.locked)
        self.assertFalse(door_two_one.opened)
        lucy = Living("lucy", "f")

        door_two_one.unlock(lucy, item=key)
        self.assertFalse(door_one_two.locked)
        door_two_one.open(lucy)
        self.assertTrue(door_one_two.opened)
        pubsub.sync()
        self.assertEqual(["door one open"], pubsub1.messages)
        self.assertEqual([], pubsub2.messages)
        door_one_two.close(lucy)
        door_one_two.lock(lucy, item=key)
        self.assertTrue(door_two_one.locked)
        self.assertFalse(door_two_one.opened)
        pubsub1.clear()
        pubsub2.clear()
        pubsub.sync()
        self.assertEqual([], pubsub1.messages)
        self.assertEqual(["door two close"], pubsub2.messages)

 def test_move(self):
     hall = Location("hall")
     attic = Location("attic")
     rat = Living("rat", "n", race="rodent")
     hall.init_inventory([rat])
     wiretap_hall = Wiretap(hall)
     wiretap_attic = Wiretap(attic)
     self.assertTrue(rat in hall.livings)
     self.assertFalse(rat in attic.livings)
     self.assertEqual(hall, rat.location)
     rat.move(attic)
     self.assertTrue(rat in attic.livings)
     self.assertFalse(rat in hall.livings)
     self.assertEqual(attic, rat.location)
     self.assertEqual([("hall", "Rat leaves.")], wiretap_hall.msgs)
     self.assertEqual([("attic", "Rat arrives.")], wiretap_attic.msgs)
     # now try silent
     wiretap_hall.clear()
     wiretap_attic.clear()
     rat.move(hall, silent=True)
     self.assertTrue(rat in hall.livings)
     self.assertFalse(rat in attic.livings)
     self.assertEqual(hall, rat.location)
     self.assertEqual([], wiretap_hall.msgs)
     self.assertEqual([], wiretap_attic.msgs)

 def test_aliases(self):
     loc = Location("hall", "empty hall")
     exit = Exit("up", "attic", "ladder to attic")
     door = Door("door", "street", "door to street")
     exit2 = Exit(["down", "hatch", "manhole"], "underground", "hatch to underground")
     door2 = Door(["east", "garden"], "garden", "door east to garden")
     self.assertEqual("up", exit.name)
     self.assertEqual("door", door.name)
     loc.add_exits([exit, door, exit2, door2])
     self.assertEqual({"up", "door", "down", "hatch", "manhole", "east", "garden"}, set(loc.exits.keys()))
     self.assertEqual(loc.exits["down"], loc.exits["hatch"])

 def test_destroy_deferreds(self):
     ctx = Context(driver=mud_context.driver)
     thing = Item("thing")
     player = Player("julie", "f")
     wolf = Monster("wolf", "m")
     loc = Location("loc")
     mud_context.driver.defer(datetime.datetime.now(), thing, "method")
     mud_context.driver.defer(datetime.datetime.now(), player, "method")
     mud_context.driver.defer(datetime.datetime.now(), wolf, "method")
     mud_context.driver.defer(datetime.datetime.now(), loc, "method")
     self.assertEqual(4, len(mud_context.driver.deferreds))
     thing.destroy(ctx)
     player.destroy(ctx)
     wolf.destroy(ctx)
     loc.destroy(ctx)
     self.assertEqual(0, len(mud_context.driver.deferreds), "all deferreds must be removed")

 def test_destroy_deferreds(self):
     ctx = Context(driver=mud_context.driver, clock=None, config=None, player_connection=None)
     thing = Item("thing")
     player = Player("julie", "f")
     wolf = NPC("wolf", "m")
     loc = Location("loc")
     mud_context.driver.defer(datetime.datetime.now(), thing.move)
     mud_context.driver.defer(datetime.datetime.now(), player.move)
     mud_context.driver.defer(datetime.datetime.now(), wolf.move)
     mud_context.driver.defer(datetime.datetime.now(), loc.move)
     self.assertEqual(4, len(mud_context.driver.deferreds))
     thing.destroy(ctx)
     player.destroy(ctx)
     wolf.destroy(ctx)
     loc.destroy(ctx)
     self.assertEqual(0, len(mud_context.driver.deferreds), "all deferreds must be removed")

 def test_destroy_player(self):
     ctx = Context()
     loc = Location("loc")
     player = Player("julie", "f")
     player.privileges = {"wizard"}
     player.create_wiretap(loc)
     player.insert(Item("key"), player)
     loc.init_inventory([player])
     self.assertEqual(loc, player.location)
     self.assertTrue(len(player.inventory) > 0)
     self.assertTrue(player in loc.livings)
     player.destroy(ctx)
     import gc
     gc.collect()
     self.assertTrue(len(player.inventory) == 0)
     self.assertFalse(player in loc.livings)
     self.assertIsNone(player.location, "destroyed player should end up nowhere (None)")

 def test_wiretap(self):
     attic = Location("Attic", "A dark attic.")
     player = Player("fritz", "m")
     io = ConsoleIo(None)
     io.supports_smartquotes = False
     pc = PlayerConnection(player, io)
     player.set_screen_sizes(0, 100)
     julie = NPC("julie", "f")
     julie.move(attic)
     player.move(attic)
     julie.tell("message for julie")
     attic.tell("message for room")
     self.assertEqual(["message for room\n"], player.test_get_output_paragraphs())
     with self.assertRaises(ActionRefused):
         player.create_wiretap(julie)
     player.privileges = {"wizard"}
     player.create_wiretap(julie)
     player.create_wiretap(attic)
     julie.tell("message for julie")
     attic.tell("message for room")
     pubsub.sync()
     output = pc.get_output()
     self.assertTrue("[wiretapped from 'Attic': message for room]" in output)
     self.assertTrue("[wiretapped from 'julie': message for julie]" in output)
     self.assertTrue("[wiretapped from 'julie': message for room]" in output)
     self.assertTrue("message for room " in output)
     # test removing the wiretaps
     player.clear_wiretaps()
     import gc
     gc.collect()
     julie.tell("message for julie")
     attic.tell("message for room")
     self.assertEqual(["message for room\n"], player.test_get_output_paragraphs())

def make_location(vnum):
    """
    Get a Tale location object for the given circle room vnum.
    This performs an on-demand conversion of the circle room data to Tale.
    """
    try:
        return converted_rooms[vnum]   # get cached version if available
    except KeyError:
        c_room = rooms[vnum]
        loc = Location(c_room.name, c_room.desc)
        loc.vnum = vnum  # keep the circle vnum
        for ed in c_room.extradesc:
            loc.add_extradesc(ed["keywords"], ed["text"])
        converted_rooms[vnum] = loc
        for circle_exit in c_room.exits.values():
            if circle_exit.roomlink >= 0:
                xt = make_exit(circle_exit)
                while True:
                    try:
                        xt.bind(loc)
                        break
                    except LocationIntegrityError as x:
                        if x.direction in xt.aliases:
                            # circlemud exit keywords can be duplicated over various exits
                            # if we have a conflict, just remove the alias from the exit and try again
                            xt.aliases = xt.aliases - {x.direction}
                            continue
                        else:
                            if loc.exits[x.direction] is xt:
                                # this can occur, the exit is already bound
                                break
                            else:
                                # in this case a true integrity error occurred
                                raise
            else:
                # add the description of the inaccessible exit to the room's own description.
                loc.description += " " + circle_exit.desc
        return loc

 def test_custom_verbs(self):
     player = Player("julie", "f")
     player.verbs["xywobble"] = "p1"
     monster = NPC("snake", "f")
     monster.verbs["snakeverb"] = "s1"
     room = Location("room")
     chair1 = Item("chair1")
     chair1.verbs["frobnitz"] = "c1"
     chair2 = Item("chair2")
     chair2.verbs["frobnitz"] = "c2"
     chair_in_inventory = Item("chair3")
     chair_in_inventory.verbs["kowabooga"] = "c3"
     box_in_inventory = Item("box")
     box_in_inventory.verbs["boxverb"] = "c4"
     player.init_inventory([box_in_inventory, chair_in_inventory])
     exit = Exit("e", "dummy", None, None)
     exit.verbs["exitverb"] = "c5"
     room.init_inventory([chair1, player, chair2, monster])
     room.add_exits([exit])
     custom_verbs = mud_context.driver.current_custom_verbs(player)
     all_verbs = mud_context.driver.current_verbs(player)
     self.assertEqual({"xywobble", "snakeverb", "frobnitz", "kowabooga", "boxverb", "exitverb"}, set(custom_verbs))
     self.assertEqual(set(), set(custom_verbs) - set(all_verbs))

 def test_print_location(self):
     p = Player("julie", "f")
     key = Item("key")
     bag = Container("bag")
     room = Location("room")
     bag.insert(key, p)
     p.insert(bag, p)
     room.insert(p, p)
     with self.assertRaises(Exception):
         p.tell_object_location(None, None)
     p.tell_object_location(key, None)
     self.assertEqual(["(It's not clear where key is).\n"], p.test_get_output_paragraphs())
     p.tell_object_location(key, None, print_parentheses=False)
     self.assertEqual(["It's not clear where key is.\n"], p.test_get_output_paragraphs())
     p.tell_object_location(key, bag)
     result = "".join(p.test_get_output_paragraphs())
     self.assertTrue("in bag" in result and "in your inventory" in result)
     p.tell_object_location(key, room)
     self.assertTrue("in your current location" in "".join(p.test_get_output_paragraphs()))
     p.tell_object_location(bag, p)
     self.assertTrue("in your inventory" in "".join(p.test_get_output_paragraphs()))
     p.tell_object_location(p, room)
     self.assertTrue("in your current location" in "".join(p.test_get_output_paragraphs()))

 def test_location(self):
     thingy = Item("thing")
     with self.assertRaises(TypeError):
         thingy.location = "foobar"
     hall = Location("hall")
     thingy.location = hall
     self.assertEqual(hall, thingy.contained_in)
     self.assertEqual(hall, thingy.location)
     person = Living("person", "m", race="human")
     key = Item("key")
     backpack = Container("backpack")
     person.insert(backpack, person)
     self.assertIsNone(key.contained_in)
     self.assertIsNone(key.location)
     self.assertTrue(backpack in person)
     self.assertEqual(person, backpack.contained_in)
     self.assertEqual(_Limbo, backpack.location)
     hall.init_inventory([person, key])
     self.assertEqual(hall, key.contained_in)
     self.assertEqual(hall, key.location)
     self.assertEqual(hall, backpack.location)
     key.move(backpack, person)
     self.assertEqual(backpack, key.contained_in)
     self.assertEqual(hall, key.location)

 def test_tell(self):
     rat = MsgTraceNPC("rat", "n", "rodent")
     self.assertTrue(rat._init_called, "init() must be called from __init__")
     julie = MsgTraceNPC("julie", "f", "human")
     hall = Location("hall")
     hall.livings = [rat, julie]
     hall.tell("roommsg")
     self.assertEqual(["roommsg"], rat.messages)
     self.assertEqual(["roommsg"], julie.messages)
     rat.clearmessages()
     julie.clearmessages()
     hall.tell("roommsg", rat, [julie], "juliemsg")
     self.assertEqual([], rat.messages)
     self.assertEqual(["juliemsg"], julie.messages)

 def test_destroy_loc(self):
     ctx = Context()
     loc = Location("loc")
     i = Item("item")
     liv = Living("rat", "n", race="rodent")
     loc.add_exits([Exit("north", "somewhere", "exit to somewhere")])
     player = Player("julie", "f")
     player.privileges = {"wizard"}
     player.create_wiretap(loc)
     loc.init_inventory([i, liv, player])
     self.assertTrue(len(loc.exits) > 0)
     self.assertTrue(len(loc.items) > 0)
     self.assertTrue(len(loc.livings) > 0)
     self.assertEqual(loc, player.location)
     self.assertEqual(loc, liv.location)
     loc.destroy(ctx)
     self.assertTrue(len(loc.exits) == 0)
     self.assertTrue(len(loc.items) == 0)
     self.assertTrue(len(loc.livings) == 0)
     self.assertEqual(_Limbo, player.location)
     self.assertEqual(_Limbo, liv.location)

    def test_handle_and_notify_action(self):
        class SpecialPlayer(Player):
            def init(self):
                self.handled = False
                self.handle_verb_called = False
                self.notify_called = False

            def handle_verb(self, parsed, actor):
                self.handle_verb_called = True
                if parsed.verb in self.verbs:
                    self.handled = True
                    return True
                else:
                    return False

            def notify_action(self, parsed, actor):
                self.notify_called = True

        player = SpecialPlayer("julie", "f")
        player.verbs["xywobble"] = ""
        room = Location("room")

        class Chair(Item):
            def init(self):
                self.handled = False
                self.handle_verb_called = False
                self.notify_called = False

            def handle_verb(self, parsed, actor):
                self.handle_verb_called = True
                if parsed.verb in self.verbs:
                    self.handled = True
                    return True
                else:
                    return False

            def notify_action(self, parsed, actor):
                self.notify_called = True

        chair_in_inventory = Chair("littlechair")
        chair_in_inventory.verbs["kerwaffle"] = ""
        player.insert(chair_in_inventory, player)
        chair = Chair("chair")
        chair.verbs["frobnitz"] = ""
        room.init_inventory([player, chair])

        # first check if the handle_verb passes to all objects including inventory
        parsed = ParseResult("kowabungaa12345")
        handled = room.handle_verb(parsed, player)
        self.assertFalse(handled)
        self.assertTrue(chair.handle_verb_called)
        self.assertTrue(player.handle_verb_called)
        self.assertTrue(chair_in_inventory.handle_verb_called)
        self.assertFalse(chair.handled)
        self.assertFalse(player.handled)
        self.assertFalse(chair_in_inventory.handled)

        # check item handling
        player.init()
        chair.init()
        chair_in_inventory.init()
        parsed = ParseResult("frobnitz")
        handled = room.handle_verb(parsed, player)
        self.assertTrue(handled)
        self.assertTrue(chair.handled)
        self.assertFalse(player.handled)
        self.assertFalse(chair_in_inventory.handled)

        # check living handling
        player.init()
        chair.init()
        chair_in_inventory.init()
        parsed = ParseResult("xywobble")
        handled = room.handle_verb(parsed, player)
        self.assertTrue(handled)
        self.assertFalse(chair.handled)
        self.assertTrue(player.handled)
        self.assertFalse(chair_in_inventory.handled)

        # check inventory handling
        player.init()
        chair.init()
        chair_in_inventory.init()
        parsed = ParseResult("kerwaffle")
        handled = room.handle_verb(parsed, player)
        self.assertTrue(handled)
        self.assertFalse(chair.handled)
        self.assertFalse(player.handled)
        self.assertTrue(chair_in_inventory.handled)

        # check notify_action
        player.init()
        chair.init()
        chair_in_inventory.init()
        room.notify_action(parsed, player)
        self.assertTrue(chair.notify_called)
        self.assertTrue(player.notify_called)
        self.assertTrue(chair_in_inventory.notify_called)

 def test_verbs(self):
     room = Location("room")
     room.verbs["smurf"] = ""
     self.assertTrue("smurf" in room.verbs)
     del room.verbs["smurf"]
     self.assertFalse("smurf" in room.verbs)