diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..bbb5a2ec2 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +venv/ +__pycache__/ +.pytest_cache/ +*.pyc +htmlcov/ +.coverage diff --git a/__init__.py b/praktikum/__init__.py similarity index 100% rename from __init__.py rename to praktikum/__init__.py diff --git a/bun.py b/praktikum/bun.py similarity index 100% rename from bun.py rename to praktikum/bun.py diff --git a/burger.py b/praktikum/burger.py similarity index 100% rename from burger.py rename to praktikum/burger.py diff --git a/database.py b/praktikum/database.py similarity index 100% rename from database.py rename to praktikum/database.py diff --git a/ingredient.py b/praktikum/ingredient.py similarity index 100% rename from ingredient.py rename to praktikum/ingredient.py diff --git a/ingredient_types.py b/praktikum/ingredient_types.py similarity index 100% rename from ingredient_types.py rename to praktikum/ingredient_types.py diff --git a/praktikum.py b/praktikum/praktikum.py similarity index 100% rename from praktikum.py rename to praktikum/praktikum.py diff --git a/tests/test_bun.py b/tests/test_bun.py new file mode 100644 index 000000000..5b073063b --- /dev/null +++ b/tests/test_bun.py @@ -0,0 +1,23 @@ +import pytest +from praktikum.bun import Bun + + +class TestBun: + + @pytest.mark.parametrize("name, price", [ + ("black bun", 100), + ("white bun", 200), + ("red bun", 300), + ]) + def test_get_name_returns_name_passed_to_constructor(self, name, price): + bun = Bun(name, price) + assert bun.get_name() == name + + @pytest.mark.parametrize("name, price", [ + ("black bun", 100.0), + ("white bun", 200.5), + ("red bun", 300.99), + ]) + def test_get_price_returns_price_passed_to_constructor(self, name, price): + bun = Bun(name, price) + assert bun.get_price() == price \ No newline at end of file diff --git a/tests/test_burger.py b/tests/test_burger.py new file mode 100644 index 000000000..df9dbd5fd --- /dev/null +++ b/tests/test_burger.py @@ -0,0 +1,92 @@ +from unittest.mock import Mock +import pytest +from praktikum.burger import Burger + + +class TestBurger: + + def test_set_buns_stores_bun(self): + burger = Burger() + mock_bun = Mock() + burger.set_buns(mock_bun) + assert burger.bun == mock_bun + + def test_add_ingredient_adds_to_list(self): + burger = Burger() + mock_ingredient = Mock() + burger.add_ingredient(mock_ingredient) + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == mock_ingredient + + def test_remove_ingredient_removes_by_index(self): + burger = Burger() + mock_ingredient1 = Mock() + mock_ingredient2 = Mock() + burger.add_ingredient(mock_ingredient1) + burger.add_ingredient(mock_ingredient2) + burger.remove_ingredient(0) + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == mock_ingredient2 + + def test_move_ingredient_changes_order(self): + burger = Burger() + mock_ingredient1 = Mock() + mock_ingredient2 = Mock() + mock_ingredient3 = Mock() + burger.add_ingredient(mock_ingredient1) + burger.add_ingredient(mock_ingredient2) + burger.add_ingredient(mock_ingredient3) + burger.move_ingredient(0, 2) + assert burger.ingredients[0] == mock_ingredient2 + assert burger.ingredients[1] == mock_ingredient3 + assert burger.ingredients[2] == mock_ingredient1 + + @pytest.mark.parametrize("bun_price, ingredient_prices, expected_price", [ + (100, [], 200), + (200, [100], 500), + (300, [100, 200], 900), + (150.5, [50.5, 75.0], 426.5), + ]) + def test_get_price_calculates_correctly(self, bun_price, ingredient_prices, expected_price): + burger = Burger() + mock_bun = Mock() + mock_bun.get_price.return_value = bun_price + burger.set_buns(mock_bun) + + for price in ingredient_prices: + mock_ingredient = Mock() + mock_ingredient.get_price.return_value = price + burger.add_ingredient(mock_ingredient) + + assert burger.get_price() == expected_price + + def test_get_receipt_returns_formatted_string(self): + burger = Burger() + mock_bun = Mock() + mock_bun.get_name.return_value = "black bun" + mock_bun.get_price.return_value = 100 + burger.set_buns(mock_bun) + + mock_ingredient1 = Mock() + mock_ingredient1.get_type.return_value = "SAUCE" + mock_ingredient1.get_name.return_value = "hot sauce" + mock_ingredient1.get_price.return_value = 100 + + mock_ingredient2 = Mock() + mock_ingredient2.get_type.return_value = "FILLING" + mock_ingredient2.get_name.return_value = "cutlet" + mock_ingredient2.get_price.return_value = 100 + + burger.add_ingredient(mock_ingredient1) + burger.add_ingredient(mock_ingredient2) + + expected_receipt = ( + "(==== black bun ====)\n" + "= sauce hot sauce =\n" + "= filling cutlet =\n" + "(==== black bun ====)\n" + "\n" + "Price: 400" + ) + + assert burger.get_receipt() == expected_receipt \ No newline at end of file diff --git a/tests/test_database.py b/tests/test_database.py new file mode 100644 index 000000000..9aabe16fc --- /dev/null +++ b/tests/test_database.py @@ -0,0 +1,19 @@ +from praktikum.database import Database + + +class TestDatabase: + + def test_available_buns_returns_list_of_three_buns(self): + database = Database() + buns = database.available_buns() + assert len(buns) == 3 + assert buns[0].get_name() == "black bun" + assert buns[1].get_name() == "white bun" + assert buns[2].get_name() == "red bun" + + def test_available_ingredients_returns_list_of_six_ingredients(self): + database = Database() + ingredients = database.available_ingredients() + assert len(ingredients) == 6 + assert ingredients[0].get_name() == "hot sauce" + assert ingredients[3].get_name() == "cutlet" \ No newline at end of file diff --git a/tests/test_ingredient.py b/tests/test_ingredient.py new file mode 100644 index 000000000..e3cc85ece --- /dev/null +++ b/tests/test_ingredient.py @@ -0,0 +1,30 @@ +import pytest +from praktikum.ingredient import Ingredient +from praktikum.ingredient_types import INGREDIENT_TYPE_SAUCE, INGREDIENT_TYPE_FILLING + + +class TestIngredient: + + @pytest.mark.parametrize("ingredient_type, name, price", [ + (INGREDIENT_TYPE_SAUCE, "hot sauce", 100), + (INGREDIENT_TYPE_FILLING, "cutlet", 150), + ]) + def test_get_name_returns_name_passed_to_constructor(self, ingredient_type, name, price): + ingredient = Ingredient(ingredient_type, name, price) + assert ingredient.get_name() == name + + @pytest.mark.parametrize("ingredient_type, name, price", [ + (INGREDIENT_TYPE_SAUCE, "sour cream", 200.0), + (INGREDIENT_TYPE_FILLING, "dinosaur", 200.5), + ]) + def test_get_price_returns_price_passed_to_constructor(self, ingredient_type, name, price): + ingredient = Ingredient(ingredient_type, name, price) + assert ingredient.get_price() == price + + @pytest.mark.parametrize("ingredient_type, name, price", [ + (INGREDIENT_TYPE_SAUCE, "chili sauce", 300), + (INGREDIENT_TYPE_FILLING, "sausage", 350), + ]) + def test_get_type_returns_type_passed_to_constructor(self, ingredient_type, name, price): + ingredient = Ingredient(ingredient_type, name, price) + assert ingredient.get_type() == ingredient_type \ No newline at end of file