ಯೂನಿಟ್ಟೆಸ್ಟ್ (unittest) - ಪೈಥಾನ್‌ನ ಬಿಲ್ಟ್-ಇನ್ ಟೆಸ್ಟಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್

unittest ಪೈಥಾನ್‌ನೊಂದಿಗೆ ಬರುವ ಒಂದು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಟೆಸ್ಟಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದೆ. ಇದನ್ನು "PyUnit" ಎಂದೂ ಕರೆಯುತ್ತಾರೆ ಮತ್ತು ಇದು ಜಾವಾದ JUnit ನಿಂದ ಪ್ರೇರಿತವಾಗಿದೆ. ಇದು ಆಬ್ಜೆಕ್ಟ್-ಓರಿಯೆಂಟೆಡ್ ರೀತಿಯಲ್ಲಿ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಬರೆಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

unittest ನ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು

1. ಟೆಸ್ಟ್ ಕೇಸ್ (Test Case): ಟೆಸ್ಟಿಂಗ್‌ನ ಮೂಲ ಘಟಕ. ಇದನ್ನು unittest.TestCase ಕ್ಲಾಸ್‌ನಿಂದ ಸಬ್‌ಕ್ಲಾಸ್ ಮಾಡುವ ಮೂಲಕ ರಚಿಸಲಾಗುತ್ತದೆ.
2. ಟೆಸ್ಟ್ ಸ್ಯೂಟ್ (Test Suite): ಹಲವು ಟೆಸ್ಟ್ ಕೇಸ್‌ಗಳ ಅಥವಾ ಇತರ ಟೆಸ್ಟ್ ಸ್ಯೂಟ್‌ಗಳ ಸಂಗ್ರಹ.
3. ಟೆಸ್ಟ್ ರನ್ನರ್ (Test Runner): ಟೆಸ್ಟ್‌ಗಳನ್ನು ಚಲಾಯಿಸುವ ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡುವ ಒಂದು ಕಾಂಪೊನೆಂಟ್.
4. ಫಿಕ್ಸ್ಚರ್ (Fixture): ಟೆಸ್ಟ್ ಮೆಥಡ್‌ಗಳನ್ನು ಚಲಾಯಿಸುವ ಮೊದಲು ಮತ್ತು ನಂತರ ಬೇಕಾಗುವ ಸೆಟಪ್ ಮತ್ತು ಟಿಯರ್‌ಡೌನ್ (cleanup) ಕ್ರಿಯೆಗಳು.

---

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

ಒಂದು ಸರಳ ಫಂಕ್ಷನ್ ಅನ್ನು ಟೆಸ್ಟ್ ಮಾಡಲು unittest ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ನೋಡೋಣ.

ಹಂತ 1: ಟೆಸ್ಟ್ ಮಾಡಬೇಕಾದ ಕೋಡ್ my_math.py ಎಂಬ ಫೈಲ್‌ನಲ್ಲಿ ಕೆಲವು ಗಣಿತದ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬರೆಯೋಣ.

# my_math.py

def add(a, b):
    """ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಕೂಡಿಸುತ್ತದೆ."""
    return a + b

def is_even(n):
    """ಒಂದು ಸಂಖ್ಯೆ ಸಮವೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ."""
    return n % 2 == 0

ಹಂತ 2: ಟೆಸ್ಟ್ ಫೈಲ್ ರಚಿಸುವುದು test_my_math.py ಎಂಬ ಹೊಸ ಫೈಲ್ ರಚಿಸಿ. ಟೆಸ್ಟ್ ಫೈಲ್‌ಗಳ ಹೆಸರು test_ ನಿಂದ ಪ್ರಾರಂಭವಾಗುವುದು ಒಂದು ಉತ್ತಮ ಅಭ್ಯಾಸ.

# test_my_math.py
import unittest
from my_math import add, is_even

class TestMathFunctions(unittest.TestCase):

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

    def test_is_even(self):
        """is_even ಫಂಕ್ಷನ್ ಅನ್ನು ಟೆಸ್ಟ್ ಮಾಡುತ್ತದೆ."""
        self.assertTrue(is_even(2))
        self.assertFalse(is_even(3))
        self.assertTrue(is_even(0))

if __name__ == '__main__':
    unittest.main()

ವಿವರಣೆ: * ನಾವು unittest ಮತ್ತು ನಮ್ಮ my_math ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಇಂಪೋರ್ಟ್ ಮಾಡಿದ್ದೇವೆ. * TestMathFunctions ಎಂಬ ಕ್ಲಾಸ್ ಅನ್ನು unittest.TestCase ನಿಂದ ಇನ್ಹೆರಿಟ್ ಮಾಡಿದ್ದೇವೆ. * ಪ್ರತಿ ಟೆಸ್ಟ್ ಮೆಥಡ್‌ನ ಹೆಸರು test_ ನಿಂದ ಪ್ರಾರಂಭವಾಗಬೇಕು. * self.assertEqual(a, b): a ಮತ್ತು b ಸಮಾನವಾಗಿವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. * self.assertTrue(x): x ಸತ್ಯವೇ (True) ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. * self.assertFalse(x): x ಸುಳ್ಳೇ (False) ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.

ಹಂತ 3: ಟೆಸ್ಟ್‌ಗಳನ್ನು ಚಲಾಯಿಸುವುದು ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಈ ಕೆಳಗಿನ ಕಮಾಂಡ್ ಚಲಾಯಿಸಿ:

python -m unittest test_my_math.py

ಔಟ್‌ಪುಟ್:

..
----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

.. ಎಂದರೆ ಎರಡು ಟೆಸ್ಟ್‌ಗಳು ಯಶಸ್ವಿಯಾಗಿ ಪಾಸ್ ಆಗಿವೆ.

ಸಾಮಾನ್ಯ ಅಸರ್ಷನ್ ಮೆಥಡ್‌ಗಳು (Assertion Methods)

ಮೆಥಡ್	ಪರಿಶೀಲನೆ
assertEqual(a, b)	a == b
assertNotEqual(a, b)	a != b
assertTrue(x)	bool(x) is True
assertFalse(x)	bool(x) is False
assertIs(a, b)	a is b
assertIsNot(a, b)	a is not b
assertIsNone(x)	x is None
assertIsNotNone(x)	x is not None
assertIn(a, b)	a in b
assertNotIn(a, b)	a not in b
assertRaises(exc, func, ...)	func(...) ಚಲಾಯಿಸಿದಾಗ exc ಎಕ್ಸೆಪ್ಷನ್ ಬರುತ್ತದೆಯೇ?

assertRaises ಉದಾಹರಣೆ:

def test_divide_by_zero(self):
    with self.assertRaises(ValueError):
        divide(10, 0) # divide ಫಂಕ್ಷನ್ ValueError ಅನ್ನು ರೈಸ್ ಮಾಡುತ್ತದೆ ಎಂದು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.

ಸೆಟಪ್ ಮತ್ತು ಟಿಯರ್‌ಡೌನ್ (Setup and Teardown)

ಟೆಸ್ಟ್‌ಗಳನ್ನು ಚಲಾಯಿಸಲು ಕೆಲವು ಪೂರ್ವ-ಸಿದ್ಧತೆಗಳು (ಉದಾ: ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕ, ಫೈಲ್ ರಚನೆ) ಮತ್ತು ನಂತರ ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆ (cleanup) ಬೇಕಾಗಬಹುದು. ಇದಕ್ಕಾಗಿ unittest ಫಿಕ್ಸ್ಚರ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

• setUp(): ಪ್ರತಿ ಟೆಸ್ಟ್ ಮೆಥಡ್ ಚಲಾಯಿಸುವ ಮೊದಲು ಕರೆಯಲ್ಪಡುತ್ತದೆ.
• tearDown(): ಪ್ರತಿ ಟೆಸ್ಟ್ ಮೆಥಡ್ ಚಲಾಯಿಸಿದ ನಂತರ ಕರೆಯಲ್ಪಡುತ್ತದೆ.
• setUpClass(): ಕ್ಲಾಸ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಟೆಸ್ಟ್‌ಗಳು ಚಲಾಯಿಸುವ ಒಮ್ಮೆ ಮೊದಲು ಕರೆಯಲ್ಪಡುತ್ತದೆ. (@classmethod ಆಗಿರಬೇಕು).
• tearDownClass(): ಕ್ಲಾಸ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಟೆಸ್ಟ್‌ಗಳು ಚಲಾಯಿಸಿದ ಒಮ್ಮೆ ನಂತರ ಕರೆಯಲ್ಪಡುತ್ತದೆ. (@classmethod ಆಗಿರಬೇಕು).

ಉದಾಹರಣೆ:

import unittest

class MyDatabaseTests(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        print("ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ...")
        # cls.db_connection = connect_to_db()

    @classmethod
    def tearDownClass(cls):
        print("ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚಲಾಗುತ್ತಿದೆ...")
        # cls.db_connection.close()

    def setUp(self):
        print("\nಹೊಸ ಟೆಸ್ಟ್ ಪ್ರಾರಂಭ: ಟೇಬಲ್ ಅನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಲಾಗುತ್ತಿದೆ...")
        # self.db_connection.clear_table()

    def tearDown(self):
        print("ಟೆಸ್ಟ್ ಮುಗಿದಿದೆ.")

    def test_insert_data(self):
        print("ಡೇಟಾ ಇನ್ಸರ್ಟ್ ಮಾಡುವುದನ್ನು ಟೆಸ್ಟ್ ಮಾಡಲಾಗುತ್ತಿದೆ...")
        self.assertTrue(True) # Placeholder

    def test_query_data(self):
        print("ಡೇಟಾ ಕ್ವೆರಿ ಮಾಡುವುದನ್ನು ಟೆಸ್ಟ್ ಮಾಡಲಾಗುತ್ತಿದೆ...")
        self.assertTrue(True) # Placeholder

if __name__ == '__main__':
    unittest.main()

ಟೆಸ್ಟ್ ಡಿಸ್ಕವರಿ (Test Discovery)

ಹಲವು ಟೆಸ್ಟ್ ಫೈಲ್‌ಗಳಿರುವಾಗ, ಅವೆಲ್ಲವನ್ನೂ ಒಂದೊಂದಾಗಿ ಚಲಾಯಿಸುವುದು ಕಷ್ಟ. unittest ನ ಟೆಸ್ಟ್ ಡಿಸ್ಕವರಿ ಫೀಚರ್ ಬಳಸಿ, ಒಂದು ಡೈರೆಕ್ಟರಿಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಒಂದೇ ಬಾರಿಗೆ ಚಲಾಯಿಸಬಹುದು.

ಪ್ರಾಜೆಕ್ಟ್‌ನ ರೂಟ್ ಡೈರೆಕ್ಟರಿಯಿಂದ ಈ ಕಮಾಂಡ್ ಚಲಾಯಿಸಿ:

python -m unittest discover

ಇದು ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿ ಮತ್ತು ಅದರ ಸಬ್‌ಡೈರೆಕ್ಟರಿಗಳಲ್ಲಿ test*.py ಪ್ಯಾಟರ್ನ್‌ಗೆ ಮ್ಯಾಚ್ ಆಗುವ ಎಲ್ಲಾ ಫೈಲ್‌ಗಳನ್ನು ಹುಡುಕಿ, ಅವುಗಳಲ್ಲಿರುವ ಟೆಸ್ಟ್‌ಗಳನ್ನು ಚಲಾಯಿಸುತ್ತದೆ.