def setUp(self):
self.chair = Furniture('100', "this is a chair", '150.00', '5.00')
self.chair2 = Furniture('120',
"this is chair #2",
'180.00',
'0.00',
material="Leather",
size="small")
def add_new_item():
# global FULL_INVENTORY
item_code = input("Enter item code: ")
item_description = input("Enter item description: ")
item_rental_price = input("Enter item rental price: ")
# Get price from the market prices module
item_price = get_latest_price(item_code)
new_item_dict = {
'product_code': item_code,
'description': item_description,
'market_price': item_price,
'rental_price': item_rental_price
}
is_furniture = input("Is this item a piece of Furniture? (Y/N): ")
if is_furniture.lower() == "y":
item_material = input("Enter item material: ")
item_size = input("Enter item size (S,M,L,XL): ")
new_item = Furniture(material=item_material,
size=item_size,
**new_item_dict)
else:
is_electric_appliance = input("Is this item an electric appliance? \
(Y/N): ")
if is_electric_appliance.lower() == "y":
item_brand = input("Enter item brand: ")
item_voltage = input("Enter item voltage: ")
new_item = ElectricAppliances(brand=item_brand,
voltage=item_voltage,
**new_item_dict)
else:
new_item = Inventory(**new_item_dict)
FULL_INVENTORY.append(new_item)
print("New inventory item added")
def add_new_item():
"""add a new item into full inventory"""
item_code = input("Enter item code: ")
item_description = input("Enter item description: ")
item_rental_price = input("Enter item rental price: ")
# Get price from the market prices module
item_price = get_latest_price(item_code)
is_furniture = input("Is this item a piece of furniture? (Y/N): ")
if is_furniture.lower() == "y":
item_material = input("Enter item material: ")
item_size = input("Enter item size (S,M,L,XL): ")
new_item = Furniture(item_code, item_description,\
item_price, item_rental_price,\
item_material, item_size)
else:
is_electric_appliance = input("Is this item an electric appliance? (Y/N): ")
if is_electric_appliance.lower() == "y":
item_brand = input("Enter item brand: ")
item_voltage = input("Enter item voltage: ")
new_item = ElectricAppliances(item_code, item_description,\
item_price, item_rental_price, item_brand, item_voltage)
else:
new_item = Inventory(item_code, item_description, item_price, item_rental_price)
FULL_INVENTORY[item_code] = new_item.return_as_dictionary()
print("New inventory item added")
def test_main_integration(self):
"""Test all functions with main as a starting point"""
price = market_prices.get_latest_price(0)
#Adding non categorized inventory item with main
item1 = ['1', 'shoe', '1', 'n', 'n']
with patch('builtins.input', side_effect=item1):
main.add_new_item()
unintegrated_item1 = Inventory(['1', 'shoe', price, '1'])
#Adding furniture item with main
item2 = ['2', 'chair', '2', 'y', 'wood', 'S']
with patch('builtins.input', side_effect=item2):
main.add_new_item()
unintegrated_item2 = Furniture(['2', 'chair', price, '2'], 'wood', 'S')
#Adding electric appliance with main
item3 = ['3', 'stove', '3', 'n', 'y', 'LG', '100']
with patch('builtins.input', side_effect=item3):
main.add_new_item()
unintegrated_item3 = ElectricAppliances(['3', 'stove', price, '3'],
'LG', '100')
actual_inventory = main.return_full_inventory()
expected_inventory = {
'1': unintegrated_item1.return_as_dictionary(),
'2': unintegrated_item2.return_as_dictionary(),
'3': unintegrated_item3.return_as_dictionary()
}
self.assertEqual(actual_inventory, expected_inventory)
def setUp(self):
self.FULL_INVENTORY = {}
self.SIMPLE_INVENTORY = {}
# setup refrigerator in inventory
self.refrigerator = ElectricAppliances(product_code=1, description='refrigerator',
market_price=24, rental_price=15,
brand='kenmore', voltage=120)
refrigerator_output = self.refrigerator.return_as_dictionary()
item_code = refrigerator_output['product_code']
self.FULL_INVENTORY[item_code] = self.refrigerator.return_as_dictionary()
# setup sofa in inventory
self.sofa = Furniture(product_code=2, description='sofa',
market_price=24, rental_price=12,
material='leather', size='L')
sofa_output = self.sofa.return_as_dictionary()
item_code = sofa_output['product_code']
self.FULL_INVENTORY[item_code] = self.sofa.return_as_dictionary()
# setup a simple inventory to test class
self.simple_inventory = Inventory(product_code=1, description='refrigerator',
market_price=24, rental_price=15)
invetory_output = self.simple_inventory.return_as_dictionary()
item_code = invetory_output['product_code']
self.SIMPLE_INVENTORY[item_code] = invetory_output
# user inputs
self.update_inventory = [
[1, 'refrigerator', 15, 'n', 'y', 'kenmore', 120],
[2, 'sofa', 12, 'y', 'leather', 'L'],
[3, 'hops', 20, 'n', 'n']
]
def setUp(self):
self.item_chair = {}
self.item_microwave = {}
self.item_sofa = {}
self.full_inventory = {}
self.inventory_string = ''
self.item_chair['product_code'] = 100
self.item_chair['description'] = 'Chair'
self.item_chair['market_price'] = 111
self.item_chair['rental_price'] = 11
self.full_inventory[self.item_chair['product_code']] = \
Inventory(**self.item_chair).return_as_dictionary()
self.item_microwave['product_code'] = 200
self.item_microwave['description'] = 'Microwave'
self.item_microwave['market_price'] = 222
self.item_microwave['rental_price'] = 22
self.item_microwave['brand'] = 'Samsung'
self.item_microwave['voltage'] = 230
self.full_inventory[self.item_microwave['product_code']] = \
ElectricAppliances(**self.item_microwave).return_as_dictionary()
self.item_sofa['product_code'] = 300
self.item_sofa['description'] = 'Sofa'
self.item_sofa['market_price'] = 333
self.item_sofa['rental_price'] = 33
self.item_sofa['material'] = 'Leather'
self.item_sofa['size'] = 'XL'
self.full_inventory[self.item_sofa['product_code']] = \
Furniture(**self.item_sofa).return_as_dictionary()
for item_code in self.full_inventory:
for value in self.full_inventory[item_code].values():
self.inventory_string += f'{value}'
def setUp(self):
self.item_table = dict()
self.item_vacuum = dict()
self.item_bed = dict()
self.full_inventory = dict()
self.item_table['product_code'] = 1
self.item_table['description'] = 'Table'
self.item_table['market_price'] = 24
self.item_table['rental_price'] = 100
self.full_inventory[self.item_table['product_code']] = \
Inventory(**self.item_table).return_as_dictionary()
self.item_vacuum['product_code'] = 2
self.item_vacuum['description'] = 'Vacuum'
self.item_vacuum['market_price'] = 24
self.item_vacuum['rental_price'] = 200
self.item_vacuum['brand'] = 'Samsung'
self.item_vacuum['voltage'] = 110
self.full_inventory[self.item_vacuum['product_code']] = \
ElectricAppliances(**self.item_vacuum).return_as_dictionary()
self.item_bed['product_code'] = 300
self.item_bed['description'] = 'Bed'
self.item_bed['market_price'] = 24
self.item_bed['rental_price'] = 300
self.item_bed['material'] = 'Wood'
self.item_bed['size'] = 'L'
self.full_inventory[self.item_bed['product_code']] = \
Furniture(**self.item_bed).return_as_dictionary()
def test_init(self):
""" Test init """
test_inventory = Furniture(123, "chair", 100, 50, "wood", "m")
self.assertEqual(test_inventory.material, "wood")
self.assertEqual(test_inventory.size, "m")
def test_furniture_props(self):
"""Test to confirm proper storage of all usual product info,
and additional furniture info."""
trial_instance = Furniture('1111', 'product description', 200.00,
50.00, 'leather', 'queen')
self.assertEqual(trial_instance.material, 'leather')
self.assertEqual(trial_instance.size, 'queen')
def test_furniture_todict(self):
"""Test that Furniture returns as dictionary"""
fields = ("productCode", "description", "marketPrice", "rentalPrice",
"material", "size")
app = Furniture(*fields)
expected = {f: f for f in fields}
self.assertEqual(app.return_as_dictionary(), expected)
def add_furniture(item_code, item_description, item_price, item_rental_price,
item_material, item_size):
""" add furniture method to decouple UI/bus logic for unit test """
new_item = Furniture(item_code, item_description, item_price,
item_rental_price, item_material, item_size)
FULL_INVENTORY[item_code] = new_item.return_as_dictionary()
print("New inventory item added")
def setUp(self):
'''
create an instance from the Furniture class,
from furniture_class module
'''
self.furniture = Furniture('product03', 'description03', 555, 111,
'material01', 'M')
def setUp(self):
''' sets up objects to run tests against '''
self.FULL_INVENTORY = {}
self.SIMPLE_INVENTORY = {
4: {
'product_code': 4,
'description': 'television',
'market_price': 24,
'rental_price': 40,
'brand': 'samsung',
'voltage': 120
}
}
self.refrigerator = ElectricAppliances(product_code=1, description='refrigerator',
market_price=24, rental_price=15,
brand='kenmore', voltage=120)
refrigerator_output = self.refrigerator.return_as_dictionary()
item_code = refrigerator_output['product_code']
self.FULL_INVENTORY[item_code] = self.refrigerator.return_as_dictionary()
self.sofa = Furniture(product_code=2, description='sofa',
market_price=24, rental_price=12,
material='leather', size='L')
sofa_output = self.sofa.return_as_dictionary()
item_code = sofa_output['product_code']
self.FULL_INVENTORY[item_code] = self.sofa.return_as_dictionary()
self.update_inventory = [
[1, 'refrigerator', 15, 'n', 'y', 'kenmore', 120],
[2, 'sofa', 12, 'y', 'leather', 'L'],
[3, 'hops', 20, 'n', 'n'],
['1', 4, 'television', 40, 'n', 'y', 'samsung', 120],
['2', 'not_found']
]
def test_integration(self):
'''testing integration'''
# integrate market price
market_price = market_prices.get_latest_price(1)
#create a dict mocking items
item_one = ['1', 'Painting', '50', 'n', 'n']
item_two = ['2', 'Desk', '100', 'y', 'wood', 'L']
item_three = ['3', 'Washer', '200', 'n', 'y', 'Kenmore', '120']
with patch('builtins.input', side_effect=item_one):
main.add_new_item()
with patch('builtins.input', side_effect=item_two):
main.add_new_item()
with patch('builtins.input', side_effect=item_three):
main.add_new_item()
test_dict = {
'1': {
'product_code': '1',
'description': 'Painting',
'market_price': 24,
'rental_price': '50'
},
'2': {
'product_code': '2',
'description': 'Desk',
'market_price': 24,
'rental_price': '100',
'material': 'wood',
'size': 'L'
},
'3': {
'product_code': '3',
'description': 'Washer',
'market_price': 24,
'rental_price': '200',
'brand': 'Kenmore',
'voltage': '120'
}
}
# create items using the class modules
class_item_one = Inventory('1', 'Painting', market_price, '50')
class_item_two = Furniture('2', 'Desk', market_price, '100', 'wood',
'L')
class_item_three = ElectricAppliances('3', 'Washer', market_price,
'200', 'Kenmore', '120')
class_dict = {
'1': class_item_one.return_as_dictionary(),
'2': class_item_two.return_as_dictionary(),
'3': class_item_three.return_as_dictionary()
}
# compare the items built with the class modules with the mock test items
self.assertEqual(class_dict, test_dict)
def test_add_new_item_furniture(self):
"""Test can add new Furniture"""
menu = MainMenu()
capture_output(menu.add_new_item)
expected = Furniture("item-code", "item-desc", MainTests.MOCK_PRICE,
"rental-price", "material",
"L").return_as_dictionary()
self.assertEqual(menu.inventory, {"item-code": expected})
def test_return_dict(self):
"""calls the return_as_dictionary function on the Furniture class"""
furniture = Furniture("2222", "Chair", "$200", "$150", "Wood", "Small")
furniture_info = furniture.return_as_dictionary()
self.assertEqual(furniture_info, {'product_code': '2222', 'description': 'Chair',
'market_price': '$200', 'rental_price': '$150',
'material' : 'Wood', 'size' : 'Small'})
def setUp(self):
"""setUP Method to create instances of each class"""
self.inventory_1 = Inventory('1234', 'lamp', '45', '10')
self.inventory_1_dic = self.inventory_1.return_as_dictionary()
self.electric_appliances_1 =ElectricAppliances('4455', 'TV', '2200', '140','Samsung', '120')
self.electric_appliances_1_dic = self.electric_appliances_1.return_as_dictionary()
self.furniture_1 = Furniture('2020', 'sofa', '1200', '100', 'leather', '22x33x44')
self.furniture_1_dic = self.furniture_1.return_as_dictionary()
def test_return_as_dictionary(self):
""" Test the return as dictionary method """
test_inventory = Furniture(123, "chair", 100, 50, "wood",
"m").return_as_dictionary()
self.assertEqual(test_inventory['material'], 'wood')
self.assertEqual(test_inventory['size'], 'm')
def test_add_new_furniture(self):
Furniture = MagicMock(return_value=0)
new_item = Furniture(material='Wood', size='M', **item_info)
Furniture.assert_called_with(material='Wood', size='M',
product_code='12345',
description='refrigerator',
market_price='2100.00',
rental_price='140.00')
def new_furniture_item(item_code, item_description, item_price,
item_rental_price, item_material, item_size):
"""
Function to add a new furniture item to dictionary
"""
new_item = Furniture(item_code, item_description, item_price,
item_rental_price, item_material, item_size)
return new_item
def test_init(self):
Couch = Furniture(62, "Couch", 2000, 150, "Leather", "Sectional")
self.assertEqual(Couch.product_code, 62)
self.assertEqual(Couch.description, "Couch")
self.assertEqual(Couch.market_price, 2000)
self.assertEqual(Couch.rental_price, 150)
self.assertEqual(Couch.material, "Leather")
self.assertEqual(Couch.style, "Sectional")
def test_init(self):
item = Furniture("Wood", "M", **item_info)
self.assertEqual('12345', item.product_code)
self.assertEqual('refrigerator', item.description)
self.assertEqual('2100.00', item.market_price)
self.assertEqual('140.00', item.rental_price)
self.assertEqual('Wood', item.material)
self.assertEqual('M', item.size)
def test_init(self):
"""Check expected values at object init."""
test_obj = Furniture(*self.input)
self.assertEqual(test_obj.product_code, 'PC')
self.assertEqual(test_obj.description, 'D')
self.assertEqual(test_obj.market_price, 'MP')
self.assertEqual(test_obj.rental_price, 'RP')
self.assertEqual(test_obj.material, 'M')
self.assertEqual(test_obj.size, 'S')
def test_furniture_dict(self):
"""Test to confirm proper info translation to a dict."""
trial_instance = Furniture('1111', 'product description', 200.00, 50.00,
'leather', 'queen')
trial_instance_dict = trial_instance.return_as_dictionary()
self.assertEqual(trial_instance_dict, {'product_code': '1111',
'description': 'product description',
'market_price': 200.00, 'rental_price': 50.00,
'material': 'leather', 'size': 'queen'})
def test_init(self):
""" Test init """
chair = Furniture(123, "chair", 100, 50, "wood", "m")
self.assertEqual(chair.product_code, 123)
self.assertEqual(chair.description, "chair")
self.assertEqual(chair.market_price, 100)
self.assertEqual(chair.rental_price, 50)
self.assertEqual(chair.material, "wood")
self.assertEqual(chair.size, "m")
def setUp(self):
self.product_dict = {}
self.product_dict['product_code'] = 100
self.product_dict['description'] = 'Chair'
self.product_dict['market_price'] = 200
self.product_dict['rental_price'] = 50
self.product_dict['material'] = 'Leather'
self.product_dict['size'] = 'L'
self.chair = Furniture(**self.product_dict)
def test_return_as_dictionary(self):
Couch_dict = Furniture(62, "Couch", 2000, 150, "Leather",
"Sectional").return_as_dictionary()
self.assertEqual(Couch_dict['product_code'], 62)
self.assertEqual(Couch_dict['description'], "Couch")
self.assertEqual(Couch_dict['market_price'], 2000)
self.assertEqual(Couch_dict['rental_price'], 150)
self.assertEqual(Couch_dict['material'], "Leather")
self.assertEqual(Couch_dict['style'], "Sectional")
def test_return_dict(self):
"""Test return as dict func"""
test_obj = Furniture(1, 2, 3, 4, 5, 6).return_as_dictionary()
self.assertEqual(test_obj['product_code'], 1)
self.assertEqual(test_obj['description'], 2)
self.assertEqual(test_obj['market_price'], 3)
self.assertEqual(test_obj['rental_price'], 4)
self.assertEqual(test_obj['material'], 5)
self.assertEqual(test_obj['size'], 6)
def test_init(self):
"""Test init"""
test_obj = Furniture(1, 2, 3, 4, 5, 6)
self.assertEqual(test_obj.product_code, 1)
self.assertEqual(test_obj.description, 2)
self.assertEqual(test_obj.market_price, 3)
self.assertEqual(test_obj.rental_price, 4)
self.assertEqual(test_obj.material, 5)
self.assertEqual(test_obj.size, 6)
def test_furniture(self):
"""test out the furniture class"""
test = Furniture(17, 'desc', 354, 144, 'bronze', 'yuge')
self.assertEqual(test.return_as_dictionary(),
{'product_code': 17,
'description': 'desc',
'market_price': 354,
'rental_price': 144,
'material': 'bronze',
'size': 'yuge'})
