class FurnitureClassTests(TestCase): '''tests for the furniture class module''' def setUp(self): '''creates a furniture object, a sofa''' self.sofa = Furniture(321, 'brown sofa', 300, 100, 'Faux Leather', 'Large') def test_init(self): '''tests init values for the sofa''' assert self.sofa.product_code == 321 assert self.sofa.description == 'brown sofa' assert self.sofa.market_price == 300 assert self.sofa.rental_price == 100 assert self.sofa.material == 'Faux Leather' assert self.sofa.size == 'Large' def test_return_as_dict(self): '''tests the return as dict method in class inventory''' sofa_dict = self.sofa.return_as_dictionary() assert sofa_dict == { 'product_code': 321, 'description': 'brown sofa', 'market_price': 300, 'rental_price': 100, 'material': 'Faux Leather', 'size': 'Large' }
class FurnitureTests(TestCase): """Test cases for Furniture 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.product_dict['material'] = 'Leather' self.product_dict['size'] = 'L' self.chair = Furniture(**self.product_dict) def test_init(self): """Tests that furniture class initializes correctly""" self.assertEqual(self.chair.product_code, self.product_dict['product_code']) self.assertEqual(self.chair.description, self.product_dict['description']) self.assertEqual(self.chair.market_price, self.product_dict['market_price']) self.assertEqual(self.chair.rental_price, self.product_dict['rental_price']) self.assertEqual(self.chair.material, self.product_dict['material']) self.assertEqual(self.chair.size, self.product_dict['size']) def test_return_as_dictionary(self): """Tests that furniture class returns the expected dictionary""" self.assertEqual(self.product_dict, self.chair.return_as_dictionary())
class inventory_test(TestCase): """unit test for inventory and its sub classes""" def setUp(self): """set up instance of each sub class""" self.furniture = Furniture(100, "test chair", 20, (1.5, "day"), "wood", "Large") self.appliance = ElectricAppliances(200, "test lamp", 30, (2.5, "day"), "basic", "110V") self.appliance_expected_output = { "product_code": 200, "description": "test lamp", "market_price": 30, "rental_price": (2.5, "day"), "brand": "basic", "voltage": "110V", } self.furniture_expected_output = { "product_code": 100, "description": "test chair", "market_price": 20, "rental_price": (1.5, "day"), "material": "wood", "size": "Large", } def test_electric_appliances(self): self.assertDictEqual(self.appliance.return_as_dictionary(), self.appliance_expected_output) def test_furniture(self): self.assertDictEqual(self.furniture.return_as_dictionary(), self.furniture_expected_output)
class furnitureClassTests(TestCase): """ Tests furniture class """ def setUp(self): """ Set up """ self.item = Furniture('100', 'couch', '500', '250', material='wool', size='10') def test_init(self): """ Tests initialization """ self.assertIsInstance(self.item, (Inventory, Furniture)) self.assertEqual(self.item.material, 'wool') self.assertEqual(self.item.size, '10') def test_returnAsDictionary(self): """ Tests returning as 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') self.assertEqual(item_dict['material'], 'wool') self.assertEqual(item_dict['size'], '10')
class FurnitureTests(TestCase): """ Unit Tests for Furniture Module. """ def setUp(self): self.furniture = Furniture("sophie", "loaphie", -34, 2000, "stuff", 2) def test_furniture_variables(self): """ Validates setting the variables of a Furniture object. """ self.assertEqual("sophie", self.furniture.product_code) self.assertEqual("loaphie", self.furniture.description) self.assertEqual(-34, self.furniture.market_price) self.assertEqual(2000, self.furniture.rental_price) self.assertEqual("stuff", self.furniture.material) self.assertEqual(2, self.furniture.size) def test_furniture_as_dictionary(self): """ Validates Return As Dictionary method of an Furniture object. """ furniture_dict = self.furniture.return_as_dictionary() self.assertEqual("sophie", furniture_dict.get("product_code")) self.assertEqual("loaphie", furniture_dict.get("description")) self.assertEqual(-34, furniture_dict.get("market_price")) self.assertEqual(2000, furniture_dict.get("rental_price")) self.assertEqual("stuff", furniture_dict.get("material")) self.assertEqual(2, furniture_dict.get("size"))
class FurnitureTests(TestCase): """ To test Furniture class and method. """ def setUp(self): self.product_code = 23 self.description = "Table" self.market_price = get_latest_price(self.product_code) self.rental_price = 23 self.material = "Wood" self.size = "L" self.furniture = Furniture(self.product_code, self.description, self.market_price, self.rental_price, self.material, self.size) def test_return_as_dictionary_call2(self): """ This """ dict_result = self.furniture.return_as_dictionary() expected_dict = {} expected_dict['product_code'] = 23 expected_dict['description'] = "Table" expected_dict['market_price'] = 24 expected_dict['rental_price'] = 23 expected_dict['material'] = "Wood" expected_dict['size'] = "L" self.assertEqual(expected_dict, dict_result)
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 test_return_as_dict_furniture(): """Tests that furniture 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 product_dict['material'] = 'Leather' product_dict['size'] = 'L' chair = Furniture(**product_dict) print(chair.return_as_dictionary()) print(product_dict) assert product_dict == chair.return_as_dictionary()
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")
class FurnitureTests(unittest.TestCase): """Contains all the tests for the Furniture Class.""" 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 test_init(self): """Test we can initialize a piece of Furniture properly.""" # test chair with no material or size self.assertEqual(self.chair.size, "N/A") self.assertEqual(self.chair.material, "N/A") # test chair with material and size defined self.assertEqual(self.chair2.size, "small") self.assertEqual(self.chair2.material, "Leather") def test_return_as_dict(self): """Test dictionary function for extended furniture needs.""" chair2_dict = self.chair2.return_as_dictionary() self.assertIsInstance(chair2_dict, dict) self.assertEqual(chair2_dict["size"], "small") self.assertEqual(chair2_dict["material"], "Leather")
class FurnitureTest(TestCase): '''unittest the Furniture class under the furniture_class module''' def setUp(self): ''' create an instance from the Furniture class, from furniture_class module ''' self.furniture = Furniture('product03', 'description03', 555, 111, 'material01', 'M') def test_furniture(self): self.assertEqual('product03', self.furniture.product_code) self.assertEqual('description03', self.furniture.description) self.assertEqual(555, self.furniture.market_price) self.assertEqual(111, self.furniture.rental_price) self.assertEqual('material01', self.furniture.material) self.assertEqual('M', self.furniture.size) def test_furniture_dict(self): self.assertEqual( { 'product_code': 'product03', 'description': 'description03', 'market_price': 555, 'rental_price': 111, 'material': 'material01', 'size': 'M' }, self.furniture.return_as_dictionary())
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 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_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_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 test_return_as_dictionary(self): couch = Furniture(3, 'comfy', 500, 600, 'leather', 'M') test_dictionary = { 'product_code': 3, 'description': 'comfy', 'market_price': 500, 'rental_price': 600, 'material': 'leather', 'size': 'M' } for key, value in test_dictionary.items(): self.assertEqual(value, couch.return_as_dictionary()[f'{key}']) self.assertEqual(dict, type(couch.return_as_dictionary()))
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_return_dict(self): furn = Furniture(54, 'Test Elec', 200, 300, 'leather', 10) furn_dict = furn.return_as_dictionary() test_dict = {'product_code': 54, 'description': 'Test Elec', 'market_price': 200, 'rental_price': 300, 'material': 'leather', 'size': 10} self.assertEqual(furn_dict, test_dict)
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'})
def test_return_as_dict_fur(self): input_dict = Furniture('a', 'b', 100, 150, 'm', 'z') dict_output = dict() dict_output['productCode'] = 'a' dict_output['description'] = 'b' dict_output['marketPrice'] = 100 dict_output['rentalPrice'] = 150 dict_output['material'] = 'm' dict_output['size'] = 'z' self.assertDictEqual(input_dict.return_as_dictionary(),dict_output)
def test_furniture(self): furn = {'product_code': '0455', 'description': 'couch', 'market_price': 280.0, 'rental_price': 30.0, 'material': 'leather', 'size': 'L'} details = ('0455', 'couch', 280.0, 30.0, 'leather', 'L') furn_test = Furniture(*details) self.assertEqual(furn, furn_test.return_as_dictionary())
def test_furniture(self): """tests the furniture item functionality""" couch = Furniture('C74', 'IKEA Malmer Couch', 24, 125, 'Leather', 'L') compare = {'productCode':'C74', 'description':'IKEA Malmer Couch', 'marketPrice':24, 'rentalPrice':125, 'material':'Leather', 'size':'L'} self.assertDictEqual(couch.return_as_dictionary(), compare)
def test_furniture(self): furn_dict_test = { 'product_code': '555', 'description': 'black', 'market_price': 250, 'rental_price': 30, 'material': 'wood', 'size': 's' } furn_dict = Furniture('555', 'black', 250, 30, 'wood', 's') self.assertEqual(furn_dict_test, furn_dict.return_as_dictionary())
def test_furniture(self): f = Furniture('X55', 'Red couch', 120, 20, 'Cloth', 'XL') f_dict = f.return_as_dictionary() assert f_dict == { 'product_code': 'X55', 'description': 'Red couch', 'market_price': 120, 'rental_price': 20, 'material': 'Cloth', 'size': 'XL' }
def test_furniture(self): f = { 'product_code': '200', 'description': 'beanbag', 'market_price': 600.0, 'rental_price': 100.0, 'material': 'faux fur', 'size': 'L' } d = ('200', 'beanbag', 600.0, 100.0, 'faux fur', 'L') test = Furniture(*d) self.assertEqual(f, test.return_as_dictionary())
def test_furniture(self): furniture = Furniture(2, 'Chair', 25, 10, 'Leather', 'S') furniture_dict_test = furniture.return_as_dictionary() self.assertEqual( furniture_dict_test, { 'product_code': 2, 'description': 'Chair', 'market_price': 25, 'rental_price': 10, 'material': 'Leather', 'size': 'S' })
def test_furniture(self): test_furn = Furniture(1234, "test product", 567, 246, "wood", "L") self.assertIsInstance(test_furn, Furniture) test_furn_dict = { "product_code": 1234, "description": "test product", "market_price": 567, "rental_price": 246, "material": "wood", "size": "L" } self.assertDictEqual(test_furn_dict, test_furn.return_as_dictionary())
def test_furniture(self): ''' furniture test''' furniture = Furniture('Code3', 'Item3 Test', 30, 3, 'Leather', 'small') self.assertAlmostEqual( furniture.return_as_dictionary(), { 'product_code': 'Code3', 'description': 'Item3 Test', 'market_price': 30, 'rental_price': 3, 'material': 'Leather', 'size': 'small' })
def test_return_as_dict(self): furniture = Furniture(1, "item", 5, 5, "material", "XL") test_dict = { 'product_code': 1, 'description': "item", 'market_price': 5, 'rental_price': 5, 'material': "material", 'size': "XL" } self.assertEqual(test_dict, furniture.return_as_dictionary())
def test_furniture(self): """Tests the creation of an instance for furniture object""" test_dict = { 'product_code': 1011, 'description': 'SuperToy', 'market_price': 50, 'rental_price': 10, 'material': 'Leather', 'size': 'Large' } test_furn = Furniture(1011, 'SuperToy', 50, 10, 'Leather', 'Large') self.assertEqual(test_dict, test_furn.return_as_dictionary())