FastAPI: மீண்டும் பயன்படுத்தப்படாத ஒரு சோதனை அஞ்சல்பெட்டி

மென்பொருள் சோதனைகளில் நிலைத்தன்மை மிகவும் முக்கியமானது, குறிப்பாக சரிபார்ப்பு மின்னஞ்சல்களை அனுப்புவதில் இது இன்றியமையாதது. நவீன மென்பொருள் உருவாக்கத்தில் தானியங்கு சோதனைகள் ஓர் அத்தியாவசிய அங்கமாக இருப்பதால், இந்த விஷயம் எப்போதும் இல்லாத அளவிற்கு இப்போது மிகவும் பொருத்தமானதாக உள்ளது.

சோதனை அஞ்சல்பெட்டிகளை மீண்டும் பயன்படுத்துவதில் உள்ள பிரச்சனை

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

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

முன்மொழியப்பட்ட தீர்வு

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

1. run_id: CI பணி அல்லது உள்ளூர் இயக்கத்திற்கான ஓர் அடையாளங்காட்டி.
2. mailbox_id: அந்த இயக்கத்திற்காக உருவாக்கப்பட்ட அஞ்சல்பெட்டிக்கான ஓர் அடையாளங்காட்டி.
3. expected_token: பெறப்பட்ட இணைப்பைச் சோதிக்கப்படும் பயனருடன் தொடர்புபடுத்தும் ஒரு டோக்கன்.

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

FastAPI-இல் செயல்படுத்துதல்

இந்த உத்தியை FastAPI-இல் செயல்படுத்த, ஒவ்வொரு சோதனைக்கும் ஒரு தனித்துவமான அஞ்சல்பெட்டியை உருவாக்கும் ஓர் endpoint-ஐ நாம் உருவாக்கலாம். அதை எவ்வாறு செய்வது என்பதற்கான ஓர் எடுத்துக்காட்டு கீழே கொடுக்கப்பட்டுள்ளது:

from dataclasses import dataclass
from uuid import uuid4
from fastapi import FastAPI

app = FastAPI()

dataclass(frozen=True)
class Mailbox:
    address: str
    mailbox_id: str


def create_test_mailbox(run_id: str) -> Mailbox:
    mailbox_id = f"{run_id}-{uuid4().hex[:8]}"
    return Mailbox(
        address=f"{mailbox_id}@test.invalid",
        mailbox_id=mailbox_id,
    )

@app.post("/test-users")
def create_test_user(run_id: str):
    mailbox = create_test_mailbox(run_id)
    token = uuid4().hex  # Guarda mailbox.mailbox_id y token junto al usuario creado.
    return {
        "email": mailbox.address,
        "mailbox_id": mailbox.mailbox_id,
        "verification_token": token,
    }

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

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

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

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

முடிவுரை

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

நன்மைகள்

• சோதனைகளைத் தனிமைப்படுத்துதல்.
• கண்டறிவதில் எளிமை.
• சோதனைகளின் நிலைத்தன்மையில் முன்னேற்றம்.

குறைபாடுகள்

• செயல்படுத்துவதற்கு ஆரம்பத்தில் அதிக வேலை தேவைப்படலாம்.
• தற்காலிக வளங்களைச் சிறந்த முறையில் நிர்வகிக்க வேண்டியது அவசியம்.

எச்சரிக்கை

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

அடிக்கடி கேட்கப்படும் கேள்விகள்

• FastAPI என்றால் என்ன? — FastAPI என்பது Python மூலம் APIs உருவாக்குவதற்கான நவீன மற்றும் வேகமான ஃப்ரேம்வொர்க் ஆகும்.
• சோதனைகளில் தனிமைப்படுத்துதல் ஏன் முக்கியமானது? — சோதனைகளைத் தனிமைப்படுத்துவது குறுக்கீடுகளையும் முரணான முடிவுகளையும் தவிர்த்து, நம்பகத்தன்மையை மேம்படுத்துகிறது.
• FastAPI-இல் தற்காலிக அஞ்சல்பெட்டியை எவ்வாறு செயல்படுத்துவது? — ஒவ்வொரு சோதனை இயக்கத்திற்கும் ஒரு தனித்துவமான அஞ்சல்பெட்டியை உருவாக்கும் ஓர் endpoint-ஐ உருவாக்கலாம்.
• run_id என்றால் என்ன? — இது வெவ்வேறு சோதனை இயக்கங்களை வேறுபடுத்திக் காட்ட உதவும் ஒரு தனித்துவமான அடையாளங்காட்டி ஆகும்.
• சோதனை அஞ்சல்பெட்டிகளை மீண்டும் பயன்படுத்துவது என்ன பிரச்சனைகளை ஏற்படுத்துகிறது? — இது விட்டுவிட்டு ஏற்படும் தோல்விகள், CI சூழல்களில் குழப்பம் மற்றும் மறுமுயற்சிகளில் சிக்கல்களை ஏற்படுத்தக்கூடும்.
• mailbox_id என்றால் என்ன? — இது ஒரு குறிப்பிட்ட அஞ்சல்பெட்டியை ஒரு சோதனை இயக்கத்துடன் தொடர்புபடுத்தும் ஓர் அடையாளங்காட்டி ஆகும்.