class WarehouseTests(unittest.TestCase):
def setUp(self):
self.warehouse = Warehouse()
self.warehouse.add('Glenlivit', 10)
def test_warehouse_shows_new_inventory(self):
self.assertEqual(self.warehouse.get_inventory('Glenlivit'), 10)
def test_warehouse_shows_added_inventory(self):
self.warehouse.add('Glenlivit', 15)
self.assertEqual(self.warehouse.get_inventory('Glenlivit'), 25)
def test_warehouse_shows_removed_inventory(self):
self.warehouse.remove('Glenlivit', 10)
self.assertEqual(self.warehouse.get_inventory('Glenlivit'), 0)
class WarehouseTests(unittest.TestCase):
def setUp(self):
self.warehouse = Warehouse()
self.warehouse.add('Glenlivit', 10)
def test_warehouse_shows_new_inventory(self):
self.assertEqual(self.warehouse.get_inventory('Glenlivit'), 10)
def test_warehouse_shows_added_inventory(self):
self.warehouse.add('Glenlivit', 15)
self.assertEqual(self.warehouse.get_inventory('Glenlivit'), 25)
def test_warehouse_shows_removed_inventory(self):
self.warehouse.remove('Glenlivit', 10)
self.assertEqual(self.warehouse.get_inventory('Glenlivit'), 0)
class OrderTests(unittest.TestCase):
def setUp(self):
self.warehouse = Warehouse()
self.warehouse.add(TALISKER, 50)
self.warehouse.add(HIGHLAND_PARK, 25)
def test_order_is_filled_if_enough_in_warehouse(self):
order = Order(TALISKER, 50)
order.fill(self.warehouse)
self.assertTrue(order.is_filled())
self.assertEqual(self.warehouse.get_inventory(TALISKER), 0)
def test_order_does_not_remove_if_not_enough(self):
order = Order(TALISKER, 51)
order.fill(self.warehouse)
self.assertFalse(order.is_filled())
self.assertEqual(self.warehouse.get_inventory(TALISKER), 50)
class OrderTests(unittest.TestCase):
def setUp(self):
self.warehouse = Warehouse()
self.warehouse.add(TALISKER, 50)
self.warehouse.add(HIGHLAND_PARK, 25)
def test_order_is_filled_if_enough_in_warehouse(self):
order = Order(TALISKER, 50)
order.fill(self.warehouse)
self.assertTrue(order.is_filled())
self.assertEqual(self.warehouse.get_inventory(TALISKER), 0)
def test_order_does_not_remove_if_not_enough(self):
order = Order(TALISKER, 51)
order.fill(self.warehouse)
self.assertFalse(order.is_filled())
self.assertEqual(self.warehouse.get_inventory(TALISKER), 50)
class Player:
# This class contains all player data.
# it is just a wrapper around warehouse class.
def __init__(self, configuration):
self._ressources = Ressources(configuration)
# build a dict with all keys
# contains all units available
self._units = Warehouse("units", configuration)
#contains all defenses available
self._defenses = Warehouse("defenses", configuration)
# define tech available
self._tech = Warehouse("tech", configuration)
# mail box
# @TODO
self._mail_box = []
def check_min_ressources(self, values):
# from a list a ressource values, return True if ressources are available
self._ressources.is_available(values)
def check_min_units(self, units):
# check a min quantity of units
return self._units.check_min(units)
def check_min_tech(self, tech):
# check a min tech level
return self._tech.check_min(tech)
def get_ressources(self):
return zip(self._ressources.get_value(), self._ressources.get_delta())
def get_units(self):
return self._units.get()
def get_defenses(self):
return self._defenses.get()
def get_tech(self):
return self._tech.get()
def add_units(self, units):
self._units.add(units)
def add_defenses(self, defenses):
self._defenses.add(defenses)
def inc_tech(self, tech_name):
self._tech.add({tech_name:1})
def sub_units(self, units):
self._units.sub(units)
def sub_defenses(self, defenses):
self._defenses.sub(defenses)
class BasicTest(unittest.TestCase):
""" A set of tests for the basic required functionality.
"""
def setUp(self):
""" Create some objects: one Warehouse, one Shelf, three of each
Container type (Bin, Box, Bag), and three each of four different
sizes of Item.
"""
self.warehouse = Warehouse()
self.shelf = Shelf()
self.bin1, self.bin2, self.bin3 = [Bin() for _ in range(3)]
self.box1, self.box2, self.box3 = [Box() for _ in range(3)]
self.bag1, self.bag2, self.bag3 = [Bag() for _ in range(3)]
self.itemS1, self.itemS2, self.itemS3 = [Item(1) for _ in range(3)]
self.itemM1, self.itemM2, self.itemM3 = [Item(6) for _ in range(3)]
self.itemL1, self.itemL2, self.itemL3 = [Item(10) for _ in range(3)]
self.itemXL1, self.itemXL2, self.itemXL3 = [Item(15) for _ in range(3)]
def test_structure(self):
""" Test basic ability to place Containers within other Containers.
"""
# A Warehouse can contain a Shelf
self.assertTrue(self.warehouse.add(self.shelf))
self.assertTrue(self.warehouse.contains(self.shelf))
# Shelves can contain Bins
self.assertTrue(self.shelf.add(self.bin1))
self.assertTrue(self.shelf.contains(self.bin1))
self.assertTrue(self.shelf.add(self.bin2))
self.assertTrue(self.shelf.contains(self.bin2))
# Bins can contain Boxes
self.assertTrue(self.bin1.add(self.box1))
self.assertTrue(self.bin1.contains(self.box1))
self.assertTrue(self.bin1.add(self.box2))
self.assertTrue(self.bin1.contains(self.box2))
# Boxes can contain Bags
self.assertTrue(self.box1.add(self.bag1))
self.assertTrue(self.box1.contains(self.bag1))
self.assertTrue(self.box1.add(self.bag2))
self.assertTrue(self.box1.contains(self.bag2))
# A Shelf "contains" nested Containers within it
self.assertTrue(self.shelf.contains(self.bin1))
self.assertTrue(self.shelf.contains(self.box1))
self.assertTrue(self.shelf.contains(self.box2))
self.assertTrue(self.shelf.contains(self.bag1))
self.assertTrue(self.shelf.contains(self.bag2))
self.assertFalse(self.shelf.contains(self.box3))
def test_contents(self):
""" Test the ability to add Items to Containers and find their
contents.
"""
# Reuse the work done by `test_structure()` to set up hierarchy
self.test_structure()
# Bins and Boxes can contain Items
self.assertTrue(self.bin2.add(self.itemS1))
self.assertTrue(self.bin2.contains(self.itemS1))
self.assertTrue(self.box1.add(self.itemS2))
self.assertTrue(self.box1.contains(self.itemS2))
# Containers "contain" Items in nested Containers within them
self.assertTrue(self.bin1.contains(self.itemS2))
self.assertTrue(self.shelf.contains(self.itemS1))
self.assertTrue(self.shelf.contains(self.itemS2))
def test_limits(self):
""" Test capacity limits.
"""
# Containers can only hold smaller Containers, not the same or larger.
# Bins cannot contain Bins
self.assertFalse(self.bin1.add(self.bin3))
self.assertFalse(self.bin1.contains(self.bin3))
# Boxes cannot contain Boxes
self.assertFalse(self.box1.add(self.box3))
self.assertFalse(self.box1.contains(self.box3))
# Bags cannot contain Bags
self.assertFalse(self.bag1.add(self.bag3))
self.assertFalse(self.bag1.contains(self.bag3))
# Containers cannot contain Items that are too large
self.assertFalse(self.bag1.add(self.itemM1))
self.assertFalse(self.bag1.contains(self.itemM1))
self.assertFalse(self.box1.add(self.itemL1))
self.assertFalse(self.box1.contains(self.itemL1))
self.assertFalse(self.bin1.add(self.itemXL1))
self.assertFalse(self.bin1.contains(self.itemXL1))
# bin1 should be empty now, otherwie the next assertions will fail
self.assertEqual(len(self.bin1), 0)
# Bins can't fit more than two Boxes
self.assertTrue(self.bin1.add(self.box1))
self.assertTrue(self.bin1.add(self.box2))
self.assertFalse(self.bin1.add(self.box3))
self.assertFalse(self.bin1.contains(self.box3))
def test_remove(self):
""" Test item removal.
"""
# Add some items to remove.
self.assertTrue(self.box1.add(self.itemS1))
self.assertTrue(self.box1.add(self.itemS2))
self.assertTrue(self.box1.add(self.itemS3))
# Test removal mode 1: no arguments, removes last added object.
self.assertIs(self.box1.remove(), self.itemS3)
self.assertFalse(self.box1.contains(self.itemS3))
# Test removal mode 2: removing a specific object.
self.assertIs(self.box1.remove(self.itemS1), self.itemS1)
self.assertFalse(self.box1.contains(self.itemS1))
# Check that itemS2 is still there.
self.assertTrue(self.box1.contains(self.itemS2))
def test_pack(self):
""" Test the `pack()` method (puts an object in the first nested
container with space for it).
"""
# An oddly-sized, space-filling Item
fillerItem = Item(5)
# Add a Box to a Bin; make the Bin too full to add another Item
self.assertTrue(self.bin1.add(self.box1))
self.assertTrue(self.bin1.add(fillerItem))
# self.itemS1 should get packed into the Box inside the Bin
self.assertTrue(self.bin1.pack(self.itemS1))
self.assertTrue(self.box1.contains(self.itemS1))
def test_shelfConstraint(self):
""" Test that a Shelf can only contain Items larger than 7
volume units. Containers smaller than 7 units are allowed.
"""
# Shelves can contain Containers smaller than 7 units, but not Items.
self.assertTrue(self.shelf.add(self.bag1))
# Shelves cannot contain items smaller than 7 units.
self.assertTrue(self.shelf.add(self.itemXL1))
self.assertTrue(self.shelf.add(self.itemL1))
self.assertFalse(self.shelf.add(self.itemM1))
self.assertFalse(self.shelf.add(self.itemS1))
# Shelves can contain Containers with smaller Items.
self.assertTrue(self.bin1.add(self.itemS1))
self.assertTrue(self.shelf.add(self.bin1))
def test_exclusivity(self):
""" Test that moving an Item from one Container to another
automatically removes it from the first Container.
"""
self.assertTrue(self.bin1.add(self.itemS1))
self.assertTrue(self.bin1.contains(self.itemS1))
self.assertFalse(self.bin2.contains(self.itemS1))
self.assertTrue(self.bin2.add(self.itemS1))
self.assertTrue(self.bin2.contains(self.itemS1))
self.assertFalse(self.bin1.contains(self.itemS1))
def test_extract(self):
""" Test the `extract()` method, which removes an item from
a Container or any Container within it.
"""
self.assertTrue(self.warehouse.add(self.shelf))
self.assertTrue(self.shelf.add(self.bin1))
self.assertTrue(self.bin1.add(self.box1))
self.assertTrue(self.box1.add(self.bag1))
self.assertTrue(self.bag1.add(self.itemS1))
self.assertTrue(self.bag1.add(self.itemS2))
self.assertIsNotNone(self.bag1.extract(self.itemS1))
self.assertIsNotNone(self.warehouse.extract(self.itemS2))
# Make sure they've actually been removed
self.assertIsNone(self.bag1.extract(self.itemS1))
self.assertIsNone(self.warehouse.extract(self.itemS2))