@pytest.fixture
def Senior():
    return Student(type=STUDENT.SENIOR)

@pytest.fixture
def foo():
    # constructor
    util_obj = Uitls()

    # yield return
    yield util_obj

    # destructor
    util_obj.delete()

@pytest.fixture(scope='session')
def sess():
    # global initialization here
    ...

import pytest

@pytest.fixture(scope='class')
def setup():
    # setup class here
    yeild
    # tear down class here

# fixture를 parameter사용하지 않고 적용하는 방법
@pytest.mark.usefixtures('setup')
class TestClass1:
    # 모든 test method가 실행 전에 setup 실행
    # 모든 test method 종료 후 tear down 부분 실행

    def test_case1(self):
        pass

    def test_case2(self):
        pass

@pytest.fixture
def foo():
    return 'Hello'

def test_baa(foo):
    print(foo)
    # 'Hello' 출력

# 위치: foo.py
@pytest.fixture
def foo():
    return 'Hello'

# 위치: bar.py
from foo impor foo

def test_bar(foo):
    print(foo)
    # 'Hello' 출력

# 위치: tests/conftest.py
import pytest

@pytest.fixture
def foo():
    return 'foo'

# 위치: tests/bar.py
# import 불필요

def test_bar(foo):
    print(foo)
    # 'foo' 출력

# 위치: tests/conftest.py

import pytest

@pytest.fixture(autouse=True)
def foo():
    print('foo')

# 위치: tests/app/test_app.py

def test_bar():
    # 여기서 'foo' 출력
    print('bar')
    # 'bar' 출력

@pytest.mark.usefixtures('foo')
def test_bar():
    # foo fixture starts here
    ...

@pytest.mark.skip(reason='호환성 이슈')
def test_foo():
    # skipped during test run
    ...

@pytest.mark.parametrize(
        ('cond', 'expected'),
        [(True, True), (False, False)])
def test_always_true(cond, expected):
    # True == True 와 False == False 두 테스트가 실행 됨
    assert cond == expected

@pytest.mark.django_db
def test_user():
    user = MedicalStaffFactory()
    user.delete()

def test_foo():
    assert True is True    # 성공
    assert True is False   # 실패, test run에서 실패 및 error message
    assert True is False, 'reason here'

import pytest

def test_exception():
    d = {}
    with pytest.raises(KeyError):  # 성공
        a = d['a']

# 위치: myapp/tests/test_serializers.py
def test_check_token_fail(self, user, mocker):
    uid_b64 = base64.urlsafe_b64encode(str(user.id).encode()).decode('utf-8')
    token = TokenGenerator().make_token(user)
    serializer = PasswordResetSerializer(data={
        'password': 'newpassword',
        'token': token,
        'uid_b64': uid_b64,
    })

    mocker.patch('myapp.serializers.TokenGenerator.check_token', return_value=False)
    with pytest.raises(AuthenticationError) as e:
        serializer.is_valid(raise_exception=True)
    assert e.value.args[0] == 'The reset link is invalid'
    assert e.value.args[1] == 401

# 위치: myapp/serializers.py
from some_library.tokens import TokenGenerator  # 이거를 mock
...
class PasswordResetSerializer(serializers.Serializer):

    def validate(self, attr):
        ...
        if not TokenGenerator().check_token(user, token):
            raise AuthenticationError('The reset link is invalid', 401)
        ...

# 위치: myapp/tests/test_views.py
@pytest.mark.django_db()
@pytest.mark.usefixtures('auth_token')
class TestResetEmailWithTokenView:

    def test_reset_email_with_token(self, user, api_client, mocker):

        # 테스트 데이터 설정
        url = reverse('reset-email-with-token')
        acc_token, _ = generate_new_tokens('web-client', user.id)
        headers = {'Authorization': f'Bearer {acc_token}'}

        mock_serializer = mocker.patch('myapp.views.ResetEmailWithTokenView.serializer_class')
        mock_serializer.is_valid.return_value = True
        mock_serializer.data.return_value = {}

        # 요청 전송
        resp = api_client.post(url, {}, **headers)
        assert resp.status_code == status.HTTP_200_OK

        # is_valid 파라미터 확인
        assert mock_serializer.call_count == 1
        assert mock_serializer.call_args[1]['context']['request'].user == user

# 위치: myapp/views.py
class ResetEmailWithTokenView(generics.GenericAPIView):
    serializer_class = ResetEmailWithTokenSerializer
    renderer_classes = (CustomResultRenderer, )

    def post(self, request):
        serializer = self.serializer_class(data=request.data, context={"request": request})
        serializer.is_valid(raise_exception=True)
        return Response(serializer.data, status=status.HTTP_200_OK)

[pytest]
DJANGO_SETTINGS_MODULE=myapp.settings
addopts = --reuse-db --disable-warnings --nomigrations
python_files = test*.py
python_functions = test*

# 위치: myapp/tests/test_serializers.py
class TestTokenAuthenticationSerializer:
    def test_validate(self, user):
        ...

# 함수에 django_db 적용
@pytest.mark.django_db
def test_foo():
    # some database access here
  ...

# class에 django_db 적용
@pytest.mark.django_db
class TestCase1:
        def test_foo(self):
                passs

# 모듈 전체 django_db 적용
pytestmark = pytest.mark.django_db

# test code here
...

[pytest]
DJANGO_SETTINGS_MODULE=myapp.settings
addopts = --reuse-db --disable-warnings --nomigrations
python_files = test*.py
python_functions = test*

$ pytest --create-db --migrations

# 위치: myapp/tests/fixtures.py

@pytest.fixture()
def mem_cache():    # noqa
    # in-memory cache to isolate cache between tests
    # also isolates cache between processes, due to it allows one process to access the cache at a time
    with override_settings(CACHES={'default': {'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'}}):
        cache.clear()
        yield
        cache.clear()

# 위치: myapp/tests/test_models.py

# using in-memory cache to isolate cache between tests
@pytest.mark.django_db()
@pytest.mark.usefixtures('mem_cache')
class TestMyModel:

    def test_cache_key_generation(self):
        # Create an instance of the model
        my_instance = MyModelFactory()

        # Cache key
        key = f'cache_key_prefix:model:{my_instance.id}'

        # Assert that the cache key is set correctly
        assert my_instance.cache_key == key

> GRANT ALL PRIVILEGES ON *.* TO 'user'@'%' WITH GRANT OPTION; FLUSH PRIVILEGES;

pip install -r requirements..txt

# 기본 실행
pytest

# 특정 테스트 파일 실행
pytest myapp/tests/test_models.py
pytest myapp/tests/test_views.py::TestTokenGeneration::test_token_generation_permission_check

# 멀티 프로세싱 적용
pytest -n auto

$ pytest --create-db --migrations

# 전체 범위
$ pytest --cov=.

# 테스트 못한 코드 표시
$ pytest --cov-report term-missing --cov=

# 80% 커버리지 이하 시 exit 1(fail), CICD에서 많이 사용
$ pytest --cov=. --cov-fail-under=80

name: Python Tests

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: 3.9

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt

    - name: Run tests with pytest
      run: |
        pytest --cov=myapp --cov-report=xml