def test_item_info(self):
"""Tests that item_info returns expected values"""
expected_return = (f'product_code:100\n'
f'description:Chair\n'
f'market_price:100\n'
f'rental_price:20\n')
FULL_INVENTORY['100'] = {
'product_code': '100',
'description': 'Chair',
'market_price': '100',
'rental_price': '20'
}
user_input = ['100']
with patch('builtins.input', side_effect=user_input):
with captured_output() as out:
item_info()
output = out.getvalue()
self.assertEqual(output, expected_return)
user_input = ['200']
with patch('builtins.input', side_effect=user_input):
with captured_output() as out:
item_info()
output = out.getvalue()
self.assertEqual(output, 'Item not found in inventory\n')
def test_get_item_info_not_present(self):
"""Tests the get_item_info function when the item is not in inventory."""
expected_print = ("Item not found in inventory.")
with patch('builtins.input', return_value='F-20'), \
patch('sys.stdout', new=StringIO()) as captured_output:
main.item_info()
self.assertEqual(captured_output.getvalue().strip(), expected_print)
def test_item_info(monkeypatch):
"""Tests that item_info returns expected values"""
expected_return = (f'product_code:100\n'
f'description:Chair\n'
f'market_price:100\n'
f'rental_price:20\n')
FULL_INVENTORY['100'] = {
'product_code': '100',
'description': 'Chair',
'market_price': '100',
'rental_price': '20'
}
monkeypatch.setattr('builtins.input', lambda x: '100')
with captured_output() as out:
item_info()
output = out.getvalue()
print(output)
print(expected_return)
assert output == expected_return
monkeypatch.setattr('builtins.input', lambda x: '200')
with captured_output() as out:
item_info()
output = out.getvalue()
print(output)
print(expected_return)
assert output == 'Item not found in inventory\n'
def test_item_info(self):
mock_input = [
12, "test_description", 15, 'n', 'y', "test_brand", '34kw'
]
with unittest.mock.patch('builtins.input', side_effect=mock_input):
main.add_new_item()
self.assertIn(12, main.full_inventory)
new_dict = main.full_inventory[12]
self.assertEqual("test_description", new_dict['description'])
self.assertEqual(15, new_dict['rental_price'])
self.assertEqual("test_brand", new_dict['brand'])
self.assertEqual('34kw', new_dict['voltage'])
with unittest.mock.patch('builtins.input', side_effect=mock_input):
main.item_info()
test2 = {
'product_code': 12,
'description': 'test_description',
'market_price': 24,
'rental_price': 15,
'brand': 'test_brand',
'voltage': '34kw'
}
def test_item_info_no_input(self, mock_management):
mock_management.get_item = MagicMock(return_value={"test_key": "test_val"})
with mock.patch('main.safe_input', return_value='my_test_value'):
with captured_output() as (out, err):
main.item_info()
result = out.getvalue().strip()
self.assertEqual(result, "test_key:test_val")
def test_item_info(self):
"""Test the item_info() method"""
with patch('builtins.input', side_effect=['DISH2K']):
#Test the valid key case
self.assertEqual(None, main.item_info())
with patch('builtins.input', side_effect=['DISH3K']):
#Test the invalid key case
self.assertEqual(None, main.item_info())
def test_get_item_info_present(self):
"""Tests the get_item_info function when the item is in inventory."""
expected_print = ('description: Dining Table\nmarket_price: 24\nmaterial: Wood\n'
'product_code: F-22\nrental_price: 45.0\nsize: L')
with patch('builtins.input', return_value='F-22'), \
patch('sys.stdout', new=StringIO()) as captured_output:
main.item_info()
self.assertEqual(captured_output.getvalue().strip(), expected_print)
def test_item_info(self):
"""Tests item info"""
furniture_input = ('01', 'Couch', 100, 'y', 'leather', 'M')
with patch('builtins.input', side_effect=furniture_input):
add_new_item()
with patch('builtins.input', side_effect=['01']):
self.assertEqual(item_info(), None)
with patch('builtins.input', side_effect=['02']):
self.assertEqual(item_info(), None)
def test_item_info(self):
main.FULL_INVENTORY.clear()
with patch('builtins.input',
side_effect=[
'123', 'RiceCooker', '5.99', 'n', 'y', 'GE', '220'
]):
main.add_new_item()
with patch('builtins.input', side_effect=['123']):
self.assertEqual(main.item_info(), True)
with patch('builtins.input', side_effect=['456']):
self.assertEqual(main.item_info(), False)
def test_integration(self):
"""Test the integrated application"""
with patch('builtins.input', side_effect=['1']):
self.assertEqual(main.main_menu(), main.add_new_item)
expected_inventory = {
'64': {
'item_code': '64',
'description': 'Nintendo 64',
'market_price': 24,
'rental_price': '5.64'
},
'WD': {
'item_code': 'WD',
'description': 'Combo washer/dryer',
'market_price': 24,
'rental_price': '13.75',
'brand': 'Baytag',
'voltage': '240V'
},
'DINTAB': {
'item_code': 'DINTAB',
'description': 'Dining table',
'market_price': 24,
'rental_price': '7.99',
'material': 'Stainless steel',
'size': 'L'
}
}
with patch('builtins.input',
side_effect=['64', 'Nintendo 64', '5.64', 'n', 'n']):
main.add_new_item()
with patch('builtins.input',
side_effect=[
'WD', 'Combo washer/dryer', '13.75', 'n', 'y', 'Baytag',
'240V'
]):
main.add_new_item()
with patch('builtins.input',
side_effect=[
'DINTAB', 'Dining table', '7.99', 'y',
'Stainless steel', 'L'
]):
main.add_new_item()
self.assertEqual(expected_inventory, main.INVENTORY_DATA)
with patch('builtins.input', side_effect=['2']):
self.assertEqual(main.main_menu(), main.item_info)
expected_item_info = """Enter item code: 64
item_code:64
description:Nintendo 64
market_price:24
rental_price:5.64"""
with patch('builtins.input', side_effect=['64']):
self.assertEqual(main.item_info(), print(expected_item_info))
with patch('builtins.input', side_effect=['q']):
self.assertEqual(main.main_menu(), main.exit_program)
def test_item_info(self):
f_inventory = {}
text_trap = io.StringIO()
sys.stdout = text_trap
user_input = ["1"]
with patch('builtins.input', side_effect=user_input):
check_f_inventory = item_info(f_inventory)
self.assertEqual(f_inventory, check_f_inventory)
def item_info(self, test_dict):
test_dict = {}
text_trap = io.StringIO()
sys.stdout = text_trap
user_input = ['123']
with patch('builtins.input', side_effect=user_input):
test_dict = item_info()
return test_dict
def item_info(self,f_inventory):
f_inventory={}
text_trap = io.StringIO()
sys.stdout = text_trap
user_input=["1"]
with patch('builtins.input', side_effect=user_input):
f_inventory=item_info(f_inventory)
return f_inventory
def test_item_info(self):
""" Verify that item_info function properly calls existing items """
example_item = ('45', 'lamp', 10, 'n', 'n', 'n')
example_string = 'product_code:45\n'\
'description:lamp\n'\
'market_price:24\n'\
'rental_price:10\m'
with patch('builtins.input', side_effect=example_item):
add_new_item()
with patch('builtins.input', side_effect=('45', )):
self.assertEqual(item_info(), print(example_string))
""" Verify that item_info function properly identifies non-existing items """
example_failed_string = 'Item not found in inventory'
with patch('builtins.input', side_effect=('1000', )):
self.assertEqual(item_info(), print(example_failed_string))
def test_item_info(self, mock_get_input):
mock_get_input.side_effect = [
101, 'item 101 desc', 100, 'y', 'item 101 matl', 'S', ""
]
add_new_item()
mock_get_input.side_effect = [101]
item_output = item_info()
self.assertTrue(item_output.startswith('product_code:101'))
self.assertIn('item 101 desc', item_output)
def test_item_info(self, mock_get_input):
mock_get_input.side_effect = [
"C555", "electric stove", 300.00, "n", "y", "Kenmore", "150 V", ""
]
add_new_item()
mock_get_input.side_effect = ["C555"]
item_output = item_info()
self.assertTrue(item_output.startswith('product_code: C555'))
self.assertIn('electric stove', item_output)
def test_menu_info(self):
'''
Testing number 2
'''
while True:
try:
with patch('builtins.input', side_effect='2'):
self.assertEqual(main_menu(), main.item_info())
except StopIteration as error_code:
return error_code
def test_item_info(self):
"""Tests :py:func:`main.item_info`"""
out1 = {1: 'a', 2: 'b'}
out2 = {3: 'c', 4: 'd'}
main.FULLINVENTORY = {'abc': out1, 'def': out2}
with mock.patch("builtins.print") as print_mock, mock.patch(
"builtins.input") as input_mock:
input_mock.return_value = "abc"
main.item_info()
for k, val in out1.items():
print_mock.assert_any_call(f"{k}:{val}")
with mock.patch("builtins.print") as print_mock, mock.patch(
"builtins.input") as input_mock:
input_mock.return_value = "def"
main.item_info()
for k, val in out2.items():
print_mock.assert_any_call(f"{k}:{val}")
with mock.patch("builtins.print") as print_mock, mock.patch(
"builtins.input") as input_mock:
input_mock.return_value = "ghi"
main.item_info()
print_mock.assert_called_with("Item not found in inventory")
def test_item_info(self):
"""
Testing main.item_info by adding an item to FULL_INVENTORY, calling
item_info with its item_code, and capturing item_info's print statements
to verify their accuracy.
"""
main.FULL_INVENTORY = {}
inputs = (user_in for user_in in [999, 'Vase', 1400, 'n', 'n'])
def mock_input(prompt):
return next(inputs)
with patch('builtins.input', mock_input):
main.add_new_item()
expected_output = ('product_code:999\n'
'description:Vase\n'
'market_price:24\n'
'rental_price:1400\n')
expected_output2 = "Item not found in inventory\n"
captured_output = io.StringIO()
sys.stdout = captured_output
main.item_info(999)
sys.stdout = sys.__stdout__
self.assertEqual(expected_output, captured_output.getvalue())
captured_output2 = io.StringIO()
sys.stdout = captured_output2
main.item_info(432)
sys.stdout = sys.__stdout__
self.assertEqual(expected_output2, captured_output2.getvalue())
def test_item_info(self):
"""Test item info """
test_data = ['1', 'dining', '50', 'y', 'glass', 'L']
with patch('builtins.input', side_effect=test_data):
main.add_new_item()
test_item_code = 1
with patch('builtins.input', side_effect='2'):
actual_output = main.item_info()
expected_output = '''product_code:1
description:dining
market_price:24
rental_price:50
material:glass
size:L'''
self.assertNotEqual(actual_output, expected_output)
test_inventory_dict = dict()
test_inventory_dict['product_code'] = 100
test_inventory_dict['description'] = "chair"
test_inventory_dict['market_price'] = "24"
test_inventory_dict['rental_price'] = 40
with patch.dict("main.FULL_INVENTORY", {"5": test_inventory_dict}):
with patch('builtins.input', side_effect='5'):
with patch('main.print') as mock_print:
main.item_info()
mock_print.assert_called_with('''rental_price:40''')
test_inventory_dict_2 = dict()
test_inventory_dict_2['product_code'] = 2
test_inventory_dict_2['description'] = "dining_table_description"
test_inventory_dict_2['market_price'] = "34"
test_inventory_dict_2['rental_price'] = 500
with patch.dict("main.FULL_INVENTORY", {"2": test_inventory_dict_2}):
with patch('builtins.input', side_effect='4'):
with patch('main.print') as mock_print:
main.item_info()
mock_print.assert_called_once_with(
"Item not found in inventory")
def test_is_a_record(self):
with patch('builtins.input', side_effect=['789']):
main.FULL_INVENTORY = {
'789': {
'description': 'test',
'market_price': 24,
'item_code': '789',
'rental_price': 5
}
}
self.assertEqual(
main.item_info(),
print('description:test\n'
'market_price:24\n'
'item_code:789\n'
'rental_price:5'))
def test_item_info(self):
"""Test item info """
test_data = ['1', 'dining', '50', 'y', 'glass', 'L']
with patch('builtins.input', side_effect=test_data):
main.add_new_item()
print(main.FULL_INVENTORY)
test_item_code = 1
with patch('builtins.input', side_effect='2'):
actual_output = main.item_info()
print("nub")
print(actual_output)
expected_output = '''product_code:1
description:dining
market_price:24
rental_price:50
material:glass
size:L'''
self.assertNotEqual(actual_output, expected_output)
def test_main_menu(self):
f_inventory={}
user_input = ["1"]
text_trap = io.StringIO()
sys.stdout = text_trap
with patch('builtins.input', side_effect=user_input):
function = main_menu()
if function.__name__=="add_new_item":
f_inventory=self.add_new_item_furniture(f_inventory)
user_input = ["2"]
with patch('builtins.input', side_effect=user_input):
function = main_menu()
if function.__name__=="item_info":
f_inventory=item_info(f_inventory)
user_input = ["q"]
with patch('builtins.input', side_effect=user_input):
function = main_menu()
if function.__name__=="exit_program":
self.assertRaises(SystemExit, exit_program, f_inventory)
def test_item_info_returned_value(self, mock_management):
mock_management.get_item = MagicMock(return_value={"test_key": "test_val"})
with captured_output() as (out, err):
main.item_info("test")
result = out.getvalue().strip()
self.assertEqual(result, "test_key:test_val")
def test_item_info(self):
"""Tests if item_info gets returned"""
input4 = [1]
with patch('builtins.input', side_effect=input4):
item = item_info()
self.assertEqual(item, None)
def test_item_information(self):
"""Tests if item_info gets returned"""
input1 = [1]
with patch('builtins.input', side_effect=input1):
self.assertEqual(item_info(), None)
def test_intem_info_not_in_dict(self, mock_item_info):
self.assertEqual(item_info(), "Item not found in inventory")
def test_item_info(self):
user_input = [1, 2]
with patch('builtins.input', side_effect=user_input):
item = item_info()
self.assertNotEqual(item, "Item not found in inventory")
def test_item_info_not_found(self, mock_management):
mock_management.get_item = MagicMock(return_value=None)
with captured_output() as (out, err):
main.item_info("test")
result = out.getvalue().strip()
self.assertEqual(result, "Item not found in inventory")
def test_is_no_record(self):
with patch('builtins.input', side_effect=['69']):
main.FULL_INVENTORY = {}
self.assertEqual(main.item_info(),
print("Item not found in inventory"))
