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_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_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_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")
class TestPaintFactory(unittest.TestCase):
def setUp(self):
self.factory = PaintFactory('a', 10)
def test_constructor(self):
self.assertEqual(self.factory.name, 'a')
self.assertEqual(self.factory.capacity, 10)
self.assertEqual(self.factory.valid_ingredients, ["white", "yellow", "blue", "green", "red"])
self.assertEqual(self.factory.ingredients, {})
def test_add_invalid_ingredient(self):
with self.assertRaises(TypeError) as exc:
self.factory.add_ingredient('brrr', 1)
def test_add_quantity_above_capacity(self):
with self.assertRaises(ValueError) as exc:
self.factory.add_ingredient('white', 100)
def test_ingredient_not_ingredientsdict_add_it_to_dict_then_add_quantity(self):
self.factory.add_ingredient('white', 1)
self.assertEqual(self.factory.ingredients['white'], 1)
def test_remove_ingredient_cannot_be_less_than_zero(self):
self.factory.add_ingredient('white', 1)
with self.assertRaises(ValueError) as exc:
self.factory.remove_ingredient('white', 6)
def test_remove_ingredient_works_as_expected(self):
self.factory.add_ingredient('white', 1)
self.factory.remove_ingredient('white', 1)
self.assertEqual(0, self.factory.ingredients['white'])
def test_products_return_ingredients_dict(self):
self.assertEqual(self.factory.products, self.factory.ingredients)
def test_can_add(self):
self.assertEqual(self.factory.can_add(1), True)
self.factory.add_ingredient('white', 10)
self.assertEqual(self.factory.can_add(1), False)
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 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(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)
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")
class TestPaintFactory(unittest.TestCase):
def setUp(self):
self.paint_factory = PaintFactory("LEKO", 20)
self.paint_factory.add_ingredient("red", 1)
def test_add_ingredient_if_ingredient_not_allowed(self):
with self.assertRaises(TypeError):
self.paint_factory.add_ingredient("BMW", 10)
def test_add_ingredient_if_space(self):
with self.assertRaises(ValueError):
self.paint_factory.add_ingredient("green", 100)
def test_add_non_existing_ingredient(self):
self.paint_factory.add_ingredient("green", 1)
result = self.paint_factory.products
self.assertEqual(result, {"red": 1, "green": 1})
def test_add_existing_ingredient(self):
self.paint_factory.add_ingredient("green", 1)
self.paint_factory.add_ingredient("green", 1)
result = self.paint_factory.ingredients
self.assertEqual(result, {"red": 1, "green": 2})
def test_remove_ingredient_key_error(self):
with self.assertRaises(KeyError):
self.paint_factory.remove_ingredient("Sony", 100)
def test_remove_ingredient_value_error(self):
self.paint_factory.add_ingredient("green", 1)
with self.assertRaises(ValueError):
self.paint_factory.remove_ingredient("green", 100)
def test_remove_ingredient(self):
self.paint_factory.add_ingredient("green", 1)
self.paint_factory.add_ingredient("green", 1)
self.paint_factory.remove_ingredient("green", 1)
result = self.paint_factory.ingredients
self.assertEqual(result, {"red": 1, "green": 1})
pass
def test_return_ingredients_property(self):
self.paint_factory.add_ingredient("green", 1)
result = self.paint_factory.products
self.assertEqual(result, {"red": 1, "green": 1})
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_capacity_of_factory(self):
with self.assertRaises(ValueError) as ex:
self.factory.add_ingredient('green', 200)
self.assertEqual('Not enough space in factory', str(ex.exception))
def test_capacity_error(self):
with self.assertRaises(ValueError):
self.factory.add_ingredient('green', 2222)
def test_remove_error(self):
self.factory.add_ingredient('green', 2)
with self.assertRaises(ValueError):
self.factory.remove_ingredient('green', 9999)
def test_remove4_error(self):
with self.assertRaises(KeyError):
self.factory.remove_ingredient('green', 9999)
def test_ingredient_remove(self):
self.factory.add_ingredient('white', 2)
self.factory.remove_ingredient('white', 1)
self.assertEqual({'white': 1}, self.factory.ingredients)
def test_paint_factory_product_prop__expect_to_return_ingredients(self):
self.assertEqual({}, self.factory.products)
def test_add_ingredient(self):
self.factory.add_ingredient('white', 2)
self.assertEqual({'white': 2}, self.factory.ingredients)
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.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(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 TestPainFactory(unittest.TestCase):
def setUp(self):
self.paint = PaintFactory('Paint', 10)
self.paint.valid_ingredients = [
"white", "yellow", "blue", "green", "red"
]
def test_set_up_corect(self):
self.assertEqual(self.paint.name, 'Paint')
self.assertEqual(self.paint.capacity, 10)
self.assertListEqual(self.paint.valid_ingredients,
["white", "yellow", "blue", "green", "red"])
self.assertEqual(self.paint.ingredients, {})
def test_paint_is_inherit_from_factory(self):
self.assertTrue(issubclass(PaintFactory, Factory))
def test_add_ingredient_when_type_not_in_valid_should_raise_error(self):
with self.assertRaises(TypeError) as ex:
self.paint.add_ingredient('black', 1)
self.assertEqual(
str(ex.exception),
"Ingredient of type black not allowed in PaintFactory")
def test_add_ingredient_when_type_is_good_but_capacity_is_less_should_raise_error(
self):
with self.assertRaises(ValueError) as ex:
self.paint.add_ingredient('white', 20)
self.assertEqual(str(ex.exception), "Not enough space in factory")
def test_add_ingredient_when_all_is_ok(self):
self.paint.add_ingredient('white', 10)
self.assertEqual(self.paint.ingredients['white'], 10)
self.assertEqual(self.paint.capacity, 10)
def test_add_ingr_when_values_and_capcity_is_less_then_value(self):
self.paint.add_ingredient('white', 5)
with self.assertRaises(ValueError) as ex:
self.paint.add_ingredient('white', 6)
self.assertEqual(str(ex.exception), "Not enough space in factory")
def test_add_infredient_for_second_time(self):
self.paint.add_ingredient('white', 3)
self.assertEqual(self.paint.ingredients['white'], 3)
self.paint.add_ingredient('white', 3)
self.assertEqual(self.paint.ingredients['white'], 6)
def test_remove_ingredient_when_type_not_iningredients_should_raise_error(
self):
with self.assertRaises(KeyError) as ex:
self.paint.remove_ingredient('black', 10)
self.assertEqual(str(ex.exception),
"'No such ingredient in the factory'")
def test_remove_ingredient_when_quanity_is_more_then_ingredianets_quantity_shoud_raise_error(
self):
self.paint.add_ingredient('white', 5)
with self.assertRaises(ValueError) as ex:
self.paint.remove_ingredient('white', 11)
self.assertEqual(str(ex.exception),
'Ingredients quantity cannot be less than zero')
def test_rempve_ingredient_all_param_is_good(self):
self.paint.add_ingredient('white', 10)
self.paint.remove_ingredient('white', 5)
self.assertEqual(self.paint.ingredients['white'], 5)
def test_products(self):
self.paint.add_ingredient('white', 10)
self.assertEqual(self.paint.products, {'white': 10})
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)
def test_remove_decrease_quantity(self):
pfac = PaintFactory('pfac', 3)
pfac.add_ingredient('white', 2)
pfac.remove_ingredient('white', 1)
self.assertEqual(1, pfac.products['white'])
class TestPaintFactory(unittest.TestCase):
def setUp(self) -> None:
self.paint_factory = PaintFactory("NewFact", 2)
def test_add_ingredient_whenHaveSpaceAndCorrectIngredientBlue(self):
self.paint_factory.add_ingredient("blue", 1)
self.assertEqual(self.paint_factory.ingredients, {"blue": 1})
self.paint_factory.add_ingredient("blue", 1)
self.assertEqual(self.paint_factory.ingredients, {"blue": 2})
def test_add_ingredient_whenDoNotHaveSpace(self):
with self.assertRaises(ValueError) as ex:
self.paint_factory.add_ingredient("blue", 4)
self.assertEqual(str(ex.exception), "Not enough space in factory")
def test_add_ingredient_whenIncorrectIngredient(self):
with self.assertRaises(TypeError) as ex:
self.paint_factory.add_ingredient("Test", 1)
self.assertEqual(str(ex.exception), "Ingredient of type Test not allowed in PaintFactory")
def test_add_ingredient_whenIncorrectIngredientAndWrongAmount(self):
with self.assertRaises(TypeError) as ex:
self.paint_factory.add_ingredient("Test", 100)
self.assertEqual(str(ex.exception), "Ingredient of type Test not allowed in PaintFactory")
def test_remove_ingredient_whenIngredientExistAndQuantityIsEnoughBlue(self):
self.paint_factory.add_ingredient("blue", 2)
self.paint_factory.remove_ingredient("blue", 1)
self.assertEqual(self.paint_factory.ingredients, {"blue": 1})
self.paint_factory.remove_ingredient("blue", 1)
self.assertEqual(self.paint_factory.ingredients, {"blue": 0})
def test_remove_ingredient_whenIngredientExistAndQuantityIsEnough(self):
self.paint_factory.add_ingredient("blue", 2)
self.paint_factory.remove_ingredient("blue", 1)
self.assertEqual(self.paint_factory.ingredients, {"blue": 1})
self.paint_factory.remove_ingredient("blue", 1)
self.assertEqual(self.paint_factory.ingredients, {"blue": 0})
def test_remove_ingredient_whenIngredientDoesNotExist(self):
self.paint_factory.add_ingredient("blue", 2)
with self.assertRaises(KeyError) as ex:
self.paint_factory.remove_ingredient("none", 3)
self.assertEqual(str(ex.exception), "'No such ingredient in the factory'")
def test_remove_ingredient_whenIngredientDoesNotExistAndQuantityOK(self):
self.paint_factory.add_ingredient("blue", 2)
with self.assertRaises(KeyError) as ex:
self.paint_factory.remove_ingredient("none", 3)
self.assertEqual(str(ex.exception), "'No such ingredient in the factory'")
def test_remove_ingredient_whenIngredientQuantityIncorrect(self):
self.paint_factory.add_ingredient("blue", 2)
with self.assertRaises(ValueError) as ex:
self.paint_factory.remove_ingredient("blue", 3)
self.assertEqual(str(ex.exception), "Ingredient quantity cannot be less than zero")
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 Test(unittest.TestCase):
def setUp(self):
self.paint_factory = PaintFactory("Colors_factory", 5)
def test__init__(self):
self.assertEqual(self.paint_factory.name, "Colors_factory")
self.assertEqual(self.paint_factory.capacity, 5)
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_valid_ingredients_raise_type_error(self):
with self.assertRaises(TypeError) as exc:
self.paint_factory.add_ingredient("brown", 5)
msg = f"Ingredient of type brown not allowed in PaintFactory"
self.assertEqual(str(exc.exception), msg)
def test_add_ingredient_ingredient_quantity_exceeds_the_paint_factory_capacity_raise_value_error(self):
with self.assertRaises(ValueError) as exc:
self.paint_factory.add_ingredient("yellow", 6)
msg = "Not enough space in factory"
self.assertEqual(str(exc.exception), msg)
def test_can_add_method(self):
self.paint_factory.add_ingredient("blue", 3)
self.assertEqual(self.paint_factory.can_add(3), False)
# with self.assertRaises(ValueError) as exc:
# self.paint_factory.can_add(3)
# self.assertEqual(str(exc.exception), "Not enough space in factory")
def test_add_ingredient_to_the_dict_successfully_ingredient_not_in_the_dict(self):
self.paint_factory.add_ingredient("yellow", 5)
self.assertEqual(self.paint_factory.ingredients, {"yellow": 5})
def test_add_ingredient_to_the_dict_successfully_ingredient_already_in_the_dict(self):
self.paint_factory.add_ingredient("blue", 3)
self.paint_factory.add_ingredient("blue", 2)
self.assertEqual(self.paint_factory.ingredients, {"blue": 5})
def test_remove_ingredient_from_the_dict_ingredient_not_in_the_dict_raises_key_error(self):
self.paint_factory.add_ingredient("blue", 3)
self.paint_factory.add_ingredient("red", 2)
with self.assertRaises(KeyError) as exc:
self.paint_factory.remove_ingredient("yellow", 4)
msg = "No such product in the factory"
self.assertEqual(msg, "No such product in the factory")
def test_remove_ingredient_from_the_dict_divide_ingredient_quantity(self):
self.paint_factory.add_ingredient("red", 3)
self.paint_factory.remove_ingredient("red", 2)
self.assertEqual(self.paint_factory.ingredients, {"red": 1})
def test_remove_ingredient_raises_value_error_quantity_cannot_be_less_than_zero(self):
self.paint_factory.add_ingredient("red", 3)
with self.assertRaises(ValueError) as exc:
self.paint_factory.remove_ingredient("red", 4)
self.assertEqual(str(exc.exception), "Ingredients quantity cannot be less than zero")
def test_products_property(self):
self.paint_factory.add_ingredient("blue", 3)
self.paint_factory.add_ingredient("red", 2)
self.assertEqual(self.paint_factory.products, {"blue": 3, "red": 2})
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(unittest.TestCase):
def setUp(self):
self.paint = PaintFactory('Paint', 100)
def test_all_set_up(self):
self.assertEqual(self.paint.name, 'Paint')
self.assertEqual(self.paint.capacity, 100)
self.assertEqual(self.paint.valid_ingredients,
["white", "yellow", "blue", "green", "red"])
self.assertEqual(self.paint.ingredients, {})
def test_ingredianet_not_in_default(self):
self.assertTrue('black' not in self.paint.valid_ingredients)
def test_ingrediant_in_default(self):
self.assertTrue('yellow' in self.paint.valid_ingredients)
def test_add_ingrediant_when_not_valid_type_should_raise_error(self):
with self.assertRaises(TypeError) as ex:
self.paint.add_ingredient('black', 100)
self.assertEqual(
str(ex.exception),
"Ingredient of type black not allowed in PaintFactory")
def test_add_ingrediant_when_capacity_less_then_quantity_should_raise_error(
self):
with self.assertRaises(ValueError) as ex:
self.paint.add_ingredient('white', 150)
self.assertEqual(str(ex.exception), "Not enough space in factory")
def test_add_ingrediant_not_in_ing_type_add_to_dict_with_tpes(self):
self.paint.add_ingredient('white', 50)
self.assertEqual(self.paint.ingredients['white'], 50)
def test_add_to_ingrediant_secod_type(self):
self.paint.add_ingredient('white', 50)
self.paint.add_ingredient('white', 50)
self.assertEqual(self.paint.ingredients['white'], 100)
def test_remove_ingrediant_when_type_not_in_keys_should_raise_error(self):
with self.assertRaises(KeyError) as ex:
self.paint.remove_ingredient('white', 50)
self.assertEqual(str(ex.exception), "'No such product in the factory'")
def test_remove_ingrediant_succesfully_reduce_quntity(self):
self.paint.add_ingredient('white', 50)
self.paint.remove_ingredient('white', 50)
self.assertEqual(self.paint.ingredients['white'], 0)
def test_remove_ingrediant_with_big_quantity_should_raise_error(self):
self.paint.add_ingredient('white', 50)
with self.assertRaises(ValueError) as ex:
self.paint.remove_ingredient('white', 60)
self.assertEqual(str(ex.exception),
"Ingredient quantity cannot be less than zero")
def test_paint_is_not_abstract_and_inheritfrom(self):
self.assertTrue(issubclass(PaintFactory, Factory))
def test_product(self):
self.assertEqual(self.paint.ingredients, {})
self.paint.add_ingredient('white', 50)
self.assertEqual(self.paint.products, {'white': 50})
def test_cann_add(self):
self.paint.add_ingredient('white', 90)
actual = self.paint.can_add(20)
self.assertEqual(actual, False)
def test_cannot_instnces(self):
with self.assertRaises(TypeError):
Factory('test', 100)
def test_add_ingrediant_is_abstract(self):
with self.assertRaises(TypeError):
Factory('test', 100).add_ingredient('white', 10)
def test_repr(self):
self.paint.add_ingredient('white', 50)
self.assertEqual(
str(self.paint),
'Factory name: Paint with capacity 100.\nwhite: 50\n')
def test_implement_all_abstract(self):
self.assertNotEqual(self.paint, 'TypeError:')
def test_add_multi(self):
self.paint.add_ingredient('white', 50)
self.paint.add_ingredient('white', 50)
self.paint.add_ingredient('white', 50)
self.assertEqual(self.paint.ingredients['white'], 150)
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)
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 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):
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})
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):
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)
