Esempio n. 1
0
    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])

        self.game.turnMain("take all")
        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])

        self.game.turnMain("take all")
        getall_msg = self.app.print_stack.pop()
        self.assertEqual(getall_msg, "There are no obvious items here to take. ")
Esempio n. 2
0
 def test_new_thing_has_empty_contains_and_sub_contains(self):
     orig = Thing(self.app.game, "bulb")
     child = Thing(self.app.game, "seed")
     sub_child = Thing(self.app.game, "life")
     sub_child.moveTo(child)
     child.moveTo(orig)
     self.assertTrue(orig.contains)
     self.assertTrue(orig.sub_contains)
     replica = orig.copyThing()
     self.assertFalse(replica.contains)
     self.assertFalse(replica.sub_contains)
class TestSell(IFPTestCase):
    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.currency = Thing(self.game, "penny")
        self.me.addThing(self.sale_item)
        self.me.addThing(self.sale_item.copyThing())
        self.actor.addWillBuy(self.sale_item, self.currency, 1, 1)
        self.start_room.addThing(self.actor)

        self.BASE_DOES_NOT_WANT_MORE_MSG = "will not buy any more"

    def test_sell(self):
        self.assertItemIn(
            self.sale_item,
            self.me.contains,
            "This test needs widgets in the inventory. ",
        )
        self.assertEqual(len(self.me.contains[self.sale_item.ix]), 2)

        self.game.turnMain(f"sell {self.sale_item.verbose_name}")

        msg = self.app.print_stack.pop()
        expected = (
            f"(Received: {self.actor.will_buy[self.sale_item.ix].price} "
            f"{self.currency.verbose_name}) ")
        self.assertEqual(msg, expected,
                         "Unexpected msg after attempting to sell item")

        self.assertItemExactlyOnceIn(
            self.currency,
            self.me.contains,
            "Attempted to sell item. Received success message. ",
        )

        SellVerb()._runVerbFuncAndEvents(self.game, self.sale_item)
        msg = self.app.print_stack.pop()

        self.assertIn(
            self.BASE_DOES_NOT_WANT_MORE_MSG,
            msg,
            "Tried to sell item to actor who should not want any more. Received "
            "unexpected msg",
        )
        self.assertItemExactlyOnceIn(
            self.currency,
            self.me.contains,
            "Attempted to buy out of stock item. Number in inventory should not have "
            "changed. ",
        )

    def test_sell_to(self):
        self.assertItemIn(
            self.sale_item,
            self.me.contains,
            "This test needs widgets in the inventory. ",
        )
        self.assertEqual(len(self.me.contains[self.sale_item.ix]), 2)

        self.game.turnMain(
            f"sell {self.sale_item.verbose_name} to {self.actor.verbose_name}")

        msg = self.app.print_stack.pop()
        expected = (
            f"(Received: {self.actor.will_buy[self.sale_item.ix].price} "
            f"{self.currency.verbose_name}) ")
        self.assertEqual(msg, expected,
                         "Unexpected msg after attempting to sell item")

        self.assertItemExactlyOnceIn(
            self.currency,
            self.me.contains,
            "Attempted to sell item. Received success message. ",
        )

        SellToVerb()._runVerbFuncAndEvents(self.game, self.sale_item,
                                           self.actor)
        msg = self.app.print_stack.pop()

        self.assertIn(
            self.BASE_DOES_NOT_WANT_MORE_MSG,
            msg,
            "Tried to sell item to actor who should not want any more. Received "
            "unexpected msg",
        )
        self.assertItemExactlyOnceIn(
            self.currency,
            self.me.contains,
            "Attempted to buy out of stock item. Number in inventory should not have "
            "changed. ",
        )
Esempio n. 4
0
class TestFullInventory(IFPTestCase):
    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 strip_desc(self, desc):
        desc = desc.replace(". ", "").replace(",", "").replace("and", "")
        return " ".join(desc.split())

    def test_inventory_items_desc(self):
        BASE_MSG = "You have"

        InvVerb()._runVerbFuncAndEvents(self.game)
        self.app.print_stack.pop()
        inv_desc = self.app.print_stack.pop()

        parent_desc = self.parent.lowNameArticle()
        stacked_desc = (f"{len(self.me.contains[self.stacked1.ix])} "
                        f"{self.stacked1.plural}")

        self.assertIn(parent_desc, inv_desc,
                      "Composite item description should be in inv desc")
        inv_desc = inv_desc.replace(parent_desc, "")

        self.assertIn(stacked_desc, inv_desc,
                      "Stacked item description should be in inv desc")
        inv_desc = inv_desc.replace(stacked_desc, "")

        inv_desc = self.strip_desc(inv_desc)
        self.assertEqual(inv_desc, BASE_MSG,
                         "Remaining inv desc should match base message")

    def test_inventory_wearing_desc(self):
        BASE_MSG = "You are wearing"

        InvVerb()._runVerbFuncAndEvents(self.game)
        wearing_desc = self.app.print_stack.pop()

        clothing_desc = self.clothing.lowNameArticle()
        stacked_clothing_desc = (f"{len(self.me.wearing[self.clothing1.ix])} "
                                 f"{self.clothing1.plural}")

        self.assertIn(
            clothing_desc,
            wearing_desc,
            "Clothing item description should be in inv desc",
        )
        wearing_desc = wearing_desc.replace(clothing_desc, "")

        self.assertIn(
            stacked_clothing_desc,
            wearing_desc,
            "Stacked clothing item description should be in inv desc",
        )
        wearing_desc = wearing_desc.replace(stacked_clothing_desc, "")

        wearing_desc = self.strip_desc(wearing_desc)
        self.assertEqual(wearing_desc, BASE_MSG,
                         "Remaining wearing desc should match base message")