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):
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 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) -> 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(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(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)
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 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):
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)
def test_2(self):
pfac = PaintFactory('pfac', 1)
self.assertEqual(pfac.can_add(2), False)
def test_1(self):
pfac = PaintFactory('pfac', 3)
self.assertEqual(pfac.can_add(1), True)