def test_ban(self):
dbfile = pathlib.Path(
tempfile.gettempdir()) / "tale_test_accdb_{0:f}.sqlite".format(
time.time())
actor = Living("normal", gender="f")
wizard = Living("wizz", gender="f")
wizard.privileges.add("wizard")
try:
accounts = MudAccounts(str(dbfile))
stats = Stats.from_race("elf", gender='f')
accounts.create("testname", "s3cr3t", "test@invalid", stats,
{"wizard"})
account = accounts.get("testname")
self.assertFalse(account.banned)
with self.assertRaises(ActionRefused):
accounts.ban("testname", actor)
with self.assertRaises(LookupError):
accounts.ban("zerp", wizard)
accounts.ban("testname", wizard)
account = accounts.get("testname")
self.assertTrue(account.banned)
with self.assertRaises(LookupError):
accounts.unban("zerp", wizard)
accounts.unban("testname", wizard)
account = accounts.get("testname")
self.assertFalse(account.banned)
finally:
dbfile.unlink()
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_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)
pubsub.sync()
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)
pubsub.sync()
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_lang(self):
living = Living("julie", "f", race="human")
self.assertEqual("her", living.objective)
self.assertEqual("her", living.possessive)
self.assertEqual("she", living.subjective)
self.assertEqual("f", living.gender)
living = Living("max", "m", race="human")
self.assertEqual("him", living.objective)
self.assertEqual("his", living.possessive)
self.assertEqual("he", living.subjective)
self.assertEqual("m", living.gender)
living = Living("herp", "n", race="human")
self.assertEqual("it", living.objective)
self.assertEqual("its", living.possessive)
self.assertEqual("it", living.subjective)
self.assertEqual("n", living.gender)
def test_show_inventory(self):
class Ctx(object):
class Config(object):
pass
config = Config()
class MoneyDriverDummy(object):
pass
ctx = Ctx()
ctx.config.money_type = "modern"
ctx.driver = MoneyDriverDummy()
ctx.driver.moneyfmt = MoneyFormatter(ctx.config.money_type)
julie = Living("julie", "f", race="human")
tap = julie.get_wiretap()
collector = PubsubCollector()
tap.subscribe(collector)
item1 = Item("key")
julie.init_inventory([item1])
julie.money = 9.23
julie.show_inventory(julie, ctx)
pubsub.sync()
text = " ".join(msg.strip() for msg in collector.messages)
self.assertEqual(
"Julie is carrying: key Money in possession: 9 dollars and 23 cents.",
text)
ctx.config.money_type = None
ctx.driver.moneyfmt = None
collector.clear()
julie.show_inventory(julie, ctx)
pubsub.sync()
text = " ".join(msg.strip() for msg in collector.messages)
self.assertEqual("Julie is carrying: key", text)
def test_contains(self):
orc = Living("orc", "m", race="orc")
axe = Weapon("axe")
orc.insert(axe, orc)
self.assertTrue(axe in orc)
self.assertTrue(axe in orc.inventory)
self.assertEqual(1, orc.inventory_size)
self.assertEqual(1, len(orc.inventory))
def test_tell(self):
julie = Living("julie", "f", race="human")
tap = julie.get_wiretap()
collector = PubsubCollector()
tap.subscribe(collector)
julie.tell("msg1", "msg2")
julie.tell("msg3", "msg4", ignored_arg=42)
pubsub.sync()
self.assertEqual(["msg1 msg2", "msg3 msg4"], collector.messages)
def test_allowance(self):
orc = Living("orc", "m", race="half-orc")
axe = Weapon("axe")
orc.insert(axe, orc)
self.assertTrue(axe in orc)
with self.assertRaises(ActionRefused) as x:
orc.remove(axe, None)
self.assertTrue("can't take" in str(x.exception))
orc.remove(axe, orc)
self.assertFalse(axe in orc)
def test_lifecycle(self):
orc = Living("orc", "m", race="orc")
axe = Weapon("axe")
orc.insert(axe, orc)
self.assertIsNotNone(orc.soul)
self.assertIsNotNone(orc.location)
self.assertGreater(orc.inventory_size, 0)
orc.destroy(Context(TestDriver(), None, None, None))
self.assertIsNone(orc.soul)
self.assertIsNone(orc.location)
self.assertEqual(orc.inventory_size, 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 = Living("wizard", "m")
wiz.privileges.add("wizard")
self.shopkeeper.validate_open_hours(wiz, current_time=datetime.time(2, 59))
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 = Living("wizard", "m")
wiz.privileges.add("wizard")
self.shopkeeper.validate_open_hours(wiz, current_time=datetime.time(21, 59))
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. "
"Living 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 = Living("julie", "f")
julie.move(attic, silent=True)
player.look(short=True)
self.assertEqual(["[Attic]\n", "Present here: julie\n"],
player.test_get_output_paragraphs())
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_look_brief(self):
player = Player("fritz", "m")
attic = Location("Attic", "A dark attic.")
cellar = Location("Cellar", "A gloomy cellar.")
julie = Living("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 here: julie\n"],
player.test_get_output_paragraphs())
player.brief = 1 # short for known, long for new locations
player.look()
self.assertEqual(["[Attic]\n", "Present here: 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 here: julie\n"],
player.test_get_output_paragraphs())
player.look(short=True) # override
self.assertEqual(["[Attic]\n", "Present here: 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())
def test_socialize(self):
player = Player("fritz", "m")
attic = Location("Attic", "A dark attic.")
julie = Living("julie", "f")
julie.move(attic)
player.move(attic)
parsed = player.parse("wave all")
self.assertEqual("wave", parsed.verb)
self.assertEqual(1, parsed.who_count)
self.assertEqual(julie, parsed.who_1)
self.assertEqual((julie, None, None), parsed.who_123)
self.assertEqual(julie, parsed.who_last)
self.assertEqual([julie], list(parsed.who_info))
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.errors.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(2, parsed.who_count)
self.assertEqual(julie, parsed.who_1)
self.assertEqual((julie, player, None), parsed.who_123)
self.assertEqual([julie, player], list(parsed.who_info))
self.assertEqual(player, parsed.who_last)
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 test_destroy_loc(self):
ctx = Context(None, None, None, None)
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_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 = Living("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 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)
descr="""
This person's engine is running but there is nobody behind the wheel.
He is a few beers short of a six-pack. Three ice bricks shy of an igloo.
Not the sharpest knife in the drawer. Anyway you get the idea: it's an idiot.
""")
rat = WalkingRat(
"rat",
"n",
race="rodent",
descr=
"A filthy looking rat. Its whiskers tremble slightly as it peers back at you."
)
ant = Living("ant",
"n",
race="insect",
short_descr="A single ant seems to have lost its way.")
clock = gameclock.clone()
clock.short_description = "On the pavement lies a clock, it seems to be working still."
square.init_inventory([
cursed_gem, normal_gem, paper, trashcan, pouch, insertonly_box,
removeonly_box, clock, towncrier, idiot, rat, ant
])
class AlleyOfDoors(Location):
def notify_player_arrived(self, player: Player,
previous_location: Location) -> None:
if previous_location is self:
def test_nonitem_insert_fail(self):
something = MudObject("thing that is not an Item")
orc = Living("orc", "m", race="half-orc")
with self.assertRaises(ActionRefused):
orc.insert(something, orc)
