From 63e419616732eee95bef68a483f3e01be8d29b6f Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 11:06:33 +0300 Subject: [PATCH 01/19] =?UTF-8?q?=5F=5Finit=5F=5F.py=20-=20=D0=9F=D1=83?= =?UTF-8?q?=D1=81=D1=82=D0=BE=D0=B9=20=D1=84=D0=B0=D0=B9=D0=BB=20=D0=B4?= =?UTF-8?q?=D0=BB=D1=8F=20=D0=BC=D0=B0=D1=80=D0=BA=D0=B8=D1=80=D0=BE=D0=B2?= =?UTF-8?q?=D0=BA=D0=B8=20=D0=B4=D0=B8=D1=80=D0=B5=D0=BA=D1=82=D0=BE=D1=80?= =?UTF-8?q?=D0=B8=D0=B8=20=D0=BA=D0=B0=D0=BA=20=D0=BF=D0=B0=D0=BA=D0=B5?= =?UTF-8?q?=D1=82=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 tests/__init__.py diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 000000000..e69de29bb From 95c47097e83fcc61b14e78d8ecacd5dbcad77a28 Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 11:14:52 +0300 Subject: [PATCH 02/19] =?UTF-8?q?conftest.py=20-=20=D1=84=D0=B8=D0=BA?= =?UTF-8?q?=D1=81=D1=82=D1=83=D1=80=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/conftest.py | 48 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 tests/conftest.py diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 000000000..ba018191c --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,48 @@ +import pytest +from unittest.mock import Mock +from praktikum.burger import Burger + + +@pytest.fixture +def burger(): + """Фикстура для создания бургера""" + return Burger() + + +@pytest.fixture +def mock_bun(): + """Фикстура для создания мока булочки""" + mock = Mock() + mock.get_name.return_value = "test bun" + mock.get_price.return_value = 100.0 + return mock + + +@pytest.fixture +def mock_ingredient_sauce(): + """Фикстура для создания мока соуса""" + mock = Mock() + mock.get_type.return_value = "SAUCE" + mock.get_name.return_value = "test sauce" + mock.get_price.return_value = 50.0 + return mock + + +@pytest.fixture +def mock_ingredient_filling(): + """Фикстура для создания мока начинки""" + mock = Mock() + mock.get_type.return_value = "FILLING" + mock.get_name.return_value = "test filling" + mock.get_price.return_value = 75.0 + return mock + + +@pytest.fixture +def mock_ingredient_extra(): + """Фикстура для создания дополнительного мока ингредиента""" + mock = Mock() + mock.get_type.return_value = "SAUCE" + mock.get_name.return_value = "extra sauce" + mock.get_price.return_value = 25.0 + return mock \ No newline at end of file From 9a3bd0c3df92a87df2af23cd9cb2354002c08449 Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 11:17:39 +0300 Subject: [PATCH 03/19] =?UTF-8?q?test=5Fburger.py=20-=20=D1=82=D0=B5=D1=81?= =?UTF-8?q?=D1=82=D1=8B=20=D0=B4=D0=BB=D1=8F=20=D0=BA=D0=BB=D0=B0=D1=81?= =?UTF-8?q?=D1=81=D0=B0=20Burger?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/test_burger.py | 349 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 349 insertions(+) create mode 100644 tests/test_burger.py diff --git a/tests/test_burger.py b/tests/test_burger.py new file mode 100644 index 000000000..4a4d501b9 --- /dev/null +++ b/tests/test_burger.py @@ -0,0 +1,349 @@ +import pytest +from unittest.mock import Mock +from praktikum.burger import Burger + + +class TestBurger: + """Тесты для класса Burger""" + + def test_burger_initialization(self, burger): + """Тест инициализации бургера""" + assert burger.bun is None + assert len(burger.ingredients) == 0 + assert isinstance(burger.ingredients, list) + + @pytest.mark.parametrize("bun_name, bun_price", [ + ("black bun", 100), + ("white bun", 200), + ("red bun", 300), + ]) + def test_set_buns_with_real_bun(self, burger, bun_name, bun_price): + """Тест установки булочки с реальными данными""" + from praktikum.bun import Bun + bun = Bun(bun_name, bun_price) + burger.set_buns(bun) + + assert burger.bun == bun + assert burger.bun.get_name() == bun_name + assert burger.bun.get_price() == bun_price + + def test_set_buns_with_mock(self, burger, mock_bun): + """Тест установки булочки с использованием мока""" + burger.set_buns(mock_bun) + assert burger.bun == mock_bun + mock_bun.get_name.assert_called_once() + mock_bun.get_price.assert_not_called() + + @pytest.mark.parametrize("ingredient_type, ingredient_name, ingredient_price", [ + ("SAUCE", "hot sauce", 100), + ("FILLING", "cutlet", 150), + ("SAUCE", "chili sauce", 200), + ]) + def test_add_ingredient_with_real_ingredient(self, burger, ingredient_type, ingredient_name, ingredient_price): + """Тест добавления ингредиента с реальными данными""" + from praktikum.ingredient import Ingredient + ingredient = Ingredient(ingredient_type, ingredient_name, ingredient_price) + burger.add_ingredient(ingredient) + + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == ingredient + assert burger.ingredients[0].get_type() == ingredient_type + assert burger.ingredients[0].get_name() == ingredient_name + assert burger.ingredients[0].get_price() == ingredient_price + + def test_add_ingredient_with_mock(self, burger, mock_ingredient_sauce): + """Тест добавления ингредиента с использованием мока""" + burger.add_ingredient(mock_ingredient_sauce) + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == mock_ingredient_sauce + + @pytest.mark.parametrize("num_ingredients", [1, 3, 5]) + def test_add_multiple_ingredients(self, burger, mock_ingredient_sauce, num_ingredients): + """Тест добавления нескольких ингредиентов""" + for _ in range(num_ingredients): + burger.add_ingredient(mock_ingredient_sauce) + + assert len(burger.ingredients) == num_ingredients + assert all(ing == mock_ingredient_sauce for ing in burger.ingredients) + + @pytest.mark.parametrize("remove_index, expected_length", [ + (0, 2), + (1, 2), + (2, 2), + ]) + def test_remove_ingredient(self, burger, mock_ingredient_sauce, mock_ingredient_filling, + mock_ingredient_extra, remove_index, expected_length): + """Тест удаления ингредиента по индексу""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + burger.add_ingredient(mock_ingredient_extra) + + burger.remove_ingredient(remove_index) + assert len(burger.ingredients) == expected_length + + def test_remove_ingredient_first(self, burger, mock_ingredient_sauce, mock_ingredient_filling): + """Тест удаления первого ингредиента""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + + burger.remove_ingredient(0) + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == mock_ingredient_filling + + def test_remove_ingredient_last(self, burger, mock_ingredient_sauce, mock_ingredient_filling): + """Тест удаления последнего ингредиента""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + + burger.remove_ingredient(1) + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == mock_ingredient_sauce + + @pytest.mark.parametrize("from_index, to_index, expected_order", [ + (0, 1, [1, 0]), + (1, 0, [1, 0]), + (0, 2, [1, 2, 0]), + (2, 0, [2, 0, 1]), + ]) + def test_move_ingredient(self, burger, mock_ingredient_sauce, mock_ingredient_filling, + mock_ingredient_extra, from_index, to_index, expected_order): + """Тест перемещения ингредиента с различными параметрами""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + burger.add_ingredient(mock_ingredient_extra) + + original_ingredients = burger.ingredients.copy() + burger.move_ingredient(from_index, to_index) + + # Проверяем порядок + for i, idx in enumerate(expected_order): + assert burger.ingredients[i] == original_ingredients[idx] + + def test_move_ingredient_same_position(self, burger, mock_ingredient_sauce, mock_ingredient_filling): + """Тест перемещения ингредиента на ту же позицию""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + + burger.move_ingredient(0, 0) + assert burger.ingredients[0] == mock_ingredient_sauce + assert burger.ingredients[1] == mock_ingredient_filling + + def test_get_price_without_bun(self, burger, mock_ingredient_sauce): + """Тест получения цены без булочки - должно вызвать ошибку""" + burger.add_ingredient(mock_ingredient_sauce) + with pytest.raises(AttributeError): + burger.get_price() + + @pytest.mark.parametrize("bun_price, expected_price", [ + (100, 200), + (150, 300), + (200, 400), + ]) + def test_get_price_with_bun_only(self, burger, bun_price, expected_price): + """Тест получения цены только с булочкой""" + mock_bun = Mock() + mock_bun.get_price.return_value = bun_price + burger.set_buns(mock_bun) + + assert burger.get_price() == expected_price + mock_bun.get_price.assert_called_once() + + @pytest.mark.parametrize("bun_price, sauce_price, filling_price, expected_price", [ + (100, 50, 75, 325), + (150, 30, 40, 370), + (200, 100, 150, 650), + ]) + def test_get_price_with_ingredients(self, burger, bun_price, sauce_price, filling_price, expected_price): + """Тест получения цены с булочкой и ингредиентами""" + mock_bun = Mock() + mock_bun.get_price.return_value = bun_price + + mock_sauce = Mock() + mock_sauce.get_price.return_value = sauce_price + + mock_filling = Mock() + mock_filling.get_price.return_value = filling_price + + burger.set_buns(mock_bun) + burger.add_ingredient(mock_sauce) + burger.add_ingredient(mock_filling) + + assert burger.get_price() == expected_price + + # Проверяем вызовы методов + assert mock_bun.get_price.call_count == 1 + assert mock_sauce.get_price.call_count == 1 + assert mock_filling.get_price.call_count == 1 + + def test_get_price_multiple_ingredients(self, burger, mock_bun): + """Тест получения цены с несколькими ингредиентами""" + burger.set_buns(mock_bun) + + mock_ingredients = [] + total_price = 0 + + for price in [10, 20, 30, 40, 50]: + mock_ing = Mock() + mock_ing.get_price.return_value = price + mock_ingredients.append(mock_ing) + burger.add_ingredient(mock_ing) + total_price += price + + expected_price = mock_bun.get_price() * 2 + total_price + assert burger.get_price() == expected_price + + def test_get_receipt_without_bun(self, burger, mock_ingredient_sauce): + """Тест получения чека без булочки - должно вызвать ошибку""" + burger.add_ingredient(mock_ingredient_sauce) + with pytest.raises(AttributeError): + burger.get_receipt() + + @pytest.mark.parametrize("bun_name", [ + "black bun", + "white bun", + "red bun", + ]) + def test_get_receipt_with_bun_only(self, burger, bun_name): + """Тест получения чека только с булочкой""" + mock_bun = Mock() + mock_bun.get_name.return_value = bun_name + mock_bun.get_price.return_value = 100 + + burger.set_buns(mock_bun) + + expected_receipt = f"""(==== {bun_name} ====) +(==== {bun_name} ====) +Price: 200.0""" + + assert burger.get_receipt() == expected_receipt + assert mock_bun.get_name.call_count == 2 + + @pytest.mark.parametrize("ingredient_type, ingredient_name", [ + ("SAUCE", "hot sauce"), + ("FILLING", "cutlet"), + ("SAUCE", "chili sauce"), + ]) + def test_get_receipt_with_one_ingredient(self, burger, mock_bun, ingredient_type, ingredient_name): + """Тест получения чека с одним ингредиентом""" + mock_bun.get_name.return_value = "test bun" + burger.set_buns(mock_bun) + + mock_ingredient = Mock() + mock_ingredient.get_type.return_value = ingredient_type + mock_ingredient.get_name.return_value = ingredient_name + mock_ingredient.get_price.return_value = 50 + + burger.add_ingredient(mock_ingredient) + + expected_receipt = f"""(==== test bun ====) += {ingredient_type.lower()} {ingredient_name} = +(==== test bun ====) +Price: 250.0""" + + assert burger.get_receipt() == expected_receipt + + def test_get_receipt_with_multiple_ingredients(self, burger, mock_bun): + """Тест получения чека с несколькими ингредиентами""" + mock_bun.get_name.return_value = "test bun" + mock_bun.get_price.return_value = 100 + burger.set_buns(mock_bun) + + ingredients_data = [ + ("SAUCE", "sauce1", 50), + ("FILLING", "filling1", 75), + ("SAUCE", "sauce2", 30), + ("FILLING", "filling2", 40), + ] + + for ing_type, ing_name, price in ingredients_data: + mock_ing = Mock() + mock_ing.get_type.return_value = ing_type + mock_ing.get_name.return_value = ing_name + mock_ing.get_price.return_value = price + burger.add_ingredient(mock_ing) + + expected_lines = ["(==== test bun ====)"] + for ing_type, ing_name, _ in ingredients_data: + expected_lines.append(f"= {ing_type.lower()} {ing_name} =") + expected_lines.append("(==== test bun ====)") + expected_lines.append("Price: 395.0") + + expected_receipt = "\n".join(expected_lines) + assert burger.get_receipt() == expected_receipt + + def test_get_receipt_with_mocks_verification(self, burger, mock_bun, mock_ingredient_sauce): + """Тест проверки вызовов моков при получении чека""" + burger.set_buns(mock_bun) + burger.add_ingredient(mock_ingredient_sauce) + burger.get_receipt() + + # Проверяем что методы были вызваны + mock_bun.get_name.assert_called() + mock_ingredient_sauce.get_type.assert_called_once() + mock_ingredient_sauce.get_name.assert_called_once() + mock_ingredient_sauce.get_price.assert_called_once() + + def test_complex_operations_sequence(self, burger, mock_bun, mock_ingredient_sauce, + mock_ingredient_filling, mock_ingredient_extra): + """Тест последовательности сложных операций с бургером""" + # 1. Устанавливаем булочку + burger.set_buns(mock_bun) + assert burger.bun == mock_bun + + # 2. Добавляем ингредиенты + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + burger.add_ingredient(mock_ingredient_extra) + burger.add_ingredient(mock_ingredient_sauce) + assert len(burger.ingredients) == 4 + + # 3. Перемещаем ингредиенты + burger.move_ingredient(0, 2) # sauce -> после filling + assert burger.ingredients[0] == mock_ingredient_filling + assert burger.ingredients[1] == mock_ingredient_extra + assert burger.ingredients[2] == mock_ingredient_sauce + assert burger.ingredients[3] == mock_ingredient_sauce + + burger.move_ingredient(3, 1) # sauce -> после extra + assert burger.ingredients[0] == mock_ingredient_filling + assert burger.ingredients[1] == mock_ingredient_sauce + assert burger.ingredients[2] == mock_ingredient_extra + assert burger.ingredients[3] == mock_ingredient_sauce + + # 4. Удаляем ингредиенты + burger.remove_ingredient(2) # удаляем extra + assert len(burger.ingredients) == 3 + assert burger.ingredients[0] == mock_ingredient_filling + assert burger.ingredients[1] == mock_ingredient_sauce + assert burger.ingredients[2] == mock_ingredient_sauce + + burger.remove_ingredient(0) # удаляем filling + assert len(burger.ingredients) == 2 + assert burger.ingredients[0] == mock_ingredient_sauce + assert burger.ingredients[1] == mock_ingredient_sauce + + # 5. Проверяем цену + mock_bun.get_price.return_value = 100 + mock_ingredient_sauce.get_price.return_value = 50 + expected_price = 100 * 2 + 50 + 50 # 300 + assert burger.get_price() == expected_price + + @pytest.mark.parametrize("operation, expected_result", [ + ("add", 1), + ("remove", 0), + ("move", 1), + ]) + def test_operations_with_mocks(self, burger, mock_ingredient_sauce, operation, expected_result): + """Тест различных операций с использованием моков""" + if operation == "add": + burger.add_ingredient(mock_ingredient_sauce) + assert len(burger.ingredients) == expected_result + elif operation == "remove": + burger.add_ingredient(mock_ingredient_sauce) + burger.remove_ingredient(0) + assert len(burger.ingredients) == expected_result + elif operation == "move": + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_sauce) + burger.move_ingredient(0, 1) + assert len(burger.ingredients) == expected_result \ No newline at end of file From 3fe5dd8a6fba77cd3c927ee452f97acfd62b1fee Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 11:29:50 +0300 Subject: [PATCH 04/19] =?UTF-8?q?conftest.py=20-=20=D1=84=D0=B8=D0=BA?= =?UTF-8?q?=D1=81=D1=82=D1=83=D1=80=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/conftest.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/tests/conftest.py b/tests/conftest.py index ba018191c..b6aa82bc6 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,6 +1,13 @@ +import sys +import os +from pathlib import Path + +# Добавляем корневую директорию в PYTHONPATH +sys.path.insert(0, str(Path(__file__).parent.parent)) + import pytest from unittest.mock import Mock -from praktikum.burger import Burger +from burger import Burger @pytest.fixture From 04fbe9c81edbfa569d4d9fde5e0c720cee2a7e64 Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 11:30:51 +0300 Subject: [PATCH 05/19] =?UTF-8?q?test=5Fburger.py=20-=20=D1=82=D0=B5=D1=81?= =?UTF-8?q?=D1=82=D1=8B=20=D0=B4=D0=BB=D1=8F=20=D0=BA=D0=BB=D0=B0=D1=81?= =?UTF-8?q?=D1=81=D0=B0=20Burger?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/test_burger.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/tests/test_burger.py b/tests/test_burger.py index 4a4d501b9..a95b1bb55 100644 --- a/tests/test_burger.py +++ b/tests/test_burger.py @@ -1,6 +1,15 @@ +import sys +import os +from pathlib import Path + +# Добавляем корневую директорию в PYTHONPATH +sys.path.insert(0, str(Path(__file__).parent.parent)) + import pytest from unittest.mock import Mock -from praktikum.burger import Burger +from burger import Burger +from bun import Bun +from ingredient import Ingredient class TestBurger: @@ -19,7 +28,6 @@ def test_burger_initialization(self, burger): ]) def test_set_buns_with_real_bun(self, burger, bun_name, bun_price): """Тест установки булочки с реальными данными""" - from praktikum.bun import Bun bun = Bun(bun_name, bun_price) burger.set_buns(bun) @@ -41,7 +49,6 @@ def test_set_buns_with_mock(self, burger, mock_bun): ]) def test_add_ingredient_with_real_ingredient(self, burger, ingredient_type, ingredient_name, ingredient_price): """Тест добавления ингредиента с реальными данными""" - from praktikum.ingredient import Ingredient ingredient = Ingredient(ingredient_type, ingredient_name, ingredient_price) burger.add_ingredient(ingredient) From c710b2413a797ba2ebd1343e0f4a15a28cddf615 Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 11:49:50 +0300 Subject: [PATCH 06/19] =?UTF-8?q?conftest.py=20-=20=D1=84=D0=B8=D0=BA?= =?UTF-8?q?=D1=81=D1=82=D1=83=D1=80=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/__init__.py | 0 tests/conftest.py | 9 +-------- 2 files changed, 1 insertion(+), 8 deletions(-) delete mode 100644 tests/__init__.py diff --git a/tests/__init__.py b/tests/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/tests/conftest.py b/tests/conftest.py index b6aa82bc6..ba018191c 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,13 +1,6 @@ -import sys -import os -from pathlib import Path - -# Добавляем корневую директорию в PYTHONPATH -sys.path.insert(0, str(Path(__file__).parent.parent)) - import pytest from unittest.mock import Mock -from burger import Burger +from praktikum.burger import Burger @pytest.fixture From b5a3fb5294ae70d81bf96a006950960d51c76626 Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 11:50:14 +0300 Subject: [PATCH 07/19] =?UTF-8?q?test=5Fburger.py=20-=20=D1=82=D0=B5=D1=81?= =?UTF-8?q?=D1=82=D1=8B=20=D0=B4=D0=BB=D1=8F=20=D0=BA=D0=BB=D0=B0=D1=81?= =?UTF-8?q?=D1=81=D0=B0=20Burger?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/conftest.py | 48 -------------------------------------------- tests/test_burger.py | 13 +++--------- 2 files changed, 3 insertions(+), 58 deletions(-) delete mode 100644 tests/conftest.py diff --git a/tests/conftest.py b/tests/conftest.py deleted file mode 100644 index ba018191c..000000000 --- a/tests/conftest.py +++ /dev/null @@ -1,48 +0,0 @@ -import pytest -from unittest.mock import Mock -from praktikum.burger import Burger - - -@pytest.fixture -def burger(): - """Фикстура для создания бургера""" - return Burger() - - -@pytest.fixture -def mock_bun(): - """Фикстура для создания мока булочки""" - mock = Mock() - mock.get_name.return_value = "test bun" - mock.get_price.return_value = 100.0 - return mock - - -@pytest.fixture -def mock_ingredient_sauce(): - """Фикстура для создания мока соуса""" - mock = Mock() - mock.get_type.return_value = "SAUCE" - mock.get_name.return_value = "test sauce" - mock.get_price.return_value = 50.0 - return mock - - -@pytest.fixture -def mock_ingredient_filling(): - """Фикстура для создания мока начинки""" - mock = Mock() - mock.get_type.return_value = "FILLING" - mock.get_name.return_value = "test filling" - mock.get_price.return_value = 75.0 - return mock - - -@pytest.fixture -def mock_ingredient_extra(): - """Фикстура для создания дополнительного мока ингредиента""" - mock = Mock() - mock.get_type.return_value = "SAUCE" - mock.get_name.return_value = "extra sauce" - mock.get_price.return_value = 25.0 - return mock \ No newline at end of file diff --git a/tests/test_burger.py b/tests/test_burger.py index a95b1bb55..4a4d501b9 100644 --- a/tests/test_burger.py +++ b/tests/test_burger.py @@ -1,15 +1,6 @@ -import sys -import os -from pathlib import Path - -# Добавляем корневую директорию в PYTHONPATH -sys.path.insert(0, str(Path(__file__).parent.parent)) - import pytest from unittest.mock import Mock -from burger import Burger -from bun import Bun -from ingredient import Ingredient +from praktikum.burger import Burger class TestBurger: @@ -28,6 +19,7 @@ def test_burger_initialization(self, burger): ]) def test_set_buns_with_real_bun(self, burger, bun_name, bun_price): """Тест установки булочки с реальными данными""" + from praktikum.bun import Bun bun = Bun(bun_name, bun_price) burger.set_buns(bun) @@ -49,6 +41,7 @@ def test_set_buns_with_mock(self, burger, mock_bun): ]) def test_add_ingredient_with_real_ingredient(self, burger, ingredient_type, ingredient_name, ingredient_price): """Тест добавления ингредиента с реальными данными""" + from praktikum.ingredient import Ingredient ingredient = Ingredient(ingredient_type, ingredient_name, ingredient_price) burger.add_ingredient(ingredient) From cdf072ea1ec40e2423858c1150f1f029d78f30e8 Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 11:53:59 +0300 Subject: [PATCH 08/19] =?UTF-8?q?conftest.py=20-=20=D1=84=D0=B8=D0=BA?= =?UTF-8?q?=D1=81=D1=82=D1=83=D1=80=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- conftest.py | 48 ++++++ tests/test_burger.py | 349 ------------------------------------------- 2 files changed, 48 insertions(+), 349 deletions(-) create mode 100644 conftest.py delete mode 100644 tests/test_burger.py diff --git a/conftest.py b/conftest.py new file mode 100644 index 000000000..ba018191c --- /dev/null +++ b/conftest.py @@ -0,0 +1,48 @@ +import pytest +from unittest.mock import Mock +from praktikum.burger import Burger + + +@pytest.fixture +def burger(): + """Фикстура для создания бургера""" + return Burger() + + +@pytest.fixture +def mock_bun(): + """Фикстура для создания мока булочки""" + mock = Mock() + mock.get_name.return_value = "test bun" + mock.get_price.return_value = 100.0 + return mock + + +@pytest.fixture +def mock_ingredient_sauce(): + """Фикстура для создания мока соуса""" + mock = Mock() + mock.get_type.return_value = "SAUCE" + mock.get_name.return_value = "test sauce" + mock.get_price.return_value = 50.0 + return mock + + +@pytest.fixture +def mock_ingredient_filling(): + """Фикстура для создания мока начинки""" + mock = Mock() + mock.get_type.return_value = "FILLING" + mock.get_name.return_value = "test filling" + mock.get_price.return_value = 75.0 + return mock + + +@pytest.fixture +def mock_ingredient_extra(): + """Фикстура для создания дополнительного мока ингредиента""" + mock = Mock() + mock.get_type.return_value = "SAUCE" + mock.get_name.return_value = "extra sauce" + mock.get_price.return_value = 25.0 + return mock \ No newline at end of file diff --git a/tests/test_burger.py b/tests/test_burger.py deleted file mode 100644 index 4a4d501b9..000000000 --- a/tests/test_burger.py +++ /dev/null @@ -1,349 +0,0 @@ -import pytest -from unittest.mock import Mock -from praktikum.burger import Burger - - -class TestBurger: - """Тесты для класса Burger""" - - def test_burger_initialization(self, burger): - """Тест инициализации бургера""" - assert burger.bun is None - assert len(burger.ingredients) == 0 - assert isinstance(burger.ingredients, list) - - @pytest.mark.parametrize("bun_name, bun_price", [ - ("black bun", 100), - ("white bun", 200), - ("red bun", 300), - ]) - def test_set_buns_with_real_bun(self, burger, bun_name, bun_price): - """Тест установки булочки с реальными данными""" - from praktikum.bun import Bun - bun = Bun(bun_name, bun_price) - burger.set_buns(bun) - - assert burger.bun == bun - assert burger.bun.get_name() == bun_name - assert burger.bun.get_price() == bun_price - - def test_set_buns_with_mock(self, burger, mock_bun): - """Тест установки булочки с использованием мока""" - burger.set_buns(mock_bun) - assert burger.bun == mock_bun - mock_bun.get_name.assert_called_once() - mock_bun.get_price.assert_not_called() - - @pytest.mark.parametrize("ingredient_type, ingredient_name, ingredient_price", [ - ("SAUCE", "hot sauce", 100), - ("FILLING", "cutlet", 150), - ("SAUCE", "chili sauce", 200), - ]) - def test_add_ingredient_with_real_ingredient(self, burger, ingredient_type, ingredient_name, ingredient_price): - """Тест добавления ингредиента с реальными данными""" - from praktikum.ingredient import Ingredient - ingredient = Ingredient(ingredient_type, ingredient_name, ingredient_price) - burger.add_ingredient(ingredient) - - assert len(burger.ingredients) == 1 - assert burger.ingredients[0] == ingredient - assert burger.ingredients[0].get_type() == ingredient_type - assert burger.ingredients[0].get_name() == ingredient_name - assert burger.ingredients[0].get_price() == ingredient_price - - def test_add_ingredient_with_mock(self, burger, mock_ingredient_sauce): - """Тест добавления ингредиента с использованием мока""" - burger.add_ingredient(mock_ingredient_sauce) - assert len(burger.ingredients) == 1 - assert burger.ingredients[0] == mock_ingredient_sauce - - @pytest.mark.parametrize("num_ingredients", [1, 3, 5]) - def test_add_multiple_ingredients(self, burger, mock_ingredient_sauce, num_ingredients): - """Тест добавления нескольких ингредиентов""" - for _ in range(num_ingredients): - burger.add_ingredient(mock_ingredient_sauce) - - assert len(burger.ingredients) == num_ingredients - assert all(ing == mock_ingredient_sauce for ing in burger.ingredients) - - @pytest.mark.parametrize("remove_index, expected_length", [ - (0, 2), - (1, 2), - (2, 2), - ]) - def test_remove_ingredient(self, burger, mock_ingredient_sauce, mock_ingredient_filling, - mock_ingredient_extra, remove_index, expected_length): - """Тест удаления ингредиента по индексу""" - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_filling) - burger.add_ingredient(mock_ingredient_extra) - - burger.remove_ingredient(remove_index) - assert len(burger.ingredients) == expected_length - - def test_remove_ingredient_first(self, burger, mock_ingredient_sauce, mock_ingredient_filling): - """Тест удаления первого ингредиента""" - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_filling) - - burger.remove_ingredient(0) - assert len(burger.ingredients) == 1 - assert burger.ingredients[0] == mock_ingredient_filling - - def test_remove_ingredient_last(self, burger, mock_ingredient_sauce, mock_ingredient_filling): - """Тест удаления последнего ингредиента""" - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_filling) - - burger.remove_ingredient(1) - assert len(burger.ingredients) == 1 - assert burger.ingredients[0] == mock_ingredient_sauce - - @pytest.mark.parametrize("from_index, to_index, expected_order", [ - (0, 1, [1, 0]), - (1, 0, [1, 0]), - (0, 2, [1, 2, 0]), - (2, 0, [2, 0, 1]), - ]) - def test_move_ingredient(self, burger, mock_ingredient_sauce, mock_ingredient_filling, - mock_ingredient_extra, from_index, to_index, expected_order): - """Тест перемещения ингредиента с различными параметрами""" - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_filling) - burger.add_ingredient(mock_ingredient_extra) - - original_ingredients = burger.ingredients.copy() - burger.move_ingredient(from_index, to_index) - - # Проверяем порядок - for i, idx in enumerate(expected_order): - assert burger.ingredients[i] == original_ingredients[idx] - - def test_move_ingredient_same_position(self, burger, mock_ingredient_sauce, mock_ingredient_filling): - """Тест перемещения ингредиента на ту же позицию""" - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_filling) - - burger.move_ingredient(0, 0) - assert burger.ingredients[0] == mock_ingredient_sauce - assert burger.ingredients[1] == mock_ingredient_filling - - def test_get_price_without_bun(self, burger, mock_ingredient_sauce): - """Тест получения цены без булочки - должно вызвать ошибку""" - burger.add_ingredient(mock_ingredient_sauce) - with pytest.raises(AttributeError): - burger.get_price() - - @pytest.mark.parametrize("bun_price, expected_price", [ - (100, 200), - (150, 300), - (200, 400), - ]) - def test_get_price_with_bun_only(self, burger, bun_price, expected_price): - """Тест получения цены только с булочкой""" - mock_bun = Mock() - mock_bun.get_price.return_value = bun_price - burger.set_buns(mock_bun) - - assert burger.get_price() == expected_price - mock_bun.get_price.assert_called_once() - - @pytest.mark.parametrize("bun_price, sauce_price, filling_price, expected_price", [ - (100, 50, 75, 325), - (150, 30, 40, 370), - (200, 100, 150, 650), - ]) - def test_get_price_with_ingredients(self, burger, bun_price, sauce_price, filling_price, expected_price): - """Тест получения цены с булочкой и ингредиентами""" - mock_bun = Mock() - mock_bun.get_price.return_value = bun_price - - mock_sauce = Mock() - mock_sauce.get_price.return_value = sauce_price - - mock_filling = Mock() - mock_filling.get_price.return_value = filling_price - - burger.set_buns(mock_bun) - burger.add_ingredient(mock_sauce) - burger.add_ingredient(mock_filling) - - assert burger.get_price() == expected_price - - # Проверяем вызовы методов - assert mock_bun.get_price.call_count == 1 - assert mock_sauce.get_price.call_count == 1 - assert mock_filling.get_price.call_count == 1 - - def test_get_price_multiple_ingredients(self, burger, mock_bun): - """Тест получения цены с несколькими ингредиентами""" - burger.set_buns(mock_bun) - - mock_ingredients = [] - total_price = 0 - - for price in [10, 20, 30, 40, 50]: - mock_ing = Mock() - mock_ing.get_price.return_value = price - mock_ingredients.append(mock_ing) - burger.add_ingredient(mock_ing) - total_price += price - - expected_price = mock_bun.get_price() * 2 + total_price - assert burger.get_price() == expected_price - - def test_get_receipt_without_bun(self, burger, mock_ingredient_sauce): - """Тест получения чека без булочки - должно вызвать ошибку""" - burger.add_ingredient(mock_ingredient_sauce) - with pytest.raises(AttributeError): - burger.get_receipt() - - @pytest.mark.parametrize("bun_name", [ - "black bun", - "white bun", - "red bun", - ]) - def test_get_receipt_with_bun_only(self, burger, bun_name): - """Тест получения чека только с булочкой""" - mock_bun = Mock() - mock_bun.get_name.return_value = bun_name - mock_bun.get_price.return_value = 100 - - burger.set_buns(mock_bun) - - expected_receipt = f"""(==== {bun_name} ====) -(==== {bun_name} ====) -Price: 200.0""" - - assert burger.get_receipt() == expected_receipt - assert mock_bun.get_name.call_count == 2 - - @pytest.mark.parametrize("ingredient_type, ingredient_name", [ - ("SAUCE", "hot sauce"), - ("FILLING", "cutlet"), - ("SAUCE", "chili sauce"), - ]) - def test_get_receipt_with_one_ingredient(self, burger, mock_bun, ingredient_type, ingredient_name): - """Тест получения чека с одним ингредиентом""" - mock_bun.get_name.return_value = "test bun" - burger.set_buns(mock_bun) - - mock_ingredient = Mock() - mock_ingredient.get_type.return_value = ingredient_type - mock_ingredient.get_name.return_value = ingredient_name - mock_ingredient.get_price.return_value = 50 - - burger.add_ingredient(mock_ingredient) - - expected_receipt = f"""(==== test bun ====) -= {ingredient_type.lower()} {ingredient_name} = -(==== test bun ====) -Price: 250.0""" - - assert burger.get_receipt() == expected_receipt - - def test_get_receipt_with_multiple_ingredients(self, burger, mock_bun): - """Тест получения чека с несколькими ингредиентами""" - mock_bun.get_name.return_value = "test bun" - mock_bun.get_price.return_value = 100 - burger.set_buns(mock_bun) - - ingredients_data = [ - ("SAUCE", "sauce1", 50), - ("FILLING", "filling1", 75), - ("SAUCE", "sauce2", 30), - ("FILLING", "filling2", 40), - ] - - for ing_type, ing_name, price in ingredients_data: - mock_ing = Mock() - mock_ing.get_type.return_value = ing_type - mock_ing.get_name.return_value = ing_name - mock_ing.get_price.return_value = price - burger.add_ingredient(mock_ing) - - expected_lines = ["(==== test bun ====)"] - for ing_type, ing_name, _ in ingredients_data: - expected_lines.append(f"= {ing_type.lower()} {ing_name} =") - expected_lines.append("(==== test bun ====)") - expected_lines.append("Price: 395.0") - - expected_receipt = "\n".join(expected_lines) - assert burger.get_receipt() == expected_receipt - - def test_get_receipt_with_mocks_verification(self, burger, mock_bun, mock_ingredient_sauce): - """Тест проверки вызовов моков при получении чека""" - burger.set_buns(mock_bun) - burger.add_ingredient(mock_ingredient_sauce) - burger.get_receipt() - - # Проверяем что методы были вызваны - mock_bun.get_name.assert_called() - mock_ingredient_sauce.get_type.assert_called_once() - mock_ingredient_sauce.get_name.assert_called_once() - mock_ingredient_sauce.get_price.assert_called_once() - - def test_complex_operations_sequence(self, burger, mock_bun, mock_ingredient_sauce, - mock_ingredient_filling, mock_ingredient_extra): - """Тест последовательности сложных операций с бургером""" - # 1. Устанавливаем булочку - burger.set_buns(mock_bun) - assert burger.bun == mock_bun - - # 2. Добавляем ингредиенты - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_filling) - burger.add_ingredient(mock_ingredient_extra) - burger.add_ingredient(mock_ingredient_sauce) - assert len(burger.ingredients) == 4 - - # 3. Перемещаем ингредиенты - burger.move_ingredient(0, 2) # sauce -> после filling - assert burger.ingredients[0] == mock_ingredient_filling - assert burger.ingredients[1] == mock_ingredient_extra - assert burger.ingredients[2] == mock_ingredient_sauce - assert burger.ingredients[3] == mock_ingredient_sauce - - burger.move_ingredient(3, 1) # sauce -> после extra - assert burger.ingredients[0] == mock_ingredient_filling - assert burger.ingredients[1] == mock_ingredient_sauce - assert burger.ingredients[2] == mock_ingredient_extra - assert burger.ingredients[3] == mock_ingredient_sauce - - # 4. Удаляем ингредиенты - burger.remove_ingredient(2) # удаляем extra - assert len(burger.ingredients) == 3 - assert burger.ingredients[0] == mock_ingredient_filling - assert burger.ingredients[1] == mock_ingredient_sauce - assert burger.ingredients[2] == mock_ingredient_sauce - - burger.remove_ingredient(0) # удаляем filling - assert len(burger.ingredients) == 2 - assert burger.ingredients[0] == mock_ingredient_sauce - assert burger.ingredients[1] == mock_ingredient_sauce - - # 5. Проверяем цену - mock_bun.get_price.return_value = 100 - mock_ingredient_sauce.get_price.return_value = 50 - expected_price = 100 * 2 + 50 + 50 # 300 - assert burger.get_price() == expected_price - - @pytest.mark.parametrize("operation, expected_result", [ - ("add", 1), - ("remove", 0), - ("move", 1), - ]) - def test_operations_with_mocks(self, burger, mock_ingredient_sauce, operation, expected_result): - """Тест различных операций с использованием моков""" - if operation == "add": - burger.add_ingredient(mock_ingredient_sauce) - assert len(burger.ingredients) == expected_result - elif operation == "remove": - burger.add_ingredient(mock_ingredient_sauce) - burger.remove_ingredient(0) - assert len(burger.ingredients) == expected_result - elif operation == "move": - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_sauce) - burger.move_ingredient(0, 1) - assert len(burger.ingredients) == expected_result \ No newline at end of file From c1e429bd234228979e253a4030361416b138c7f0 Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 11:55:18 +0300 Subject: [PATCH 09/19] =?UTF-8?q?test=5Fburger.py=20-=20=D1=82=D0=B5=D1=81?= =?UTF-8?q?=D1=82=D1=8B=20=D0=B4=D0=BB=D1=8F=20=D0=BA=D0=BB=D0=B0=D1=81?= =?UTF-8?q?=D1=81=D0=B0=20Burger?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test_burger.py | 349 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 349 insertions(+) create mode 100644 test_burger.py diff --git a/test_burger.py b/test_burger.py new file mode 100644 index 000000000..4a4d501b9 --- /dev/null +++ b/test_burger.py @@ -0,0 +1,349 @@ +import pytest +from unittest.mock import Mock +from praktikum.burger import Burger + + +class TestBurger: + """Тесты для класса Burger""" + + def test_burger_initialization(self, burger): + """Тест инициализации бургера""" + assert burger.bun is None + assert len(burger.ingredients) == 0 + assert isinstance(burger.ingredients, list) + + @pytest.mark.parametrize("bun_name, bun_price", [ + ("black bun", 100), + ("white bun", 200), + ("red bun", 300), + ]) + def test_set_buns_with_real_bun(self, burger, bun_name, bun_price): + """Тест установки булочки с реальными данными""" + from praktikum.bun import Bun + bun = Bun(bun_name, bun_price) + burger.set_buns(bun) + + assert burger.bun == bun + assert burger.bun.get_name() == bun_name + assert burger.bun.get_price() == bun_price + + def test_set_buns_with_mock(self, burger, mock_bun): + """Тест установки булочки с использованием мока""" + burger.set_buns(mock_bun) + assert burger.bun == mock_bun + mock_bun.get_name.assert_called_once() + mock_bun.get_price.assert_not_called() + + @pytest.mark.parametrize("ingredient_type, ingredient_name, ingredient_price", [ + ("SAUCE", "hot sauce", 100), + ("FILLING", "cutlet", 150), + ("SAUCE", "chili sauce", 200), + ]) + def test_add_ingredient_with_real_ingredient(self, burger, ingredient_type, ingredient_name, ingredient_price): + """Тест добавления ингредиента с реальными данными""" + from praktikum.ingredient import Ingredient + ingredient = Ingredient(ingredient_type, ingredient_name, ingredient_price) + burger.add_ingredient(ingredient) + + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == ingredient + assert burger.ingredients[0].get_type() == ingredient_type + assert burger.ingredients[0].get_name() == ingredient_name + assert burger.ingredients[0].get_price() == ingredient_price + + def test_add_ingredient_with_mock(self, burger, mock_ingredient_sauce): + """Тест добавления ингредиента с использованием мока""" + burger.add_ingredient(mock_ingredient_sauce) + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == mock_ingredient_sauce + + @pytest.mark.parametrize("num_ingredients", [1, 3, 5]) + def test_add_multiple_ingredients(self, burger, mock_ingredient_sauce, num_ingredients): + """Тест добавления нескольких ингредиентов""" + for _ in range(num_ingredients): + burger.add_ingredient(mock_ingredient_sauce) + + assert len(burger.ingredients) == num_ingredients + assert all(ing == mock_ingredient_sauce for ing in burger.ingredients) + + @pytest.mark.parametrize("remove_index, expected_length", [ + (0, 2), + (1, 2), + (2, 2), + ]) + def test_remove_ingredient(self, burger, mock_ingredient_sauce, mock_ingredient_filling, + mock_ingredient_extra, remove_index, expected_length): + """Тест удаления ингредиента по индексу""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + burger.add_ingredient(mock_ingredient_extra) + + burger.remove_ingredient(remove_index) + assert len(burger.ingredients) == expected_length + + def test_remove_ingredient_first(self, burger, mock_ingredient_sauce, mock_ingredient_filling): + """Тест удаления первого ингредиента""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + + burger.remove_ingredient(0) + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == mock_ingredient_filling + + def test_remove_ingredient_last(self, burger, mock_ingredient_sauce, mock_ingredient_filling): + """Тест удаления последнего ингредиента""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + + burger.remove_ingredient(1) + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == mock_ingredient_sauce + + @pytest.mark.parametrize("from_index, to_index, expected_order", [ + (0, 1, [1, 0]), + (1, 0, [1, 0]), + (0, 2, [1, 2, 0]), + (2, 0, [2, 0, 1]), + ]) + def test_move_ingredient(self, burger, mock_ingredient_sauce, mock_ingredient_filling, + mock_ingredient_extra, from_index, to_index, expected_order): + """Тест перемещения ингредиента с различными параметрами""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + burger.add_ingredient(mock_ingredient_extra) + + original_ingredients = burger.ingredients.copy() + burger.move_ingredient(from_index, to_index) + + # Проверяем порядок + for i, idx in enumerate(expected_order): + assert burger.ingredients[i] == original_ingredients[idx] + + def test_move_ingredient_same_position(self, burger, mock_ingredient_sauce, mock_ingredient_filling): + """Тест перемещения ингредиента на ту же позицию""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + + burger.move_ingredient(0, 0) + assert burger.ingredients[0] == mock_ingredient_sauce + assert burger.ingredients[1] == mock_ingredient_filling + + def test_get_price_without_bun(self, burger, mock_ingredient_sauce): + """Тест получения цены без булочки - должно вызвать ошибку""" + burger.add_ingredient(mock_ingredient_sauce) + with pytest.raises(AttributeError): + burger.get_price() + + @pytest.mark.parametrize("bun_price, expected_price", [ + (100, 200), + (150, 300), + (200, 400), + ]) + def test_get_price_with_bun_only(self, burger, bun_price, expected_price): + """Тест получения цены только с булочкой""" + mock_bun = Mock() + mock_bun.get_price.return_value = bun_price + burger.set_buns(mock_bun) + + assert burger.get_price() == expected_price + mock_bun.get_price.assert_called_once() + + @pytest.mark.parametrize("bun_price, sauce_price, filling_price, expected_price", [ + (100, 50, 75, 325), + (150, 30, 40, 370), + (200, 100, 150, 650), + ]) + def test_get_price_with_ingredients(self, burger, bun_price, sauce_price, filling_price, expected_price): + """Тест получения цены с булочкой и ингредиентами""" + mock_bun = Mock() + mock_bun.get_price.return_value = bun_price + + mock_sauce = Mock() + mock_sauce.get_price.return_value = sauce_price + + mock_filling = Mock() + mock_filling.get_price.return_value = filling_price + + burger.set_buns(mock_bun) + burger.add_ingredient(mock_sauce) + burger.add_ingredient(mock_filling) + + assert burger.get_price() == expected_price + + # Проверяем вызовы методов + assert mock_bun.get_price.call_count == 1 + assert mock_sauce.get_price.call_count == 1 + assert mock_filling.get_price.call_count == 1 + + def test_get_price_multiple_ingredients(self, burger, mock_bun): + """Тест получения цены с несколькими ингредиентами""" + burger.set_buns(mock_bun) + + mock_ingredients = [] + total_price = 0 + + for price in [10, 20, 30, 40, 50]: + mock_ing = Mock() + mock_ing.get_price.return_value = price + mock_ingredients.append(mock_ing) + burger.add_ingredient(mock_ing) + total_price += price + + expected_price = mock_bun.get_price() * 2 + total_price + assert burger.get_price() == expected_price + + def test_get_receipt_without_bun(self, burger, mock_ingredient_sauce): + """Тест получения чека без булочки - должно вызвать ошибку""" + burger.add_ingredient(mock_ingredient_sauce) + with pytest.raises(AttributeError): + burger.get_receipt() + + @pytest.mark.parametrize("bun_name", [ + "black bun", + "white bun", + "red bun", + ]) + def test_get_receipt_with_bun_only(self, burger, bun_name): + """Тест получения чека только с булочкой""" + mock_bun = Mock() + mock_bun.get_name.return_value = bun_name + mock_bun.get_price.return_value = 100 + + burger.set_buns(mock_bun) + + expected_receipt = f"""(==== {bun_name} ====) +(==== {bun_name} ====) +Price: 200.0""" + + assert burger.get_receipt() == expected_receipt + assert mock_bun.get_name.call_count == 2 + + @pytest.mark.parametrize("ingredient_type, ingredient_name", [ + ("SAUCE", "hot sauce"), + ("FILLING", "cutlet"), + ("SAUCE", "chili sauce"), + ]) + def test_get_receipt_with_one_ingredient(self, burger, mock_bun, ingredient_type, ingredient_name): + """Тест получения чека с одним ингредиентом""" + mock_bun.get_name.return_value = "test bun" + burger.set_buns(mock_bun) + + mock_ingredient = Mock() + mock_ingredient.get_type.return_value = ingredient_type + mock_ingredient.get_name.return_value = ingredient_name + mock_ingredient.get_price.return_value = 50 + + burger.add_ingredient(mock_ingredient) + + expected_receipt = f"""(==== test bun ====) += {ingredient_type.lower()} {ingredient_name} = +(==== test bun ====) +Price: 250.0""" + + assert burger.get_receipt() == expected_receipt + + def test_get_receipt_with_multiple_ingredients(self, burger, mock_bun): + """Тест получения чека с несколькими ингредиентами""" + mock_bun.get_name.return_value = "test bun" + mock_bun.get_price.return_value = 100 + burger.set_buns(mock_bun) + + ingredients_data = [ + ("SAUCE", "sauce1", 50), + ("FILLING", "filling1", 75), + ("SAUCE", "sauce2", 30), + ("FILLING", "filling2", 40), + ] + + for ing_type, ing_name, price in ingredients_data: + mock_ing = Mock() + mock_ing.get_type.return_value = ing_type + mock_ing.get_name.return_value = ing_name + mock_ing.get_price.return_value = price + burger.add_ingredient(mock_ing) + + expected_lines = ["(==== test bun ====)"] + for ing_type, ing_name, _ in ingredients_data: + expected_lines.append(f"= {ing_type.lower()} {ing_name} =") + expected_lines.append("(==== test bun ====)") + expected_lines.append("Price: 395.0") + + expected_receipt = "\n".join(expected_lines) + assert burger.get_receipt() == expected_receipt + + def test_get_receipt_with_mocks_verification(self, burger, mock_bun, mock_ingredient_sauce): + """Тест проверки вызовов моков при получении чека""" + burger.set_buns(mock_bun) + burger.add_ingredient(mock_ingredient_sauce) + burger.get_receipt() + + # Проверяем что методы были вызваны + mock_bun.get_name.assert_called() + mock_ingredient_sauce.get_type.assert_called_once() + mock_ingredient_sauce.get_name.assert_called_once() + mock_ingredient_sauce.get_price.assert_called_once() + + def test_complex_operations_sequence(self, burger, mock_bun, mock_ingredient_sauce, + mock_ingredient_filling, mock_ingredient_extra): + """Тест последовательности сложных операций с бургером""" + # 1. Устанавливаем булочку + burger.set_buns(mock_bun) + assert burger.bun == mock_bun + + # 2. Добавляем ингредиенты + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + burger.add_ingredient(mock_ingredient_extra) + burger.add_ingredient(mock_ingredient_sauce) + assert len(burger.ingredients) == 4 + + # 3. Перемещаем ингредиенты + burger.move_ingredient(0, 2) # sauce -> после filling + assert burger.ingredients[0] == mock_ingredient_filling + assert burger.ingredients[1] == mock_ingredient_extra + assert burger.ingredients[2] == mock_ingredient_sauce + assert burger.ingredients[3] == mock_ingredient_sauce + + burger.move_ingredient(3, 1) # sauce -> после extra + assert burger.ingredients[0] == mock_ingredient_filling + assert burger.ingredients[1] == mock_ingredient_sauce + assert burger.ingredients[2] == mock_ingredient_extra + assert burger.ingredients[3] == mock_ingredient_sauce + + # 4. Удаляем ингредиенты + burger.remove_ingredient(2) # удаляем extra + assert len(burger.ingredients) == 3 + assert burger.ingredients[0] == mock_ingredient_filling + assert burger.ingredients[1] == mock_ingredient_sauce + assert burger.ingredients[2] == mock_ingredient_sauce + + burger.remove_ingredient(0) # удаляем filling + assert len(burger.ingredients) == 2 + assert burger.ingredients[0] == mock_ingredient_sauce + assert burger.ingredients[1] == mock_ingredient_sauce + + # 5. Проверяем цену + mock_bun.get_price.return_value = 100 + mock_ingredient_sauce.get_price.return_value = 50 + expected_price = 100 * 2 + 50 + 50 # 300 + assert burger.get_price() == expected_price + + @pytest.mark.parametrize("operation, expected_result", [ + ("add", 1), + ("remove", 0), + ("move", 1), + ]) + def test_operations_with_mocks(self, burger, mock_ingredient_sauce, operation, expected_result): + """Тест различных операций с использованием моков""" + if operation == "add": + burger.add_ingredient(mock_ingredient_sauce) + assert len(burger.ingredients) == expected_result + elif operation == "remove": + burger.add_ingredient(mock_ingredient_sauce) + burger.remove_ingredient(0) + assert len(burger.ingredients) == expected_result + elif operation == "move": + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_sauce) + burger.move_ingredient(0, 1) + assert len(burger.ingredients) == expected_result \ No newline at end of file From 4fce155fa2ca5e871085fb248d3acf95303fde56 Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 12:51:25 +0300 Subject: [PATCH 10/19] conftest.py --- unit_tests/conftest.py | 48 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 unit_tests/conftest.py diff --git a/unit_tests/conftest.py b/unit_tests/conftest.py new file mode 100644 index 000000000..9f7ac5195 --- /dev/null +++ b/unit_tests/conftest.py @@ -0,0 +1,48 @@ +import pytest +from unittest.mock import Mock +from burger import Burger + + +@pytest.fixture +def burger(): + """Фикстура для создания бургера""" + return Burger() + + +@pytest.fixture +def mock_bun(): + """Фикстура для создания мока булочки""" + mock = Mock() + mock.get_name.return_value = "test bun" + mock.get_price.return_value = 100.0 + return mock + + +@pytest.fixture +def mock_ingredient_sauce(): + """Фикстура для создания мока соуса""" + mock = Mock() + mock.get_type.return_value = "SAUCE" + mock.get_name.return_value = "test sauce" + mock.get_price.return_value = 50.0 + return mock + + +@pytest.fixture +def mock_ingredient_filling(): + """Фикстура для создания мока начинки""" + mock = Mock() + mock.get_type.return_value = "FILLING" + mock.get_name.return_value = "test filling" + mock.get_price.return_value = 75.0 + return mock + + +@pytest.fixture +def mock_ingredient_extra(): + """Фикстура для создания дополнительного мока ингредиента""" + mock = Mock() + mock.get_type.return_value = "SAUCE" + mock.get_name.return_value = "extra sauce" + mock.get_price.return_value = 25.0 + return mock \ No newline at end of file From d69eefb6b8234001e5cb3006754c3361ea79066b Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 12:52:33 +0300 Subject: [PATCH 11/19] test_burger.py --- unit_tests/test_burger.py | 349 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 349 insertions(+) create mode 100644 unit_tests/test_burger.py diff --git a/unit_tests/test_burger.py b/unit_tests/test_burger.py new file mode 100644 index 000000000..527088a63 --- /dev/null +++ b/unit_tests/test_burger.py @@ -0,0 +1,349 @@ +import pytest +from unittest.mock import Mock +from burger import Burger +from bun import Bun +from ingredient import Ingredient + + +class TestBurger: + """Тесты для класса Burger""" + + def test_burger_initialization(self, burger): + """Тест инициализации бургера""" + assert burger.bun is None + assert len(burger.ingredients) == 0 + assert isinstance(burger.ingredients, list) + + @pytest.mark.parametrize("bun_name, bun_price", [ + ("black bun", 100), + ("white bun", 200), + ("red bun", 300), + ]) + def test_set_buns_with_real_bun(self, burger, bun_name, bun_price): + """Тест установки булочки с реальными данными""" + bun = Bun(bun_name, bun_price) + burger.set_buns(bun) + + assert burger.bun == bun + assert burger.bun.get_name() == bun_name + assert burger.bun.get_price() == bun_price + + def test_set_buns_with_mock(self, burger, mock_bun): + """Тест установки булочки с использованием мока""" + burger.set_buns(mock_bun) + assert burger.bun == mock_bun + + @pytest.mark.parametrize("ingredient_type, ingredient_name, ingredient_price", [ + ("SAUCE", "hot sauce", 100), + ("FILLING", "cutlet", 150), + ("SAUCE", "chili sauce", 200), + ]) + def test_add_ingredient_with_real_ingredient(self, burger, ingredient_type, ingredient_name, ingredient_price): + """Тест добавления ингредиента с реальными данными""" + ingredient = Ingredient(ingredient_type, ingredient_name, ingredient_price) + burger.add_ingredient(ingredient) + + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == ingredient + assert burger.ingredients[0].get_type() == ingredient_type + assert burger.ingredients[0].get_name() == ingredient_name + assert burger.ingredients[0].get_price() == ingredient_price + + def test_add_ingredient_with_mock(self, burger, mock_ingredient_sauce): + """Тест добавления ингредиента с использованием мока""" + burger.add_ingredient(mock_ingredient_sauce) + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == mock_ingredient_sauce + + @pytest.mark.parametrize("num_ingredients", [1, 3, 5]) + def test_add_multiple_ingredients(self, burger, mock_ingredient_sauce, num_ingredients): + """Тест добавления нескольких ингредиентов""" + for _ in range(num_ingredients): + burger.add_ingredient(mock_ingredient_sauce) + + assert len(burger.ingredients) == num_ingredients + assert all(ing == mock_ingredient_sauce for ing in burger.ingredients) + + @pytest.mark.parametrize("remove_index, expected_length", [ + (0, 2), + (1, 2), + (2, 2), + ]) + def test_remove_ingredient(self, burger, mock_ingredient_sauce, mock_ingredient_filling, + mock_ingredient_extra, remove_index, expected_length): + """Тест удаления ингредиента по индексу""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + burger.add_ingredient(mock_ingredient_extra) + + burger.remove_ingredient(remove_index) + assert len(burger.ingredients) == expected_length + + def test_remove_ingredient_first(self, burger, mock_ingredient_sauce, mock_ingredient_filling): + """Тест удаления первого ингредиента""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + + burger.remove_ingredient(0) + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == mock_ingredient_filling + + def test_remove_ingredient_last(self, burger, mock_ingredient_sauce, mock_ingredient_filling): + """Тест удаления последнего ингредиента""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + + burger.remove_ingredient(1) + assert len(burger.ingredients) == 1 + assert burger.ingredients[0] == mock_ingredient_sauce + + @pytest.mark.parametrize("from_index, to_index, expected_order", [ + (0, 1, [1, 0]), + (1, 0, [1, 0]), + (0, 2, [1, 2, 0]), + (2, 0, [2, 0, 1]), + ]) + def test_move_ingredient(self, burger, mock_ingredient_sauce, mock_ingredient_filling, + mock_ingredient_extra, from_index, to_index, expected_order): + """Тест перемещения ингредиента с различными параметрами""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + burger.add_ingredient(mock_ingredient_extra) + + original_ingredients = burger.ingredients.copy() + burger.move_ingredient(from_index, to_index) + + # Проверяем порядок + for i, idx in enumerate(expected_order): + assert burger.ingredients[i] == original_ingredients[idx] + + def test_move_ingredient_same_position(self, burger, mock_ingredient_sauce, mock_ingredient_filling): + """Тест перемещения ингредиента на ту же позицию""" + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + + burger.move_ingredient(0, 0) + assert burger.ingredients[0] == mock_ingredient_sauce + assert burger.ingredients[1] == mock_ingredient_filling + + def test_get_price_without_bun(self, burger, mock_ingredient_sauce): + """Тест получения цены без булочки - должно вызвать ошибку""" + burger.add_ingredient(mock_ingredient_sauce) + with pytest.raises(AttributeError): + burger.get_price() + + @pytest.mark.parametrize("bun_price, expected_price", [ + (100, 200), + (150, 300), + (200, 400), + ]) + def test_get_price_with_bun_only(self, burger, bun_price, expected_price): + """Тест получения цены только с булочкой""" + mock_bun = Mock() + mock_bun.get_price.return_value = bun_price + burger.set_buns(mock_bun) + + assert burger.get_price() == expected_price + mock_bun.get_price.assert_called_once() + + @pytest.mark.parametrize("bun_price, sauce_price, filling_price, expected_price", [ + (100, 50, 75, 325), + (150, 30, 40, 370), + (200, 100, 150, 650), + ]) + def test_get_price_with_ingredients(self, burger, bun_price, sauce_price, filling_price, expected_price): + """Тест получения цены с булочкой и ингредиентами""" + mock_bun = Mock() + mock_bun.get_price.return_value = bun_price + + mock_sauce = Mock() + mock_sauce.get_price.return_value = sauce_price + + mock_filling = Mock() + mock_filling.get_price.return_value = filling_price + + burger.set_buns(mock_bun) + burger.add_ingredient(mock_sauce) + burger.add_ingredient(mock_filling) + + assert burger.get_price() == expected_price + + # Проверяем вызовы методов + assert mock_bun.get_price.call_count == 1 + assert mock_sauce.get_price.call_count == 1 + assert mock_filling.get_price.call_count == 1 + + def test_get_price_multiple_ingredients(self, burger, mock_bun): + """Тест получения цены с несколькими ингредиентами""" + burger.set_buns(mock_bun) + + mock_ingredients = [] + total_price = 0 + + for price in [10, 20, 30, 40, 50]: + mock_ing = Mock() + mock_ing.get_price.return_value = price + mock_ingredients.append(mock_ing) + burger.add_ingredient(mock_ing) + total_price += price + + expected_price = mock_bun.get_price() * 2 + total_price + assert burger.get_price() == expected_price + + def test_get_receipt_without_bun(self, burger, mock_ingredient_sauce): + """Тест получения чека без булочки - должно вызвать ошибку""" + burger.add_ingredient(mock_ingredient_sauce) + with pytest.raises(AttributeError): + burger.get_receipt() + + @pytest.mark.parametrize("bun_name", [ + ("black bun"), + ("white bun"), + ("red bun"), + ]) + def test_get_receipt_with_bun_only(self, burger, bun_name): + """Тест получения чека только с булочкой""" + mock_bun = Mock() + mock_bun.get_name.return_value = bun_name + mock_bun.get_price.return_value = 100 + + burger.set_buns(mock_bun) + + expected_receipt = f"""(==== {bun_name} ====) +(==== {bun_name} ====) + +Price: 200""" + + assert burger.get_receipt() == expected_receipt + + @pytest.mark.parametrize("ingredient_type, ingredient_name", [ + ("SAUCE", "hot sauce"), + ("FILLING", "cutlet"), + ("SAUCE", "chili sauce"), + ]) + def test_get_receipt_with_one_ingredient(self, burger, mock_bun, ingredient_type, ingredient_name): + """Тест получения чека с одним ингредиентом""" + mock_bun.get_name.return_value = "test bun" + mock_bun.get_price.return_value = 100 + burger.set_buns(mock_bun) + + mock_ingredient = Mock() + mock_ingredient.get_type.return_value = ingredient_type + mock_ingredient.get_name.return_value = ingredient_name + mock_ingredient.get_price.return_value = 50 + + burger.add_ingredient(mock_ingredient) + + expected_receipt = f"""(==== test bun ====) += {ingredient_type.lower()} {ingredient_name} = +(==== test bun ====) + +Price: 250""" + + assert burger.get_receipt() == expected_receipt + + def test_get_receipt_with_multiple_ingredients(self, burger, mock_bun): + """Тест получения чека с несколькими ингредиентами""" + mock_bun.get_name.return_value = "test bun" + mock_bun.get_price.return_value = 100 + burger.set_buns(mock_bun) + + ingredients_data = [ + ("SAUCE", "sauce1", 50), + ("FILLING", "filling1", 75), + ("SAUCE", "sauce2", 30), + ("FILLING", "filling2", 40), + ] + + for ing_type, ing_name, price in ingredients_data: + mock_ing = Mock() + mock_ing.get_type.return_value = ing_type + mock_ing.get_name.return_value = ing_name + mock_ing.get_price.return_value = price + burger.add_ingredient(mock_ing) + + expected_lines = ["(==== test bun ====)"] + for ing_type, ing_name, _ in ingredients_data: + expected_lines.append(f"= {ing_type.lower()} {ing_name} =") + expected_lines.append("(==== test bun ====)") + expected_lines.append("") # Пустая строка из-за \n + expected_lines.append("Price: 395") + + expected_receipt = "\n".join(expected_lines) + assert burger.get_receipt() == expected_receipt + + def test_get_receipt_with_mocks_verification(self, burger, mock_bun, mock_ingredient_sauce): + """Тест проверки вызовов моков при получении чека""" + burger.set_buns(mock_bun) + burger.add_ingredient(mock_ingredient_sauce) + burger.get_receipt() + + # Проверяем что методы были вызваны + mock_bun.get_name.assert_called() + mock_ingredient_sauce.get_type.assert_called_once() + mock_ingredient_sauce.get_name.assert_called_once() + + def test_complex_operations_sequence(self, burger, mock_bun, mock_ingredient_sauce, + mock_ingredient_filling, mock_ingredient_extra): + """Тест последовательности сложных операций с бургером""" + # 1. Устанавливаем булочку + burger.set_buns(mock_bun) + assert burger.bun == mock_bun + + # 2. Добавляем ингредиенты + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_filling) + burger.add_ingredient(mock_ingredient_extra) + burger.add_ingredient(mock_ingredient_sauce) + assert len(burger.ingredients) == 4 + + # 3. Перемещаем ингредиенты + burger.move_ingredient(0, 2) # sauce -> после filling + assert burger.ingredients[0] == mock_ingredient_filling + assert burger.ingredients[1] == mock_ingredient_extra + assert burger.ingredients[2] == mock_ingredient_sauce + assert burger.ingredients[3] == mock_ingredient_sauce + + burger.move_ingredient(3, 1) # sauce -> после extra + assert burger.ingredients[0] == mock_ingredient_filling + assert burger.ingredients[1] == mock_ingredient_sauce + assert burger.ingredients[2] == mock_ingredient_extra + assert burger.ingredients[3] == mock_ingredient_sauce + + # 4. Удаляем ингредиенты + burger.remove_ingredient(2) # удаляем extra + assert len(burger.ingredients) == 3 + assert burger.ingredients[0] == mock_ingredient_filling + assert burger.ingredients[1] == mock_ingredient_sauce + assert burger.ingredients[2] == mock_ingredient_sauce + + burger.remove_ingredient(0) # удаляем filling + assert len(burger.ingredients) == 2 + assert burger.ingredients[0] == mock_ingredient_sauce + assert burger.ingredients[1] == mock_ingredient_sauce + + # 5. Проверяем цену + mock_bun.get_price.return_value = 100 + mock_ingredient_sauce.get_price.return_value = 50 + expected_price = 100 * 2 + 50 + 50 # 300 + assert burger.get_price() == expected_price + + @pytest.mark.parametrize("operation, expected_result", [ + ("add", 1), + ("remove", 0), + ("move", 2), + ]) + def test_operations_with_mocks(self, burger, mock_ingredient_sauce, operation, expected_result): + """Тест различных операций с использованием моков""" + if operation == "add": + burger.add_ingredient(mock_ingredient_sauce) + assert len(burger.ingredients) == expected_result + elif operation == "remove": + burger.add_ingredient(mock_ingredient_sauce) + burger.remove_ingredient(0) + assert len(burger.ingredients) == expected_result + elif operation == "move": + burger.add_ingredient(mock_ingredient_sauce) + burger.add_ingredient(mock_ingredient_sauce) + burger.move_ingredient(0, 1) + assert len(burger.ingredients) == expected_result \ No newline at end of file From 303985549113aad317add51223e4d2612394c09b Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 12:53:05 +0300 Subject: [PATCH 12/19] __init__.py --- unit_tests/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 unit_tests/__init__.py diff --git a/unit_tests/__init__.py b/unit_tests/__init__.py new file mode 100644 index 000000000..e69de29bb From a140277da7668d6bff94a6008a805c4d3fc2de8c Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 12:54:11 +0300 Subject: [PATCH 13/19] test_burger.py --- test_burger.py | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/test_burger.py b/test_burger.py index 4a4d501b9..527088a63 100644 --- a/test_burger.py +++ b/test_burger.py @@ -1,6 +1,8 @@ import pytest from unittest.mock import Mock -from praktikum.burger import Burger +from burger import Burger +from bun import Bun +from ingredient import Ingredient class TestBurger: @@ -19,7 +21,6 @@ def test_burger_initialization(self, burger): ]) def test_set_buns_with_real_bun(self, burger, bun_name, bun_price): """Тест установки булочки с реальными данными""" - from praktikum.bun import Bun bun = Bun(bun_name, bun_price) burger.set_buns(bun) @@ -31,8 +32,6 @@ def test_set_buns_with_mock(self, burger, mock_bun): """Тест установки булочки с использованием мока""" burger.set_buns(mock_bun) assert burger.bun == mock_bun - mock_bun.get_name.assert_called_once() - mock_bun.get_price.assert_not_called() @pytest.mark.parametrize("ingredient_type, ingredient_name, ingredient_price", [ ("SAUCE", "hot sauce", 100), @@ -41,7 +40,6 @@ def test_set_buns_with_mock(self, burger, mock_bun): ]) def test_add_ingredient_with_real_ingredient(self, burger, ingredient_type, ingredient_name, ingredient_price): """Тест добавления ингредиента с реальными данными""" - from praktikum.ingredient import Ingredient ingredient = Ingredient(ingredient_type, ingredient_name, ingredient_price) burger.add_ingredient(ingredient) @@ -199,9 +197,9 @@ def test_get_receipt_without_bun(self, burger, mock_ingredient_sauce): burger.get_receipt() @pytest.mark.parametrize("bun_name", [ - "black bun", - "white bun", - "red bun", + ("black bun"), + ("white bun"), + ("red bun"), ]) def test_get_receipt_with_bun_only(self, burger, bun_name): """Тест получения чека только с булочкой""" @@ -213,10 +211,10 @@ def test_get_receipt_with_bun_only(self, burger, bun_name): expected_receipt = f"""(==== {bun_name} ====) (==== {bun_name} ====) -Price: 200.0""" + +Price: 200""" assert burger.get_receipt() == expected_receipt - assert mock_bun.get_name.call_count == 2 @pytest.mark.parametrize("ingredient_type, ingredient_name", [ ("SAUCE", "hot sauce"), @@ -226,6 +224,7 @@ def test_get_receipt_with_bun_only(self, burger, bun_name): def test_get_receipt_with_one_ingredient(self, burger, mock_bun, ingredient_type, ingredient_name): """Тест получения чека с одним ингредиентом""" mock_bun.get_name.return_value = "test bun" + mock_bun.get_price.return_value = 100 burger.set_buns(mock_bun) mock_ingredient = Mock() @@ -238,7 +237,8 @@ def test_get_receipt_with_one_ingredient(self, burger, mock_bun, ingredient_type expected_receipt = f"""(==== test bun ====) = {ingredient_type.lower()} {ingredient_name} = (==== test bun ====) -Price: 250.0""" + +Price: 250""" assert burger.get_receipt() == expected_receipt @@ -266,7 +266,8 @@ def test_get_receipt_with_multiple_ingredients(self, burger, mock_bun): for ing_type, ing_name, _ in ingredients_data: expected_lines.append(f"= {ing_type.lower()} {ing_name} =") expected_lines.append("(==== test bun ====)") - expected_lines.append("Price: 395.0") + expected_lines.append("") # Пустая строка из-за \n + expected_lines.append("Price: 395") expected_receipt = "\n".join(expected_lines) assert burger.get_receipt() == expected_receipt @@ -281,7 +282,6 @@ def test_get_receipt_with_mocks_verification(self, burger, mock_bun, mock_ingred mock_bun.get_name.assert_called() mock_ingredient_sauce.get_type.assert_called_once() mock_ingredient_sauce.get_name.assert_called_once() - mock_ingredient_sauce.get_price.assert_called_once() def test_complex_operations_sequence(self, burger, mock_bun, mock_ingredient_sauce, mock_ingredient_filling, mock_ingredient_extra): @@ -331,7 +331,7 @@ def test_complex_operations_sequence(self, burger, mock_bun, mock_ingredient_sau @pytest.mark.parametrize("operation, expected_result", [ ("add", 1), ("remove", 0), - ("move", 1), + ("move", 2), ]) def test_operations_with_mocks(self, burger, mock_ingredient_sauce, operation, expected_result): """Тест различных операций с использованием моков""" From 473ede787295d334444b4075e540ce86fb5df1c8 Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 12:55:06 +0300 Subject: [PATCH 14/19] conftest.py --- conftest.py | 2 +- test_burger.py | 349 ------------------------------------------------- 2 files changed, 1 insertion(+), 350 deletions(-) delete mode 100644 test_burger.py diff --git a/conftest.py b/conftest.py index ba018191c..9f7ac5195 100644 --- a/conftest.py +++ b/conftest.py @@ -1,6 +1,6 @@ import pytest from unittest.mock import Mock -from praktikum.burger import Burger +from burger import Burger @pytest.fixture diff --git a/test_burger.py b/test_burger.py deleted file mode 100644 index 527088a63..000000000 --- a/test_burger.py +++ /dev/null @@ -1,349 +0,0 @@ -import pytest -from unittest.mock import Mock -from burger import Burger -from bun import Bun -from ingredient import Ingredient - - -class TestBurger: - """Тесты для класса Burger""" - - def test_burger_initialization(self, burger): - """Тест инициализации бургера""" - assert burger.bun is None - assert len(burger.ingredients) == 0 - assert isinstance(burger.ingredients, list) - - @pytest.mark.parametrize("bun_name, bun_price", [ - ("black bun", 100), - ("white bun", 200), - ("red bun", 300), - ]) - def test_set_buns_with_real_bun(self, burger, bun_name, bun_price): - """Тест установки булочки с реальными данными""" - bun = Bun(bun_name, bun_price) - burger.set_buns(bun) - - assert burger.bun == bun - assert burger.bun.get_name() == bun_name - assert burger.bun.get_price() == bun_price - - def test_set_buns_with_mock(self, burger, mock_bun): - """Тест установки булочки с использованием мока""" - burger.set_buns(mock_bun) - assert burger.bun == mock_bun - - @pytest.mark.parametrize("ingredient_type, ingredient_name, ingredient_price", [ - ("SAUCE", "hot sauce", 100), - ("FILLING", "cutlet", 150), - ("SAUCE", "chili sauce", 200), - ]) - def test_add_ingredient_with_real_ingredient(self, burger, ingredient_type, ingredient_name, ingredient_price): - """Тест добавления ингредиента с реальными данными""" - ingredient = Ingredient(ingredient_type, ingredient_name, ingredient_price) - burger.add_ingredient(ingredient) - - assert len(burger.ingredients) == 1 - assert burger.ingredients[0] == ingredient - assert burger.ingredients[0].get_type() == ingredient_type - assert burger.ingredients[0].get_name() == ingredient_name - assert burger.ingredients[0].get_price() == ingredient_price - - def test_add_ingredient_with_mock(self, burger, mock_ingredient_sauce): - """Тест добавления ингредиента с использованием мока""" - burger.add_ingredient(mock_ingredient_sauce) - assert len(burger.ingredients) == 1 - assert burger.ingredients[0] == mock_ingredient_sauce - - @pytest.mark.parametrize("num_ingredients", [1, 3, 5]) - def test_add_multiple_ingredients(self, burger, mock_ingredient_sauce, num_ingredients): - """Тест добавления нескольких ингредиентов""" - for _ in range(num_ingredients): - burger.add_ingredient(mock_ingredient_sauce) - - assert len(burger.ingredients) == num_ingredients - assert all(ing == mock_ingredient_sauce for ing in burger.ingredients) - - @pytest.mark.parametrize("remove_index, expected_length", [ - (0, 2), - (1, 2), - (2, 2), - ]) - def test_remove_ingredient(self, burger, mock_ingredient_sauce, mock_ingredient_filling, - mock_ingredient_extra, remove_index, expected_length): - """Тест удаления ингредиента по индексу""" - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_filling) - burger.add_ingredient(mock_ingredient_extra) - - burger.remove_ingredient(remove_index) - assert len(burger.ingredients) == expected_length - - def test_remove_ingredient_first(self, burger, mock_ingredient_sauce, mock_ingredient_filling): - """Тест удаления первого ингредиента""" - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_filling) - - burger.remove_ingredient(0) - assert len(burger.ingredients) == 1 - assert burger.ingredients[0] == mock_ingredient_filling - - def test_remove_ingredient_last(self, burger, mock_ingredient_sauce, mock_ingredient_filling): - """Тест удаления последнего ингредиента""" - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_filling) - - burger.remove_ingredient(1) - assert len(burger.ingredients) == 1 - assert burger.ingredients[0] == mock_ingredient_sauce - - @pytest.mark.parametrize("from_index, to_index, expected_order", [ - (0, 1, [1, 0]), - (1, 0, [1, 0]), - (0, 2, [1, 2, 0]), - (2, 0, [2, 0, 1]), - ]) - def test_move_ingredient(self, burger, mock_ingredient_sauce, mock_ingredient_filling, - mock_ingredient_extra, from_index, to_index, expected_order): - """Тест перемещения ингредиента с различными параметрами""" - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_filling) - burger.add_ingredient(mock_ingredient_extra) - - original_ingredients = burger.ingredients.copy() - burger.move_ingredient(from_index, to_index) - - # Проверяем порядок - for i, idx in enumerate(expected_order): - assert burger.ingredients[i] == original_ingredients[idx] - - def test_move_ingredient_same_position(self, burger, mock_ingredient_sauce, mock_ingredient_filling): - """Тест перемещения ингредиента на ту же позицию""" - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_filling) - - burger.move_ingredient(0, 0) - assert burger.ingredients[0] == mock_ingredient_sauce - assert burger.ingredients[1] == mock_ingredient_filling - - def test_get_price_without_bun(self, burger, mock_ingredient_sauce): - """Тест получения цены без булочки - должно вызвать ошибку""" - burger.add_ingredient(mock_ingredient_sauce) - with pytest.raises(AttributeError): - burger.get_price() - - @pytest.mark.parametrize("bun_price, expected_price", [ - (100, 200), - (150, 300), - (200, 400), - ]) - def test_get_price_with_bun_only(self, burger, bun_price, expected_price): - """Тест получения цены только с булочкой""" - mock_bun = Mock() - mock_bun.get_price.return_value = bun_price - burger.set_buns(mock_bun) - - assert burger.get_price() == expected_price - mock_bun.get_price.assert_called_once() - - @pytest.mark.parametrize("bun_price, sauce_price, filling_price, expected_price", [ - (100, 50, 75, 325), - (150, 30, 40, 370), - (200, 100, 150, 650), - ]) - def test_get_price_with_ingredients(self, burger, bun_price, sauce_price, filling_price, expected_price): - """Тест получения цены с булочкой и ингредиентами""" - mock_bun = Mock() - mock_bun.get_price.return_value = bun_price - - mock_sauce = Mock() - mock_sauce.get_price.return_value = sauce_price - - mock_filling = Mock() - mock_filling.get_price.return_value = filling_price - - burger.set_buns(mock_bun) - burger.add_ingredient(mock_sauce) - burger.add_ingredient(mock_filling) - - assert burger.get_price() == expected_price - - # Проверяем вызовы методов - assert mock_bun.get_price.call_count == 1 - assert mock_sauce.get_price.call_count == 1 - assert mock_filling.get_price.call_count == 1 - - def test_get_price_multiple_ingredients(self, burger, mock_bun): - """Тест получения цены с несколькими ингредиентами""" - burger.set_buns(mock_bun) - - mock_ingredients = [] - total_price = 0 - - for price in [10, 20, 30, 40, 50]: - mock_ing = Mock() - mock_ing.get_price.return_value = price - mock_ingredients.append(mock_ing) - burger.add_ingredient(mock_ing) - total_price += price - - expected_price = mock_bun.get_price() * 2 + total_price - assert burger.get_price() == expected_price - - def test_get_receipt_without_bun(self, burger, mock_ingredient_sauce): - """Тест получения чека без булочки - должно вызвать ошибку""" - burger.add_ingredient(mock_ingredient_sauce) - with pytest.raises(AttributeError): - burger.get_receipt() - - @pytest.mark.parametrize("bun_name", [ - ("black bun"), - ("white bun"), - ("red bun"), - ]) - def test_get_receipt_with_bun_only(self, burger, bun_name): - """Тест получения чека только с булочкой""" - mock_bun = Mock() - mock_bun.get_name.return_value = bun_name - mock_bun.get_price.return_value = 100 - - burger.set_buns(mock_bun) - - expected_receipt = f"""(==== {bun_name} ====) -(==== {bun_name} ====) - -Price: 200""" - - assert burger.get_receipt() == expected_receipt - - @pytest.mark.parametrize("ingredient_type, ingredient_name", [ - ("SAUCE", "hot sauce"), - ("FILLING", "cutlet"), - ("SAUCE", "chili sauce"), - ]) - def test_get_receipt_with_one_ingredient(self, burger, mock_bun, ingredient_type, ingredient_name): - """Тест получения чека с одним ингредиентом""" - mock_bun.get_name.return_value = "test bun" - mock_bun.get_price.return_value = 100 - burger.set_buns(mock_bun) - - mock_ingredient = Mock() - mock_ingredient.get_type.return_value = ingredient_type - mock_ingredient.get_name.return_value = ingredient_name - mock_ingredient.get_price.return_value = 50 - - burger.add_ingredient(mock_ingredient) - - expected_receipt = f"""(==== test bun ====) -= {ingredient_type.lower()} {ingredient_name} = -(==== test bun ====) - -Price: 250""" - - assert burger.get_receipt() == expected_receipt - - def test_get_receipt_with_multiple_ingredients(self, burger, mock_bun): - """Тест получения чека с несколькими ингредиентами""" - mock_bun.get_name.return_value = "test bun" - mock_bun.get_price.return_value = 100 - burger.set_buns(mock_bun) - - ingredients_data = [ - ("SAUCE", "sauce1", 50), - ("FILLING", "filling1", 75), - ("SAUCE", "sauce2", 30), - ("FILLING", "filling2", 40), - ] - - for ing_type, ing_name, price in ingredients_data: - mock_ing = Mock() - mock_ing.get_type.return_value = ing_type - mock_ing.get_name.return_value = ing_name - mock_ing.get_price.return_value = price - burger.add_ingredient(mock_ing) - - expected_lines = ["(==== test bun ====)"] - for ing_type, ing_name, _ in ingredients_data: - expected_lines.append(f"= {ing_type.lower()} {ing_name} =") - expected_lines.append("(==== test bun ====)") - expected_lines.append("") # Пустая строка из-за \n - expected_lines.append("Price: 395") - - expected_receipt = "\n".join(expected_lines) - assert burger.get_receipt() == expected_receipt - - def test_get_receipt_with_mocks_verification(self, burger, mock_bun, mock_ingredient_sauce): - """Тест проверки вызовов моков при получении чека""" - burger.set_buns(mock_bun) - burger.add_ingredient(mock_ingredient_sauce) - burger.get_receipt() - - # Проверяем что методы были вызваны - mock_bun.get_name.assert_called() - mock_ingredient_sauce.get_type.assert_called_once() - mock_ingredient_sauce.get_name.assert_called_once() - - def test_complex_operations_sequence(self, burger, mock_bun, mock_ingredient_sauce, - mock_ingredient_filling, mock_ingredient_extra): - """Тест последовательности сложных операций с бургером""" - # 1. Устанавливаем булочку - burger.set_buns(mock_bun) - assert burger.bun == mock_bun - - # 2. Добавляем ингредиенты - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_filling) - burger.add_ingredient(mock_ingredient_extra) - burger.add_ingredient(mock_ingredient_sauce) - assert len(burger.ingredients) == 4 - - # 3. Перемещаем ингредиенты - burger.move_ingredient(0, 2) # sauce -> после filling - assert burger.ingredients[0] == mock_ingredient_filling - assert burger.ingredients[1] == mock_ingredient_extra - assert burger.ingredients[2] == mock_ingredient_sauce - assert burger.ingredients[3] == mock_ingredient_sauce - - burger.move_ingredient(3, 1) # sauce -> после extra - assert burger.ingredients[0] == mock_ingredient_filling - assert burger.ingredients[1] == mock_ingredient_sauce - assert burger.ingredients[2] == mock_ingredient_extra - assert burger.ingredients[3] == mock_ingredient_sauce - - # 4. Удаляем ингредиенты - burger.remove_ingredient(2) # удаляем extra - assert len(burger.ingredients) == 3 - assert burger.ingredients[0] == mock_ingredient_filling - assert burger.ingredients[1] == mock_ingredient_sauce - assert burger.ingredients[2] == mock_ingredient_sauce - - burger.remove_ingredient(0) # удаляем filling - assert len(burger.ingredients) == 2 - assert burger.ingredients[0] == mock_ingredient_sauce - assert burger.ingredients[1] == mock_ingredient_sauce - - # 5. Проверяем цену - mock_bun.get_price.return_value = 100 - mock_ingredient_sauce.get_price.return_value = 50 - expected_price = 100 * 2 + 50 + 50 # 300 - assert burger.get_price() == expected_price - - @pytest.mark.parametrize("operation, expected_result", [ - ("add", 1), - ("remove", 0), - ("move", 2), - ]) - def test_operations_with_mocks(self, burger, mock_ingredient_sauce, operation, expected_result): - """Тест различных операций с использованием моков""" - if operation == "add": - burger.add_ingredient(mock_ingredient_sauce) - assert len(burger.ingredients) == expected_result - elif operation == "remove": - burger.add_ingredient(mock_ingredient_sauce) - burger.remove_ingredient(0) - assert len(burger.ingredients) == expected_result - elif operation == "move": - burger.add_ingredient(mock_ingredient_sauce) - burger.add_ingredient(mock_ingredient_sauce) - burger.move_ingredient(0, 1) - assert len(burger.ingredients) == expected_result \ No newline at end of file From 9b15a2331195d888fb48fd38faa5de433bed027a Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 12:56:12 +0300 Subject: [PATCH 15/19] burger.py --- burger.py | 4 ++-- conftest.py | 48 ------------------------------------------------ 2 files changed, 2 insertions(+), 50 deletions(-) delete mode 100644 conftest.py diff --git a/burger.py b/burger.py index 2b3b6a88b..3f71aaa29 100644 --- a/burger.py +++ b/burger.py @@ -1,7 +1,7 @@ from typing import List -from praktikum.bun import Bun -from praktikum.ingredient import Ingredient +from bun import Bun +from ingredient import Ingredient class Burger: diff --git a/conftest.py b/conftest.py deleted file mode 100644 index 9f7ac5195..000000000 --- a/conftest.py +++ /dev/null @@ -1,48 +0,0 @@ -import pytest -from unittest.mock import Mock -from burger import Burger - - -@pytest.fixture -def burger(): - """Фикстура для создания бургера""" - return Burger() - - -@pytest.fixture -def mock_bun(): - """Фикстура для создания мока булочки""" - mock = Mock() - mock.get_name.return_value = "test bun" - mock.get_price.return_value = 100.0 - return mock - - -@pytest.fixture -def mock_ingredient_sauce(): - """Фикстура для создания мока соуса""" - mock = Mock() - mock.get_type.return_value = "SAUCE" - mock.get_name.return_value = "test sauce" - mock.get_price.return_value = 50.0 - return mock - - -@pytest.fixture -def mock_ingredient_filling(): - """Фикстура для создания мока начинки""" - mock = Mock() - mock.get_type.return_value = "FILLING" - mock.get_name.return_value = "test filling" - mock.get_price.return_value = 75.0 - return mock - - -@pytest.fixture -def mock_ingredient_extra(): - """Фикстура для создания дополнительного мока ингредиента""" - mock = Mock() - mock.get_type.return_value = "SAUCE" - mock.get_name.return_value = "extra sauce" - mock.get_price.return_value = 25.0 - return mock \ No newline at end of file From 0aadfad2734b08c45ed09d9c46bc00e7fa20703e Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 12:56:32 +0300 Subject: [PATCH 16/19] database.py --- database.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/database.py b/database.py index 4c75baf71..84d3685d0 100644 --- a/database.py +++ b/database.py @@ -1,8 +1,8 @@ from typing import List -from praktikum.bun import Bun -from praktikum.ingredient import Ingredient -from praktikum.ingredient_types import INGREDIENT_TYPE_SAUCE, INGREDIENT_TYPE_FILLING +from bun import Bun +from ingredient import Ingredient +from ingredient_types import INGREDIENT_TYPE_SAUCE, INGREDIENT_TYPE_FILLING class Database: From fb572213ef7c535c35d07581640c7b2b27943991 Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 12:56:51 +0300 Subject: [PATCH 17/19] praktikum.py --- praktikum.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/praktikum.py b/praktikum.py index ec522fa6d..88b77abd1 100644 --- a/praktikum.py +++ b/praktikum.py @@ -1,9 +1,9 @@ from typing import List -from praktikum.bun import Bun -from praktikum.burger import Burger -from praktikum.database import Database -from praktikum.ingredient import Ingredient +from bun import Bun +from burger import Burger +from database import Database +from ingredient import Ingredient def main(): From fb02429dbf28239e1d0207c665dfd9ae21125897 Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 12:57:23 +0300 Subject: [PATCH 18/19] .gitignore --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..d8a1bb093 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +__pycache__ +.coverage From 13f283e23a1ae820ba6d3726c7be96c6d83f31b5 Mon Sep 17 00:00:00 2001 From: Alexandra Rozhneva Date: Wed, 29 Jul 2026 13:00:54 +0300 Subject: [PATCH 19/19] requirements.txt --- requirements.txt | Bin 0 -> 1250 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 requirements.txt diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..8765419712aff0a172a70f67e05475e7e5609e47 GIT binary patch literal 1250 zcmZ`(+fKqz5Zq@IKc$4W2>Rfw&nA9=sRiLgpp{k-K3<)f?P>8AQV@4`cFyb^K0gXu z3@%4}q*P4PaqOS`bY&?~EKi{28S8@%|f`KP-D@2;=}Deh;xL$WV ze+25ibEMIPcw0F;)lG{EPEcD&DOq{{{5HBT{LSERM}UG{bLlI0;r*^{u51S+k57&J_