பைத்தான் ஜாங்கோ சோதனை: டெஸ்ட்கேஸ் vs. டிரான்ஸாக்சன்டெஸ்ட்கேஸ்

மென்பொருள் வளர்ச்சியில் சோதனை என்பது ஒரு முக்கியமான அம்சமாகும், இது உங்கள் பயன்பாடு எதிர்பார்த்தபடி செயல்படுவதையும் காலப்போக்கில் வலுவாக இருப்பதையும் உறுதி செய்கிறது. பைத்தான் வலை கட்டமைப்பான ஜாங்கோ, பயனுள்ள சோதனைகளை எழுத உங்களுக்கு உதவும் ஒரு சக்திவாய்ந்த சோதனை கட்டமைப்பை வழங்குகிறது. இந்த வலைப்பதிவு இடுகை ஜாங்கோவின் சோதனை கட்டமைப்பிற்குள் இரண்டு அடிப்படை வகுப்புகளை ஆராயும்: டெஸ்ட்கேஸ் மற்றும் டிரான்ஸாக்சன்டெஸ்ட்கேஸ். அவற்றின் வேறுபாடுகள், பயன்பாட்டு வழக்குகள் ஆகியவற்றை ஆராய்வோம், மேலும் உங்கள் சோதனைத் தேவைகளுக்கு சரியான வகுப்பைத் தேர்ந்தெடுக்க உதவும் நடைமுறை எடுத்துக்காட்டுகளை வழங்குவோம்.

ஏன் ஜாங்கோவில் சோதனை முக்கியம்

டெஸ்ட்கேஸ் மற்றும் டிரான்ஸாக்சன்டெஸ்ட்கேஸ் ஆகியவற்றின் விவரங்களுக்குள் செல்வதற்கு முன், ஜாங்கோ வளர்ச்சியில் சோதனை ஏன் மிகவும் முக்கியமானது என்பதைப் பற்றி சுருக்கமாக விவாதிப்போம்:

• குறியீடு தரத்தை உறுதி செய்கிறது: சோதனைகள் வளர்ச்சியின் ஆரம்ப கட்டத்திலேயே பிழைகளை கண்டறிய உதவுகின்றன, அவை உற்பத்தியில் நுழைவதைத் தடுக்கின்றன.
• மறுசீரமைப்பை எளிதாக்குகிறது: ஒரு விரிவான சோதனை தொகுப்புடன், உங்கள் குறியீட்டை நம்பிக்கையுடன் மறுசீரமைக்க முடியும், சோதனைகள் ஏதேனும் பின்னடைவுகளை அறிமுகப்படுத்தினால் உங்களுக்கு எச்சரிக்கை செய்யும் என்பதை அறிந்து.
• கூட்டு முயற்சியை மேம்படுத்துகிறது: நன்கு எழுதப்பட்ட சோதனைகள் உங்கள் குறியீட்டிற்கான ஆவணங்களாக செயல்படுகின்றன, மற்ற டெவலப்பர்கள் புரிந்து கொள்ளவும் பங்களிக்கவும் உதவுகின்றன.
• சோதனை சார்ந்த வளர்ச்சியை (TDD) ஆதரிக்கிறது: TDD என்பது ஒரு வளர்ச்சி அணுகுமுறையாகும், இதில் நீங்கள் உண்மையான குறியீட்டை எழுதுவதற்கு முன்பு சோதனைகளை எழுதுகிறீர்கள். இது உங்கள் பயன்பாட்டின் விரும்பிய நடத்தையைப் பற்றி முன்னதாகவே சிந்திக்க கட்டாயப்படுத்துகிறது, இது சுத்தமான மற்றும் பராமரிக்கக்கூடிய குறியீட்டிற்கு வழிவகுக்கிறது.

ஜாங்கோவின் சோதனை கட்டமைப்பு: ஒரு விரைவான கண்ணோட்டம்

ஜாங்கோவின் சோதனை கட்டமைப்பு பைத்தானின் உள்ளமைக்கப்பட்ட யூனிட்டெஸ்ட் தொகுதியின் அடிப்படையில் உருவாக்கப்பட்டது. ஜாங்கோ பயன்பாடுகளை சோதிப்பதை எளிதாக்கும் பல அம்சங்களை இது வழங்குகிறது, அவற்றுள்:

• சோதனை கண்டுபிடிப்பு: ஜாங்கோ உங்கள் திட்டத்திற்குள் சோதனைகளை தானாகவே கண்டுபிடித்து இயக்குகிறது.
• சோதனை ரன்னர்: ஜாங்கோ உங்கள் சோதனைகளை இயக்கி முடிவுகளை தெரிவிக்கும் ஒரு சோதனை ரன்னரை வழங்குகிறது.
• உறுதிப்படுத்தல் முறைகள்: உங்கள் குறியீட்டின் எதிர்பார்க்கப்பட்ட நடத்தையை சரிபார்க்க நீங்கள் பயன்படுத்தக்கூடிய உறுதிப்படுத்தல் முறைகளின் தொகுப்பை ஜாங்கோ வழங்குகிறது.
• கிளையண்ட்: ஜாங்கோவின் சோதனை கிளையண்ட் படிவங்களை சமர்ப்பித்தல் அல்லது API கோரிக்கைகளைச் செய்தல் போன்ற உங்கள் பயன்பாட்டுடன் பயனர் தொடர்புகளை உருவகப்படுத்த உங்களை அனுமதிக்கிறது.
• டெஸ்ட்கேஸ் மற்றும் டிரான்ஸாக்சன்டெஸ்ட்கேஸ்: இவை ஜாங்கோவில் சோதனைகளை எழுதுவதற்கான இரண்டு அடிப்படை வகுப்புகள், அவற்றை நாங்கள் விரிவாக ஆராய்வோம்.

டெஸ்ட்கேஸ்: வேகமான மற்றும் திறமையான அலகு சோதனை

டெஸ்ட்கேஸ் என்பது ஜாங்கோவில் அலகு சோதனைகளை எழுதுவதற்கான முதன்மை வகுப்பாகும். இது ஒவ்வொரு சோதனை வழக்கிற்கும் ஒரு சுத்தமான தரவுத்தள சூழலை வழங்குகிறது, சோதனைகள் தனிமைப்படுத்தப்பட்டு ஒருவருக்கொருவர் தலையிடாததை உறுதி செய்கிறது.

டெஸ்ட்கேஸ் எவ்வாறு செயல்படுகிறது

நீங்கள் டெஸ்ட்கேஸ் பயன்படுத்தும் போது, ஜாங்கோ ஒவ்வொரு சோதனை முறைக்கும் பின்வரும் படிகளைச் செய்கிறது:

1. ஒரு சோதனை தரவுத்தளத்தை உருவாக்குகிறது: ஜாங்கோ ஒவ்வொரு சோதனைக்கும் ஒரு தனி சோதனை தரவுத்தளத்தை உருவாக்குகிறது.
2. தரவுத்தளத்தை வெளியேற்றுகிறது: ஒவ்வொரு சோதனை முறைக்கும் முன், ஜாங்கோ சோதனை தரவுத்தளத்தை வெளியேற்றி, ஏற்கனவே உள்ள தரவை நீக்குகிறது.
3. சோதனை முறையை இயக்குகிறது: நீங்கள் உருவாக்கிய சோதனை முறையை ஜாங்கோ இயக்குகிறது.
4. பரிவர்த்தனையை உருட்டுகிறது: ஒவ்வொரு சோதனை முறைக்குப் பிறகும், ஜாங்கோ பரிவர்த்தனையை உருட்டுகிறது, சோதனையின் போது தரவுத்தளத்தில் செய்யப்பட்ட எந்த மாற்றங்களையும் திறம்பட செயல்தவிர்க்கிறது.

இந்த அணுகுமுறை, ஒவ்வொரு சோதனை முறையும் ஒரு சுத்தமான நிலையில் தொடங்குகிறது மற்றும் தரவுத்தளத்தில் செய்யப்பட்ட எந்த மாற்றங்களும் தானாகவே மாற்றியமைக்கப்படுகின்றன என்பதை உறுதி செய்கிறது. இது டெஸ்ட்கேஸ்-ஐ அலகு சோதனைக்கு ஏற்றதாக ஆக்குகிறது, அங்கு உங்கள் பயன்பாட்டின் தனிப்பட்ட கூறுகளை தனிமைப்படுத்தி சோதிக்க விரும்புகிறீர்கள்.

எடுத்துக்காட்டு: ஒரு எளிய மாதிரியை சோதித்தல்

டெஸ்ட்கேஸ் பயன்படுத்தி ஜாங்கோ மாதிரியை சோதிப்பதற்கான ஒரு எளிய உதாரணத்தைக் கருத்தில் கொள்வோம்:

from django.test import TestCase
from .models import Product

class ProductModelTest(TestCase):
    def test_product_creation(self):
        product = Product.objects.create(name="Test Product", price=10.00)
        self.assertEqual(product.name, "Test Product")
        self.assertEqual(product.price, 10.00)
        self.assertTrue(isinstance(product, Product))

இந்த எடுத்துக்காட்டில், ஒரு Product மாதிரி நிகழ்வை உருவாக்குவதை நாங்கள் சோதிக்கிறோம். test_product_creation முறை ஒரு புதிய தயாரிப்பை உருவாக்குகிறது, பின்னர் தயாரிப்பின் பண்புக்கூறுகள் சரியாக அமைக்கப்பட்டுள்ளதா என்பதை சரிபார்க்க உறுதிப்படுத்தல் முறைகளைப் பயன்படுத்துகிறது.

டெஸ்ட்கேஸை எப்போது பயன்படுத்துவது

டெஸ்ட்கேஸ் பொதுவாக பெரும்பாலான ஜாங்கோ சோதனை சூழ்நிலைகளுக்கு விருப்பமான தேர்வாகும். இது வேகமானது, திறமையானது மற்றும் ஒவ்வொரு சோதனைக்கும் ஒரு சுத்தமான தரவுத்தள சூழலை வழங்குகிறது. நீங்கள் டெஸ்ட்கேஸ் ஐப் பயன்படுத்தவும்:

• உங்கள் பயன்பாட்டின் தனிப்பட்ட மாதிரிகள், காட்சிகள் அல்லது பிற கூறுகளை நீங்கள் சோதிக்கும்போது.
• உங்கள் சோதனைகள் தனிமைப்படுத்தப்பட்டு ஒருவருக்கொருவர் தலையிடாததை நீங்கள் உறுதிப்படுத்த விரும்பினால்.
• நீங்கள் பல பரிவர்த்தனைகளை உள்ளடக்கிய சிக்கலான தரவுத்தள தொடர்புகளை சோதிக்க வேண்டியதில்லை என்றால்.

டிரான்ஸாக்சன்டெஸ்ட்கேஸ்: சிக்கலான தரவுத்தள தொடர்புகளை சோதித்தல்

டிரான்ஸாக்சன்டெஸ்ட்கேஸ் என்பது ஜாங்கோவில் சோதனைகளை எழுதுவதற்கான மற்றொரு வகுப்பாகும், ஆனால் இது தரவுத்தள பரிவர்த்தனைகளை எவ்வாறு கையாளுகிறது என்பதில் டெஸ்ட்கேஸ் இலிருந்து வேறுபடுகிறது. ஒவ்வொரு சோதனை முறைக்குப் பிறகும் பரிவர்த்தனையை உருட்டுவதற்குப் பதிலாக, டிரான்ஸாக்சன்டெஸ்ட்கேஸ் பரிவர்த்தனையை உறுதிப்படுத்துகிறது. இது சிக்னல்கள் அல்லது அணு பரிவர்த்தனைகள் போன்ற பல பரிவர்த்தனைகளை உள்ளடக்கிய சிக்கலான தரவுத்தள தொடர்புகளை சோதிப்பதற்கு ஏற்றதாக அமைகிறது.

டிரான்ஸாக்சன்டெஸ்ட்கேஸ் எவ்வாறு செயல்படுகிறது

நீங்கள் டிரான்ஸாக்சன்டெஸ்ட்கேஸ் பயன்படுத்தும் போது, ஜாங்கோ ஒவ்வொரு சோதனை வழக்கிற்கும் பின்வரும் படிகளைச் செய்கிறது:

1. ஒரு சோதனை தரவுத்தளத்தை உருவாக்குகிறது: ஜாங்கோ ஒவ்வொரு சோதனைக்கும் ஒரு தனி சோதனை தரவுத்தளத்தை உருவாக்குகிறது.
2. தரவுத்தளத்தை வெளியேற்றுவதில்லை: டிரான்ஸாக்சன்டெஸ்ட்கேஸ் ஒவ்வொரு சோதனைக்கும் முன் தானாகவே தரவுத்தளத்தை வெளியேற்றாது. ஒவ்வொரு சோதனையும் இயங்கும் முன் தரவுத்தளம் நிலையான நிலையில் இருக்கும் என்று எதிர்பார்க்கிறது.
3. சோதனை முறையை இயக்குகிறது: நீங்கள் உருவாக்கிய சோதனை முறையை ஜாங்கோ இயக்குகிறது.
4. பரிவர்த்தனையை உறுதிப்படுத்துகிறது: ஒவ்வொரு சோதனை முறைக்குப் பிறகும், ஜாங்கோ பரிவர்த்தனையை உறுதிப்படுத்துகிறது, சோதனை தரவுத்தளத்தில் மாற்றங்களை நிரந்தரமாக்குகிறது.
5. அட்டவணைகளை வெட்டுகிறது: டிரான்ஸாக்சன்டெஸ்ட்கேஸில் உள்ள அனைத்து சோதனைகளிலும் முடிவில், தரவை அழிக்க அட்டவணைகள் வெட்டப்படுகின்றன.

டிரான்ஸாக்சன்டெஸ்ட்கேஸ் ஒவ்வொரு சோதனை முறைக்குப் பிறகும் பரிவர்த்தனையை உறுதிப்படுத்துவதால், உங்கள் சோதனைகள் தரவுத்தளத்தை ஒரு முரண்பாடான நிலையில் விட்டுவிடாததை உறுதி செய்வது அவசியம். அடுத்தடுத்த சோதனைகளில் தலையிடுவதைத் தவிர்க்க, சோதனை நேரத்தில் உருவாக்கப்பட்ட எந்த தரவையும் நீங்கள் கைமுறையாக சுத்தம் செய்ய வேண்டியிருக்கலாம்.

எடுத்துக்காட்டு: சிக்னல்களை சோதித்தல்

டிரான்ஸாக்சன்டெஸ்ட்கேஸ் பயன்படுத்தி ஜாங்கோ சிக்னல்களை சோதிப்பதற்கான ஒரு உதாரணத்தைக் கருத்தில் கொள்வோம்:

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="Created")

class ProductSignalTest(TransactionTestCase):
    def test_product_creation_signal(self):
        product = Product.objects.create(name="Test Product", price=10.00)
        self.assertEqual(ProductLog.objects.count(), 1)
        self.assertEqual(ProductLog.objects.first().product, product)
        self.assertEqual(ProductLog.objects.first().action, "Created")

இந்த எடுத்துக்காட்டில், ஒரு புதிய Product நிகழ்வு உருவாக்கப்பட்டபோதெல்லாம் ஒரு ProductLog நிகழ்வை உருவாக்கும் ஒரு சிக்னலை சோதிக்கிறோம். test_product_creation_signal முறை ஒரு புதிய தயாரிப்பை உருவாக்குகிறது, பின்னர் ஒரு தொடர்புடைய தயாரிப்பு பதிவு உள்ளீடு உருவாக்கப்பட்டுள்ளதா என்பதை சரிபார்க்கிறது.

டிரான்ஸாக்சன்டெஸ்ட்கேஸை எப்போது பயன்படுத்துவது

டிரான்ஸாக்சன்டெஸ்ட்கேஸ் பொதுவாக பல பரிவர்த்தனைகளை உள்ளடக்கிய சிக்கலான தரவுத்தள தொடர்புகளை சோதிக்க வேண்டிய குறிப்பிட்ட சூழ்நிலைகளில் பயன்படுத்தப்படுகிறது. நீங்கள் டிரான்ஸாக்சன்டெஸ்ட்கேஸ் ஐப் பயன்படுத்தலாம்:

• தரவுத்தள செயல்பாடுகளால் தூண்டப்படும் சிக்னல்களை நீங்கள் சோதிக்கும்போது.
• பல தரவுத்தள செயல்பாடுகளை உள்ளடக்கிய அணு பரிவர்த்தனைகளை நீங்கள் சோதிக்கும்போது.
• தொடர்புடைய தொடர் செயல்பாடுகளுக்குப் பிறகு தரவுத்தளத்தின் நிலையை நீங்கள் சரிபார்க்க வேண்டும்.
• சோதனைகளுக்கு இடையில் நிலைத்திருக்க, தானாக அதிகரிக்கும் ஐடியைப் பயன்படுத்தும் குறியீட்டை நீங்கள் பயன்படுத்துகிறீர்கள் (இது பொதுவாக மோசமான நடைமுறையாகக் கருதப்படுகிறது).

டிரான்ஸாக்சன்டெஸ்ட்கேஸைப் பயன்படுத்தும் போது முக்கியமான கருத்தாக இருக்க வேண்டியவை

டிரான்ஸாக்சன்டெஸ்ட்கேஸ் பரிவர்த்தனைகளை உறுதிப்படுத்துவதால், பின்வரும் விஷயங்களை அறிந்து கொள்வது முக்கியம்:

• தரவுத்தள சுத்தம்: அடுத்தடுத்த சோதனைகளில் தலையிடுவதைத் தவிர்க்க, சோதனை நேரத்தில் உருவாக்கப்பட்ட எந்த தரவையும் நீங்கள் கைமுறையாக சுத்தம் செய்ய வேண்டியிருக்கலாம். சோதனை தரவை நிர்வகிக்க setUp மற்றும் tearDown முறைகளைப் பயன்படுத்துவதைக் கவனியுங்கள்.
• சோதனை தனிமைப்படுத்தல்: டிரான்ஸாக்சன்டெஸ்ட்கேஸ், டெஸ்ட்கேஸ் போலவே சோதனை தனிமைப்படுத்தலின் அதே அளவை வழங்காது. சோதனைகளுக்கு இடையேயான சாத்தியமான தொடர்புகளை நினைவில் வைத்து, முந்தைய சோதனைகளிலிருந்து தரவுத்தளத்தின் நிலையில் உங்கள் சோதனைகள் தங்கியிருக்கவில்லை என்பதை உறுதிப்படுத்திக் கொள்ளுங்கள்.
• செயல்திறன்: டிரான்ஸாக்சன்டெஸ்ட்கேஸ் பரிவர்த்தனைகளை உள்ளடக்கியிருப்பதால் டெஸ்ட்கேஸ் ஐ விட மெதுவாக இருக்கலாம். அதை விவேகத்துடன் பயன்படுத்துங்கள், தேவைப்பட்டால் மட்டுமே.

ஜாங்கோ சோதனைகளுக்கான சிறந்த நடைமுறைகள்

ஜாங்கோவில் சோதனைகளை எழுதும் போது நினைவில் கொள்ள வேண்டிய சில சிறந்த நடைமுறைகள் இங்கே:

• தெளிவான மற்றும் சுருக்கமான சோதனைகளை எழுதுங்கள்: சோதனைகள் புரிந்து கொள்ளவும் பராமரிக்கவும் எளிதாக இருக்க வேண்டும். சோதனை முறைகள் மற்றும் உறுதிப்படுத்தல்களுக்கு விளக்கமான பெயர்களைப் பயன்படுத்துங்கள்.
• ஒரே நேரத்தில் ஒன்றைச் சோதிக்கவும்: ஒவ்வொரு சோதனை முறையும் உங்கள் குறியீட்டின் ஒரே ஒரு அம்சத்தை சோதிப்பதில் கவனம் செலுத்த வேண்டும். ஒரு சோதனை தோல்வியுற்றால், தோல்வியின் மூலத்தைக் கண்டறிவது எளிதாக்குகிறது.
• பொருள் பொதிந்த உறுதிப்படுத்தல்களைப் பயன்படுத்துங்கள்: உங்கள் குறியீட்டின் எதிர்பார்க்கப்பட்ட நடத்தையை தெளிவாக வெளிப்படுத்தும் உறுதிப்படுத்தல் முறைகளைப் பயன்படுத்தவும். பல்வேறு சூழ்நிலைகளுக்காக ஜாங்கோ ஒரு சிறந்த உறுதிப்படுத்தல் முறைகளை வழங்குகிறது.
• அரேஞ்ச்-ஆக்ட்-அசட் பேட்டர்னைப் பின்பற்றவும்: உங்கள் சோதனைகளை அரேஞ்ச்-ஆக்ட்-அசட் பேட்டர்ன் படி கட்டமைக்கவும்: சோதனை தரவை ஏற்பாடு செய்யுங்கள், சோதனையின் கீழ் உள்ள குறியீட்டில் செயல்படுங்கள், மேலும் எதிர்பார்க்கப்பட்ட முடிவை உறுதிப்படுத்துங்கள்.
• உங்கள் சோதனைகளை வேகமாக்குங்கள்: மெதுவான சோதனைகள் டெவலப்பர்களை அடிக்கடி இயக்க ஊக்குவிக்காது. செயல்படுத்தும் நேரத்தை குறைக்க உங்கள் சோதனைகளை மேம்படுத்துங்கள்.
• சோதனை தரவுகளுக்கு பிக்சர்களைப் பயன்படுத்துங்கள்: உங்கள் சோதனை தரவுத்தளத்தில் ஆரம்ப தரவை ஏற்ற பிக்சர்கள் ஒரு வசதியான வழியாகும். நிலையான மற்றும் மீண்டும் பயன்படுத்தக்கூடிய சோதனை தரவை உருவாக்க பிக்சர்களைப் பயன்படுத்தவும். ஐடிகளை ஹார்ட்கோடிங் செய்வதைத் தவிர்க்க பிக்சர்களில் இயற்கை விசைகளைப் பயன்படுத்துவதைக் கவனியுங்கள்.
• 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') # Activate German language
            with self.settings(LANGUAGE_CODE='de'): # Set the language in settings
                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) # Restore original language

இந்த எடுத்துக்காட்டு, ஜாங்கோவின் translation மற்றும் formats தொகுதிகளைப் பயன்படுத்தி வெவ்வேறு மொழி அமைப்புகளுடன் தேதி வடிவமைப்பை எவ்வாறு சோதிப்பது என்பதை விளக்குகிறது.

முடிவுரை

டெஸ்ட்கேஸ் மற்றும் டிரான்ஸாக்சன்டெஸ்ட்கேஸ் ஆகியவற்றுக்கு இடையேயான வேறுபாடுகளைப் புரிந்துகொள்வது, ஜாங்கோவில் பயனுள்ள மற்றும் நம்பகமான சோதனைகளை எழுதுவதற்கு அவசியம். டெஸ்ட்கேஸ் பொதுவாக பெரும்பாலான சோதனை சூழ்நிலைகளுக்கு விருப்பமான தேர்வாகும், இது உங்கள் பயன்பாட்டின் தனிப்பட்ட கூறுகளை தனிமைப்படுத்தி சோதிக்க ஒரு வேகமான மற்றும் திறமையான வழியை வழங்குகிறது. சிக்னல்கள் அல்லது அணு பரிவர்த்தனைகள் போன்ற பல பரிவர்த்தனைகளை உள்ளடக்கிய சிக்கலான தரவுத்தள தொடர்புகளை சோதிப்பதற்கு டிரான்ஸாக்சன்டெஸ்ட்கேஸ் பயனுள்ளதாக இருக்கும். சிறந்த நடைமுறைகளைப் பின்பற்றுவதன் மூலம் மற்றும் சர்வதேசமயமாக்கல் அம்சங்களைக் கருத்தில் கொள்வதன் மூலம், உங்கள் ஜாங்கோ பயன்பாடுகளின் தரம் மற்றும் பராமரிப்புத்தன்மையை உறுதி செய்யும் ஒரு வலுவான சோதனை தொகுப்பை நீங்கள் உருவாக்கலாம்.

மேலும் கற்றல்

• ஜாங்கோ சோதனை ஆவணங்கள்
• பைத்தான் யூனிட்டெஸ்ட் ஆவணங்கள்
• pytest ஆவணங்கள்