ಪೈಥಾನ್ ಯೂನಿಟ್ ಟೆಸ್ಟಿಂಗ್: ಸಂದರ್ಶನ ಪ್ರಶ್ನೆಗಳು

1. ಯೂನಿಟ್ ಟೆಸ್ಟಿಂಗ್ (Unit Testing) ಎಂದರೇನು?

ಉತ್ತರ: ಯೂನಿಟ್ ಟೆಸ್ಟಿಂಗ್ ಎನ್ನುವುದು ಸಾಫ್ಟ್‌ವೇರ್ ಡೆವಲಪ್‌ಮೆಂಟ್‌ನ ಒಂದು ಪ್ರಕ್ರಿಯೆ, ಇದರಲ್ಲಿ ಪ್ರೋಗ್ರಾಂನ ಸಣ್ಣ, ಪ್ರತ್ಯೇಕ ಭಾಗಗಳನ್ನು (" ಯೂನಿಟ್‌ಗಳು") ಪ್ರತ್ಯೇಕವಾಗಿ ಪರೀಕ್ಷಿಸಲಾಗುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ, ಒಂದು ಯೂನಿಟ್ ಎಂದರೆ ಒಂದು ಫಂಕ್ಷನ್, ಮೆಥಡ್, ಅಥವಾ ಕ್ಲಾಸ್.

ಉದ್ದೇಶ:

• ಪ್ರತಿ ಯೂನಿಟ್ ನಿರೀಕ್ಷೆಯಂತೆ ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು.
• ದೋಷಗಳನ್ನು (bugs) ಬೇಗನೆ ಪತ್ತೆಹಚ್ಚುವುದು.
• ಕೋಡ್‌ನ ಗುಣಮಟ್ಟವನ್ನು ಸುಧಾರಿಸುವುದು.
• ಭವಿಷ್ಯದಲ್ಲಿ ಕೋಡ್ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುವಾಗ (refactoring) ವಿಶ್ವಾಸವನ್ನು ನೀಡುವುದು.

2. ಪೈಥಾನ್‌ನಲ್ಲಿರುವ unittest ಫ್ರೇಮ್‌ವರ್ಕ್‌ನ ಪ್ರಮುಖ ಅಂಶಗಳು ಯಾವುವು?

ಉತ್ತರ: unittest ಪೈಥಾನ್‌ನ ಬಿಲ್ಟ್-ಇನ್ ಟೆಸ್ಟಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್. ಇದರ ಪ್ರಮುಖ ಅಂಶಗಳು:

1. ಟೆಸ್ಟ್ ಕೇಸ್ (Test Case):

   • unittest.TestCase ಕ್ಲಾಸ್‌ನಿಂದ ಇನ್ಹೆರಿಟ್ ಮಾಡುವ ಮೂಲಕ ಟೆಸ್ಟ್ ಕೇಸ್‌ಗಳನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ.
   • ಇದು ಟೆಸ್ಟ್‌ಗಳ ಒಂದು ಗುಂಪು.

2. ಟೆಸ್ಟ್ ಮೆಥಡ್ (Test Method):

   • TestCase ಕ್ಲಾಸ್‌ನೊಳಗಿನ ಮೆಥಡ್‌ಗಳು.
   • ಇವುಗಳ ಹೆಸರು test_ ನಿಂದ ಪ್ರಾರಂಭವಾಗಬೇಕು. ಪ್ರತಿಯೊಂದು ಮೆಥಡ್ ಒಂದು ನಿರ್ದಿಷ್ಟ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ.

3. ಅಸರ್ಶನ್ಸ್ (Assertions):

   • TestCase ಕ್ಲಾಸ್‌ನಲ್ಲಿರುವ assert ಮೆಥಡ್‌ಗಳನ್ನು ಬಳಸಿ, ಒಂದು ಷರತ್ತು True ಆಗಿದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತದೆ. ಷರತ್ತು False ಆದರೆ, ಟೆಸ್ಟ್ ಫೇಲ್ ಆಗುತ್ತದೆ.
   • ಉದಾಹರಣೆ: assertEqual(), assertTrue(), assertRaises().

4. ಟೆಸ್ಟ್ ಸ್ಯೂಟ್ (Test Suite):

   • ಹಲವಾರು ಟೆಸ್ಟ್ ಕೇಸ್‌ಗಳು ಅಥವಾ ಟೆಸ್ಟ್ ಸ್ಯೂಟ್‌ಗಳ ಒಂದು ಸಂಗ್ರಹ. ಇದನ್ನು ಒಟ್ಟಿಗೆ ರನ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ.

5. ಟೆಸ್ಟ್ ರನ್ನರ್ (Test Runner):

   • ಟೆಸ್ಟ್‌ಗಳನ್ನು ಎಕ್ಸಿಕ್ಯೂಟ್ ಮಾಡಿ, ಫಲಿತಾಂಶವನ್ನು ಬಳಕೆದಾರರಿಗೆ ನೀಡುವ ಒಂದು ಕಾಂಪೊನೆಂಟ್.

3. ಒಂದು ಸರಳ unittest ಟೆಸ್ಟ್ ಕೇಸ್ ಅನ್ನು ಬರೆಯಿರಿ.

ಉತ್ತರ: ಕೆಳಗೆ ಒಂದು ಸರಳ add ಫಂಕ್ಷನ್ ಮತ್ತು ಅದನ್ನು ಪರೀಕ್ಷಿಸಲು ಒಂದು ಟೆಸ್ಟ್ ಕೇಸ್ ಇದೆ.

my_math.py:

def add(a, b):
    """Returns the sum of two numbers."""
    return a + b

test_my_math.py:

import unittest
from my_math import add


class TestAddFunction(unittest.TestCase):

    def test_add_positive_numbers(self):
        """Test adding two positive numbers."""
        self.assertEqual(add(2, 3), 5)

    def test_add_negative_numbers(self):
        """Test adding two negative numbers."""
        self.assertEqual(add(-2, -3), -5)

    def test_add_mixed_numbers(self):
        """Test adding a positive and a negative number."""
        self.assertEqual(add(5, -3), 2)


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

ಈ ಟೆಸ್ಟ್ ಫೈಲ್ ಅನ್ನು ರನ್ ಮಾಡಲು: python -m unittest test_my_math.py

4. setUp ಮತ್ತು tearDown ಮೆಥಡ್‌ಗಳ ಉಪಯೋಗವೇನು?

ಉತ್ತರ:

• setUp():

  • ಪ್ರತಿ ಟೆಸ್ಟ್ ಮೆಥಡ್ ರನ್ ಆಗುವ ಮೊದಲು ಈ ಮೆಥಡ್ ಕಾಲ್ ಆಗುತ್ತದೆ.
  • ಟೆಸ್ಟ್‌ಗಳಿಗೆ ಬೇಕಾದ ಸಾಮಾನ್ಯ ಸೆಟಪ್ ಕೋಡ್ ಅನ್ನು (ಉದಾ: ಡೇಟಾಬೇಸ್ ಕನೆಕ್ಷನ್, ಆಬ್ಜೆಕ್ಟ್ ರಚನೆ) ಇಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ.

• tearDown():

  • ಪ್ರತಿ ಟೆಸ್ಟ್ ಮೆಥಡ್ ರನ್ ಆದ ನಂತರ ಈ ಮೆಥಡ್ ಕಾಲ್ ಆಗುತ್ತದೆ.
  • setUp ನಲ್ಲಿ ರಚಿಸಲಾದ ರಿಸೋರ್ಸ್‌ಗಳನ್ನು ಕ್ಲೀನ್ ಅಪ್ ಮಾಡಲು (ಉದಾ: ಫೈಲ್ ಡಿಲೀಟ್, ಕನೆಕ್ಷನ್ ಕ್ಲೋಸ್) ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

setUpClass ಮತ್ತು tearDownClass:

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

ಉದಾಹರಣೆ:

class MyTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        print("setUpClass called once")

    def setUp(self):
        print("setUp called before each test")

    def test_one(self):
        print("Running test_one")

    def test_two(self):
        print("Running test_two")

    def tearDown(self):
        print("tearDown called after each test")

    @classmethod
    def tearDownClass(cls):
        print("tearDownClass called once")

5. ಮಾಕಿಂಗ್ (Mocking) ಎಂದರೇನು? unittest.mock ಅನ್ನು ಏಕೆ ಬಳಸಲಾಗುತ್ತದೆ?

ಉತ್ತರ: ಮಾಕಿಂಗ್ ಎನ್ನುವುದು ಟೆಸ್ಟಿಂಗ್ ಸಮಯದಲ್ಲಿ ನಿಜವಾದ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಬದಲಿಗೆ ನಕಲಿ (mock) ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಬಳಸುವ ಒಂದು ತಂತ್ರ.

ಏಕೆ ಬಳಸಬೇಕು:

• ಬಾಹ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು (Isolate Dependencies): ನಿಮ್ಮ ಕೋಡ್ ಡೇಟಾಬೇಸ್, ವೆಬ್ ಸರ್ವಿಸ್, ಅಥವಾ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನಂತಹ ಬಾಹ್ಯ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಿದ್ದರೆ, ಟೆಸ್ಟಿಂಗ್ ಸಮಯದಲ್ಲಿ ಆ ಸಿಸ್ಟಮ್‌ಗಳು ಲಭ್ಯವಿಲ್ಲದಿರಬಹುದು ಅಥವಾ ನಿಧಾನವಾಗಿರಬಹುದು. ಮಾಕ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಈ ಬಾಹ್ಯ ಸಿಸ್ಟಮ್‌ಗಳಂತೆ ನಟಿಸುತ್ತವೆ.
• ಟೆಸ್ಟ್‌ಗಳನ್ನು ವೇಗಗೊಳಿಸಲು: ನಿಜವಾದ ನೆಟ್‌ವರ್ಕ್ ಅಥವಾ ಡೇಟಾಬೇಸ್ ಕಾಲ್‌ಗಳನ್ನು ಮಾಡುವುದಕ್ಕಿಂತ ಮಾಕ್‌ಗಳನ್ನು ಬಳಸುವುದು ಹೆಚ್ಚು ವೇಗ.
• ಎಡ್ಜ್ ಕೇಸ್‌ಗಳನ್ನು ಸಿಮ್ಯುಲೇಟ್ ಮಾಡಲು: ಎರರ್ ಕಂಡೀಶನ್‌ಗಳನ್ನು (ಉದಾ: ನೆಟ್‌ವರ್ಕ್ ಎರರ್) ಸುಲಭವಾಗಿ ಸಿಮ್ಯುಲೇಟ್ ಮಾಡಲು.

unittest.mock ಮಾಡ್ಯೂಲ್ Mock ಮತ್ತು patch ನಂತಹ ಪರಿಕರಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ಪೈಥಾನ್‌ನಲ್ಲಿ ಮಾಕಿಂಗ್ ಅನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.