def test_repr_method(self):
paint_f = PaintFactory('test', 20)
paint_f.add_ingredient('red', 10)
expected_output = f"Factory name: {paint_f.name} with capacity {paint_f.capacity}.\n"
for key, value in paint_f.ingredients.items():
expected_output += f"{key}: {value}\n"
self.assertEqual(paint_f.__repr__(), expected_output)
def test_remove_raise_error_if_quantity_bigger(self):
pfac = PaintFactory('pfac', 3)
pfac.add_ingredient('white', 2)
with self.assertRaises(ValueError) as cm:
pfac.remove_ingredient('white', 3)
self.assertEqual(str(cm.exception),
"Ingredient quantity cannot be less than zero")
def test_add_ingredients_sets_new_ingredients_types_quantities_to_given_quantities(
self):
test_paint_factory = PaintFactory("Charley's", 10)
test_paint_factory.add_ingredient("white", 2)
test_paint_factory.add_ingredient("blue", 3)
self.assertEqual(test_paint_factory.ingredients["white"], 2)
self.assertEqual(test_paint_factory.ingredients["blue"], 3)
def test_remove_raise_error_if_ingredient_not_in(self):
pfac = PaintFactory('pfac', 3)
pfac.add_ingredient('white', 2)
with self.assertRaises(KeyError) as cm:
pfac.remove_ingredient('blue', 1)
self.assertEqual("'No such ingredient in the factory'",
str(cm.exception))
def test_can_add_method(self):
paint_f = PaintFactory('test', 20)
paint_f.add_ingredient('red', 5)
self.assertIn('red', paint_f.ingredients.keys())
with self.assertRaises(ValueError) as ex:
paint_f.add_ingredient('red', 20)
self.assertEqual(str(ex.exception), "Not enough space in factory")
def test_add_ingredient_raise_error_if_ingreient_not_valid(self):
pfac = PaintFactory('pfac', 2)
with self.assertRaises(TypeError) as cm:
pfac.add_ingredient('cghfg', 1)
self.assertEqual(
str(cm.exception),
"Ingredient of type cghfg not allowed in PaintFactory")
def test_remove_ingredient_raises_error_when_not_enough_quantity_of_remaining_product_to_be_removed(
self):
test_paint_factory = PaintFactory("Charley's", 10)
test_paint_factory.add_ingredient("white", 5)
with self.assertRaises(ValueError) as context:
test_paint_factory.remove_ingredient("white", 7)
self.assertEqual(str(context.exception),
"Ingredient quantity cannot be less than zero")
def test_remove_ingredient_raises_error_when_no_such_product_to_be_removed(
self):
test_paint_factory = PaintFactory("Charley's", 10)
test_paint_factory.add_ingredient("white", 5)
with self.assertRaises(KeyError) as context:
test_paint_factory.remove_ingredient("black", 7)
self.assertEqual(str(context.exception),
"'No such ingredient in the factory'")
def test_add_ingredient_raises_exception_when_wrong_ingredient_type_given(
self):
test_paint_factory = PaintFactory("Charley's", 10)
with self.assertRaises(TypeError) as context:
test_paint_factory.add_ingredient("banana", 2)
self.assertEqual(
str(context.exception),
"Ingredient of type banana not allowed in PaintFactory")
def test_remove_ingredient(self):
paint_f = PaintFactory('test', 20)
paint_f.add_ingredient('red', 5)
paint_f.remove_ingredient('red', 2)
self.assertEqual(paint_f.ingredients['red'], 3)
with self.assertRaises(KeyError) as ex:
paint_f.remove_ingredient('sd', 2)
self.assertEqual(str(ex.exception),
"'No such ingredient in the factory'")
with self.assertRaises(ValueError) as ex:
paint_f.remove_ingredient('red', 10)
self.assertEqual(str(ex.exception),
"Ingredient quantity cannot be less than zero")
def test_products(self):
pfac = PaintFactory('pfac', 3)
pfac.add_ingredient('yellow', 1)
pfac.add_ingredient('white', 1)
pfac.add_ingredient('blue', 1)
actual = pfac.products
expected = {'blue': 1, 'white': 1, 'yellow': 1}
self.assertEqual(expected, actual)
def test_add_ingredient(self):
paint_f = PaintFactory('test', 20)
paint_f.add_ingredient('red', 5)
self.assertIn('red', paint_f.ingredients)
self.assertEqual(paint_f.ingredients['red'], 5)
with self.assertRaises(TypeError) as ex:
paint_f.add_ingredient('sd', 5)
self.assertEqual(str(ex.exception),
f"Ingredient of type sd not allowed in PaintFactory")
with self.assertRaises(ValueError) as ex:
paint_f.add_ingredient('red', 20)
self.assertEqual(str(ex.exception), "Not enough space in factory")
class TestPaintFactory(unittest.TestCase):
def setUp(self):
self.fabrika = PaintFactory('Qica', 2500)
def test_one(self):
result = (self.fabrika.name, self.fabrika.capacity,
self.fabrika.ingredients)
expected = ('Qica', 2500, {})
self.assertEqual(result, expected)
def test_two(self):
with self.assertRaises(TypeError):
self.fabrika.add_ingredient('test', 2000)
with self.assertRaises(ValueError):
self.fabrika.add_ingredient('white', 3000)
self.fabrika.add_ingredient('white', 5)
self.assertEqual(self.fabrika.products, {'white': 5})
self.assertEqual(self.fabrika.capacity, 2495)
def test_three(self):
with self.assertRaises(KeyError):
self.fabrika.remove_ingredient('test', 5)
self.fabrika.add_ingredient('white', 5)
with self.assertRaises(ValueError):
self.fabrika.remove_ingredient('white', 6)
self.fabrika.remove_ingredient('white', 2)
self.assertEqual(self.fabrika.products, {'white': 3})
def test_four(self):
self.assertFalse(self.fabrika.can_add(5000))
self.assertTrue(self.fabrika.can_add(10))
class TestPaintFactory(unittest.TestCase):
def setUp(self) -> None:
self.factory = PaintFactory(name='Sharo', capacity=5)
def test_paint_factory_if_all_attributes_are_set_correctly(self):
self.assertEqual('Sharo', self.factory.name)
self.assertEqual(5, self.factory.capacity)
self.assertEqual({}, self.factory.ingredients)
self.assertEqual({}, self.factory.products)
# self.assertEqual(["white", "yellow", "blue", "green", "red"], self.factory.valid_ingredients)
def test_paint_factory_add_ingredient_if_is_NOT_in_ingredients_list(self):
with self.assertRaises(Exception) as ex:
self.factory.add_ingredient('pink', 5)
self.assertEqual("Ingredient of type pink not allowed in PaintFactory", str(ex.exception))
def test_paint_factory_add_ingredient_if_capacity_is_NOT_enough(self):
with self.assertRaises(Exception) as ex:
self.factory.add_ingredient('white', 10)
self.assertEqual("Not enough space in factory", str(ex.exception))
def test_paint_factory_add_ingredient_if_ingredient_type_NOT_in_ingredients_dict(self):
self.assertTrue('white' not in self.factory.ingredients)
self.factory.add_ingredient('white', 3)
self.assertTrue('white' in self.factory.ingredients)
self.assertEqual(3, self.factory.ingredients['white'])
def test_paint_factory_remove_ingredient_if_ingredient_type_NOT_in_ingredients_dict(self):
with self.assertRaises(Exception) as ex:
self.factory.remove_ingredient('white', 3)
self.assertEqual("'No such ingredient in the factory'", str(ex.exception))
def test_paint_factory_remove_ingredients_if_quantity_is_bigger_than_capacity(self):
self.factory.ingredients['white'] = 5
with self.assertRaises(Exception) as ex:
self.factory.remove_ingredient('white', 6)
self.assertEqual("Ingredients quantity cannot be less than zero", str(ex.exception))
def test_paint_factory_remove_ingredients_if_all_conditions_are_covered(self):
self.factory.ingredients['white'] = 5
self.factory.remove_ingredient('white', 3)
self.assertEqual(2, self.factory.ingredients['white'])
class TestPaintFactory(unittest.TestCase):
def setUp(self):
self.paint_factory = PaintFactory("PF", 100)
def test__init(self):
self.assertEqual(self.paint_factory.name, "PF")
self.assertEqual(self.paint_factory.capacity, 100)
self.assertEqual(self.paint_factory.ingredients, {})
self.assertEqual(self.paint_factory.valid_ingredients,
["white", "yellow", "blue", "green", "red"])
def test__prop_products__return_ingredients_dict(self):
self.assertEqual(self.paint_factory.products, {})
def test__add_ingredient__non_type__raise_type_error(self):
with self.assertRaises(TypeError) as te:
self.paint_factory.add_ingredient("magenta", 100)
expected_msg = str(te.exception)
actual_msg = "Ingredient of type magenta not allowed in PaintFactory"
self.assertEqual(expected_msg, actual_msg)
def test__add_ingredient___less_capacity__raise_value_error(self):
with self.assertRaises(ValueError) as ve:
self.paint_factory.add_ingredient("blue", 110)
expected_msg = str(ve.exception)
actual_msg = "Not enough space in factory"
self.assertEqual(expected_msg, actual_msg)
def test_inherits_from_factory(self):
self.assertTrue(issubclass(PaintFactory, Factory))
def test__add_ingredient__add_in_dict__set_val_to_qty(self):
self.assertEqual(self.paint_factory.products, {})
self.paint_factory.add_ingredient("blue", 10)
self.assertEqual(self.paint_factory.products, {"blue": 10})
self.paint_factory.add_ingredient("red", 10)
self.assertEqual(self.paint_factory.products, {"blue": 10, "red": 10})
self.paint_factory.add_ingredient("red", 10)
self.assertEqual(self.paint_factory.products, {"blue": 10, "red": 20})
def test__remove_ingredient__not_in_dict__raise_key_error(self):
self.paint_factory.add_ingredient("blue", 100)
with self.assertRaises(KeyError) as ke:
self.paint_factory.remove_ingredient("magenta", 10)
expected_msg = str(ke.exception)
actual_msg = "'No such product in the factory'"
self.assertEqual(expected_msg, actual_msg)
def test__remove_ingredient__more_qty__raise_value_error(self):
self.paint_factory.add_ingredient("blue", 100)
with self.assertRaises(ValueError) as ve:
self.paint_factory.remove_ingredient("blue", 110)
expected_msg = str(ve.exception)
actual_msg = "Ingredient quantity cannot be less than zero"
self.assertEqual(expected_msg, actual_msg)
def test_remove_ingredient_quantity(self):
self.paint_factory.add_ingredient("white", 5)
self.paint_factory.remove_ingredient("white", 3)
self.assertEqual(self.paint_factory.ingredients, {"white": 2})
self.paint_factory.remove_ingredient("white", 2)
self.assertEqual(self.paint_factory.ingredients, {"white": 0})
def test__remove_ingredient__remove_qty_from_ingredient_val(self):
self.paint_factory.add_ingredient("blue", 100)
self.paint_factory.remove_ingredient("blue", 50)
self.assertEqual(self.paint_factory.products, {"blue": 50})
def test_get_ingredients(self):
self.paint_factory.add_ingredient("white", 5)
self.paint_factory.add_ingredient("yellow", 10)
dict = self.paint_factory.ingredients
self.assertEqual(dict, {"white": 5, "yellow": 10})
def test__can_add__return_true(self):
self.assertTrue(self.paint_factory.can_add(10))
self.assertFalse(self.paint_factory.can_add(110))
def test_add_zero(self):
self.paint_factory.add_ingredient("white", 0)
self.assertEqual(self.paint_factory.products, {"white": 0})
def test_can_add(self):
self.paint_factory.add_ingredient("white", 5)
self.assertEqual(self.paint_factory.can_add(100), False)
self.assertEqual(self.paint_factory.can_add(10), True)
def test_if_isinstance(self):
self.assertIsInstance(PaintFactory, Factory)
def test_add_ingredient_raises_ingredient_type_quantity_with_given_quantity(
self):
test_paint_factory = PaintFactory("Charley's", 10)
test_paint_factory.add_ingredient("white", 2)
test_paint_factory.add_ingredient("white", 4)
self.assertEqual(test_paint_factory.ingredients["white"], 6)
def test_add_ingredient_raises_error_when_capacity_is_less_than_quantity(
self):
test_paint_factory = PaintFactory("Charley's", 10)
with self.assertRaises(ValueError) as context:
test_paint_factory.add_ingredient("white", 20)
self.assertEqual(str(context.exception), "Not enough space in factory")
class PaintFactoryTests(unittest.TestCase):
def setUp(self):
self.paint_factory = PaintFactory("name", 100)
# self.valid_ingredients = ["white", "yellow", "blue", "green", "red"]
def test_paint_factory_initialized(self):
self.assertEqual(self.paint_factory.name, "name")
self.assertEqual(self.paint_factory.capacity, 100)
self.assertEqual(self.paint_factory.ingredients, {})
self.assertEqual(self.paint_factory.valid_ingredients,
["white", "yellow", "blue", "green", "red"])
def test_add_ingredient_ingredient_type_not_in_list(self):
self.assertRaises(TypeError, self.paint_factory.add_ingredient,
"brown", 5)
def test_add_ingredient_capacity_less_than_quantity(self):
self.assertRaises(ValueError, self.paint_factory.add_ingredient,
"green", 105)
def test_inherits_from_factory(self):
self.assertTrue(issubclass(PaintFactory, Factory))
def test_add_zero(self):
self.paint_factory.add_ingredient("white", 0)
self.assertEqual(self.paint_factory.ingredients, {"white": 0})
def test_add_ingredient_add_new_ingredient_type(self):
self.paint_factory.add_ingredient("white", 5)
self.assertEqual(self.paint_factory.ingredients, {"white": 5})
def test_remove_ingredient_ingredient_type_not_in_list(self):
self.assertRaises(KeyError, self.paint_factory.remove_ingredient,
"brown", 5)
def test_remove_ingredient_quantity_more_than_existing(self):
self.paint_factory.add_ingredient("white", 5)
self.assertRaises(ValueError, self.paint_factory.remove_ingredient,
"white", 6)
def test_remove_ingredient_quantity(self):
self.paint_factory.add_ingredient("white", 5)
self.paint_factory.remove_ingredient("white", 3)
self.assertEqual(self.paint_factory.ingredients, {"white": 2})
self.paint_factory.remove_ingredient("white", 2)
self.assertEqual(self.paint_factory.ingredients, {"white": 0})
def test_get_ingredients(self):
self.paint_factory.add_ingredient("white", 5)
self.paint_factory.add_ingredient("yellow", 10)
dict = self.paint_factory.ingredients
self.assertEqual(dict, {"white": 5, "yellow": 10})
def test_can_add(self):
self.paint_factory.add_ingredient("white", 5)
self.assertEqual(self.paint_factory.can_add(100), False)
self.assertEqual(self.paint_factory.can_add(10), True)
def test_if_instanse(self):
self.assertIsInstance(PaintFactory)
def test_property_products(self):
self.assertEqual({}, self.paint_factory.products)
def test_remove_ingredient_quantity_with_given_quantity(self):
test_paint_factory = PaintFactory("Charley's", 10)
test_paint_factory.add_ingredient("white", 5)
test_paint_factory.remove_ingredient("white", 3)
self.assertEqual(test_paint_factory.ingredients["white"], 2)
class TestPaintFactory(unittest.TestCase):
def setUp(self) -> None:
self.paint_factory = PaintFactory('PF', 1000)
def test_paint_factory_init_method(self):
ingredients = ["white", "yellow", "blue", "green", "red"]
self.assertEqual(self.paint_factory.name, 'PF')
self.assertEqual(self.paint_factory.capacity, 1000)
self.assertEqual(self.paint_factory.valid_ingredients, ingredients)
self.assertEqual(self.paint_factory.products, {})
def test_paint_factory_add_ingredient_method_when_igredient_in_list(self):
collor = 'white'
self.paint_factory.add_ingredient(collor, 10)
self.assertEqual(self.paint_factory.ingredients, {'white': 10})
def test_paint_factory_add_igredient_method_when_not_enough_space_should_raises(
self):
collor = 'white'
with self.assertRaises(ValueError) as ex:
self.paint_factory.add_ingredient(collor, 1001)
self.assertIsNotNone(str(ex.exception))
def test_paint_factory_add_igredient_method_when_product_not_allowed_should_raises(
self):
collor = 'purple'
with self.assertRaises(TypeError) as ex:
self.paint_factory.add_ingredient(collor, 10)
self.assertIsNotNone(str(ex.exception))
def test_paint_factory_remove_ingredient_method_when_product_in_list(self):
collor = 'white'
self.paint_factory.add_ingredient(collor, 10)
self.paint_factory.remove_ingredient(collor, 5)
self.assertEqual(self.paint_factory.ingredients, {'white': 5})
def test_paint_factory_remove_ingredient_method_when_product_less_than_zero_should_raises(
self):
collor = 'white'
self.paint_factory.add_ingredient(collor, 10)
with self.assertRaises(ValueError) as ex:
self.paint_factory.remove_ingredient(collor, 15)
self.assertIsNotNone(str(ex.exception))
def test_paint_factory_remove_ingredient_method_when_product_not_allowed_should_raises(
self):
collor2 = 'purple'
collor = 'green'
self.paint_factory.add_ingredient(collor, 10)
with self.assertRaises(KeyError) as ex:
self.paint_factory.remove_ingredient(collor2, 5)
self.assertIsNotNone(str(ex.exception))
class TestPaintFactory(TestCase):
def setUp(self):
self.paint_factory = PaintFactory("My name", 30)
def test_attributes_are_set(self):
self.assertEqual("My name", self.paint_factory.name)
self.assertEqual(30, self.paint_factory.capacity)
self.assertDictEqual({}, self.paint_factory.ingredients)
def test_add_ingredient_not_valid_raises_exception(self):
with self.assertRaises(TypeError) as ex:
self.paint_factory.add_ingredient("purple", 5)
expected = "Ingredient of type purple not allowed in PaintFactory"
self.assertEqual(expected, str(ex.exception))
def test_try_to_add_ingredient__not_enough_capacity_raises(self):
with self.assertRaises(ValueError) as ex:
self.paint_factory.add_ingredient("blue", 40)
expected = "Not enough space in factory"
self.assertEqual(expected, str(ex.exception))
def test_add_ingredient__ingredient_type_not_in_ingredients_dict(self):
self.paint_factory.add_ingredient("blue", 10)
expected = {"blue": 10}
actual_result = self.paint_factory.ingredients
self.assertDictEqual(expected, actual_result)
def test_add_ingredient__ingredient_type_already_in_ingredients_dict(self):
self.assertDictEqual({}, self.paint_factory.ingredients)
self.paint_factory.add_ingredient("blue", 12)
self.paint_factory.add_ingredient("blue", 5)
expected = {"blue": 17}
actual_result = self.paint_factory.ingredients
self.assertDictEqual(expected, actual_result)
def test_try_to_remove_ingredient__type_not_in_ingredients_dict_raises(self):
self.paint_factory.add_ingredient("yellow", 5)
with self.assertRaises(KeyError) as ex:
self.paint_factory.remove_ingredient("green", 8)
expected = "'No such product in the factory'"
self.assertEqual(expected, str(ex.exception))
def test_try_to_remove_ingredient__quantity_gets_less_than_zero_raises(self):
self.paint_factory.add_ingredient("red", 15)
with self.assertRaises(ValueError) as ex:
self.paint_factory.remove_ingredient("red", 17)
expected = "Ingredient quantity cannot be less than zero"
self.assertEqual(expected, str(ex.exception))
def test_remove_ingredient_from_ingredients(self):
self.paint_factory.add_ingredient("red", 15)
self.paint_factory.remove_ingredient("red", 10)
expected = {"red": 5}
actual_result = self.paint_factory.ingredients
self.assertDictEqual(expected, actual_result)
self.assertNotIn("blue", self.paint_factory.ingredients.keys())
def test_paint_factory_products__expect_ingredients(self):
self.paint_factory.add_ingredient("blue", 30)
expected_result = self.paint_factory.products
self.assertDictEqual(expected_result, self.paint_factory.ingredients)
class TestPaintFactory(unittest.TestCase):
def setUp(self):
self.p = PaintFactory("Factory", 100)
def test_init(self): # 1 test
self.assertEqual(self.p.name, "Factory")
self.assertEqual(self.p.capacity, 100)
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
def test_which_are_valid(self):
self.assertEqual(self.p.valid_ingredients,
['white', 'yellow', 'blue', 'green', 'red'])
def test_change_the_valid_pieces(self):
self.assertEqual(self.p.valid_ingredients,
['white', 'yellow', 'blue', 'green', 'red'])
self.p.valid_ingredients = ['blackish']
self.assertEqual(self.p.valid_ingredients, ['blackish'])
def test_add_successfully(self): # 2, 3, 4, 5 test
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
self.p.add_ingredient("white", 1)
self.assertEqual(self.p.ingredients, {"white": 1})
self.assertEqual(self.p.products, {"white": 1})
self.p.add_ingredient("white", 0)
self.assertEqual(self.p.ingredients, {"white": 1})
self.assertEqual(self.p.products, {"white": 1})
def test_add_all_successfully(self):
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
self.p.add_ingredient("white", 1)
self.p.add_ingredient("yellow", 1)
self.p.add_ingredient("blue", 1)
self.p.add_ingredient("green", 1)
self.p.add_ingredient("red", 1)
self.assertEqual(self.p.ingredients, {
"white": 1,
"yellow": 1,
"blue": 1,
"green": 1,
"red": 1
})
self.assertEqual(self.p.products, {
"white": 1,
"yellow": 1,
"blue": 1,
"green": 1,
"red": 1
})
def test_add_zero(self):
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
self.p.add_ingredient("white", 0)
self.assertEqual(self.p.ingredients, {"white": 0})
self.assertEqual(self.p.products, {"white": 0})
def test_products_and_capacity(self):
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
self.assertEqual(self.p.capacity, 100)
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
self.p.add_ingredient("white", 5)
self.assertEqual(self.p.products, {"white": 5})
self.assertEqual(self.p.ingredients, {"white": 5})
self.assertEqual(self.p.capacity, 100)
def test_remove_successfully(self): # 6 test
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
self.p.add_ingredient("white", 4)
self.p.remove_ingredient("white", 1)
self.assertEqual(self.p.ingredients, {"white": 3})
self.assertEqual(self.p.products, {"white": 3})
self.p.remove_ingredient("white", 3)
self.assertEqual(self.p.ingredients, {"white": 0})
self.assertEqual(self.p.products, {"white": 0})
def test_can_add_true(self):
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
self.p.add_ingredient("white", 4)
self.assertEqual(self.p.can_add(10), True)
self.p.add_ingredient("white", 10)
self.assertEqual(self.p.ingredients, {"white": 14})
self.assertEqual(self.p.products, {"white": 14})
def test_can_add_false(self):
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
self.p.add_ingredient("white", 4)
self.assertEqual(self.p.can_add(100000), False)
self.assertEqual(self.p.ingredients, {"white": 4})
self.assertEqual(self.p.products, {"white": 4})
def test_not_allowed(self):
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
self.p.add_ingredient("white", 4)
black = "cheren"
with self.assertRaises(TypeError) as ex:
self.p.add_ingredient(black, 5)
expected = str(ex.exception)
actual = f"Ingredient of type {black} not allowed in PaintFactory"
self.assertEqual(expected, actual)
self.assertEqual(self.p.ingredients, {"white": 4})
self.assertEqual(self.p.products, {"white": 4})
def test_not_enough_space(self):
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
self.p.add_ingredient("white", 4)
with self.assertRaises(ValueError) as ex:
self.p.add_ingredient("white", 4000000)
expected = str(ex.exception)
actual = "Not enough space in factory"
self.assertEqual(expected, actual)
self.assertEqual(self.p.ingredients, {"white": 4})
self.assertEqual(self.p.products, {"white": 4})
def test_remove_non_existing_ingredient(self):
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
self.p.add_ingredient("white", 4)
with self.assertRaises(KeyError) as ex:
self.p.remove_ingredient("blackmagic", 5)
expected = str(ex.exception)
actual = "\'No such product in the factory\'"
self.assertEqual(expected, actual)
self.assertEqual(self.p.ingredients, {"white": 4})
self.assertEqual(self.p.products, {"white": 4})
def test_remove_ingredient_with_less_than_zero(self):
self.assertEqual(self.p.ingredients, {})
self.assertEqual(self.p.products, {})
self.p.add_ingredient("white", 4)
with self.assertRaises(ValueError) as ex:
self.p.remove_ingredient("white", 400)
expected = str(ex.exception)
actual = "Ingredient quantity cannot be less than zero"
self.assertEqual(expected, actual)
self.assertEqual(self.p.ingredients, {"white": 4})
self.assertEqual(self.p.products, {"white": 4})
class PaintFactoryTests(unittest.TestCase):
def setUp(self):
self.paint_factory = PaintFactory("Factory", 100)
def test_init__expect_attributes_to_be_set(self):
self.assertEqual("Factory", self.paint_factory.name)
self.assertEqual(100, self.paint_factory.capacity)
# self.assertEqual(["white", "yellow", "blue", "green", "red"], self.paint_factory.valid_ingredients)
self.assertEqual({}, self.paint_factory.ingredients)
self.assertEqual({}, self.paint_factory.products)
def test_add_ingredient__when_ingredient_is_not_valid_expect_type_error(
self):
with self.assertRaises(TypeError) as err:
self.paint_factory.add_ingredient("purple", 10)
expected_msg = "Ingredient of type purple not allowed in PaintFactory"
self.assertEqual(expected_msg, str(err.exception))
def test_add_ingredient__when_capacity_is_not_enough_expect_value_error(
self):
with self.assertRaises(ValueError) as err:
self.paint_factory.add_ingredient("white", 105)
expected_msg = "Not enough space in factory"
self.assertEqual(expected_msg, str(err.exception))
def test_add_ingredient__when_ingredient_is_not_in_ingredients_expect_to_add_it(
self):
self.paint_factory.add_ingredient("white", 10)
expected = {"white": 10}
self.assertEqual(expected, self.paint_factory.products)
def test_add_ingredient__when_ingredient_is_in_ingredients_expect_to_raise_it_s_value(
self):
self.paint_factory.add_ingredient("white", 10)
self.paint_factory.add_ingredient("white", 10)
expected = {"white": 20}
self.assertEqual(expected, self.paint_factory.products)
def test_remove_ingredient__when_ingredient_type_not_in_ingredients_expect_key_error(
self):
with self.assertRaises(KeyError) as err:
self.paint_factory.remove_ingredient("white", 10)
expected_msg = "'No such ingredient in the factory'"
self.assertEqual(expected_msg, str(err.exception))
def test_remove_ingredient__when_quantity_exceeds_ingredient_quantity_expect_value_error(
self):
self.paint_factory.add_ingredient("white", 5)
with self.assertRaises(ValueError) as err:
self.paint_factory.remove_ingredient("white", 10)
expected_msg = "Ingredients quantity cannot be less than zero"
self.assertEqual(expected_msg, str(err.exception))
def test_remove_ingredient__expect_to_decrease_ingredient_quantity_with_given(
self):
self.paint_factory.add_ingredient("white", 10)
self.paint_factory.remove_ingredient("white", 5)
expected = {"white": 5}
self.assertEqual(expected, self.paint_factory.products)
class TestPaintFactory(unittest.TestCase):
def setUp(self) -> None:
self.paint_factory = PaintFactory('TestName', 10)
def test_init__expect_attrs_set(self) -> None:
self.assertEqual(self.paint_factory.name, 'TestName')
self.assertEqual(self.paint_factory.capacity, 10)
self.assertEqual(self.paint_factory.ingredients, {})
def test_add_ingredient__when_valid_enough_space__expect_added(
self) -> None:
self.paint_factory.add_ingredient('white', 5)
self.assertEqual(self.paint_factory.ingredients, {'white': 5})
self.paint_factory.add_ingredient('white', 3)
self.assertEqual(self.paint_factory.ingredients, {'white': 8})
def test_add_ingredient__when_valid_not_enough_space__expect_exception(
self) -> None:
with self.assertRaises(ValueError) as context:
self.paint_factory.add_ingredient('white', 15)
self.assertEqual(context.exception.args[0],
'Not enough space in factory')
def test_add_ingredient__when_invalid__expect_exception(self) -> None:
with self.assertRaises(TypeError) as context:
self.paint_factory.add_ingredient('purple', 5)
self.assertEqual(
context.exception.args[0],
'Ingredient of type purple not allowed in PaintFactory')
def test_remove_ingredient__when_invalid__expect_exception(self) -> None:
with self.assertRaises(KeyError) as context:
self.paint_factory.remove_ingredient('white', 10)
self.assertEqual(context.exception.args[0],
'No such ingredient in the factory')
def test_remove_ingredient__when_valid_enough_quantity(self) -> None:
self.paint_factory.add_ingredient('white', 8)
self.paint_factory.remove_ingredient('white', 3)
self.assertEqual(self.paint_factory.ingredients, {'white': 5})
def test_remove_ingredient__when_valid_not_enough_quantity__expect_exception(
self) -> None:
self.paint_factory.add_ingredient('white', 5)
with self.assertRaises(ValueError) as context:
self.paint_factory.remove_ingredient('white', 10)
self.assertEqual(context.exception.args[0],
'Ingredients quantity cannot be less than zero')
def test_property_products(self) -> None:
self.assertEqual(self.paint_factory.products, {})
self.paint_factory.add_ingredient('white', 8)
self.assertEqual(self.paint_factory.products, {'white': 8})
def test_repr_method(self) -> None:
self.paint_factory.add_ingredient('white', 5)
self.paint_factory.add_ingredient('blue', 3)
self.assertEqual(
repr(self.paint_factory),
'Factory name: TestName with capacity 10.\nwhite: 5\nblue: 3\n')
class TestPaintFactory(TestCase):
def setUp(self) -> None:
self.paint_factory = PaintFactory("Test", 100)
def test_initializing_all_attributes(self):
self.assertEqual("Test", self.paint_factory.name)
self.assertEqual(100, self.paint_factory.capacity)
self.assertListEqual(["white", "yellow", "blue", "green", "red"], self.paint_factory.valid_ingredients)
self.assertDictEqual(self.paint_factory.products, self.paint_factory.ingredients)
def test_can_add(self):
self.paint_factory.ingredients = {"white": 10, "yellow": 10}
result = self.paint_factory.can_add(50)
self.assertEqual(True, result)
result2 = self.paint_factory.can_add(90)
self.assertEqual(False, result2)
def test_add_gradient_invalid_product_type_raises(self):
with self.assertRaises(TypeError) as ex:
self.paint_factory.add_ingredient("pink", 10)
self.assertEqual("Ingredient of type pink not allowed in PaintFactory", str(ex.exception))
def test_add_gradient_not_enough_space_raises(self):
with self.assertRaises(ValueError) as ex:
self.paint_factory.add_ingredient("white", 120)
self.assertEqual("Not enough space in factory", str(ex.exception))
def test_add_gradient_successfully(self):
self.assertDictEqual({}, self.paint_factory.products)
result = self.paint_factory.add_ingredient("white", 50)
self.assertDictEqual({"white": 50}, self.paint_factory.products)
self.assertIsNone(result)
self.paint_factory.add_ingredient("white", 10)
self.assertDictEqual({"white": 60}, self.paint_factory.products)
self.paint_factory.add_ingredient("yellow", 10)
self.assertDictEqual({"white": 60, "yellow": 10}, self.paint_factory.products)
def test_remove_gradient_not_found_rises(self):
with self.assertRaises(KeyError) as ex:
self.paint_factory.remove_ingredient("white", 10)
self.assertEqual("'No such ingredient in the factory'", str(ex.exception))
def test_remove_gradient_less_than_zero(self):
self.paint_factory.ingredients = {"white": 10}
with self.assertRaises(ValueError) as ex:
self.paint_factory.remove_ingredient("white", 20)
self.assertEqual("Ingredients quantity cannot be less than zero", str(ex.exception))
def test_remove_gradient_successfully(self):
self.paint_factory.ingredients = {"white": 20}
result = self.paint_factory.remove_ingredient("white", 10)
self.assertDictEqual({"white": 10}, self.paint_factory.ingredients)
self.assertIsNone(result)
def test_repr_representation(self):
self.paint_factory.ingredients = {"white": 10, "yellow": 10}
expected = "Factory name: Test with capacity 100.\n" \
"white: 10\n" \
"yellow: 10\n"
self.assertEqual(expected, repr(self.paint_factory))
class TestPaintFactory(TestCase):
def setUp(self):
self.pf = PaintFactory("Test", 100)
def test_init(self):
pf = PaintFactory("Test", 100)
self.assertEqual("Test", pf.name)
self.assertEqual(100, pf.capacity)
self.assertEqual({}, pf.ingredients)
self.assertEqual(["white", "yellow", "blue", "green", "red"],
pf.valid_ingredients)
# add_ingredient
def test_add_ingredient_invalid_product_type_raises(self):
with self.assertRaises(TypeError) as ex:
self.pf.add_ingredient("purple", 2)
self.assertEqual(
"Ingredient of type purple not allowed in PaintFactory",
str(ex.exception))
def test_add_ingredient_invalid_quantity_raises(self):
with self.assertRaises(ValueError) as ex:
self.pf.add_ingredient("white", 101)
self.assertEqual("Not enough space in factory", str(ex.exception))
def test_add_ingredient(self):
self.assertEqual({}, self.pf.ingredients)
self.pf.add_ingredient("white", 2)
self.assertEqual({"white": 2}, self.pf.ingredients)
def test_add_ingredient_already_existing_increases(self):
self.assertEqual({}, self.pf.ingredients)
self.pf.add_ingredient("white", 2)
self.assertEqual({"white": 2}, self.pf.ingredients)
self.pf.add_ingredient("white", 2)
self.assertEqual({"white": 4}, self.pf.ingredients)
# remove_ingredient
def test_remove_invalid_product_type_raises(self):
with self.assertRaises(KeyError) as ex:
self.pf.remove_ingredient("test_type", 2)
self.assertEqual("'No such ingredient in the factory'",
str(ex.exception))
def test_remove_ingredient_if_quantity_less_than_0(self):
self.pf.add_ingredient("white", 2)
with self.assertRaises(ValueError) as ex:
self.pf.remove_ingredient("white", 3)
self.assertEqual("Ingredients quantity cannot be less than zero",
str(ex.exception))
def test_remove_ingredient(self):
self.pf.add_ingredient("white", 2)
self.pf.remove_ingredient("white", 1)
self.assertEqual({"white": 1}, self.pf.ingredients)
def test_product_property(self):
self.pf.add_ingredient("white", 2)
self.assertEqual({"white": 2}, self.pf.products)
class TestPaintFactory(unittest.TestCase):
def setUp(self):
self.factory = PaintFactory("Test", 5)
def test_paint_factory_init__expect_correct_attributes(self):
self.assertEqual("Test", self.factory.name)
self.assertEqual(5, self.factory.capacity)
self.assertEqual({}, self.factory.ingredients)
def test_paint_factory_add_ingredient__when_not_valid_ingredients_type__expect_type_error(
self):
with self.assertRaises(TypeError) as context:
self.factory.add_ingredient("test", 2)
self.assertEqual(
f"Ingredient of type test not allowed in PaintFactory",
str(context.exception))
def test_paint_factory_add_ingredient__when_not_enough_capacity__expect_value_error(
self):
with self.assertRaises(ValueError) as context:
self.factory.add_ingredient("white", 6)
self.assertEqual("Not enough space in factory", str(context.exception))
def test_paint_factory_add_ingredient__when_ingredient_not_in_ingredients__expect_to_add_it_with_given_value(
self):
self.assertEqual({}, self.factory.ingredients)
self.factory.add_ingredient("white", 2)
self.assertEqual({"white": 2}, self.factory.ingredients)
def test_paint_factory_add_ingredient__when_ingredient_in_ingredients__expect_to_addition(
self):
self.factory.add_ingredient("white", 2)
self.factory.add_ingredient("white", 2)
self.assertEqual({"white": 4}, self.factory.ingredients)
def test_paint_factory_remove_ingredient__when_ingredient_not_in_ingredients__expect_key_error(
self):
with self.assertRaises(KeyError) as context:
self.factory.remove_ingredient("test", 2)
self.assertEqual("'No such ingredient in the factory'",
str(context.exception))
def test_paint_factory_remove_ingredient__when_given_quantity_is_more_than_item_has__expect_value_error(
self):
self.factory.add_ingredient("white", 2)
with self.assertRaises(ValueError) as context:
self.factory.remove_ingredient("white", 3)
self.assertEqual("Ingredients quantity cannot be less than zero",
str(context.exception))
def test_paint_factory_remove_ingredient__when_correct_params__expect_to_subtract_item_quantity(
self):
self.factory.add_ingredient("white", 2)
self.factory.remove_ingredient("white", 2)
self.assertEqual({"white": 0}, self.factory.ingredients)
def test_paint_factory_product_prop__expect_to_return_ingredients(self):
self.assertEqual({}, self.factory.products)
class TestPaintFactory(unittest.TestCase):
name = 'Art Factory'
capacity = 10
valid_ingredients = ["white", "yellow", "blue", "green", "red"]
ingredients = {}
def setUp(self):
self.paint_factory = PaintFactory(self.name, self.capacity)
def test_init_attributes(self):
self.assertEqual('Art Factory', self.paint_factory.name)
self.assertEqual(10, self.paint_factory.capacity)
self.assertDictEqual({}, self.paint_factory.ingredients)
self.assertDictEqual({}, self.paint_factory.products)
expect = ["white", "yellow", "blue", "green", "red"]
self.assertListEqual(expect, self.paint_factory.valid_ingredients)
def test_add_ingredient__when_ingredient_not_in_ingredients__expect_to_add(self):
self.paint_factory.add_ingredient('white', 5)
self.assertDictEqual({'white': 5}, self.paint_factory.ingredients)
def test_add_ingredient__when_ingredient_in_ingredients__expect_to_increase_quantity(self):
self.paint_factory.add_ingredient('white', 5)
self.assertDictEqual({'white': 5}, self.paint_factory.ingredients)
self.paint_factory.add_ingredient('white', 5)
self.assertDictEqual({'white': 10}, self.paint_factory.ingredients)
def test_add_ingredient__when_ingredient_type_not_in_valid_ingredient_types__expect_to_raise(self):
with self.assertRaises(TypeError) as ex:
self.paint_factory.add_ingredient('pink', 5)
expect = f"Ingredient of type pink not allowed in PaintFactory"
actual = str(ex.exception)
self.assertEqual(expect, actual)
def test_add_ingredient__when_ingredient_is_valid_and_capacity_is_less_than_quantity__expect_to_raise(self):
with self.assertRaises(ValueError) as ex:
self.paint_factory.add_ingredient('white', 15)
expect = "Not enough space in factory"
actual = str(ex.exception)
self.assertEqual(expect, actual)
def test_remove_ingredient__when_ingredient_in_ingredients__expect_to_decrease_quantity(self):
self.paint_factory.add_ingredient('white', 5)
self.paint_factory.remove_ingredient('white', 3)
self.assertDictEqual({'white': 2}, self.paint_factory.ingredients)
self.paint_factory.remove_ingredient('white', 2)
self.assertDictEqual({'white': 0}, self.paint_factory.ingredients)
def test_remove_ingredient__when_ingredient_not_in_ingredients__expect_to_raise_exception(self):
with self.assertRaises(KeyError) as ex:
self.paint_factory.remove_ingredient('pink', 5)
expect = "No such ingredient in the factory" # Correct in Judge - Wrong in skeleton
# expect = "No such product in the factory" # Wrong in Judge - Correct in skeleton
actual = str(ex.exception.args[0])
self.assertEqual(expect, actual)
def test_remove_ingredient__when_ingredient_quantity_is_big_than_stored_quantity__expect_to_raise_exception(self):
self.paint_factory.add_ingredient('white', 10)
with self.assertRaises(ValueError) as ex:
self.paint_factory.remove_ingredient('white', 25)
expect = "Ingredient quantity cannot be less than zero"
actual = str(ex.exception)
self.assertEqual(expect, actual)
def test_product_property__expect_to_return_ingredients(self):
self.assertDictEqual({}, self.paint_factory.products)
self.paint_factory.add_ingredient('white', 10)
self.assertDictEqual({'white': 10}, self.paint_factory.products)
def test_can_add__expect_to_return_true(self):
self.assertTrue(self.paint_factory.can_add(10))
def test_can_add__expect_to_return_false(self):
self.assertFalse(self.paint_factory.can_add(11))
class TestPaintFactory(TestCase):
def setUp(self):
self.pf = PaintFactory("Anycomp", 100)
def test_init(self):
self.assertEqual("Anycomp", self.pf.name)
self.assertEqual(100, self.pf.capacity)
self.assertEqual(["white", "yellow", "blue", "green", "red"],
self.pf.valid_ingredients)
self.assertEqual({}, self.pf.ingredients)
def test_add_ingredient_valid_product_type_and_quantity_product_type_exist(
self):
self.pf.ingredients = {"white": 10}
self.pf.add_ingredient("white", 20)
self.assertEqual({"white": 30}, self.pf.ingredients)
def test_add_ingredient_valid_product_type_and_quantity_product_type_not_exist(
self):
self.assertEqual({}, self.pf.ingredients)
self.pf.add_ingredient("white", 20)
self.assertEqual({"white": 20}, self.pf.ingredients)
def test_add_ingredient_insufficient_capacity_raises(self):
with self.assertRaises(ValueError) as ex:
self.pf.add_ingredient("white", 150)
self.assertEqual("Not enough space in factory", str(ex.exception))
def test_add_ingredient_invalid_ingredients_raises(self):
with self.assertRaises(TypeError) as ex:
self.pf.add_ingredient("black", 50)
self.assertEqual(
f"Ingredient of type black not allowed in {self.pf.__class__.__name__}",
str(ex.exception))
def test_remove_ingredient_if_ingredient_exist_greater_than_zero(self):
self.pf.ingredients = {"white": 120}
self.pf.remove_ingredient("white", 20)
self.assertEqual({"white": 100}, self.pf.ingredients)
def test_remove_ingredient_if_ingredient_exist_equal_to__zero(self):
self.pf.ingredients = {"white": 120}
self.pf.remove_ingredient("white", 120)
self.assertEqual({"white": 0}, self.pf.ingredients)
def test_remove_ingredient_if_ingredient_exist_less_than__zero_raises(
self):
self.pf.ingredients = {"white": 120}
with self.assertRaises(ValueError) as ex:
self.pf.remove_ingredient("white", 130)
self.assertEqual("Ingredients quantity cannot be less than zero",
str(ex.exception))
def test_remove_ingredient_if_ingredient_not_exist_raises(self):
with self.assertRaises(KeyError) as ex:
self.pf.remove_ingredient("white", 130)
self.assertEqual("'No such ingredient in the factory'",
str(ex.exception))
def test_product_property(self):
self.pf.ingredients = {"white": 120}
result = self.pf.products
self.assertEqual({"white": 120}, result)
class TestPaintFactory(unittest.TestCase):
def setUp(self) -> None:
self.factory = PaintFactory('test_name', 2)
def test_init(self):
test_factory = PaintFactory('name', 10)
self.assertEqual(test_factory.name, 'name')
self.assertEqual(test_factory.capacity, 10)
def test_add_ingredient_should_increase_quantity(self):
self.factory.add_ingredient('blue', 1)
expected_len = 1
actual_len = len(self.factory.ingredients)
self.assertEqual(expected_len, actual_len)
expected_quantity = 1
actual_quantity = self.factory.ingredients['blue']
self.assertEqual(expected_quantity, actual_quantity)
def test_add_ingredient__when_not_valid_ingredient__should_raise(self):
with self.assertRaises(TypeError) as ex:
self.factory.add_ingredient('test', 1)
expected = "Ingredient of type test not allowed in PaintFactory"
actual = ex.exception.args[0]
self.assertEqual(expected, actual)
def test_add_ingredient__when_not_enough_capacity__should_raise(self):
with self.assertRaises(ValueError) as ex:
self.factory.add_ingredient('blue', 10)
expected = "Not enough space in factory"
actual = ex.exception.args[0]
self.assertEqual(expected, actual)
def test_remove_ingredient__should_decrease_quantity(self):
self.factory.add_ingredient('blue', 2)
self.factory.remove_ingredient('blue', 1)
expected_len = 1
actual_len = self.factory.ingredients['blue']
self.assertEqual(expected_len, actual_len)
def test_remove_ingredient__when_missing_in_factory__should_raise(self):
with self.assertRaises(KeyError) as ex:
self.factory.remove_ingredient('red', 1)
expected = "No such product in the factory"
actual = ex.exception.args[0]
self.assertEqual(expected, actual)
def test_remove_ingredient__when_given_quantity_bigger_then_current__should_raise(
self):
self.factory.add_ingredient('red', 2)
with self.assertRaises(ValueError) as ex:
self.factory.remove_ingredient('red', 20)
expected = "Ingredient quantity cannot be less than zero"
actual = ex.exception.args[0]
self.assertEqual(expected, actual)
def test_products_should_return_ingredients_in_factory(self):
self.factory.add_ingredient('red', 2)
self.factory.add_ingredient('blue', 2)
self.assertEqual(self.factory.products, {'blue': 2, 'red': 2})