ಪೈಥಾನ್ ಡ್ಯಾಂಗೋ ಪರೀಕ್ಷೆ: ಟೆಸ್ಟ್‌ಕೇಸ್ (TestCase) ವರ್ಸಸ್ ಟ್ರಾನ್ಸಾಕ್ಷನ್‌ಟೆಸ್ಟ್‌ಕೇಸ್ (TransactionTestCase)

ಪರೀಕ್ಷೆಯು ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ನಿರ್ಣಾಯಕ ಅಂಶವಾಗಿದೆ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ನಿರೀಕ್ಷಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಕಾಲಾನಂತರದಲ್ಲಿ ದೃಢವಾಗಿರುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಜನಪ್ರಿಯ ಪೈಥಾನ್ ವೆಬ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆದ ಡ್ಯಾಂಗೋ, ಪರಿಣಾಮಕಾರಿ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲು ಶಕ್ತಿಶಾಲಿ ಪರೀಕ್ಷಾ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಬ್ಲಾಗ್ ಪೋಸ್ಟ್ ಡ್ಯಾಂಗೋನ ಪರೀಕ್ಷಾ ಫ್ರೇಮ್‌ವರ್ಕ್‌ನಲ್ಲಿರುವ ಎರಡು ಮೂಲಭೂತ ವರ್ಗಗಳಾದ: TestCase ಮತ್ತು TransactionTestCase ಕುರಿತು ವಿವರಿಸುತ್ತದೆ. ಅವುಗಳ ವ್ಯತ್ಯಾಸಗಳು, ಬಳಕೆಯ ಸಂದರ್ಭಗಳು ಮತ್ತು ನಿಮ್ಮ ಪರೀಕ್ಷಾ ಅಗತ್ಯಗಳಿಗಾಗಿ ಸರಿಯಾದ ವರ್ಗವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುವ ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳನ್ನು ನಾವು ಇಲ್ಲಿ ನೀಡುತ್ತೇವೆ.

ಡ್ಯಾಂಗೋದಲ್ಲಿ ಪರೀಕ್ಷೆ ಏಕೆ ಮುಖ್ಯ?

TestCase ಮತ್ತು TransactionTestCase ನ ನಿರ್ದಿಷ್ಟತೆಗಳಿಗೆ ಹೋಗುವ ಮೊದಲು, ಡ್ಯಾಂಗೋ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಪರೀಕ್ಷೆ ಏಕೆ ಮುಖ್ಯ ಎಂಬುದನ್ನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಚರ್ಚಿಸೋಣ:

• ಕೋಡ್ ಗುಣಮಟ್ಟವನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ: ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಯ ಆರಂಭದಲ್ಲಿಯೇ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಪರೀಕ್ಷೆಗಳು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ, ಅವುಗಳು ಉತ್ಪಾದನೆಗೆ ಹೋಗುವುದನ್ನು ತಡೆಯುತ್ತವೆ.
• ರಿಫ್ಯಾಕ್ಟರಿಂಗ್ ಅನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ: ಸಮಗ್ರ ಪರೀಕ್ಷಾ ಸೂಟ್‌ನೊಂದಿಗೆ, ನೀವು ಯಾವುದೇ ರಿಗ್ರೆಷನ್‌ಗಳನ್ನು ಪರಿಚಯಿಸಿದರೆ ಪರೀಕ್ಷೆಗಳು ನಿಮ್ಮನ್ನು ಎಚ್ಚರಿಸುತ್ತವೆ ಎಂದು ತಿಳಿದು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ವಿಶ್ವಾಸದಿಂದ ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡಬಹುದು.
• ಸಹಯೋಗವನ್ನು ಸುಧಾರಿಸುತ್ತದೆ: ಉತ್ತಮವಾಗಿ ಬರೆದ ಪರೀಕ್ಷೆಗಳು ನಿಮ್ಮ ಕೋಡ್‌ಗೆ ದಾಖಲಾತಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಇತರ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಕೊಡುಗೆ ನೀಡಲು ಸುಲಭವಾಗುತ್ತದೆ.
• ಟೆಸ್ಟ್-ಡ್ರಿವನ್ ಡೆವಲಪ್‌ಮೆಂಟ್ (TDD) ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ: TDD ಒಂದು ಅಭಿವೃದ್ಧಿ ವಿಧಾನವಾಗಿದ್ದು, ನೀವು ನಿಜವಾದ ಕೋಡ್ ಬರೆಯುವ ಮೊದಲು ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುತ್ತೀರಿ. ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಅಪೇಕ್ಷಿತ ನಡವಳಿಕೆಯ ಬಗ್ಗೆ ಮುಂಚಿತವಾಗಿ ಯೋಚಿಸಲು ನಿಮ್ಮನ್ನು ಒತ್ತಾಯಿಸುತ್ತದೆ, ಇದು ಶುದ್ಧ ಮತ್ತು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಡ್ಯಾಂಗೋನ ಪರೀಕ್ಷಾ ಫ್ರೇಮ್‌ವರ್ಕ್: ಒಂದು ಸಂಕ್ಷಿಪ್ತ ಅವಲೋಕನ

ಡ್ಯಾಂಗೋನ ಪರೀಕ್ಷಾ ಫ್ರೇಮ್‌ವರ್ಕ್ ಪೈಥಾನ್‌ನ ಅಂತರ್ಗತ unittest ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಆಧರಿಸಿದೆ. ಇದು ಡ್ಯಾಂಗೋ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದನ್ನು ಸುಲಭಗೊಳಿಸುವ ಹಲವಾರು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಅವುಗಳೆಂದರೆ:

• ಪರೀಕ್ಷಾ ಶೋಧನೆ: ಡ್ಯಾಂಗೋ ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿನ ಪರೀಕ್ಷೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಂಡುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ರನ್ ಮಾಡುತ್ತದೆ.
• ಪರೀಕ್ಷಾ ರನ್ನರ್: ಡ್ಯಾಂಗೋ ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ವರದಿ ಮಾಡುವ ಪರೀಕ್ಷಾ ರನ್ನರ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.
• ಅಸ್ಸರ್ಷನ್ ವಿಧಾನಗಳು: ನಿಮ್ಮ ಕೋಡ್‌ನ ನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ನೀವು ಬಳಸಬಹುದಾದ ಅಸ್ಸರ್ಷನ್ ವಿಧಾನಗಳ ಗುಂಪನ್ನು ಡ್ಯಾಂಗೋ ಒದಗಿಸುತ್ತದೆ.
• ಕ್ಲೈಂಟ್: ಡ್ಯಾಂಗೋನ ಪರೀಕ್ಷಾ ಕ್ಲೈಂಟ್ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನೊಂದಿಗೆ ಬಳಕೆದಾರರ ಸಂವಾದಗಳನ್ನು ಅನುಕರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಫಾರ್ಮ್‌ಗಳನ್ನು ಸಲ್ಲಿಸುವುದು ಅಥವಾ API ವಿನಂತಿಗಳನ್ನು ಮಾಡುವುದು.
• TestCase ಮತ್ತು TransactionTestCase: ಇವು ಡ್ಯಾಂಗೋದಲ್ಲಿ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಲು ಎರಡು ಮೂಲಭೂತ ವರ್ಗಗಳಾಗಿವೆ, ಇವುಗಳನ್ನು ನಾವು ವಿವರವಾಗಿ ವಿಶ್ಲೇಷಿಸುತ್ತೇವೆ.

TestCase: ವೇಗದ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಯೂನಿಟ್ ಪರೀಕ್ಷೆ

TestCase ಡ್ಯಾಂಗೋದಲ್ಲಿ ಯೂನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಲು ಪ್ರಾಥಮಿಕ ವರ್ಗವಾಗಿದೆ. ಇದು ಪ್ರತಿ ಪರೀಕ್ಷಾ ಪ್ರಕರಣಕ್ಕೆ ಸ್ವಚ್ಛವಾದ ಡೇಟಾಬೇಸ್ ಪರಿಸರವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಪರೀಕ್ಷೆಗಳು ಪ್ರತ್ಯೇಕವಾಗಿರುತ್ತವೆ ಮತ್ತು ಪರಸ್ಪರ ಹಸ್ತಕ್ಷೇಪ ಮಾಡುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

TestCase ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

ನೀವು TestCase ಅನ್ನು ಬಳಸಿದಾಗ, ಪ್ರತಿ ಪರೀಕ್ಷಾ ವಿಧಾನಕ್ಕಾಗಿ ಡ್ಯಾಂಗೋ ಈ ಕೆಳಗಿನ ಹಂತಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ:

1. ಪರೀಕ್ಷಾ ಡೇಟಾಬೇಸ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ: ಡ್ಯಾಂಗೋ ಪ್ರತಿ ಪರೀಕ್ಷಾ ರನ್‌ಗೆ ಪ್ರತ್ಯೇಕ ಪರೀಕ್ಷಾ ಡೇಟಾಬೇಸ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
2. ಡೇಟಾಬೇಸ್ ಅನ್ನು ಫ್ಲಶ್ ಮಾಡುತ್ತದೆ: ಪ್ರತಿ ಪರೀಕ್ಷಾ ವಿಧಾನದ ಮೊದಲು, ಡ್ಯಾಂಗೋ ಪರೀಕ್ಷಾ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಫ್ಲಶ್ ಮಾಡುತ್ತದೆ, ಎಲ್ಲಾ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಡೇಟಾವನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.
3. ಪರೀಕ್ಷಾ ವಿಧಾನವನ್ನು ರನ್ ಮಾಡುತ್ತದೆ: ಡ್ಯಾಂಗೋ ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಿದ ಪರೀಕ್ಷಾ ವಿಧಾನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.
4. ವಹಿವಾಟನ್ನು ರೋಲ್‌ಬ್ಯಾಕ್ ಮಾಡುತ್ತದೆ: ಪ್ರತಿ ಪರೀಕ್ಷಾ ವಿಧಾನದ ನಂತರ, ಡ್ಯಾಂಗೋ ವಹಿವಾಟನ್ನು ರೋಲ್‌ಬ್ಯಾಕ್ ಮಾಡುತ್ತದೆ, ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ಡೇಟಾಬೇಸ್‌ಗೆ ಮಾಡಿದ ಯಾವುದೇ ಬದಲಾವಣೆಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ರದ್ದುಗೊಳಿಸುತ್ತದೆ.

ಈ ವಿಧಾನವು ಪ್ರತಿ ಪರೀಕ್ಷಾ ವಿಧಾನವು ಶುದ್ಧ ಸ್ಥಿತಿಯಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಡೇಟಾಬೇಸ್‌ಗೆ ಮಾಡಿದ ಯಾವುದೇ ಬದಲಾವಣೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಇದು TestCase ಅನ್ನು ಯೂನಿಟ್ ಪರೀಕ್ಷೆಗಾಗಿ ಸೂಕ್ತವಾಗಿಸುತ್ತದೆ, ಅಲ್ಲಿ ನೀವು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ವೈಯಕ್ತಿಕ ಘಟಕಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಪರೀಕ್ಷಿಸಲು ಬಯಸುತ್ತೀರಿ.

ಉದಾಹರಣೆ: ಸರಳ ಮಾಡೆಲ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವುದು

TestCase ಬಳಸಿ ಡ್ಯಾಂಗೋ ಮಾಡೆಲ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವ ಸರಳ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ:

from django.test import TestCase
from .models import Product

class ProductModelTest(TestCase):
 def test_product_creation(self):
 product = Product.objects.create(name="ಪರೀಕ್ಷಾ ಉತ್ಪನ್ನ", price=10.00)
 self.assertEqual(product.name, "ಪರೀಕ್ಷಾ ಉತ್ಪನ್ನ")
 self.assertEqual(product.price, 10.00)
 self.assertTrue(isinstance(product, Product))

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು Product ಮಾಡೆಲ್ ನಿದರ್ಶನದ ರಚನೆಯನ್ನು ಪರೀಕ್ಷಿಸುತ್ತಿದ್ದೇವೆ. test_product_creation ವಿಧಾನವು ಹೊಸ ಉತ್ಪನ್ನವನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಉತ್ಪನ್ನದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಸರಿಯಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಅಸ್ಸರ್ಷನ್ ವಿಧಾನಗಳನ್ನು ಬಳಸುತ್ತದೆ.

TestCase ಅನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು

ಹೆಚ್ಚಿನ ಡ್ಯಾಂಗೋ ಪರೀಕ್ಷಾ ಸನ್ನಿವೇಶಗಳಿಗೆ TestCase ಸಾಮಾನ್ಯವಾಗಿ ಆದ್ಯತೆಯ ಆಯ್ಕೆಯಾಗಿದೆ. ಇದು ವೇಗವಾಗಿದೆ, ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ ಮತ್ತು ಪ್ರತಿ ಪರೀಕ್ಷೆಗೆ ಶುದ್ಧವಾದ ಡೇಟಾಬೇಸ್ ಪರಿಸರವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಕೆಳಗಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ TestCase ಬಳಸಿ:

• ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ವೈಯಕ್ತಿಕ ಮಾಡೆಲ್‌ಗಳು, ವೀಕ್ಷಣೆಗಳು ಅಥವಾ ಇತರ ಘಟಕಗಳನ್ನು ನೀವು ಪರೀಕ್ಷಿಸುತ್ತಿರುವಾಗ.
• ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳು ಪ್ರತ್ಯೇಕವಾಗಿವೆ ಮತ್ತು ಪರಸ್ಪರ ಹಸ್ತಕ್ಷೇಪ ಮಾಡುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನೀವು ಬಯಸಿದಾಗ.
• ಬಹು ವಹಿವಾಟುಗಳನ್ನು ಒಳಗೊಂಡ ಸಂಕೀರ್ಣ ಡೇಟಾಬೇಸ್ ಸಂವಾದಗಳನ್ನು ನೀವು ಪರೀಕ್ಷಿಸಬೇಕಾಗಿಲ್ಲದಿದ್ದಾಗ.

TransactionTestCase: ಸಂಕೀರ್ಣ ಡೇಟಾಬೇಸ್ ಸಂವಾದಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದು

TransactionTestCase ಡ್ಯಾಂಗೋದಲ್ಲಿ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಲು ಇನ್ನೊಂದು ವರ್ಗವಾಗಿದೆ, ಆದರೆ ಇದು ಡೇಟಾಬೇಸ್ ವಹಿವಾಟುಗಳನ್ನು ನಿರ್ವಹಿಸುವ ವಿಧಾನದಲ್ಲಿ TestCase ನಿಂದ ಭಿನ್ನವಾಗಿದೆ. ಪ್ರತಿ ಪರೀಕ್ಷಾ ವಿಧಾನದ ನಂತರ ವಹಿವಾಟನ್ನು ರೋಲ್‌ಬ್ಯಾಕ್ ಮಾಡುವ ಬದಲು, TransactionTestCase ವಹಿವಾಟನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ (commits). ಇದು ಸಿಗ್ನಲ್‌ಗಳು ಅಥವಾ ಅಣು ವಹಿವಾಟುಗಳನ್ನು (atomic transactions) ಒಳಗೊಂಡಂತೆ ಬಹು ವಹಿವಾಟುಗಳನ್ನು ವ್ಯಾಪಿಸುವ ಸಂಕೀರ್ಣ ಡೇಟಾಬೇಸ್ ಸಂವಾದಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಸೂಕ್ತವಾಗಿದೆ.

TransactionTestCase ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

ನೀವು TransactionTestCase ಅನ್ನು ಬಳಸಿದಾಗ, ಪ್ರತಿ ಪರೀಕ್ಷಾ ಪ್ರಕರಣಕ್ಕಾಗಿ ಡ್ಯಾಂಗೋ ಈ ಕೆಳಗಿನ ಹಂತಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ:

1. ಪರೀಕ್ಷಾ ಡೇಟಾಬೇಸ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ: ಡ್ಯಾಂಗೋ ಪ್ರತಿ ಪರೀಕ್ಷಾ ರನ್‌ಗೆ ಪ್ರತ್ಯೇಕ ಪರೀಕ್ಷಾ ಡೇಟಾಬೇಸ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.
2. ಡೇಟಾಬೇಸ್ ಅನ್ನು ಫ್ಲಶ್ ಮಾಡುವುದಿಲ್ಲ: TransactionTestCase *does not* automatically flush the database before each test. It expects the database to be in a consistent state before each test is run.
3. ಪರೀಕ್ಷಾ ವಿಧಾನವನ್ನು ರನ್ ಮಾಡುತ್ತದೆ: ಡ್ಯಾಂಗೋ ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಿದ ಪರೀಕ್ಷಾ ವಿಧಾನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.
4. ವಹಿವಾಟನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ (Commits): ಪ್ರತಿ ಪರೀಕ್ಷಾ ವಿಧಾನದ ನಂತರ, ಡ್ಯಾಂಗೋ ವಹಿವಾಟನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ, ಪರೀಕ್ಷಾ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಬದಲಾವಣೆಗಳನ್ನು ಶಾಶ್ವತವಾಗಿಸುತ್ತದೆ.
5. ಕೋಷ್ಟಕಗಳನ್ನು ಟ್ರಂಕೇಟ್ ಮಾಡುತ್ತದೆ: TransactionTestCase ನಲ್ಲಿನ ಎಲ್ಲಾ ಪರೀಕ್ಷೆಗಳ *ಕೊನೆಯಲ್ಲಿ*, ಡೇಟಾವನ್ನು ತೆರವುಗೊಳಿಸಲು ಕೋಷ್ಟಕಗಳನ್ನು ಟ್ರಂಕೇಟ್ ಮಾಡಲಾಗುತ್ತದೆ.

TransactionTestCase ಪ್ರತಿ ಪರೀಕ್ಷಾ ವಿಧಾನದ ನಂತರ ವಹಿವಾಟನ್ನು ನಿರ್ಬಂಧಿಸುವುದರಿಂದ, ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳು ಡೇಟಾಬೇಸ್ ಅನ್ನು ಅಸಮಂಜಸ ಸ್ಥಿತಿಯಲ್ಲಿ ಬಿಡದಂತೆ ನೋಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ. ನಂತರದ ಪರೀಕ್ಷೆಗಳಿಗೆ ಅಡ್ಡಿಪಡಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ರಚಿಸಲಾದ ಯಾವುದೇ ಡೇಟಾವನ್ನು ನೀವು ಹಸ್ತಚಾಲಿತವಾಗಿ ಸ್ವಚ್ಛಗೊಳಿಸಬೇಕಾಗಬಹುದು.

ಉದಾಹರಣೆ: ಸಿಗ್ನಲ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದು

TransactionTestCase ಬಳಸಿ ಡ್ಯಾಂಗೋ ಸಿಗ್ನಲ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸುವ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ:

from django.test import TransactionTestCase
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Product, ProductLog

@receiver(post_save, sender=Product)
def create_product_log(sender, instance, created, **kwargs):
 if created:
 ProductLog.objects.create(product=instance, action="ರಚಿಸಲಾಗಿದೆ")

class ProductSignalTest(TransactionTestCase):
def test_product_creation_signal(self):
 product = Product.objects.create(name="ಪರೀಕ್ಷಾ ಉತ್ಪನ್ನ", price=10.00)
 self.assertEqual(ProductLog.objects.count(), 1)
 self.assertEqual(ProductLog.objects.first().product, product)
 self.assertEqual(ProductLog.objects.first().action, "ರಚಿಸಲಾಗಿದೆ")

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಹೊಸ Product ನಿದರ್ಶನವನ್ನು ರಚಿಸಿದಾಗಲೆಲ್ಲಾ ProductLog ನಿದರ್ಶನವನ್ನು ರಚಿಸುವ ಸಿಗ್ನಲ್ ಅನ್ನು ನಾವು ಪರೀಕ್ಷಿಸುತ್ತಿದ್ದೇವೆ. test_product_creation_signal ವಿಧಾನವು ಹೊಸ ಉತ್ಪನ್ನವನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಅನುಗುಣವಾದ ಉತ್ಪನ್ನ ಲಾಗ್ ನಮೂದು ರಚಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.

TransactionTestCase ಅನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು

TransactionTestCase ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ನಿರ್ದಿಷ್ಟ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ, ಅಲ್ಲಿ ನೀವು ಬಹು ವಹಿವಾಟುಗಳನ್ನು ವ್ಯಾಪಿಸುವ ಸಂಕೀರ್ಣ ಡೇಟಾಬೇಸ್ ಸಂವಾದಗಳನ್ನು ಪರೀಕ್ಷಿಸಬೇಕಾಗುತ್ತದೆ. ಈ ಕೆಳಗಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ TransactionTestCase ಅನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ:

• ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಂದ ಪ್ರಚೋದಿಸಲ್ಪಡುವ ಸಿಗ್ನಲ್‌ಗಳನ್ನು ನೀವು ಪರೀಕ್ಷಿಸುತ್ತಿರುವಾಗ.
• ಬಹು ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಅಣು ವಹಿವಾಟುಗಳನ್ನು ನೀವು ಪರೀಕ್ಷಿಸುತ್ತಿರುವಾಗ.
• ಸಂಬಂಧಿತ ಕಾರ್ಯಾಚರಣೆಗಳ ಸರಣಿಯ ನಂತರ ಡೇಟಾಬೇಸ್‌ನ ಸ್ಥಿತಿಯನ್ನು ನೀವು ಪರಿಶೀಲಿಸಬೇಕಾದಾಗ.
• ಪರೀಕ್ಷೆಗಳ ನಡುವೆ ಉಳಿಯಲು ಸ್ವಯಂ-ಇನ್‌ಕ್ರಿಮೆಂಟ್ ಐಡಿಯನ್ನು ಅವಲಂಬಿಸಿರುವ ಕೋಡ್ ಅನ್ನು ನೀವು ಬಳಸುತ್ತಿರುವಾಗ (ಆದರೂ ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಕೆಟ್ಟ ಅಭ್ಯಾಸವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ).

TransactionTestCase ಬಳಸುವಾಗ ಪ್ರಮುಖ ಪರಿಗಣನೆಗಳು

TransactionTestCase ವಹಿವಾಟುಗಳನ್ನು ನಿರ್ಬಂಧಿಸುವುದರಿಂದ, ಈ ಕೆಳಗಿನ ಪರಿಗಣನೆಗಳ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದು ಮುಖ್ಯವಾಗಿದೆ:

• ಡೇಟಾಬೇಸ್ ಸ್ವಚ್ಛತೆ: ನಂತರದ ಪರೀಕ್ಷೆಗಳಿಗೆ ಅಡ್ಡಿಪಡಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ರಚಿಸಲಾದ ಯಾವುದೇ ಡೇಟಾವನ್ನು ನೀವು ಹಸ್ತಚಾಲಿತವಾಗಿ ಸ್ವಚ್ಛಗೊಳಿಸಬೇಕಾಗಬಹುದು. ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು setUp ಮತ್ತು tearDown ವಿಧಾನಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
• ಪರೀಕ್ಷಾ ಪ್ರತ್ಯೇಕತೆ: TransactionTestCase, TestCase ನಂತೆ ಅದೇ ಮಟ್ಟದ ಪರೀಕ್ಷಾ ಪ್ರತ್ಯೇಕತೆಯನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ. ಪರೀಕ್ಷೆಗಳ ನಡುವಿನ ಸಂಭಾವ್ಯ ಸಂವಹನಗಳ ಬಗ್ಗೆ ಗಮನವಿರಲಿ ಮತ್ತು ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳು ಹಿಂದಿನ ಪರೀಕ್ಷೆಗಳಿಂದ ಡೇಟಾಬೇಸ್‌ನ ಸ್ಥಿತಿಯನ್ನು ಅವಲಂಬಿಸಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಕಾರ್ಯಕ್ಷಮತೆ: TransactionTestCase, TestCase ಗಿಂತ ನಿಧಾನವಾಗಿರಬಹುದು ಏಕೆಂದರೆ ಇದು ವಹಿವಾಟುಗಳನ್ನು ನಿರ್ಬಂಧಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಅದನ್ನು ವಿವೇಚನೆಯಿಂದ ಮತ್ತು ಅಗತ್ಯವಿದ್ದಾಗ ಮಾತ್ರ ಬಳಸಿ.

ಡ್ಯಾಂಗೋ ಪರೀಕ್ಷೆಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಡ್ಯಾಂಗೋದಲ್ಲಿ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯುವಾಗ ಗಮನದಲ್ಲಿಟ್ಟುಕೊಳ್ಳಬೇಕಾದ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಇಲ್ಲಿವೆ:

• ಸ್ಪಷ್ಟ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ: ಪರೀಕ್ಷೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿರಬೇಕು. ಪರೀಕ್ಷಾ ವಿಧಾನಗಳು ಮತ್ತು ಅಸ್ಸರ್ಷನ್‌ಗಳಿಗೆ ವಿವರಣಾತ್ಮಕ ಹೆಸರುಗಳನ್ನು ಬಳಸಿ.
• ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ವಿಷಯವನ್ನು ಪರೀಕ್ಷಿಸಿ: ಪ್ರತಿ ಪರೀಕ್ಷಾ ವಿಧಾನವು ನಿಮ್ಮ ಕೋಡ್‌ನ ಒಂದು ಅಂಶವನ್ನು ಪರೀಕ್ಷಿಸುವತ್ತ ಗಮನ ಹರಿಸಬೇಕು. ಪರೀಕ್ಷೆಯು ವಿಫಲವಾದಾಗ ದೋಷದ ಮೂಲವನ್ನು ಗುರುತಿಸಲು ಇದು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.
• ಅರ್ಥಪೂರ್ಣ ಅಸ್ಸರ್ಷನ್‌ಗಳನ್ನು ಬಳಸಿ: ನಿಮ್ಮ ಕೋಡ್‌ನ ನಿರೀಕ್ಷಿತ ನಡವಳಿಕೆಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ವ್ಯಕ್ತಪಡಿಸುವ ಅಸ್ಸರ್ಷನ್ ವಿಧಾನಗಳನ್ನು ಬಳಸಿ. ಡ್ಯಾಂಗೋ ವಿವಿಧ ಸನ್ನಿವೇಶಗಳಿಗಾಗಿ ಅಸ್ಸರ್ಷನ್ ವಿಧಾನಗಳ ಸಮೃದ್ಧ ಗುಂಪನ್ನು ಒದಗಿಸುತ್ತದೆ.
• ಅರೇಂಜ್-ಆಕ್ಟ್-ಅಸ್ಸರ್ಟ್ ಮಾದರಿಯನ್ನು ಅನುಸರಿಸಿ: ಅರೇಂಜ್-ಆಕ್ಟ್-ಅಸ್ಸರ್ಟ್ ಮಾದರಿಯ ಪ್ರಕಾರ ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳನ್ನು ರಚಿಸಿ: ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಅರೇಂಜ್ ಮಾಡಿ, ಪರೀಕ್ಷೆಗೆ ಒಳಪಡುವ ಕೋಡ್‌ನಲ್ಲಿ ಆಕ್ಟ್ ಮಾಡಿ ಮತ್ತು ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶವನ್ನು ಅಸ್ಸರ್ಟ್ ಮಾಡಿ.
• ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳನ್ನು ವೇಗವಾಗಿ ಇರಿಸಿ: ನಿಧಾನವಾದ ಪರೀಕ್ಷೆಗಳು ಡೆವಲಪರ್‌ಗಳನ್ನು ಅವುಗಳನ್ನು ಆಗಾಗ್ಗೆ ಚಲಾಯಿಸದಂತೆ ನಿರುತ್ಸಾಹಗೊಳಿಸಬಹುದು. ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳನ್ನು ಉತ್ತಮಗೊಳಿಸಿ.
• ಪರೀಕ್ಷಾ ಡೇಟಾಕ್ಕಾಗಿ ಫಿಕ್ಚರ್‌ಗಳನ್ನು ಬಳಸಿ: ನಿಮ್ಮ ಪರೀಕ್ಷಾ ಡೇಟಾಬೇಸ್‌ಗೆ ಆರಂಭಿಕ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲು ಫಿಕ್ಚರ್‌ಗಳು ಅನುಕೂಲಕರ ಮಾರ್ಗವಾಗಿದೆ. ಸ್ಥಿರ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ರಚಿಸಲು ಫಿಕ್ಚರ್‌ಗಳನ್ನು ಬಳಸಿ. ಐಡಿಗಳನ್ನು ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸಲು ಫಿಕ್ಚರ್‌ಗಳಲ್ಲಿ ನೈಸರ್ಗಿಕ ಕೀಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
• pytest ನಂತಹ ಪರೀಕ್ಷಾ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ: ಡ್ಯಾಂಗೋನ ಅಂತರ್ಗತ ಪರೀಕ್ಷಾ ಫ್ರೇಮ್‌ವರ್ಕ್ ಶಕ್ತಿಶಾಲಿಯಾಗಿದ್ದರೂ, pytest ನಂತಹ ಲೈಬ್ರರಿಗಳು ಹೆಚ್ಚುವರಿ ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ನಮ್ಯತೆಯನ್ನು ನೀಡಬಹುದು.
• ಹೆಚ್ಚಿನ ಪರೀಕ್ಷಾ ವ್ಯಾಪ್ತಿಗಾಗಿ ಶ್ರಮಿಸಿ: ನಿಮ್ಮ ಕೋಡ್ ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಲ್ಪಟ್ಟಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಹೆಚ್ಚಿನ ಪರೀಕ್ಷಾ ವ್ಯಾಪ್ತಿಗಾಗಿ ಶ್ರಮಿಸಿ. ನಿಮ್ಮ ಪರೀಕ್ಷಾ ವ್ಯಾಪ್ತಿಯನ್ನು ಅಳೆಯಲು ಮತ್ತು ಹೆಚ್ಚು ಪರೀಕ್ಷೆಯ ಅಗತ್ಯವಿರುವ ಪ್ರದೇಶಗಳನ್ನು ಗುರುತಿಸಲು ಕವರೇಜ್ ಪರಿಕರಗಳನ್ನು ಬಳಸಿ.
• ನಿಮ್ಮ CI/CD ಪೈಪ್‌ಲೈನ್‌ಗೆ ಪರೀಕ್ಷೆಗಳನ್ನು ಸಂಯೋಜಿಸಿ: ನಿಮ್ಮ ನಿರಂತರ ಏಕೀಕರಣ ಮತ್ತು ನಿರಂತರ ನಿಯೋಜನೆ (CI/CD) ಪೈಪ್‌ಲೈನ್‌ನ ಭಾಗವಾಗಿ ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರನ್ ಮಾಡಿ. ಇದು ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಯ ಆರಂಭದಲ್ಲಿಯೇ ಯಾವುದೇ ರಿಗ್ರೆಷನ್‌ಗಳನ್ನು ಹಿಡಿಯುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ವಾಸ್ತವ-ಪ್ರಪಂಚದ ಸನ್ನಿವೇಶಗಳನ್ನು ಪ್ರತಿಬಿಂಬಿಸುವ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಿರಿ: ಬಳಕೆದಾರರು ಅದರೊಂದಿಗೆ ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತಾರೆ ಎಂಬುದನ್ನು ಅನುಕರಿಸುವ ರೀತಿಯಲ್ಲಿ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಿ. ಇದು ಸರಳ ಯೂನಿಟ್ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಸ್ಪಷ್ಟವಾಗಿ ಗೋಚರಿಸದ ದೋಷಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಫಾರ್ಮ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸುವಾಗ ಅಂತರರಾಷ್ಟ್ರೀಯ ವಿಳಾಸಗಳು ಮತ್ತು ಫೋನ್ ಸಂಖ್ಯೆಗಳಲ್ಲಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸಿ.

ಅಂತರಾಷ್ಟ್ರೀಯೀಕರಣ (i18n) ಮತ್ತು ಪರೀಕ್ಷೆ

ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಡ್ಯಾಂಗೋ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ, ಅಂತರಾಷ್ಟ್ರೀಯೀಕರಣ (i18n) ಮತ್ತು ಸ್ಥಳೀಕರಣ (l10n) ವನ್ನು ಪರಿಗಣಿಸುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳು ವಿವಿಧ ಭಾಷೆಗಳು, ದಿನಾಂಕ ಸ್ವರೂಪಗಳು ಮತ್ತು ಕರೆನ್ಸಿ ಚಿಹ್ನೆಗಳನ್ನು ಒಳಗೊಂಡಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಕೆಲವು ಸಲಹೆಗಳು ಇಲ್ಲಿವೆ:

• ವಿವಿಧ ಭಾಷಾ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ ಪರೀಕ್ಷಿಸಿ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ವಿವಿಧ ಭಾಷಾ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ ಪರೀಕ್ಷಿಸಲು ಡ್ಯಾಂಗೋನ override_settings ಡೆಕೋರೇಟರ್ ಅನ್ನು ಬಳಸಿ.
• ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಸ್ಥಳೀಕೃತ ಡೇಟಾವನ್ನು ಬಳಸಿ: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ವಿವಿಧ ದಿನಾಂಕ ಸ್ವರೂಪಗಳು, ಕರೆನ್ಸಿ ಚಿಹ್ನೆಗಳು ಮತ್ತು ಇತರ ಸ್ಥಳೀಯ-ನಿರ್ದಿಷ್ಟ ಡೇಟಾವನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ ಪರೀಕ್ಷಾ ಫಿಕ್ಚರ್‌ಗಳು ಮತ್ತು ಪರೀಕ್ಷಾ ವಿಧಾನಗಳಲ್ಲಿ ಸ್ಥಳೀಕೃತ ಡೇಟಾವನ್ನು ಬಳಸಿ.
• ನಿಮ್ಮ ಅನುವಾದ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಿ: ನಿಮ್ಮ ಅನುವಾದ ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಸರಿಯಾಗಿ ಅನುವಾದಿಸಲ್ಪಟ್ಟಿವೆ ಮತ್ತು ಅವು ವಿವಿಧ ಭಾಷೆಗಳಲ್ಲಿ ಸರಿಯಾಗಿ ರೆಂಡರ್ ಆಗುತ್ತವೆ ಎಂದು ಪರಿಶೀಲಿಸಿ.
• localize ಟೆಂಪ್ಲೇಟ್ ಟ್ಯಾಗ್ ಬಳಸಿ: ನಿಮ್ಮ ಟೆಂಪ್ಲೇಟ್‌ಗಳಲ್ಲಿ, ಬಳಕೆದಾರರ ಪ್ರಸ್ತುತ ಸ್ಥಳೀಯತೆಗೆ ಅನುಗುಣವಾಗಿ ದಿನಾಂಕಗಳು, ಸಂಖ್ಯೆಗಳು ಮತ್ತು ಇತರ ಸ್ಥಳೀಯ-ನಿರ್ದಿಷ್ಟ ಡೇಟಾವನ್ನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಲು localize ಟೆಂಪ್ಲೇಟ್ ಟ್ಯಾಗ್ ಅನ್ನು ಬಳಸಿ.

ಉದಾಹರಣೆ: ವಿಭಿನ್ನ ಭಾಷಾ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ ಪರೀಕ್ಷಿಸುವುದು

from django.test import TestCase
from django.utils import translation
from django.conf import settings

class InternationalizationTest(TestCase):

 def test_localized_date_format(self):
 original_language = translation.get_language()
 try:
 translation.activate('de') # ಜರ್ಮನ್ ಭಾಷೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ
 with self.settings(LANGUAGE_CODE='de'): # ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ಭಾಷೆಯನ್ನು ಹೊಂದಿಸಿ
 from django.utils import formats
 from datetime import date
 d = date(2024, 1, 20)
 formatted_date = formats.date_format(d, 'SHORT_DATE_FORMAT')
 self.assertEqual(formatted_date, '20.01.2024')
 finally:
 translation.activate(original_language) # ಮೂಲ ಭಾಷೆಯನ್ನು ಮರುಸ್ಥಾಪಿಸಿ

ಈ ಉದಾಹರಣೆಯು ಡ್ಯಾಂಗೋನ translation ಮತ್ತು formats ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಬಳಸಿ ವಿಭಿನ್ನ ಭಾಷಾ ಸೆಟ್ಟಿಂಗ್‌ಗಳೊಂದಿಗೆ ದಿನಾಂಕ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಅನ್ನು ಹೇಗೆ ಪರೀಕ್ಷಿಸುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.

ತೀರ್ಮಾನ

TestCase ಮತ್ತು TransactionTestCase ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಡ್ಯಾಂಗೋದಲ್ಲಿ ಪರಿಣಾಮಕಾರಿ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಲು ಅತ್ಯಗತ್ಯ. ಹೆಚ್ಚಿನ ಪರೀಕ್ಷಾ ಸನ್ನಿವೇಶಗಳಿಗೆ TestCase ಸಾಮಾನ್ಯವಾಗಿ ಆದ್ಯತೆಯ ಆಯ್ಕೆಯಾಗಿದೆ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ವೈಯಕ್ತಿಕ ಘಟಕಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಪರೀಕ್ಷಿಸಲು ವೇಗವಾದ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. TransactionTestCase ಬಹು ವಹಿವಾಟುಗಳನ್ನು ವ್ಯಾಪಿಸುವ ಸಂಕೀರ್ಣ ಡೇಟಾಬೇಸ್ ಸಂವಾದಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ಉಪಯುಕ್ತವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ ಸಿಗ್ನಲ್‌ಗಳು ಅಥವಾ ಅಣು ವಹಿವಾಟುಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ. ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ ಮತ್ತು ಅಂತರಾಷ್ಟ್ರೀಯೀಕರಣದ ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಡ್ಯಾಂಗೋ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಗುಣಮಟ್ಟ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಖಚಿತಪಡಿಸುವ ದೃಢವಾದ ಪರೀಕ್ಷಾ ಸೂಟ್ ಅನ್ನು ನೀವು ರಚಿಸಬಹುದು.

ಹೆಚ್ಚಿನ ಕಲಿಕೆ

• ಡ್ಯಾಂಗೋ ಪರೀಕ್ಷಾ ದಾಖಲಾತಿ
• ಪೈಥಾನ್ ಯೂನಿಟ್‌ಟೆಸ್ಟ್ ದಾಖಲಾತಿ
• pytest ದಾಖಲಾತಿ