ವಿಷಯಕ್ಕೆ ತೆರಳಿ

ಪೈಟೆಸ್ಟ್ (pytest) - ಸರಳ ಮತ್ತು ಶಕ್ತಿಯುತ ಟೆಸ್ಟಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್

pytest ಪೈಥಾನ್‌ನ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಮೂರನೇ-ಪಕ್ಷದ (third-party) ಟೆಸ್ಟಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದೆ. ಇದು unittest ಗಿಂತ ಕಡಿಮೆ ಕೋಡ್ (boilerplate) ಬಳಸಿ, ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಬರೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

pytest ಅನ್ನು ಏಕೆ ಬಳಸಬೇಕು?

  • ಸರಳ ಸಿಂಟ್ಯಾಕ್ಸ್: ಟೆಸ್ಟ್‌ಗಳನ್ನು ಸಾಮಾನ್ಯ ಪೈಥಾನ್ ಫಂಕ್ಷನ್‌ಗಳಾಗಿ ಬರೆಯಬಹುದು. TestCase ಕ್ಲಾಸ್‌ಗಳ ಅಗತ್ಯವಿಲ್ಲ.
  • ಶಕ್ತಿಯುತ ಅಸರ್ಷನ್‌ಗಳು: ಸಾಮಾನ್ಯ assert ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ವಿಫಲವಾದಾಗ ವಿವರವಾದ ಮಾಹಿತಿಯನ್ನು ನೀಡುತ್ತದೆ.
  • ಫಿಕ್ಸ್ಚರ್‌ಗಳು (Fixtures): ಟೆಸ್ಟ್‌ಗಳಿಗೆ ಬೇಕಾದ ಸೆಟಪ್, ಟಿಯರ್‌ಡೌನ್ ಮತ್ತು ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ಅತ್ಯಂತ ಶಕ್ತಿಯುತವಾದ ವ್ಯವಸ್ಥೆ.
  • ದೊಡ್ಡ ಪ್ಲಗಿನ್ ವ್ಯವಸ್ಥೆ: ಕೋಡ್ ಕವರೇಜ್ (pytest-cov), ಸಮಾನಾಂತರ ಟೆಸ್ಟಿಂಗ್ (pytest-xdist) ಮುಂತಾದ ಸಾವಿರಾರು ಪ್ಲಗಿನ್‌ಗಳು ಲಭ್ಯವಿದೆ.
  • ಉತ್ತಮ ಏಕೀಕರಣ: unittest ಮತ್ತು nose ಟೆಸ್ಟ್ ಸ್ಯೂಟ್‌ಗಳನ್ನು ಸಹ ಚಲಾಯಿಸಬಲ್ಲದು.

pytest ಅನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡುವುದು

pytest ಅನ್ನು pip ಬಳಸಿ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಬಹುದು: 

pip install pytest

ಸರಳ ಟೆಸ್ಟ್ ಬರೆಯುವುದು

unittest ಉದಾಹರಣೆಯಲ್ಲಿ ಬಳಸಿದ ಅದೇ my_math.py ಫೈಲ್ ಅನ್ನು pytest ಬಳಸಿ ಟೆಸ್ಟ್ ಮಾಡೋಣ.

ಹಂತ 1: ಟೆಸ್ಟ್ ಮಾಡಬೇಕಾದ ಕೋಡ್ 

# my_math.py

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

def is_even(n):
    return n % 2 == 0

ಹಂತ 2: pytest ಟೆಸ್ಟ್ ಫೈಲ್ ರಚಿಸುವುದು test_math_pytest.py ಎಂಬ ಫೈಲ್ ರಚಿಸಿ. pytest ಸ್ವಯಂಚಾಲಿತವಾಗಿ test_*.py ಅಥವಾ *_test.py ಫೈಲ್‌ಗಳಲ್ಲಿರುವ test_ ನಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಟೆಸ್ಟ್‌ಗಳೆಂದು ಗುರುತಿಸುತ್ತದೆ.

# test_math_pytest.py
from my_math import add, is_even

def test_add():
    """add ಫಂಕ್ಷನ್ ಅನ್ನು ಟೆಸ್ಟ್ ಮಾಡುತ್ತದೆ."""
    assert add(5, 3) == 8
    assert add(-1, 1) == 0
    assert add(-5, -5) == -10

def test_is_even():
    """is_even ಫಂಕ್ಷನ್ ಅನ್ನು ಟೆಸ್ಟ್ ಮಾಡುತ್ತದೆ."""
    assert is_even(2)
    assert not is_even(3)
    assert is_even(0)
unittest ಜೊತೆಗಿನ ವ್ಯತ್ಯಾಸಗಳು: * unittest.TestCase ಕ್ಲಾಸ್ ಅನ್ನು ಇನ್ಹೆರಿಟ್ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ. * ಟೆಸ್ಟ್‌ಗಳು ಕೇವಲ ಸಾಮಾನ್ಯ ಫಂಕ್ಷನ್‌ಗಳು. * self.assertEqual ಬದಲಿಗೆ, ಸರಳ assert ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ಗಳನ್ನು ಬಳಸಲಾಗಿದೆ.

ಹಂತ 3: ಟೆಸ್ಟ್‌ಗಳನ್ನು ಚಲಾಯಿಸುವುದು ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ, ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಕೇವಲ pytest ಎಂದು ಟೈಪ್ ಮಾಡಿ: 

pytest
pytest ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಎಲ್ಲಾ ಟೆಸ್ಟ್ ಫೈಲ್‌ಗಳನ್ನು ಮತ್ತು ಟೆಸ್ಟ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಹುಡುಕಿ ಚಲಾಯಿಸುತ್ತದೆ.

ಔಟ್‌ಪುಟ್: 

============================= test session starts ==============================
...
collected 2 items

test_math_pytest.py ..                                                 [100%]

============================== 2 passed in ...s ===============================

ಫಿಕ್ಸ್ಚರ್‌ಗಳು (Fixtures)

ಫಿಕ್ಸ್ಚರ್‌ಗಳು pytest ನ ಅತ್ಯಂತ ಶಕ್ತಿಯುತ ವೈಶಿಷ್ಟ್ಯ. ಇವು ಟೆಸ್ಟ್‌ಗಳಿಗೆ ಬೇಕಾದ ಡೇಟಾ, ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಅಥವಾ ಯಾವುದೇ ಸೆಟಪ್ ಕೋಡ್ ಅನ್ನು ಒದಗಿಸುತ್ತವೆ. @pytest.fixture ಡೆಕೋರೇಟರ್ ಬಳಸಿ ಫಿಕ್ಸ್ಚರ್‌ಗಳನ್ನು ಡಿಫೈನ್ ಮಾಡಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ: ಒಂದು ಟೆಸ್ಟ್‌ಗೆ ಒಂದು ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಲಿಸ್ಟ್ ಬೇಕೆಂದು ಭಾವಿಸೋಣ. 

import pytest

@pytest.fixture
def sample_data():
    """ಟೆಸ್ಟ್‌ಗಳಿಗಾಗಿ ಒಂದು ಮಾದರಿ ಲಿಸ್ಟ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ."""
    print("\n(ಫಿಕ್ಸ್ಚರ್: sample_data ರಚಿಸಲಾಗುತ್ತಿದೆ...)")
    return [10, 20, 30, 40, 50]

def test_sum(sample_data):
    """ಲಿಸ್ಟ್‌ನ ಮೊತ್ತವನ್ನು ಟೆಸ್ಟ್ ಮಾಡುತ್ತದೆ."""
    print("test_sum ಚಲಾಯಿಸಲಾಗುತ್ತಿದೆ...")
    assert sum(sample_data) == 150

def test_length(sample_data):
    """ಲಿಸ್ಟ್‌ನ ಉದ್ದವನ್ನು ಟೆಸ್ಟ್ ಮಾಡುತ್ತದೆ."""
    print("test_length ಚಲಾಯಿಸಲಾಗುತ್ತಿದೆ...")
    assert len(sample_data) == 5
ವಿವರಣೆ: * sample_data ಎಂಬ ಫಿಕ್ಸ್ಚರ್ ಅನ್ನು ಡಿಫೈನ್ ಮಾಡಲಾಗಿದೆ. * test_sum ಮತ್ತು test_length ಫಂಕ್ಷನ್‌ಗಳು sample_data ಅನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಕೇಳುತ್ತಿವೆ. * pytest ಸ್ವಯಂಚಾಲಿತವಾಗಿ sample_data ಫಿಕ್ಸ್ಚರ್ ಅನ್ನು ಚಲಾಯಿಸಿ, ಅದರ ರಿಟರ್ನ್ ಮೌಲ್ಯವನ್ನು ಈ ಟೆಸ್ಟ್ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಪಾಸ್ ಮಾಡುತ್ತದೆ.

ಪ್ಯಾರಾಮೀಟರೈಸಿಂಗ್ ಟೆಸ್ಟ್‌ಗಳು (Parametrizing Tests)

ಒಂದೇ ಟೆಸ್ಟ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಹಲವು ವಿಭಿನ್ನ ಇನ್‌ಪುಟ್‌ಗಳು ಮತ್ತು ನಿರೀಕ್ಷಿತ ಔಟ್‌ಪುಟ್‌ಗಳೊಂದಿಗೆ ಚಲಾಯಿಸಲು @pytest.mark.parametrize ಡೆಕೋರೇಟರ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆ: add ಫಂಕ್ಷನ್ ಅನ್ನು ಹಲವು ಇನ್‌ಪುಟ್‌ಗಳೊಂದಿಗೆ ಟೆಸ್ಟ್ ಮಾಡೋಣ. 

import pytest
from my_math import add

@pytest.mark.parametrize("a, b, expected", [
    (5, 3, 8),          # ಟೆಸ್ಟ್ ಕೇಸ್ 1
    (-1, 1, 0),         # ಟೆಸ್ಟ್ ಕೇಸ್ 2
    (-5, -5, -10),      # ಟೆಸ್ಟ್ ಕೇಸ್ 3
    (100, 200, 300)     # ಟೆಸ್ಟ್ ಕೇಸ್ 4
])
def test_add_parametrized(a, b, expected):
    assert add(a, b) == expected
ಈಗ pytest ಚಲಾಯಿಸಿದಾಗ, test_add_parametrized ಫಂಕ್ಷನ್ ನಾಲ್ಕು ಬಾರಿ ಚಲಾಯಿಸಲ್ಪಡುತ್ತದೆ, ಪ್ರತಿ ಬಾರಿ parametrize ನಲ್ಲಿ ನೀಡಿದ ಮೌಲ್ಯಗಳೊಂದಿಗೆ. ಇದು ಕೋಡ್ ಪುನರಾವರ್ತನೆಯನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

pytest ನ ಕೆಲವು ಉಪಯುಕ್ತ ಫ್ಲ್ಯಾಗ್‌ಗಳು

  • pytest -v: ಹೆಚ್ಚು ವಿವರವಾದ ಔಟ್‌ಪುಟ್ (Verbose).
  • pytest -k "add": ಹೆಸರಿನಲ್ಲಿ "add" ಇರುವ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಮಾತ್ರ ಚಲಾಯಿಸುತ್ತದೆ.
  • pytest --maxfail=1: ಒಂದು ಟೆಸ್ಟ್ ವಿಫಲವಾದ ತಕ್ಷಣ ನಿಲ್ಲಿಸುತ್ತದೆ.
  • pytest -x: maxfail=1 ನ ಶಾರ್ಟ್‌ಕಟ್.

pytest ತನ್ನ ಸರಳತೆ, ಶಕ್ತಿಯುತ ಫೀಚರ್‌ಗಳು ಮತ್ತು ವಿಸ್ತರಣೀಯತೆಯಿಂದಾಗಿ ಆಧುನಿಕ ಪೈಥಾನ್ ಡೆವಲಪ್‌ಮೆಂಟ್‌ನಲ್ಲಿ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಟೆಸ್ಟಿಂಗ್ ಟೂಲ್ ಆಗಿದೆ.