Exemple #1
0
    def test_move_notify(self):
        class LocationNotify(Location):
            def notify_npc_left(self, npc, target_location):
                self.npc_left = npc
                self.npc_left_target = target_location

            def notify_npc_arrived(self, npc, previous_location):
                self.npc_arrived = npc
                self.npc_arrived_from = previous_location

            def notify_player_left(self, player, target_location):
                self.player_left = player
                self.player_left_target = target_location

            def notify_player_arrived(self, player, previous_location):
                self.player_arrived = player
                self.player_arrived_from = previous_location

        npc = NPC("rat", "m", race="rodent")
        room1 = LocationNotify("room1")
        room2 = LocationNotify("room2")
        room1.insert(npc, None)
        npc.move(room2)
        pubsub.sync()
        self.assertEqual(room2, npc.location)
        self.assertEqual(npc, room1.npc_left)
        self.assertEqual(room2, room1.npc_left_target)
        self.assertEqual(npc, room2.npc_arrived)
        self.assertEqual(room1, room2.npc_arrived_from)
Exemple #2
0
 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)
Exemple #3
0
 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
Exemple #4
0
 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_move_notify(self):
     class LocationNotify(Location):
         def notify_npc_left(self, npc, target_location):
             self.npc_left = npc
             self.npc_left_target = target_location
         def notify_npc_arrived(self, npc, previous_location):
             self.npc_arrived = npc
             self.npc_arrived_from = previous_location
         def notify_player_left(self, player, target_location):
             self.player_left = player
             self.player_left_target = target_location
         def notify_player_arrived(self, player, previous_location):
             self.player_arrived = player
             self.player_arrived_from = previous_location
     npc = NPC("rat", "m", race="rodent")
     room1 = LocationNotify("room1")
     room2 = LocationNotify("room2")
     room1.insert(npc, None)
     npc.move(room2)
     mud_context.driver.execute_after_player_actions()
     self.assertEqual(room2, npc.location)
     self.assertEqual(npc, room1.npc_left)
     self.assertEqual(room2, room1.npc_left_target)
     self.assertEqual(npc, room2.npc_arrived)
     self.assertEqual(room1, room2.npc_arrived_from)
 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
Exemple #7
0
 def test_look_brief(self):
     player = Player("fritz", "m")
     attic = Location("Attic", "A dark attic.")
     cellar = Location("Cellar", "A gloomy cellar.")
     julie = NPC("julie", "f")
     julie.move(attic, silent=True)
     player.move(attic, silent=True)
     player.brief = 0  # default setting: always long descriptions
     player.look()
     self.assertEqual(["[Attic]\n", "A dark attic.\n", "Julie is here.\n"], player.test_get_output_paragraphs())
     player.look()
     self.assertEqual(["[Attic]\n", "A dark attic.\n", "Julie is here.\n"], player.test_get_output_paragraphs())
     player.look(short=True)   # override
     self.assertEqual(["[Attic]\n", "Present: julie\n"], player.test_get_output_paragraphs())
     player.brief = 1  # short for known, long for new locations
     player.look()
     self.assertEqual(["[Attic]\n", "Present: julie\n"], player.test_get_output_paragraphs())
     player.move(cellar, silent=True)
     player.look()
     self.assertEqual(["[Cellar]\n", "A gloomy cellar.\n"], player.test_get_output_paragraphs())
     player.look()
     self.assertEqual(["[Cellar]\n"], player.test_get_output_paragraphs())
     player.brief = 2  # short always
     player.known_locations.clear()
     player.look()
     self.assertEqual(["[Cellar]\n"], player.test_get_output_paragraphs())
     player.move(attic, silent=True)
     player.look()
     self.assertEqual(["[Attic]\n", "Present: julie\n"], player.test_get_output_paragraphs())
     player.look(short=True)   # override
     self.assertEqual(["[Attic]\n", "Present: julie\n"], player.test_get_output_paragraphs())
     player.look(short=False)  # override
     self.assertEqual(["[Attic]\n", "A dark attic.\n", "Julie is here.\n"], player.test_get_output_paragraphs())
Exemple #8
0
 def test_enter_leave(self):
     hall = Location("hall")
     rat1 = NPC("rat1", "n")
     rat2 = NPC("rat2", "n")
     julie = NPC("julie", "f")
     with self.assertRaises(TypeError):
         hall.insert(12345, julie)
     self.assertEqual(_limbo, rat1.location)
     self.assertFalse(rat1 in hall.livings)
     wiretap = Wiretap(hall)
     hall.insert(rat1, julie)
     self.assertEqual(hall, rat1.location)
     self.assertTrue(rat1 in hall.livings)
     self.assertEqual([], wiretap.msgs,
                      "insert shouldn't produce arrival messages")
     hall.insert(rat2, julie)
     self.assertTrue(rat2 in hall.livings)
     self.assertEqual([], wiretap.msgs,
                      "insert shouldn't produce arrival messages")
     # now test leave
     wiretap.clear()
     hall.remove(rat1, julie)
     self.assertFalse(rat1 in hall.livings)
     self.assertIsNone(rat1.location)
     self.assertEqual([], wiretap.msgs,
                      "remove shouldn't produce exit message")
     hall.remove(rat2, julie)
     self.assertFalse(rat2 in hall.livings)
     self.assertEqual([], wiretap.msgs,
                      "remove shouldn't produce exit message")
     # test random leave
     hall.remove(rat1, julie)
     hall.remove(12345, julie)
Exemple #9
0
 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)
Exemple #10
0
 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())
Exemple #11
0
 def test_look(self):
     player = Player("fritz", "m")
     attic = Location("Attic", "A dark attic.")
     player.look()
     self.assertEqual(["[Limbo]\n", "The intermediate or transitional place or state. There's only nothingness.\nLiving beings end up here if they're not in a proper location yet.\n"], player.test_get_output_paragraphs())
     player.move(attic, silent=True)
     player.look(short=True)
     self.assertEqual(["[Attic]\n"], player.test_get_output_paragraphs())
     julie = NPC("julie", "f")
     julie.move(attic, silent=True)
     player.look(short=True)
     self.assertEqual(["[Attic]\n", "Present: julie\n"], player.test_get_output_paragraphs())
 def test_init_inventory(self):
     rat = NPC("rat", "n", race="rodent")
     rat.insert(Item("thing"), None)
     wizz = Player("wizard", "f")
     wizz.privileges.add("wizard")
     rat.insert(Item("thing2"), wizz)
     self.assertEqual(2, rat.inventory_size)
     stuff = [Item("thing")]
     with self.assertRaises(AssertionError):
         rat.init_inventory(stuff)
     rat = NPC("rat", "n", race="rodent")
     rat.init_inventory(stuff)
     self.assertEqual(1, rat.inventory_size)
Exemple #13
0
 def test_look(self):
     player = Player("fritz", "m")
     attic = Location("Attic", "A dark attic.")
     player.look()
     self.assertEqual([
         "[Limbo]\n",
         "The intermediate or transitional place or state. There's only nothingness.\nLiving beings end up here if they're not in a proper location yet.\n"
     ], player.test_get_output_paragraphs())
     player.move(attic, silent=True)
     player.look(short=True)
     self.assertEqual(["[Attic]\n"], player.test_get_output_paragraphs())
     julie = NPC("julie", "f")
     julie.move(attic, silent=True)
     player.look(short=True)
     self.assertEqual(["[Attic]\n", "Present: julie\n"],
                      player.test_get_output_paragraphs())
 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")
Exemple #15
0
 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
     ])
Exemple #16
0
 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")
Exemple #17
0
 def test_look_brief(self):
     player = Player("fritz", "m")
     attic = Location("Attic", "A dark attic.")
     cellar = Location("Cellar", "A gloomy cellar.")
     julie = NPC("julie", "f")
     julie.move(attic, silent=True)
     player.move(attic, silent=True)
     player.brief = 0  # default setting: always long descriptions
     player.look()
     self.assertEqual(["[Attic]\n", "A dark attic.\n", "Julie is here.\n"],
                      player.test_get_output_paragraphs())
     player.look()
     self.assertEqual(["[Attic]\n", "A dark attic.\n", "Julie is here.\n"],
                      player.test_get_output_paragraphs())
     player.look(short=True)  # override
     self.assertEqual(["[Attic]\n", "Present: julie\n"],
                      player.test_get_output_paragraphs())
     player.brief = 1  # short for known, long for new locations
     player.look()
     self.assertEqual(["[Attic]\n", "Present: julie\n"],
                      player.test_get_output_paragraphs())
     player.move(cellar, silent=True)
     player.look()
     self.assertEqual(["[Cellar]\n", "A gloomy cellar.\n"],
                      player.test_get_output_paragraphs())
     player.look()
     self.assertEqual(["[Cellar]\n"], player.test_get_output_paragraphs())
     player.brief = 2  # short always
     player.known_locations.clear()
     player.look()
     self.assertEqual(["[Cellar]\n"], player.test_get_output_paragraphs())
     player.move(attic, silent=True)
     player.look()
     self.assertEqual(["[Attic]\n", "Present: julie\n"],
                      player.test_get_output_paragraphs())
     player.look(short=True)  # override
     self.assertEqual(["[Attic]\n", "Present: julie\n"],
                      player.test_get_output_paragraphs())
     player.look(short=False)  # override
     self.assertEqual(["[Attic]\n", "A dark attic.\n", "Julie is here.\n"],
                      player.test_get_output_paragraphs())
Exemple #18
0
 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())
Exemple #19
0
 def test_open_hours(self):
     self.shopkeeper.validate_open_hours(current_time=datetime.time(9, 0))
     self.shopkeeper.validate_open_hours(current_time=datetime.time(9, 1))
     self.shopkeeper.validate_open_hours(current_time=datetime.time(13, 0))
     self.shopkeeper.validate_open_hours(current_time=datetime.time(16, 59))
     self.shopkeeper.validate_open_hours(current_time=datetime.time(22, 0))
     self.shopkeeper.validate_open_hours(current_time=datetime.time(23, 59))
     self.shopkeeper.validate_open_hours(current_time=datetime.time(0, 0))
     self.shopkeeper.validate_open_hours(current_time=datetime.time(0, 1))
     self.shopkeeper.validate_open_hours(current_time=datetime.time(2, 59))
     wiz = NPC("wizard", "m")
     wiz.privileges.add("wizard")
     self.shopkeeper.validate_open_hours(wiz,
                                         current_time=datetime.time(2, 59))
Exemple #20
0
 def test_container_contains(self):
     bag = Container("bag")
     key = Item("key")
     self.assertEqual(0, len(bag.inventory))
     self.assertEqual(0, bag.inventory_size)
     npc = NPC("julie", "f")
     bag.insert(key, npc)
     self.assertTrue(key in bag)
     self.assertEqual(1, bag.inventory_size)
     bag.remove(key, npc)
     self.assertEqual(0, bag.inventory_size)
     self.assertFalse(key in bag)
     with self.assertRaises(KeyError):
         bag.remove("not_existing", npc)
 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))
Exemple #22
0
 def test_init(self):
     rat = NPC("rat", "n", race="rodent")
     julie = NPC("julie",
                 "f",
                 title="attractive Julie",
                 description="""
                 She's quite the looker.
                 """,
                 race="human")
     self.assertFalse(julie.aggressive)
     self.assertEqual("julie", julie.name)
     self.assertEqual("attractive Julie", julie.title)
     self.assertEqual("She's quite the looker.", julie.description)
     self.assertEqual("human", julie.stats.race)
     self.assertEqual("f", julie.gender)
     self.assertTrue(1 < julie.stats.agi < 100)
     self.assertEqual("rat", rat.name)
     self.assertEqual("rat", rat.title)
     self.assertEqual("rodent", rat.stats.race)
     self.assertEqual("", rat.description)
     self.assertEqual("n", rat.gender)
     self.assertTrue(1 < rat.stats.agi < 100)
     dragon = NPC("dragon", "f", race="dragon")
     self.assertFalse(dragon.aggressive)
Exemple #23
0
 def test_closed_hours(self):
     with self.assertRaises(ActionRefused):
         self.shopkeeper.validate_open_hours(
             current_time=datetime.time(6, 30))
     with self.assertRaises(ActionRefused):
         self.shopkeeper.validate_open_hours(
             current_time=datetime.time(8, 59))
     with self.assertRaises(ActionRefused):
         self.shopkeeper.validate_open_hours(
             current_time=datetime.time(17, 0))
     with self.assertRaises(ActionRefused):
         self.shopkeeper.validate_open_hours(
             current_time=datetime.time(21, 59))
     with self.assertRaises(ActionRefused):
         self.shopkeeper.validate_open_hours(
             current_time=datetime.time(3, 0))
     wiz = NPC("wizard", "m")
     wiz.privileges.add("wizard")
     self.shopkeeper.validate_open_hours(wiz,
                                         current_time=datetime.time(21, 59))
Exemple #24
0
 def test_init_inventory(self):
     rat = NPC("rat", "n", race="rodent")
     rat.aggressive = True
     with self.assertRaises(ActionRefused):
         rat.insert(Item("thing"), None)
     rat.insert(Item("thing"), rat)
     wizz = Player("wizard", "f")
     wizz.privileges.add("wizard")
     rat.insert(Item("thing2"), wizz)
     self.assertEqual(2, rat.inventory_size)
     stuff = [Item("thing")]
     with self.assertRaises(AssertionError):
         rat.init_inventory(stuff)
     rat = NPC("rat", "n", race="rodent")
     rat.aggressive = True
     rat.init_inventory(stuff)
     self.assertEqual(1, rat.inventory_size)