def test_desc_does_not_contain_contents_if_lid_is_closed(self):
subject = Container(self.game, self._get_unique_noun())
subject.giveLid()
subject.is_open = False
content = Thing(self.game, self._get_unique_noun())
subject.addThing(content)
self.start_room.addThing(subject)
self.game.turnMain(f"x {subject.verbose_name}")
msg = self.app.print_stack.pop()
self.assertNotIn(content.verbose_name, msg)
def setUp(self):
super().setUp()
self.sale_item = Thing(self.game, "widget")
self.sale_item.makeKnown(self.me)
self.actor = Actor(self.game, "Dmitri")
self.me.addThing(self.sale_item)
self.start_room.addThing(self.actor)
self.BASE_DOES_NOT_WANT_MSG = "doesn't want to buy"
def test_gets_correct_objects_with_adjacent_dobj_iobj(self):
dobj_item = Actor(self.game, self._get_unique_noun())
self.start_room.addThing(dobj_item)
iobj_item = Thing(self.game, self._get_unique_noun())
self.start_room.addThing(iobj_item)
self.game.turnMain(f"give {dobj_item.name} {iobj_item.name}")
self.assertEqual(self.game.parser.command.dobj.target, dobj_item)
self.assertEqual(self.game.parser.command.iobj.target, iobj_item)
def test_look_in_closed_container_implies_open_first(self):
parent = Container(self.game, "shoebox")
parent.giveLid()
parent.is_open = False
child = Thing(self.game, "penny")
parent.addThing(child)
parent.moveTo(self.start_room)
self.game.turnMain("look in shoebox")
self.assertIn("You open the shoebox", self.app.print_stack.pop(-2))
def test_move_item_to_nested_adding_container_first_then_item(self):
container = Container(self.game, "cup")
item = Thing(self.game, "bead")
container.moveTo(self.start_room)
self.assertIs(container.location, self.start_room)
item.moveTo(container)
self.assertIs(item.location, container)
self.assertTrue(container.topLevelContainsItem(item))
def test_move_to_removes_item_from_old_location_and_adds_to_new_location(self):
old = Room(self.game, "old", "It is old")
child = Thing(self.game, "child")
old.addThing(child)
new = Container(self.game, "new")
child.moveTo(new)
self.assertItemIn(child, new.contains, "Item not added to new location")
self.assertItemNotIn(child, old.contains, "Item not removed from old location")
self.assertIs(child.location, new, "Item not added to new location")
def test_verb_func_adds_invitem_to_inv(self):
item = Thing(self.game, self._get_unique_noun())
item.invItem = True
self.start_room.addThing(item)
success = GetVerb()._runVerbFuncAndEvents(self.game, item)
self.assertTrue(success)
self.assertIn(item.ix, self.me.contains)
self.assertEqual(len(self.me.contains[item.ix]), 1)
self.assertIn(item, self.me.contains[item.ix])
def test_verb_func_does_not_add_to_inv_where_invitem_false(self):
item = Thing(self.game, self._get_unique_noun())
item.invItem = False
self.start_room.addThing(item)
self.assertFalse(item.ix in self.me.contains)
success = GetVerb()._runVerbFuncAndEvents(self.game, item)
self.assertFalse(success)
self.assertNotIn(item.ix, self.me.contains)
def test_undescribed_underspace_not_included_in_composite_desc(self):
subject = Thing(self.game, self._get_unique_noun())
child = UnderSpace(self.game, "child")
subject.addComposite(child)
self.start_room.addThing(subject)
self.assertNotIn(child.verbose_name, subject.composite_desc)
self.game.turnMain(f"l {subject.verbose_name}")
msg = self.app.print_stack.pop()
self.assertNotIn(child.verbose_name, msg)
def test_gets_correct_verb_with_preposition_dobj_and_iobj(self):
dobj = Thing(self.game, self._get_unique_noun())
self.start_room.addThing(dobj)
iobj = Surface(self.game, self._get_unique_noun())
self.start_room.addThing(iobj)
self.game.turnMain(f"set {dobj.name} on {iobj.name}")
self.assertIs(self.game.parser.command.verb, SetOnVerb)
self.assertIs(self.game.parser.command.dobj.target, dobj)
self.assertIs(self.game.parser.command.iobj.target, iobj)
def test_get_item_when_pc_is_in_thing_with_no_corresponding_exit_verb(
self):
loc = Thing(self.game, "brick")
loc.moveTo(self.start_room)
loc.can_contain_standing_player = True
self.game.me.moveTo(loc)
self.game.turnMain("take brick")
self.assertIn("Could not move player out of brick",
self.app.print_stack)
def test_disambiguate_with_index(self):
east_pillar = Thing(self.game, "pillar")
east_pillar.setAdjectives(["east"])
west_pillar = Thing(self.game, "pillar")
west_pillar.setAdjectives(["west"])
self.start_room.addThing(east_pillar)
self.start_room.addThing(west_pillar)
self.game.turnMain("x pillar")
self.assertTrue(self.game.parser.command.ambiguous)
self.game.turnMain("1")
self.assertIn(
self.game.parser.command.dobj.target,
[east_pillar, west_pillar],
"Unexpected direct object after attempting to disambiguate with index",
)
def setUp(self):
super().setUp()
self.actor = Actor(self.game, "girl")
self.actor.moveTo(self.start_room)
self.item = Thing(self.game, "mess")
self.item.moveTo(self.start_room)
self.CANNOT_TALK_MSG = "You cannot talk to that. "
self.topic = Topic(self.game,
'"Ah, yes," says the girl mysteriously. ')
self.sticky_topic = Topic(
self.game, '"But remember about the thing!" insists the girl. ')
self.game.turnMain("l")
def test_verb_func_drops_item(self):
item = Thing(self.game, self._get_unique_noun())
item.invItem = True
self.me.addThing(item)
self.assertIn(item.ix, self.me.contains)
self.assertEqual(len(self.me.contains[item.ix]), 1)
self.assertIn(item, self.me.contains[item.ix])
self.game.turnMain(f"drop {item.verbose_name}")
self.assertItemNotIn(item, self.me.contains,
"Dropped item, but item still in inventory")
def test_verb_rejected_if_keyword_not_accounted_for(self):
everything_box = Thing(self.game, self._get_unique_noun())
self.start_room.addThing(everything_box)
self.game.turnMain(f"x everything good {everything_box.name}")
self.assertIsNot(
self.game.parser.command.verb,
ExamineVerb,
"Examine verb does not have keyword `everything`. Should not have matched.",
)
def test_verb_rejected_if_preposition_not_accounted_for(self):
up_ladder = Thing(self.game, self._get_unique_noun())
self.start_room.addThing(up_ladder)
self.game.turnMain(f"x up big {up_ladder.name}")
self.assertIsNot(
self.game.parser.command.verb,
ExamineVerb,
"Examine verb does not have preposition `up`. Should not have matched.",
)
def test_reveal_contents(self):
box = Container(self.app.game, "box")
widget = Thing(self.app.game, "widget")
widget.moveTo(box)
sub_widget = Thing(self.app.game, "glitter")
sub_widget.moveTo(widget)
box.giveLid()
box.makeClosed()
box.moveTo(self.start_room)
self.assertItemNotIn(
widget, self.start_room.sub_contains, "Contents shown before reveal"
)
box.makeOpen()
self.assertItemIn(
widget, self.start_room.sub_contains, "Contents not shown after reveal"
)
self.assertItemIn(
sub_widget,
self.start_room.sub_contains,
"Sub contents not shown after reveal",
)
def test_verb_func_does_not_add_to_inv_where_already_in_inv(self):
item = Thing(self.game, self._get_unique_noun())
item.invItem = True
self.me.addThing(item)
self.assertTrue(item.ix in self.me.contains)
self.assertEqual(len(self.me.contains[item.ix]), 1)
self.assertIn(item, self.me.contains[item.ix])
success = GetVerb()._runVerbFuncAndEvents(self.game, item)
self.assertFalse(success)
self.assertEqual(len(self.me.contains[item.ix]), 1)
def test_take_all_takes_known_objects_from_sub_locations(self):
desk = Surface(self.game, "desk")
desk.inv_item = False
desk.desc_reveal = True
desk.moveTo(self.start_room)
hat = Thing(self.game, "hat")
hat.moveTo(desk)
self.game.turnMain("l")
self.game.turnMain("take all")
self.assertTrue(self.game.me.containsItem(hat))
def test_take_all_does_not_take_items_that_are_not_discovered(self):
desk = Surface(self.game, "desk")
desk.inv_item = False
desk.desc_reveal = False # don't reveal the contents with "look"
desk.moveTo(self.start_room)
hat = Thing(self.game, "hat")
hat.moveTo(desk)
self.game.turnMain("l")
self.game.turnMain("take all")
self.assertTrue(self.game.me.containsItem(hat))
def test_preposition_directional_verb(self):
girl = Thing(self.game, "girl")
self.start_room.addThing(girl)
self.game.turnMain(f"lead girl up")
self.assertIs(
self.game.parser.command.verb,
LeadDirVerb,
"Unexpected verb after using a direction that doubles as a preposition (up) "
"for a directional verb",
)
def setUp(self):
super().setUp()
self.parent = Thing(self.game, "cube")
self.child = Container(self.game, "slot")
self.parent.addComposite(self.child)
self.stacked1 = Thing(self.game, "tile")
self.stacked2 = self.stacked1.copyThing()
self.clothing = Clothing(self.game, "scarf")
self.clothing1 = Clothing(self.game, "mitten")
self.clothing2 = self.clothing1.copyThing()
self.me.addThing(self.parent)
self.me.addThing(self.child)
self.me.addThing(self.stacked1)
self.me.addThing(self.stacked2)
self.me.addThing(self.clothing)
self.me.addThing(self.clothing1)
self.me.addThing(self.clothing2)
WearVerb()._runVerbFuncAndEvents(self.game, self.clothing)
WearVerb()._runVerbFuncAndEvents(self.game, self.clothing1)
WearVerb()._runVerbFuncAndEvents(self.game, self.clothing2)
def test_set_in_adds_item(self):
item = Thing(self.game, self._get_unique_noun())
item.invItem = True
self.me.addThing(item)
container = Container(self.game, self._get_unique_noun())
self.start_room.addThing(container)
self.assertNotIn(item.ix, container.contains)
success = SetInVerb()._runVerbFuncAndEvents(self.game, item, container)
self.assertTrue(success)
self.assertIn(item.ix, container.contains)
self.assertIn(item, container.contains[item.ix])
def test_set_on_adds_item(self):
item = Thing(self.game, self._get_unique_noun())
item.invItem = True
self.me.addThing(item)
surface = Surface(self.game, self._get_unique_noun())
self.start_room.addThing(surface)
self.assertNotIn(item.ix, surface.contains)
success = SetOnVerb()._runVerbFuncAndEvents(self.game, item, surface)
self.assertTrue(success)
self.assertIn(item.ix, surface.contains)
self.assertIn(item, surface.contains[item.ix])
def test_get_thing_nested_in_thing_in_inventory(self):
container = Container(self.game, "cup")
container.moveTo(self.start_room)
item = Thing(self.game, "bead")
container.moveTo(self.game.me)
item.moveTo(container)
self.game.turnMain("look in cup")
self.game.turnMain("take bead")
self.assertIn("You remove the bead from the cup. ",
self.app.print_stack)
def test_reveal_contents(self):
box = UnderSpace(self.app.game, "box")
widget = Thing(self.app.game, "widget")
widget.moveTo(box)
sub_widget = Thing(self.app.game, "glitter")
sub_widget.moveTo(widget)
box.moveTo(self.start_room)
box.revealed = False
self.app.game.turnMain("l")
self.app.game.turnMain("take widget")
self.assertIn("don't see any widget", self.app.print_stack.pop())
self.assertItemNotIn(
widget, self.start_room.sub_contains, "Contents shown before reveal"
)
box.revealUnder()
self.assertItemIn(
widget, self.start_room.sub_contains, "Contents not shown after reveal"
)
self.assertItemIn(
sub_widget,
self.start_room.sub_contains,
"Sub contents not shown after reveal",
)
def test_examine(self):
item = Thing(self.game, "widget")
item.xdescribeThing("It's a shiny little widget. ")
item.moveTo(self.start_room)
self.game.turnMain("x widget")
examine_desc = self.app.print_stack.pop()
self.assertEqual(
examine_desc,
item.xdesc,
f"Examine desc printed incorrectly. Expecting {item.xdesc}, got {examine_desc}",
)
def test_move_item_to_nested_adding_item_first_then_container(self):
container = Container(self.game, "cup")
item = Thing(self.game, "bead")
item.moveTo(container)
self.assertIs(
item.location,
container,
"Move item to container failed to set item location when container location was None",
)
container.moveTo(self.start_room)
self.assertIs(item.location, container)
self.assertTrue(container.topLevelContainsItem(item))
def test_get_all_drop(self):
item1 = Thing(self.game, "miracle")
item2 = Thing(self.game, "wonder")
item1.invItem = True
item2.invItem = True
item3 = item2.copyThing()
item1.makeKnown(self.me)
item3.makeKnown(self.me)
self.start_room.addThing(item1)
self.start_room.addThing(item3)
self.me.addThing(item2)
self.assertNotIn(item1.ix, self.me.contains)
self.assertIn(item2.ix, self.me.contains)
self.assertNotIn(item3, self.me.contains[item2.ix])
GetAllVerb()._runVerbFuncAndEvents(self.game)
getall_msg = self.app.print_stack.pop()
self.assertIn(
item1.ix,
self.me.contains,
f"Item not added to inv with get all. Msg: '{getall_msg}'",
)
self.assertIn(item1, self.me.contains[item1.ix])
self.assertIn(
item2.ix,
self.me.contains,
f"Item not added to inv with get all. Msg: '{getall_msg}'",
)
self.assertIn(item2, self.me.contains[item2.ix])
GetAllVerb()._runVerbFuncAndEvents(self.game)
getall_msg = self.app.print_stack.pop()
self.assertEqual(getall_msg,
"There are no obvious items here to take. ")
def test_get_object_from_closed_container_in_inventory(self):
box = Container(self.game, "box")
box.giveLid()
item = Thing(self.game, "bead")
item.moveTo(box)
box.makeOpen()
box.moveTo(self.game.me)
self.assertFalse(self.game.me.topLevelContainsItem(item))
self.game.turnMain("look in box")
self.assertIn("bead", self.app.print_stack.pop())
self.game.turnMain("close box")
self.assertFalse(box.is_open, "Failed to close box")
self.game.turnMain("take bead")
self.assertTrue(self.game.me.topLevelContainsItem(item))
