மாக் செயல்பாடுகள்: டெவலப்பர்களுக்கான ஒரு விரிவான வழிகாட்டி

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

மாக் செயல்பாடுகள் என்றால் என்ன?

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

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

மாக் செயல்பாடுகள் இவற்றிற்கு சக்திவாய்ந்த கருவிகள்:

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

மாக் செயல்பாடுகளை எப்போது பயன்படுத்த வேண்டும்

மாக்ஸ் இந்த சூழ்நிலைகளில் மிகவும் பயனுள்ளதாக இருக்கும்:

1. வெளிப்புற சார்புகளுடன் யூனிட்களைத் தனிமைப்படுத்துதல்

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

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

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

2. சிக்கலான ஊடாடல்களைச் சோதித்தல்

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

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

3. பிழை நிலைகளை உருவகப்படுத்துதல்

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

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

4. ஒத்திசைவற்ற குறியீட்டைச் சோதித்தல்

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

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

5. எதிர்பாராத பக்க விளைவுகளைத் தடுத்தல்

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

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

மாக் செயல்பாடுகளை எவ்வாறு பயன்படுத்துவது

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

1. சார்புகளை அடையாளம் காணுதல்: நீங்கள் எந்த வெளிப்புற சார்புகளை மாக் செய்ய வேண்டும் என்பதைத் தீர்மானிக்கவும்.
2. மாக் ஆப்ஜெக்ட்களை உருவாக்குதல்: உண்மையான சார்புகளை மாற்றுவதற்கு மாக் ஆப்ஜெக்ட்கள் அல்லது செயல்பாடுகளை உருவாக்கவும். இந்த மாக்ஸ் பெரும்பாலும் `called`, `returnValue`, மற்றும் `callArguments` போன்ற பண்புகளைக் கொண்டிருக்கும்.
3. மாக் நடத்தையை உள்ளமைத்தல்: மாக் செயல்பாடுகளின் நடத்தையை வரையறுக்கவும், அதாவது அவற்றின் ரிட்டர்ன் மதிப்புகள், பிழை நிலைகள், மற்றும் அழைப்பு எண்ணிக்கை.
4. மாக்ஸ்களை உட்செலுத்துதல்: உங்கள் சோதனைக்குட்பட்ட யூனிட்டில் உண்மையான சார்புகளை மாக் ஆப்ஜெக்ட்களுடன் மாற்றவும். இது பெரும்பாலும் சார்பு உட்செலுத்துதல் (dependency injection) மூலம் செய்யப்படுகிறது.
5. சோதனையை இயக்குதல்: உங்கள் சோதனையை இயக்கவும் மற்றும் சோதனைக்குட்பட்ட யூனிட் மாக் செயல்பாடுகளுடன் எவ்வாறு தொடர்பு கொள்கிறது என்பதைக் கவனிக்கவும்.
6. ஊடாடல்களை சரிபார்த்தல்: மாக் செயல்பாடுகள் எதிர்பார்க்கப்படும் ஆர்குமென்ட்கள், ரிட்டர்ன் மதிப்புகள், மற்றும் எத்தனை முறை அழைக்கப்பட்டன என்பதைச் சரிபார்க்கவும்.
7. அசல் செயல்பாட்டை மீட்டமைத்தல்: சோதனைக்குப் பிறகு, மாக் ஆப்ஜெக்ட்களை அகற்றி, உண்மையான சார்புகளுக்குத் திரும்புவதன் மூலம் அசல் செயல்பாட்டை மீட்டெடுக்கவும். இது மற்ற சோதனைகளில் பக்க விளைவுகளைத் தவிர்க்க உதவுகிறது.

வெவ்வேறு மொழிகளில் மாக் செயல்பாடுகளின் எடுத்துக்காட்டுகள்

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

ஜாவாஸ்கிரிப்ட் மற்றும் ஜெஸ்ட்

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

// சோதிக்க வேண்டிய செயல்பாடு
function fetchData(callback) {
  setTimeout(() => {
    callback('Data from server');
  }, 100);
}

// சோதனை வழக்கு
test('fetchData calls callback with correct data', (done) => {
  const mockCallback = jest.fn();
  fetchData(mockCallback);

  setTimeout(() => {
    expect(mockCallback).toHaveBeenCalledWith('Data from server');
    done();
  }, 200);
});

இந்த எடுத்துக்காட்டில், `jest.fn()` உண்மையான கால்பேக் செயல்பாட்டை மாற்றும் ஒரு மாக் செயல்பாட்டை உருவாக்குகிறது. சோதனை `toHaveBeenCalledWith()` ஐப் பயன்படுத்தி மாக் செயல்பாடு சரியான தரவுகளுடன் அழைக்கப்படுகிறதா என்பதைச் சரிபார்க்கிறது.

மாட்யூல்களைப் பயன்படுத்தி மேலும் மேம்பட்ட உதாரணம்:

// user.js
import { getUserDataFromAPI } from './api';

export async function displayUserName(userId) {
  const userData = await getUserDataFromAPI(userId);
  return userData.name;
}

// api.js
export async function getUserDataFromAPI(userId) {
  // API அழைப்பை உருவகப்படுத்துதல்
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ id: userId, name: 'John Doe' });
    }, 50);
  });
}

// user.test.js
import { displayUserName } from './user';
import * as api from './api';

describe('displayUserName', () => {
  it('should display the user name', async () => {
    // getUserDataFromAPI செயல்பாட்டை மாக் செய்யவும்
    const mockGetUserData = jest.spyOn(api, 'getUserDataFromAPI');
    mockGetUserData.mockResolvedValue({ id: 123, name: 'Mocked Name' });

    const userName = await displayUserName(123);
    expect(userName).toBe('Mocked Name');

    // அசல் செயல்பாட்டை மீட்டமைக்கவும்
    mockGetUserData.mockRestore();
  });
});

இங்கே, `./api` மாட்யூலிலிருந்து இறக்குமதி செய்யப்பட்ட `getUserDataFromAPI` செயல்பாட்டிற்கு ஒரு மாக் செயல்பாட்டை உருவாக்க `jest.spyOn` பயன்படுத்தப்படுகிறது. `mockResolvedValue` மாக்கின் ரிட்டர்ன் மதிப்பைக் குறிப்பிடப் பயன்படுத்தப்படுகிறது. மற்ற சோதனைகள் தற்செயலாக மாக் செய்யப்பட்ட பதிப்பைப் பயன்படுத்துவதைத் தவிர்க்க `mockRestore` அவசியம்.

பைதான் மற்றும் pytest மற்றும் unittest.mock

பைதான் `unittest.mock` (உள்ளமைக்கப்பட்டது) மற்றும் pytest உடன் எளிமைப்படுத்தப்பட்ட பயன்பாட்டிற்கான `pytest-mock` போன்ற நூலகங்கள் உட்பட, மாக் செய்வதற்கான பல நூலகங்களை வழங்குகிறது.

# சோதிக்க வேண்டிய செயல்பாடு
def get_data_from_api(url):
    # ஒரு நிஜ சூழ்நிலையில், இது ஒரு API அழைப்பைச் செய்யும்
    # எளிமைக்காக, நாம் ஒரு API அழைப்பை உருவகப்படுத்துகிறோம்
    if url == "https://example.com/api":
        return {"data": "API data"}
    else:
        return None

def process_data(url):
    data = get_data_from_api(url)
    if data:
        return data["data"]
    else:
        return "No data found"

# unittest.mock பயன்படுத்தி சோதனை வழக்கு
import unittest
from unittest.mock import patch

class TestProcessData(unittest.TestCase):
    @patch('__main__.get_data_from_api') # பிரதான மாட்யூலில் get_data_from_api-ஐ மாற்றவும்
    def test_process_data_success(self, mock_get_data_from_api):
        # மாக்கை உள்ளமைக்கவும்
        mock_get_data_from_api.return_value = {"data": "Mocked data"}

        # சோதிக்கப்படும் செயல்பாட்டை அழைக்கவும்
        result = process_data("https://example.com/api")

        # முடிவை உறுதிப்படுத்தவும்
        self.assertEqual(result, "Mocked data")
        mock_get_data_from_api.assert_called_once_with("https://example.com/api")

    @patch('__main__.get_data_from_api')
    def test_process_data_failure(self, mock_get_data_from_api):
        mock_get_data_from_api.return_value = None
        result = process_data("https://example.com/api")
        self.assertEqual(result, "No data found")

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

இந்த எடுத்துக்காட்டு `get_data_from_api` செயல்பாட்டை ஒரு மாக் உடன் மாற்றுவதற்கு `unittest.mock.patch` ஐப் பயன்படுத்துகிறது. சோதனை மாக்கை ஒரு குறிப்பிட்ட மதிப்பைத் திருப்பித் தருமாறு உள்ளமைக்கிறது, பின்னர் `process_data` செயல்பாடு எதிர்பார்க்கப்படும் முடிவைத் தருகிறதா என்பதைச் சரிபார்க்கிறது.

`pytest-mock` ஐப் பயன்படுத்தி அதே உதாரணம் இங்கே:

# பைடெஸ்ட் பதிப்பு
import pytest

def get_data_from_api(url):
    # ஒரு நிஜ சூழ்நிலையில், இது ஒரு API அழைப்பைச் செய்யும்
    # எளிமைக்காக, நாம் ஒரு API அழைப்பை உருவகப்படுத்துகிறோம்
    if url == "https://example.com/api":
        return {"data": "API data"}
    else:
        return None

def process_data(url):
    data = get_data_from_api(url)
    if data:
        return data["data"]
    else:
        return "No data found"


def test_process_data_success(mocker):
    mocker.patch('__main__.get_data_from_api', return_value={"data": "Mocked data"})
    result = process_data("https://example.com/api")
    assert result == "Mocked data"


def test_process_data_failure(mocker):
    mocker.patch('__main__.get_data_from_api', return_value=None)
    result = process_data("https://example.com/api")
    assert result == "No data found"

`pytest-mock` நூலகம் ஒரு `mocker` ஃபிக்சரை வழங்குகிறது, இது pytest சோதனைகளுக்குள் மாக்ஸ்களை உருவாக்குவதையும் உள்ளமைப்பதையும் எளிதாக்குகிறது.

ஜாவா மற்றும் மாக்கிட்டோ

மாக்கிட்டோ என்பது ஜாவாவிற்கான ஒரு பிரபலமான மாக் செய்யும் கட்டமைப்பாகும்.

import org.junit.jupiter.api.Test;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

interface DataFetcher {
    String fetchData(String url);
}

class DataProcessor {
    private final DataFetcher dataFetcher;

    public DataProcessor(DataFetcher dataFetcher) {
        this.dataFetcher = dataFetcher;
    }

    public String processData(String url) {
        String data = dataFetcher.fetchData(url);
        if (data != null) {
            return "Processed: " + data;
        } else {
            return "No data";
        }
    }
}

public class DataProcessorTest {

    @Test
    public void testProcessDataSuccess() {
        // ஒரு மாக் DataFetcher-ஐ உருவாக்கவும்
        DataFetcher mockDataFetcher = mock(DataFetcher.class);

        // மாக்கை உள்ளமைக்கவும்
        when(mockDataFetcher.fetchData("https://example.com/api")).thenReturn("API Data");

        // மாக் உடன் DataProcessor-ஐ உருவாக்கவும்
        DataProcessor dataProcessor = new DataProcessor(mockDataFetcher);

        // சோதிக்கப்படும் செயல்பாட்டை அழைக்கவும்
        String result = dataProcessor.processData("https://example.com/api");

        // முடிவை உறுதிப்படுத்தவும்
        assertEquals("Processed: API Data", result);

        // மாக் அழைக்கப்பட்டதா என்பதைச் சரிபார்க்கவும்
        verify(mockDataFetcher).fetchData("https://example.com/api");
    }

    @Test
    public void testProcessDataFailure() {
        DataFetcher mockDataFetcher = mock(DataFetcher.class);
        when(mockDataFetcher.fetchData("https://example.com/api")).thenReturn(null);

        DataProcessor dataProcessor = new DataProcessor(mockDataFetcher);
        String result = dataProcessor.processData("https://example.com/api");
        assertEquals("No data", result);
        verify(mockDataFetcher).fetchData("https://example.com/api");
    }
}

இந்த எடுத்துக்காட்டில், `Mockito.mock()` `DataFetcher` இடைமுகத்திற்கு ஒரு மாக் ஆப்ஜெக்டை உருவாக்குகிறது. `when()` மாக்கின் ரிட்டர்ன் மதிப்பை உள்ளமைக்கப் பயன்படுத்தப்படுகிறது, மற்றும் `verify()` மாக் எதிர்பார்க்கப்படும் ஆர்குமென்ட்களுடன் அழைக்கப்பட்டதா என்பதைச் சரிபார்க்கப் பயன்படுத்தப்படுகிறது.

மாக் செயல்பாடுகளைப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

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

மாக் செயல்பாடுகளுக்கு மாற்றுகள்

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

• ஸ்டப்ஸ் (Stubs): ஸ்டப்ஸ் மாக்ஸ்களை விட எளிமையானவை. அவை செயல்பாட்டு அழைப்புகளுக்கு முன் வரையறுக்கப்பட்ட பதில்களை வழங்குகின்றன, ஆனால் அந்த அழைப்புகள் எவ்வாறு செய்யப்பட்டன என்பதை பொதுவாக சரிபார்க்காது. உங்கள் சோதனைக்குட்பட்ட யூனிட்டிற்கான உள்ளீட்டைக் கட்டுப்படுத்த மட்டுமே உங்களுக்குத் தேவைப்படும்போது அவை பயனுள்ளதாக இருக்கும்.
• ஸ்பைஸ் (Spies): ஸ்பைஸ் ஒரு உண்மையான செயல்பாட்டின் அசல் தர்க்கத்தை இயக்க அனுமதிக்கும்போதே அதன் நடத்தையைக் கவனிக்க உங்களை அனுமதிக்கின்றன. ஒரு செயல்பாட்டின் செயல்பாட்டை முழுவதுமாக மாற்றாமல், அது குறிப்பிட்ட ஆர்குமென்ட்களுடன் அல்லது ஒரு குறிப்பிட்ட எண்ணிக்கையிலான முறை அழைக்கப்படுகிறதா என்பதைச் சரிபார்க்க விரும்பும்போது அவை பயனுள்ளதாக இருக்கும்.
• ஃபேக்ஸ் (Fakes): ஃபேக்ஸ் என்பது ஒரு சார்பின் வேலை செய்யும் செயலாக்கங்கள், ஆனால் சோதனை நோக்கங்களுக்காக எளிமைப்படுத்தப்பட்டவை. ஒரு இன்-மெமரி தரவுத்தளம் ஒரு ஃபேக்கின் எடுத்துக்காட்டு.
• ஒருங்கிணைப்பு சோதனைகள் (Integration Tests): ஒருங்கிணைப்பு சோதனைகள் பல கூறுகளுக்கு இடையிலான ஊடாடல்களைச் சரிபார்க்கின்றன. ஒரு அமைப்பின் நடத்தையை முழுமையாக சோதிக்க விரும்பும்போது, மாக்ஸ் உடனான யூனிட் சோதனைகளுக்கு அவை ஒரு நல்ல மாற்றாக இருக்கலாம்.

முடிவுரை

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