def test_return_as_dict_inventory():
"""Tests that inventory class returns the expected dictionary"""
product_dict = {}
product_dict['product_code'] = 100
product_dict['description'] = 'Chair'
product_dict['market_price'] = 200
product_dict['rental_price'] = 50
inventory = Inventory(**product_dict)
print(inventory.return_as_dictionary())
print(product_dict)
assert product_dict == inventory.return_as_dictionary()
def return_as_dictionary(self):
""" return electric appliance dictionary from the super class. """
elec_appliances = Inventory.return_as_dictionary(self)
elec_appliances['brand'] = self.brand
elec_appliances['voltage'] = self.voltage
return elec_appliances
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 return_as_dictionary(self):
""" method to return a complete info of furniture items as dict"""
output_dict = Inventory.return_as_dictionary(self)
output_dict['material'] = self.material
output_dict['size'] = self.size
return output_dict
def return_as_dictionary(self):
"""Return all inventory with furniture as a dictionary"""
output_dict = Inventory.return_as_dictionary(self)
output_dict['material'] = self.material
output_dict['size'] = self.size
return output_dict
def return_as_dictionary(self):
"""returns a dictionary containing product information"""
output_dict = Inventory.return_as_dictionary(self)
output_dict['brand'] = self.brand
output_dict['voltage'] = self.voltage
return output_dict
def test_inventory_dict(self):
"""Test to confirm proper info translation to a dict."""
trial_instance = Inventory('1111', 'product description', 200.00, 50.00)
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})
def return_as_dictionary(self):
""" return the electric appliance item as dictionary """
output_dict = Inventory.return_as_dictionary(self)
output_dict['brand'] = self.brand
output_dict['voltage'] = self.voltage
return output_dict
def return_as_dictionary(self):
"""return as dictionary"""
output_dict = Inventory.return_as_dictionary(self)
output_dict['brand'] = self.brand
output_dict['voltage'] = self.voltage
return output_dict
class InventoryTests(TestCase):
"""Test cases for Inventory class"""
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.inventory = Inventory(**self.product_dict)
def test_init(self):
"""Tests that inventory class initializes correctly"""
self.assertEqual(self.inventory.product_code,
self.product_dict['product_code'])
self.assertEqual(self.inventory.description,
self.product_dict['description'])
self.assertEqual(self.inventory.market_price,
self.product_dict['market_price'])
self.assertEqual(self.inventory.rental_price,
self.product_dict['rental_price'])
def test_return_as_dictionary(self):
"""Tests that inventory class returns the expected dictionary"""
self.assertEqual(self.product_dict,
self.inventory.return_as_dictionary())
def return_as_dictionary(self):
""" return the furniture item as dictionary """
output_dict = Inventory.return_as_dictionary(self)
output_dict['material'] = self.material
output_dict['size'] = self.size
return output_dict
def return_as_dictionary(self):
"""Return class info in a dict"""
output_dict = Inventory.return_as_dictionary(self)
output_dict['brand'] = self.brand
output_dict['voltage'] = self.voltage
return output_dict
def return_as_dictionary(self):
"""Return class info as dict."""
output_dict = Inventory.return_as_dictionary(self)
output_dict['material'] = self.material
output_dict['size'] = self.size
return output_dict
def test_return_dict(self):
"""calls the return_as_dictionary function on the inventory class"""
item = Inventory("1234", "Book", "$100", "$75")
item_info = item.return_as_dictionary()
self.assertEqual(item_info, {'product_code': '1234', 'description': 'Book',
'market_price': '$100', 'rental_price': '$75'})
def return_as_dictionary(self):
"""returns a dictionary containing product information"""
output_dict = Inventory.return_as_dictionary(self)
output_dict['material'] = self.material
output_dict['size'] = self.size
return output_dict
def test_return_as_dictionary(self):
chair = Inventory(1, 'brown', 25, 30)
test_dictionary = {
'product_code': 1,
'description': 'brown',
'market_price': 25,
'rental_price': 30
}
for key, value in test_dictionary.items():
self.assertEqual(test_dictionary[f'{key}'],
chair.return_as_dictionary()[f'{key}'])
self.assertEqual(dict, type(chair.return_as_dictionary()))
class inventoryClassTests(TestCase):
def setUp(self):
"""
Set up
"""
self.item = Inventory('100', 'couch', '500', '250')
def test_init(self):
"""
Tests initialization
"""
self.assertEqual(self.item.product_code, '100')
self.assertEqual(self.item.description, 'couch')
self.assertEqual(self.item.market_price, '500')
self.assertEqual(self.item.rental_price, '250')
def test_returnAsDictionary(self):
"""
Tests dictionary
"""
item_dict = self.item.return_as_dictionary()
self.assertIsInstance(item_dict, dict)
self.assertEqual(item_dict['product_code'], '100')
self.assertEqual(item_dict['description'], 'couch')
self.assertEqual(item_dict['market_price'], '500')
self.assertEqual(item_dict['rental_price'], '250')
def return_as_dictionary(self):
""" return a furniture dictionary from the parent class """
output_dict = Inventory.return_as_dictionary(self)
output_dict['material'] = self.material
output_dict['size'] = self.size
return output_dict
def return_as_dictionary(self):
"""Return all inventory with electric appliances as a dictionary"""
output_dict = Inventory.return_as_dictionary(self)
output_dict['brand'] = self.brand
output_dict['voltage'] = self.voltage
return output_dict
def return_as_dictionary(self):
""" method to return a complete info of electric items as dict"""
output_dict = Inventory.return_as_dictionary(self)
output_dict['brand'] = self.brand
output_dict['voltage'] = self.voltage
return output_dict
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_inventory(self):
"""tests the adding inventory item functionality"""
nintendo64 = Inventory('N64', 'Nintendo 64', 200, 75)
compare = {'productCode':'N64',
'description':'Nintendo 64',
'marketPrice':200,
'rentalPrice':75}
self.assertDictEqual(nintendo64.return_as_dictionary(), compare)
def test_inventory(self):
"""best the base inventory class"""
test = Inventory(0, 'desc', 1, 2)
self.assertEqual(test.return_as_dictionary(),
{'product_code': 0,
'description': 'desc',
'market_price': 1,
'rental_price': 2})
def return_as_dictionary(self):
""" Return inventory item to a dict """
output_dict = Inventory.return_as_dictionary(self)
output_dict['material'] = self.material
output_dict['size'] = self.size
return output_dict
def test_return_as_dict(self):
base_dict = Inventory('a', 'b', 100, 150)
dict_output = dict()
dict_output['productCode'] = 'a'
dict_output['description'] = 'b'
dict_output ['marketPrice'] = 100
dict_output ['rentalPrice'] = 150
self.assertDictEqual(base_dict.return_as_dictionary(), dict_output)
def return_as_dictionary(self):
"""Returns characteristics of electronic appliances as dict"""
output_dict = Inventory.return_as_dictionary(self)
output_dict['brand'] = self.brand
output_dict['voltage'] = self.voltage
return output_dict
def test_return_dict(self):
inv = Inventory(125, 'Test Item', 50, 80)
inv_dict = inv.return_as_dictionary()
test_dict = {'product_code': 125,
'description': 'Test Item',
'market_price': 50,
'rental_price': 80}
self.assertEqual(inv_dict, test_dict)
def test_inventory(self):
inv = {'product_code': '545',
'description': 'pan',
'market_price': 42.0,
'rental_price': 13.0}
details = ('545', 'pan', 42.0, 13.0)
inv_test = Inventory(*details)
self.assertEqual(inv, inv_test.return_as_dictionary())
def return_as_dictionary(self):
"""Returns characteristics of furniture as dict"""
output_dict = Inventory.return_as_dictionary(self)
output_dict['material'] = self.material
output_dict['size'] = self.size
return output_dict
def test_inventory(self):
inv_dict_test = {
'product_code': '555',
'description': 'black',
'market_price': 250,
'rental_price': 30
}
inv_dict = Inventory('555', 'black', 250, 30)
self.assertEqual(inv_dict_test, inv_dict.return_as_dictionary())
