🤔 Как еще мы можем гарантировать закрытие файла, если не через with?

Использование оператора with является рекомендованным способом гарантированного закрытия файла, так как он автоматически управляет открытием и закрытием ресурса. Однако, если по какой-то причине вы не можете использовать with, можно гарантировать закрытие файла другими способами, такими как использование явного вызова метода close() в блоке finally.

🟠С использованием `try-finally`
Открытие и закрытие файла с использованием блока try-finally гарантирует, что файл будет закрыт, даже если в блоке try произойдет исключение. В этом примере файл открывается в блоке try, и его содержимое читается. Независимо от того, происходит ли исключение в блоке try или нет, блок finally будет выполнен, и файл будет закрыт.

file = None
try:
    file = open('example.txt', 'r')
    content = file.read()
    print(content)
finally:
    if file:
        file.close()

🟠С использованием контекстного менеджера
Вы можете создать свой собственный контекстный менеджер, используя классы, который будет управлять открытием и закрытием файла. Это более сложный подход, но он полезен для понимания внутренних механизмов.

class FileManager:
    def __init__(self, filename, mode):
        self.filename = filename
        self.mode = mode
        self.file = None
    
    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file
    
    def __exit__(self, exc_type, exc_value, traceback):
        if self.file:
            self.file.close()

# Примеры использования
file_manager = FileManager('example.txt', 'r')
try:
    file = file_manager.__enter__()
    content = file.read()
    print(content)
finally:
    file_manager.__exit__(None, None, None)

🟠С использованием декоратора
Еще один способ — использование декоратора для автоматического управления открытием и закрытием файла.

from functools import wraps

def open_file(filename, mode):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            file = open(filename, mode)
            try:
                result = func(file, *args, **kwargs)
            finally:
                file.close()
            return result
        return wrapper
    return decorator

@open_file('example.txt', 'r')
def read_file(f):
    return f.read()

# Примеры использования
print(read_file())

🟠С использованием менеджера контекста из `contextlib`
Модуль contextlib предоставляет полезные утилиты для создания контекстных менеджеров. Одной из таких утилит является contextlib.contextmanager, которая позволяет создавать контекстные менеджеры с помощью генераторов.

from contextlib import contextmanager

@contextmanager
def open_file(filename, mode):
    file = open(filename, mode)
    try:
        yield file
    finally:
        file.close()

# Примеры использования
file_manager = open_file('example.txt', 'r')
file = file_manager.__enter__()
try:
    content = file.read()
    print(content)
finally:
    file_manager.__exit__(None, None, None)

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что знаешь про singleton?

Singleton — это паттерн проектирования, который гарантирует создание только одного экземпляра класса. Его применяют для управления глобальными ресурсами, такими как настройки или подключение к базе данных. Однако он критикуется за сложность тестирования и возможные нарушения принципов SOLID.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое monkey patch?

Monkey patching (буквально "заплатка обезьяны") в программировании — это техника, позволяющая динамически изменять или расширять код во время выполнения программы. В Python это означает изменение или дополнение методов, атрибутов или классов в модуле или библиотеке, даже если у вас нет прямого доступа к исходному коду.

🚩Зачем нужен monkey patching

🟠Исправление ошибок
Быстрое исправление ошибок в сторонних библиотеках без необходимости изменения их исходного кода.
🟠Добавление функциональности
Расширение возможностей сторонних библиотек.
🟠Изменение поведения
Замена существующих функций или методов на свои собственные для изменения поведения программы.

🚩Пример monkey patching

import time

# Оригинальная функция
def original_sleep(seconds):
    time.sleep(seconds)
    print(f"Slept for {seconds} seconds")

# Monkey patching функции sleep
def patched_sleep(seconds):
    print(f"Patched! Should have slept for {seconds} seconds")

# Применение monkey patching
time.sleep = patched_sleep

# Примеры использования
time.sleep(3)  # Вывод: Patched! Should have slept for 3 seconds

🚩Недостатки

➖Неявные изменения
Изменения могут быть неочевидны другим разработчикам, что может привести к путанице и затруднениям в отладке.
➖Совместимость
Monkey patching может вызвать проблемы совместимости при обновлении библиотек или модулей.
➖Непредсказуемость
Изменения в поведении программы могут быть трудно предсказуемыми и отлаживаемыми.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Для чего нужен сериализатор?

Сериализатор преобразует данные из одного формата в другой, например, из объектов в JSON или обратно. Он используется для передачи данных между системами, а также для хранения или передачи структурированных данных. В веб-разработке сериализаторы часто применяются для работы с API.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое pytest?

Это популярный фреймворк для тестирования на языке Python. Он используется для написания и выполнения тестов, чтобы гарантировать, что код работает правильно.

🚩Зачем нужен

🟠Проверка корректности кода
Позволяет выявить ошибки и дефекты на ранних стадиях разработки
🟠Поддержка и рефакторинг
Обеспечивает уверенность, что изменения в коде не приводят к новым ошибкам.
🟠Документация
Тесты могут служить примером использования кода и его поведения.

🚩Как используется

🟠Написание тестов
Тесты пишутся в виде функций, начинающихся с test_.
🟠Запуск тестов
Тесты выполняются с помощью команды pytest в командной строке.
🟠Ассерты
Используются стандартные утверждения (assert) для проверки условий.

🚩Основные возможности

🟠Автоматическое обнаружение тестов
pytest автоматически находит тестовые функции, классы и файлы.
🟠Фикстуры: Позволяют определять подготовительный и завершающий код для тестов.
🟠Параметризация
Позволяет запускать один и тот же тест с различными входными данными.
🟠Плагины
Расширяют функциональность фреймворка, например, для генерации отчетов, интеграции с CI/CD системами.

🚩Пример теста с использованием

# test_sample.py
def test_addition():
    assert 1 + 1 == 2

def test_subtraction():
    assert 2 - 1 == 1

Запуск тестов:

pytest

🟠Фикстуры
Фикстуры позволяют подготовить необходимые данные или состояния для тестов.

import pytest

@pytest.fixture
def sample_data():
    return {"key1": "value1", "key2": "value2"}

def test_sample_data(sample_data):
    assert sample_data["key1"] == "value1"

🟠Параметризация тестов
Позволяет запускать один тест с разными наборами данных.

import pytest

@pytest.mark.parametrize("a, b, result", [
    (1, 2, 3),
    (2, 3, 5),
    (3, 5, 8)
])
def test_addition(a, b, result):
    assert a + b == result

Ставь 👍 и забирай 📚 Базу знаний

🤔 Зачем нужен метод super в классе?

Метод super позволяет вызывать методы родительского класса в контексте текущего класса. Это удобно при переопределении методов для сохранения их базового поведения. Также super используется для инициализации атрибутов родительского класса.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое mock?

Это объект, который имитирует поведение реального объекта в контролируемом и предсказуемом виде. В контексте тестирования, особенно в Python, это используется для создания фиктивных объектов, которые замещают реальные компоненты системы во время выполнения тестов.

🚩Зачем нужен

🟠Изоляция тестов
Позволяет тестировать компоненты системы независимо от других частей.
🟠Контроль над внешними зависимостями
Можно моделировать ответы и поведение зависимостей, таких как базы данных или веб-сервисы.
🟠Ускорение тестов
Тесты с mock-объектами выполняются быстрее, так как не требуют взаимодействия с реальными ресурсами.
🟠Тестирование ошибок
Легко симулировать ошибки и исключения, которые сложно воспроизвести с реальными объектами.

🚩Основные возможности

🟠Создание mock-объектов
Могут заменять любые объекты в коде.
🟠Настройка поведения
Указание, какие значения должны возвращать mock-объекты.
🟠Отслеживание вызовов
Возможность проверять, как и сколько раз были вызваны методы mock-объекта.
🟠Контекстные менеджеры и декораторы
Упрощают замену объектов в тестах на mock.

🚩Пример использования

Предположим, у нас есть функция, которая обращается к внешнему API:

import requests

def get_user_data(user_id):
    response = requests.get(f"https://api.example.com/users/{user_id}")
    return response.json()

Чтобы протестировать эту функцию без реальных запросов, можно использовать mock:

from unittest.mock import patch

@patch('requests.get')
def test_get_user_data(mock_get):
    mock_get.return_value.json.return_value = {"id": 1, "name": "John Doe"}
    
    result = get_user_data(1)
    
    assert result == {"id": 1, "name": "John Doe"}
    mock_get.assert_called_once_with("https://api.example.com/users/1")

🚩Основные методы и атрибуты

🟠return_value
Устанавливает возвращаемое значение метода.
🟠side_effect
Устанавливает последовательность возвращаемых значений или исключений.
🟠assert_called_with()
Проверяет, что метод был вызван с определенными аргументами.
🟠assert_called_once_with()
Проверяет, что метод был вызван ровно один раз с определенными аргументами.

🚩Пример с контекстным менеджером

import requests
from unittest.mock import patch

def get_status_code(url):
    response = requests.get(url)
    return response.status_code

def test_get_status_code():
    with patch('requests.get') as mock_get:
        mock_get.return_value.status_code = 200
        
        assert get_status_code("https://example.com") == 200
        mock_get.assert_called_once_with("https://example.com")

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое абстрактные классы?

Абстрактные классы — это классы, которые нельзя инстанцировать, но которые могут содержать как реализацию, так и абстрактные методы, определяемые в подклассах. Они служат основой для создания классов с обязательной реализацией определённых методов. Это полезно для создания архитектуры приложений.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие бывают виды тестов?

Существует несколько видов тестов, каждый из которых имеет свою цель и особенности.

🚩Виды

🟠Юнит-тесты (Unit Tests)
Проверка работы отдельных модулей или функций в изоляции от других частей системы.
Ориентированы на минимальные части кода (функции, методы, классы).
Высокая скорость выполнения.
Простота написания и отладки.
Обычно пишутся разработчиками.

def add(a, b):
    return a + b

def test_add():
    assert add(1, 2) == 3

🟠Интеграционные тесты (Integration Tests)
Проверка взаимодействия между различными модулями или компонентами системы.
Тестируют комбинации модулей и их взаимодействие.
Более сложные и медленные по сравнению с юнит-тестами.
Могут выявить проблемы в интерфейсах между модулями.

def fetch_data_from_api():
    response = requests.get('https://api.example.com/data')
    return response.json()

def test_fetch_data_from_api():
    data = fetch_data_from_api()
    assert 'key' in data

🟠Системные тесты (System Tests)
Проверка всей системы целиком на соответствие требованиям.
Тестируют систему в рабочей среде.
Включают проверку всех функциональных и нефункциональных требований.
Могут включать пользовательские сценарии.
Тестирование веб-приложения на основе реальных пользовательских сценариев, включая проверку интерфейса, баз данных и API.

🟠Приемочные тесты (Acceptance Tests)
Проверка соответствия системы требованиям и ожиданиям заказчика или конечного пользователя.
Часто выполняются вместе с заказчиком или пользователем.
Фокусируются на бизнес-требованиях и пользовательских сценариях.
Успешное прохождение приемочных тестов является критерием готовности системы к выпуску.
Тестирование нового функционала с участием конечных пользователей для проверки его удобства и соответствия их ожиданиям.

🟠Регрессионные тесты (Regression Tests)
Убедиться, что изменения в коде не вызвали новых ошибок в уже работающем функционале.
Выполняются после внесения изменений в код.
Обычно автоматизируются и включают повторное выполнение всех или части существующих тестов.
Повторное выполнение всех юнит-тестов и интеграционных тестов после рефакторинга кода.

🟠Нефункциональные тесты (Non-functional Tests)
Проверка нефункциональных аспектов системы, таких как производительность, безопасность, удобство использования и др.

🚩Основные виды:

🟠Тесты производительности
Измеряют скорость выполнения, пропускную способность и время отклика системы.
🟠Тесты безопасности
Оценивают защищенность системы от угроз и атак.
🟠Тесты удобства использования
Проверяют удобство и интуитивность пользовательского интерфейса.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как работает middleware?

Middleware — это промежуточный слой, обрабатывающий запросы и ответы между клиентом и сервером. Он может изменять запросы, добавлять данные, проверять авторизацию или логировать действия. Middleware используется для модульности и управления логикой обработки запросов.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Пирамида тестирования?

Это концепция, предложенная Майком Коэном (Mike Cohn), которая описывает оптимальное соотношение разных видов тестов для обеспечения качественного программного обеспечения. Пирамида тестирования визуально представлена в виде треугольника, где каждый уровень соответствует определённому виду тестов, а ширина уровня отражает рекомендуемое количество тестов этого вида.

🚩Уровни пирамиды тестирования

🟠Юнит-тесты (Unit Tests)
Расположение: Основание пирамиды.
Цель: Тестирование отдельных функций или методов в изоляции.
Количество: Наибольшее количество тестов.
Особенности: Высокая скорость выполнения, низкая стоимость написания и поддержки.

def add(a, b):
return a + b

def test_add():
assert add(1, 2) == 3

🟠Интеграционные тесты (Integration Tests)
Расположение: Средний уровень пирамиды.
Цель: Тестирование взаимодействия между различными модулями или компонентами.
Количество: Меньше, чем юнит-тестов, но больше, чем системных тестов.
Особенности: Проверка интерфейсов и взаимодействия между модулями, более сложные и медленные, чем юнит-тесты.

def fetch_data_from_api():
response = requests.get('https://api.example.com/data')
return response.json()

def test_fetch_data_from_api():
data = fetch_data_from_api()
assert 'key' in data

🟠Системные тесты (System Tests)
Расположение: Вершина пирамиды.
Цель: Тестирование всей системы целиком на соответствие требованиям.
Количество: Наименьшее количество тестов.
Особенности: Включают тестирование пользовательских сценариев, проверку функциональных и нефункциональных требований, самые сложные и медленные.

🚩Зачем нужна

🟠Оптимизация затрат на тестирование
Юнит-тесты дешевле в написании и выполнении, чем интеграционные и системные тесты.
🟠Снижение времени выполнения тестов
Большое количество юнит-тестов позволяет быстро находить ошибки на ранних стадиях разработки.
🟠Поддержание качества кода
Юнит-тесты способствуют улучшению дизайна кода и повышают его тестируемость.
🟠Снижение риска регрессий
Хорошее покрытие юнит-тестами позволяет быстро обнаруживать и исправлять ошибки, возникающие после внесения изменений в код.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Чем отличаются декораторы classmethod и staticmethod?

classmethod делает метод привязанным к классу, а не к экземпляру, и первым аргументом передаёт сам класс (cls). staticmethod не привязан ни к классу, ни к экземпляру, и ведёт себя как обычная функция внутри класса. Оба декоратора используются для разделения логики методов в зависимости от их назначения.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что делать, если тестируемая функция использует удалённое подключение к внешним сервисам, которое иногда выдает ошибку таймаута, 404 и им подобные?

Такие ситуации можно обработать и протестировать несколькими способами. Один из наиболее распространенных подходов — использование mock-объектов для имитации поведения внешних сервисов. Это позволяет изолировать тестируемую функцию и контролировать ее взаимодействие с внешними сервисами.

🚩Шаги для решения проблемы

1⃣Использование библиотеки `unittest.mock` для создания mock-объектов
С помощью библиотеки unittest.mock можно подменить вызовы к внешним сервисам и задать их поведение, включая ошибки и исключения.

2⃣Обработка исключений в тестируемой функции
В тестируемой функции следует предусмотреть обработку возможных ошибок, таких как таймауты и HTTP-статусы (например, 404), чтобы она корректно реагировала на эти ситуации.

Предположим, у нас есть функция, которая запрашивает данные с удаленного сервиса

import requests

def fetch_data_from_api(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.Timeout:
        return {"error": "Timeout"}
    except requests.exceptions.HTTPError as http_err:
        return {"error": f"HTTP error: {http_err.response.status_code}"}
    except requests.exceptions.RequestException as err:
        return {"error": f"Request error: {err}"}

🚩Тестирование с использованием `unittest.mock`

Установка поведения для mock-объекта
Создадим тесты, которые подменяют вызов requests.get и задают различные сценарии ошибок.

from unittest.mock import patch
import requests
import pytest

def test_fetch_data_timeout():
    with patch('requests.get') as mock_get:
        mock_get.side_effect = requests.exceptions.Timeout
        result = fetch_data_from_api("https://example.com/data")
        assert result == {"error": "Timeout"}

def test_fetch_data_404():
    with patch('requests.get') as mock_get:
        mock_response = mock_get.return_value
        mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError(response=mock_response)
        mock_response.status_code = 404
        result = fetch_data_from_api("https://example.com/data")
        assert result == {"error": "HTTP error: 404"}

def test_fetch_data_request_exception():
    with patch('requests.get') as mock_get:
        mock_get.side_effect = requests.exceptions.RequestException("Connection error")
        result = fetch_data_from_api("https://example.com/data")
        assert result == {"error": "Request error: Connection error"}

1⃣Тест на таймаут
Используем mock_get.side_effect = requests.exceptions.Timeout для имитации ошибки таймаута. Проверяем, что функция возвращает ожидаемое значение при таймауте.

2⃣Тест на HTTP ошибку 404
Устанавливаем mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError(response=mock_response) для имитации HTTP ошибки. Устанавливаем код статуса mock_response.status_code = 404. Проверяем, что функция возвращает ожидаемое значение при HTTP ошибке 404.

3⃣Тест на общую ошибку запроса
Используем mock_get.side_effect = requests.exceptions.RequestException("Connection error") для имитации общей ошибки запроса. Проверяем, что функция возвращает ожидаемое значение при общей ошибке запроса.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что происходит в момент итерации по списку?

Во время итерации Python использует итератор, который возвращает элементы списка по одному. Итератор хранит текущее состояние, чтобы продолжить с того места, где остановился. Это позволяет эффективно обходить элементы, не создавая дополнительных копий данных.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что делать, если тестируемая функция занимает много времени на выполнение повторяющихся операций внутри неё?

Можно использовать мокирование (mocking) зависимостей или стабирование (stubbing), чтобы заменить долгие операции на быстрые фиктивные реализации, которые будут возвращать заранее заданные значения. Также можно рассмотреть параллельное выполнение или кеширование результатов для ускорения тестов.

🚩Подходы к оптимизации тестов

🟠Кэширование результатов
Если функция выполняет одинаковые операции с одинаковыми входными данными, можно кэшировать результаты этих операций, чтобы не выполнять их повторно.
🟠Мокирование (mocking) повторяющихся операций
Используйте mock-объекты для замены дорогих операций фиктивными, которые возвращают заранее определенные результаты.
🟠Использование фикстур (fixtures)
Фикстуры позволяют подготовить данные или состояния один раз перед выполнением тестов и повторно использовать их в разных тестах.
🟠Параллельное выполнение тестов
Параллельное выполнение тестов может значительно сократить общее время тестирования. Допустим, у нас есть функция, которая выполняет дорогую операцию:

import time

def expensive_operation(data):
    time.sleep(5)  # Имитация долгой операции
    return sum(data)

def process_data(data):
    result = []
    for item in data:
        result.append(expensive_operation(item))
    return result

🚩Оптимизация с использованием

🟠Мокирования
Мы можем замокировать expensive_operation, чтобы она возвращала заранее определенные результаты без выполнения долгих операций.

from unittest.mock import patch

def test_process_data():
    data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

    with patch('__main__.expensive_operation') as mock_expensive:
        mock_expensive.side_effect = [6, 15, 24]  # Заранее определенные результаты
        
        result = process_data(data)
        
        assert result == [6, 15, 24]
        assert mock_expensive.call_count == 3  # Проверка, что функция вызвана 3 раза

🟠Кэширования

Используем кэширование для хранения результатов дорогостоящих операций.

from functools import lru_cache

@lru_cache(maxsize=None)
def expensive_operation(data):
    time.sleep(5)  # Имитация долгой операции
    return sum(data)

def process_data(data):
    result = []
    for item in data:
        result.append(expensive_operation(tuple(item)))  # Преобразуем список в кортеж для кэширования
    return result

🚩Использование фикстур в pytest

Фикстуры для подготовки данных
Создаем фикстуры для подготовки данных, которые используются в тестах.

import pytest

@pytest.fixture
def sample_data():
    return [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

def test_process_data(sample_data):
    with patch('__main__.expensive_operation') as mock_expensive:
        mock_expensive.side_effect = [6, 15, 24]  # Заранее определенные результаты
        
        result = process_data(sample_data)
        
        assert result == [6, 15, 24]

🚩Параллельное выполнение тестов

Запуск тестов параллельно
Используйте возможности параллельного выполнения тестов, например, с помощью pytest-xdist.

pytest -n 4  # Запуск тестов в 4 параллельных потоках

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как в функцию передаются аргументы, по ссылке или по значению?

В Python аргументы передаются по ссылке на объект, но так как типы делятся на изменяемые (списки, словари) и неизменяемые (числа, строки), поведение зависит от типа. Изменяемые объекты могут быть изменены внутри функции, а неизменяемые создают новые экземпляры при попытке их изменить.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Чем интеграционное тестирование отличается от функционального?

🚩Интеграционное тестирование

Проверка взаимодействия между различными модулями или компонентами системы.

🟠Фокус на взаимодействии
Проверяет, как отдельные части системы работают вместе.
🟠Обнаружение интерфейсных ошибок
Выявляет проблемы, которые могут возникнуть при передаче данных или управлении между модулями.
🟠Промежуточное тестирование
Проводится после юнит-тестов и перед системными тестами.
🟠Тестирование зависимостей
Включает взаимодействие с внешними сервисами, базами данных, файлами и другими модулями.
🟠Инструменты
Часто используются mock-объекты для замены реальных зависимостей.

def fetch_data_from_db():
    # Имитация запроса к базе данных
    return {"user": "John", "email": "john@example.com"}

def send_email(data):
    # Имитация отправки электронной почты
    print(f"Sending email to {data['email']}")

def process_user_data():
    data = fetch_data_from_db()
    send_email(data)

Интеграционный тест может выглядеть так

def test_process_user_data():
    data = fetch_data_from_db()
    assert data["email"] == "john@example.com"
    send_email(data)

🚩Функциональное тестирование

Проверка функциональности системы на соответствие требованиям.

🟠Фокус на функциональности
Проверяет, выполняет ли система свои функции в соответствии с заданными требованиями.
🟠Проверка конечного поведения
Тестирует систему с точки зрения конечного пользователя.
🟠Все уровни тестирования
Может включать юнит-тесты, интеграционные тесты, системные и приемочные тесты.
🟠Тестирование "черного ящика"
Не требует знания внутренней структуры или кода системы.
🟠Инструменты
Могут использоваться автоматизированные тестовые фреймворки, такие как Selenium для веб-приложений.

def register_user(username, password):
    # Имитация регистрации пользователя
    if username and password:
        return "Registration successful"
    else:
        return "Registration failed"

Функциональный тест может выглядеть так:

def test_register_user():
    assert register_user("testuser", "securepassword") == "Registration successful"
    assert register_user("", "securepassword") == "Registration failed"

🚩Ключевые отличия

🟠Цель
Интеграционное тестирование: Проверка взаимодействия между модулями.
Функциональное тестирование: Проверка функциональности системы на соответствие требованиям.
🟠Фокус
Интеграционное тестирование: Взаимодействие и интерфейсы между модулями.
Функциональное тестирование: Поведение системы с точки зрения пользователя.
🟠Уровень тестирования
Интеграционное тестирование: Промежуточный уровень между юнит-тестами и системными тестами.
Функциональное тестирование: Может охватывать все уровни, включая юнит-тесты, интеграционные, системные и приемочные тесты.
🟠Методология
Интеграционное тестирование: Тестирование "серого ящика" (частичное знание внутренней структуры).
Функциональное тестирование: Тестирование "черного ящика" (без знания внутренней структуры).

Ставь 👍 и забирай 📚 Базу знаний

🤔 Кем себя видишь через два года при работе в фуллтайм?

Через два года вижу себя специалистом, обладающим глубокими знаниями и опытом в выбранной области, участвующим в крупных проектах и развивающим новые навыки, возможно, в области автоматизации или масштабируемых систем.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что происходит с запросом после того как мы обработали его во вьюхе?

🚩Этапы обработки запроса после вьюхи

1⃣Формирование ответа (Response) во вьюхе
Вьюха обрабатывает запрос (например, получение данных из базы данных, выполнение бизнес-логики). На основе обработки данных вьюха формирует объект ответа. В Django это может быть HttpResponse, JsonResponse и т.д. В Flask это может быть объект Response или просто строка, которая будет конвертирована в ответ.

from django.http import HttpResponse

def my_view(request):
   data = "Hello, World!"
   return HttpResponse(data)   

Пример в Flask

from flask import Flask, Response

app = Flask(__name__)

@app.route('/')
def my_view():
   return Response("Hello, World!")   

2⃣Обработка промежуточными слоями (Middleware)
После того как вьюха сформировала ответ, он проходит через цепочку промежуточных слоев (middleware). Middleware могут модифицировать объект ответа, добавлять заголовки, обрабатывать ошибки и т.д. Примеры обработки включают логирование, сжатие контента, обработку сессий и т.д.

class SimpleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)
        response['X-Custom-Header'] = 'My Custom Header'
        return response

3⃣Обработка сервером и отправка ответа
После прохождения всех промежуточных слоев ответ передается веб-серверу. Веб-сервер, такой как Nginx или Apache, отправляет сформированный ответ обратно клиенту (например, браузеру). Сервер обрабатывает низкоуровневые детали HTTP-протокола, такие как установка соединения, обработка заголовков и передача данных.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что знаешь про два основных типа данных Python?

Основные типы данных Python — изменяемые (списки, множества, словари) и неизменяемые (строки, числа, кортежи). Изменяемые можно модифицировать после создания, тогда как неизменяемые остаются неизменными.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Каким образом проходит информация валидацию?

Это процесс проверки корректности и полноты данных, поступающих в систему, прежде чем они будут использованы или сохранены. Этот процесс может происходить на разных уровнях веб-приложения: клиентская сторона, серверная сторона, и на уровне базы данных.

🟠Клиентская валидация (Client-side Validation)
До отправки данных на сервер. Используются HTML5 атрибуты и JavaScript. Снижение нагрузки на сервер, мгновенная обратная связь для пользователя. Не является надежной, так как пользователь может обойти ее.

<form>
    <input type="text" name="username" required minlength="3">
    <input type="email" name="email" required>
    <input type="submit">
</form>

Пример JavaScript валидации

document.querySelector('form').addEventListener('submit', function(event) {
    const username = document.querySelector('input[name="username"]').value;
    if (username.length < 3) {
        alert('Username must be at least 3 characters long.');
        event.preventDefault();
    }
});

🟠Серверная валидация (Server-side Validation)
После получения данных от клиента. Используются встроенные или сторонние библиотеки и фреймворки. Надежная защита, обязательна даже при наличии клиентской валидации. Добавляет нагрузку на сервер, может увеличить время отклика.

from django import forms

class UserForm(forms.Form):
    username = forms.CharField(min_length=3, max_length=100)
    email = forms.EmailField()

def my_view(request):
    if request.method == 'POST':
        form = UserForm(request.POST)
        if form.is_valid():
            # Обработка данных
            pass
        else:
            # Обработка ошибок
            pass
    else:
        form = UserForm()
    return render(request, 'my_template.html', {'form': form})

Пример в Flask

from flask import Flask, request, render_template_string
from wtforms import Form, StringField, validators

app = Flask(__name__)

class UserForm(Form):
    username = StringField('Username', [validators.Length(min=3, max=100)])
    email = StringField('Email', [validators.Email()])

@app.route('/', methods=['GET', 'POST'])
def my_view():
    form = UserForm(request.form)
    if request.method == 'POST' and form.validate():
        # Обработка данных
        pass
    return render_template_string('<form method="POST">{{ form.csrf_token }}{{ form.username }}{{ form.email }}<input type="submit"></form>', form=form)

🟠Валидация на уровне базы данных (Database Validation)
При сохранении данных в базу данных. Используются ограничения базы данных (constraints) и триггеры. Гарантия целостности данных на уровне хранения. Может вызвать ошибки, если данные уже были приняты сервером, но не прошли валидацию на уровне БД.

Пример ограничения в SQL

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(100) NOT NULL CHECK (LENGTH(username) >= 3),
    email VARCHAR(100) NOT NULL UNIQUE
);

Ставь 👍 и забирай 📚 Базу знаний