મૉક ફંક્શન્સ: ડેવલપર્સ માટે એક વિસ્તૃત માર્ગદર્શિકા

સોફ્ટવેર ડેવલપમેન્ટની દુનિયામાં, મજબૂત અને વિશ્વસનીય કોડ લખવો એ સર્વોપરી છે. આ લક્ષ્ય હાંસલ કરવા માટે સંપૂર્ણ પરીક્ષણ (testing) નિર્ણાયક છે. યુનિટ ટેસ્ટિંગ, ખાસ કરીને, અલગ-અલગ ઘટકો અથવા ફંક્શન્સને અલગથી ચકાસવા પર ધ્યાન કેન્દ્રિત કરે છે. જોકે, વાસ્તવિક-દુનિયાની એપ્લિકેશન્સમાં ઘણીવાર જટિલ ડિપેન્ડન્સીઝ (dependencies) સામેલ હોય છે, જેનાથી યુનિટ્સને સંપૂર્ણ અલગતામાં ચકાસવું પડકારજનક બને છે. અહીં જ મૉક ફંક્શન્સ કામમાં આવે છે.

મૉક ફંક્શન્સ શું છે?

મૉક ફંક્શન એ વાસ્તવિક ફંક્શનનું સિમ્યુલેટેડ (બનાવટી) વર્ઝન છે જેનો તમે તમારા ટેસ્ટ્સમાં ઉપયોગ કરી શકો છો. વાસ્તવિક ફંક્શનના લોજિકને ચલાવવાને બદલે, મૉક ફંક્શન તમને તેના વર્તનને નિયંત્રિત કરવાની, તેને કેવી રીતે કોલ કરવામાં આવી રહ્યું છે તે જોવાની અને તેના રિટર્ન વેલ્યુઝને નિર્ધારિત કરવાની મંજૂરી આપે છે. તે ટેસ્ટ ડબલનો એક પ્રકાર છે.

તેને આ રીતે વિચારો: કલ્પના કરો કે તમે કારના એન્જિન (ટેસ્ટ હેઠળનું યુનિટ)નું પરીક્ષણ કરી રહ્યા છો. એન્જિન અન્ય વિવિધ ઘટકો પર આધાર રાખે છે, જેમ કે ફ્યુઅલ ઇન્જેક્શન સિસ્ટમ અને કૂલિંગ સિસ્ટમ. એન્જિન ટેસ્ટ દરમિયાન વાસ્તવિક ફ્યુઅલ ઇન્જેક્શન અને કૂલિંગ સિસ્ટમ ચલાવવાને બદલે, તમે મૉક સિસ્ટમ્સનો ઉપયોગ કરી શકો છો જે તેમના વર્તનનું અનુકરણ કરે છે. આ તમને એન્જિનને અલગ કરવાની અને ખાસ કરીને તેના પ્રદર્શન પર ધ્યાન કેન્દ્રિત કરવાની મંજૂરી આપે છે.

મૉક ફંક્શન્સ આના માટે શક્તિશાળી સાધનો છે:

• યુનિટ્સને અલગ કરવા: એક ફંક્શન અથવા ઘટકના વર્તન પર ધ્યાન કેન્દ્રિત કરવા માટે બાહ્ય ડિપેન્ડન્સીઝને દૂર કરવી.
• વર્તનને નિયંત્રિત કરવા: ટેસ્ટિંગ દરમિયાન ચોક્કસ રિટર્ન વેલ્યુઝ નિર્ધારિત કરવા, એરર ફેંકવા અથવા કસ્ટમ લોજિક ચલાવવું.
• ઇન્ટરેક્શન્સનું નિરીક્ષણ કરવું: ફંક્શનને કેટલી વાર કોલ કરવામાં આવે છે, તેને કયા આર્ગ્યુમેન્ટ્સ મળે છે, અને તેને કયા ક્રમમાં કોલ કરવામાં આવે છે તે ટ્રેક કરવું.
• એજ કેસોનું અનુકરણ કરવું: એવી પરિસ્થિતિઓ સરળતાથી બનાવવી જે વાસ્તવિક વાતાવરણમાં પુનઃઉત્પાદન કરવી મુશ્કેલ અથવા અશક્ય હોય (દા.ત., નેટવર્ક નિષ્ફળતા, ડેટાબેઝ એરર).

મૉક ફંક્શન્સનો ઉપયોગ ક્યારે કરવો

મૉક્સ આ પરિસ્થિતિઓમાં સૌથી વધુ ઉપયોગી છે:

1. બાહ્ય ડિપેન્ડન્સીઝવાળા યુનિટ્સને અલગ કરવા

જ્યારે તમારું ટેસ્ટ હેઠળનું યુનિટ બાહ્ય સેવાઓ, ડેટાબેઝ, APIs, અથવા અન્ય ઘટકો પર આધાર રાખે છે, ત્યારે ટેસ્ટિંગ દરમિયાન વાસ્તવિક ડિપેન્ડન્સીઝનો ઉપયોગ કરવાથી ઘણી સમસ્યાઓ ઊભી થઈ શકે છે:

• ધીમા ટેસ્ટ્સ: વાસ્તવિક ડિપેન્ડન્સીઝ સેટઅપ અને એક્ઝિક્યુટ કરવામાં ધીમી હોઈ શકે છે, જે ટેસ્ટ એક્ઝિક્યુશન સમયમાં નોંધપાત્ર વધારો કરે છે.
• અવિશ્વસનીય ટેસ્ટ્સ: બાહ્ય ડિપેન્ડન્સીઝ અણધારી અને નિષ્ફળતાની સંભાવનાવાળી હોઈ શકે છે, જેનાથી ફ્લેકી (અસ્થિર) ટેસ્ટ્સ પરિણમે છે.
• જટિલતા: વાસ્તવિક ડિપેન્ડન્સીઝનું સંચાલન અને કન્ફિગરેશન તમારા ટેસ્ટ સેટઅપમાં બિનજરૂરી જટિલતા ઉમેરી શકે છે.
• ખર્ચ: બાહ્ય સેવાઓનો ઉપયોગ કરવાથી ઘણીવાર ખર્ચ થાય છે, ખાસ કરીને વ્યાપક ટેસ્ટિંગ માટે.

ઉદાહરણ: કલ્પના કરો કે તમે એક એવા ફંક્શનનું પરીક્ષણ કરી રહ્યા છો જે રિમોટ API માંથી યુઝર ડેટા મેળવે છે. ટેસ્ટિંગ દરમિયાન વાસ્તવિક API કોલ્સ કરવાને બદલે, તમે API રિસ્પોન્સનું અનુકરણ કરવા માટે મૉક ફંક્શનનો ઉપયોગ કરી શકો છો. આ તમને બાહ્ય API ની ઉપલબ્ધતા અથવા પ્રદર્શન પર આધાર રાખ્યા વિના ફંક્શનના લોજિકનું પરીક્ષણ કરવાની મંજૂરી આપે છે. આ ખાસ કરીને ત્યારે મહત્વનું છે જ્યારે API માં રેટ લિમિટ્સ હોય અથવા દરેક રિક્વેસ્ટ માટે ખર્ચ સંકળાયેલો હોય.

2. જટિલ ઇન્ટરેક્શન્સનું પરીક્ષણ કરવું

કેટલાક કિસ્સાઓમાં, તમારું ટેસ્ટ હેઠળનું યુનિટ અન્ય ઘટકો સાથે જટિલ રીતે ઇન્ટરેક્ટ કરી શકે છે. મૉક ફંક્શન્સ તમને આ ઇન્ટરેક્શન્સનું અવલોકન અને ચકાસણી કરવાની મંજૂરી આપે છે.

ઉદાહરણ: પેમેન્ટ ટ્રાન્ઝેક્શન્સ પર પ્રક્રિયા કરતા ફંક્શનનો વિચાર કરો. આ ફંક્શન પેમેન્ટ ગેટવે, ડેટાબેઝ અને નોટિફિકેશન સેવા સાથે ઇન્ટરેક્ટ કરી શકે છે. મૉક ફંક્શન્સનો ઉપયોગ કરીને, તમે ચકાસી શકો છો કે ફંક્શન સાચા ટ્રાન્ઝેક્શન વિગતો સાથે પેમેન્ટ ગેટવેને કોલ કરે છે, ટ્રાન્ઝેક્શન સ્ટેટસ સાથે ડેટાબેઝને અપડેટ કરે છે, અને યુઝરને નોટિફિકેશન મોકલે છે.

3. એરરની પરિસ્થિતિઓનું અનુકરણ કરવું

તમારી એપ્લિકેશનની મજબૂતાઈ સુનિશ્ચિત કરવા માટે એરર હેન્ડલિંગનું પરીક્ષણ કરવું નિર્ણાયક છે. મૉક ફંક્શન્સ એવી એરરની પરિસ્થિતિઓનું અનુકરણ કરવાનું સરળ બનાવે છે જે વાસ્તવિક વાતાવરણમાં પુનઃઉત્પાદન કરવી મુશ્કેલ અથવા અશક્ય હોય છે.

ઉદાહરણ: ધારો કે તમે એવા ફંક્શનનું પરીક્ષણ કરી રહ્યા છો જે ક્લાઉડ સ્ટોરેજ સર્વિસ પર ફાઇલો અપલોડ કરે છે. તમે અપલોડ પ્રક્રિયા દરમિયાન નેટવર્ક એરરનું અનુકરણ કરવા માટે મૉક ફંક્શનનો ઉપયોગ કરી શકો છો. આ તમને ચકાસવાની મંજૂરી આપે છે કે ફંક્શન એરરને યોગ્ય રીતે હેન્ડલ કરે છે, અપલોડ ફરીથી પ્રયાસ કરે છે, અથવા યુઝરને સૂચિત કરે છે.

4. એસિંક્રોનસ કોડનું પરીક્ષણ કરવું

એસિંક્રોનસ કોડ, જેમ કે કોલબેક્સ, પ્રોમિસ અથવા async/await નો ઉપયોગ કરતો કોડ, પરીક્ષણ માટે પડકારજનક હોઈ શકે છે. મૉક ફંક્શન્સ તમને એસિંક્રોનસ ઓપરેશન્સના સમય અને વર્તનને નિયંત્રિત કરવામાં મદદ કરી શકે છે.

ઉદાહરણ: કલ્પના કરો કે તમે એવા ફંક્શનનું પરીક્ષણ કરી રહ્યા છો જે એસિંક્રોનસ રિક્વેસ્ટનો ઉપયોગ કરીને સર્વરમાંથી ડેટા મેળવે છે. તમે સર્વર રિસ્પોન્સનું અનુકરણ કરવા અને રિસ્પોન્સ ક્યારે પાછો આવે તે નિયંત્રિત કરવા માટે મૉક ફંક્શનનો ઉપયોગ કરી શકો છો. આ તમને પરીક્ષણ કરવાની મંજૂરી આપે છે કે ફંક્શન વિવિધ રિસ્પોન્સ પરિસ્થિતિઓ અને ટાઈમઆઉટને કેવી રીતે હેન્ડલ કરે છે.

5. અનિચ્છનીય આડઅસરો અટકાવવી

કેટલીકવાર, ટેસ્ટિંગ દરમિયાન વાસ્તવિક ફંક્શનને કોલ કરવાથી અનિચ્છનીય આડઅસરો થઈ શકે છે, જેમ કે ડેટાબેઝમાં ફેરફાર કરવો, ઇમેઇલ્સ મોકલવા, અથવા બાહ્ય પ્રક્રિયાઓને ટ્રિગર કરવી. મૉક ફંક્શન્સ વાસ્તવિક ફંક્શનને નિયંત્રિત સિમ્યુલેશન સાથે બદલીને આ આડઅસરોને અટકાવે છે.

ઉદાહરણ: તમે એક એવા ફંક્શનનું પરીક્ષણ કરી રહ્યા છો જે નવા યુઝર્સને સ્વાગત ઇમેઇલ્સ મોકલે છે. મૉક ઇમેઇલ સેવાનો ઉપયોગ કરીને, તમે ખાતરી કરી શકો છો કે ઇમેઇલ મોકલવાની કાર્યક્ષમતા તમારા ટેસ્ટ સ્યુટ રન દરમિયાન વાસ્તવિક યુઝર્સને ઇમેઇલ્સ મોકલતી નથી. તેના બદલે, તમે ચકાસી શકો છો કે ફંક્શન સાચી માહિતી સાથે ઇમેઇલ મોકલવાનો પ્રયાસ કરે છે.

મૉક ફંક્શન્સનો ઉપયોગ કેવી રીતે કરવો

મૉક ફંક્શન્સનો ઉપયોગ કરવાના ચોક્કસ પગલાં તમે ઉપયોગ કરી રહ્યાં છો તે પ્રોગ્રામિંગ ભાષા અને ટેસ્ટિંગ ફ્રેમવર્ક પર આધાર રાખે છે. જોકે, સામાન્ય પ્રક્રિયામાં સામાન્ય રીતે નીચેના પગલાં શામેલ હોય છે:

1. ડિપેન્ડન્સીઝને ઓળખો: તમારે કઈ બાહ્ય ડિપેન્ડન્સીઝને મૉક કરવાની જરૂર છે તે નક્કી કરો.
2. મૉક ઑબ્જેક્ટ્સ બનાવો: વાસ્તવિક ડિપેન્ડન્સીઝને બદલવા માટે મૉક ઑબ્જેક્ટ્સ અથવા ફંક્શન્સ બનાવો. આ મૉક્સમાં ઘણીવાર `called`, `returnValue`, અને `callArguments` જેવી પ્રોપર્ટીઝ હોય છે.
3. મૉક વર્તન કન્ફિગર કરો: મૉક ફંક્શન્સના વર્તનને નિર્ધારિત કરો, જેમ કે તેમના રિટર્ન વેલ્યુઝ, એરરની પરિસ્થિતિઓ, અને કોલ કાઉન્ટ.
4. મૉક્સ ઇન્જેક્ટ કરો: તમારા ટેસ્ટ હેઠળના યુનિટમાં વાસ્તવિક ડિપેન્ડન્સીઝને મૉક ઑબ્જેક્ટ્સ સાથે બદલો. આ ઘણીવાર ડિપેન્ડન્સી ઇન્જેક્શનનો ઉપયોગ કરીને કરવામાં આવે છે.
5. ટેસ્ટ ચલાવો: તમારો ટેસ્ટ ચલાવો અને અવલોકન કરો કે ટેસ્ટ હેઠળનું યુનિટ મૉક ફંક્શન્સ સાથે કેવી રીતે ઇન્ટરેક્ટ કરે છે.
6. ઇન્ટરેક્શન્સ ચકાસો: ચકાસો કે મૉક ફંક્શન્સને અપેક્ષિત આર્ગ્યુમેન્ટ્સ, રિટર્ન વેલ્યુઝ, અને સંખ્યામાં કોલ કરવામાં આવ્યા હતા.
7. મૂળ કાર્યક્ષમતા પુનઃસ્થાપિત કરો: ટેસ્ટ પછી, મૉક ઑબ્જેક્ટ્સને દૂર કરીને અને વાસ્તવિક ડિપેન્ડન્સીઝ પર પાછા ફરીને મૂળ કાર્યક્ષમતા પુનઃસ્થાપિત કરો. આ અન્ય ટેસ્ટ્સ પર આડઅસરો ટાળવામાં મદદ કરે છે.

વિવિધ ભાષાઓમાં મૉક ફંક્શનના ઉદાહરણો

અહીં લોકપ્રિય પ્રોગ્રામિંગ ભાષાઓ અને ટેસ્ટિંગ ફ્રેમવર્કમાં મૉક ફંક્શન્સનો ઉપયોગ કરવાના ઉદાહરણો છે:

Jest સાથે જાવાસ્ક્રિપ્ટ

Jest એ એક લોકપ્રિય જાવાસ્ક્રિપ્ટ ટેસ્ટિંગ ફ્રેમવર્ક છે જે મૉક ફંક્શન્સ માટે બિલ્ટ-ઇન સપોર્ટ પૂરું પાડે છે.

// ટેસ્ટ કરવા માટેનું ફંક્શન
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` નો ઉપયોગ કરીને સમાન ઉદાહરણ છે:

# pytest વર્ઝન
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 ટેસ્ટ્સની અંદર મૉક્સની રચના અને કન્ફિગરેશનને સરળ બનાવે છે.

Mockito સાથે Java

Mockito એ Java માટે એક લોકપ્રિય મૉકિંગ ફ્રેમવર્ક છે.

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): ફેક્સ એ ડિપેન્ડન્સીનું કાર્યરત અમલીકરણ છે, પરંતુ પરીક્ષણના હેતુઓ માટે સરળ બનાવવામાં આવે છે. ઇન-મેમરી ડેટાબેઝ એ ફેકનું ઉદાહરણ છે.
• ઇન્ટિગ્રેશન ટેસ્ટ્સ: ઇન્ટિગ્રેશન ટેસ્ટ્સ બહુવિધ ઘટકો વચ્ચેના ઇન્ટરેક્શન્સને ચકાસે છે. જ્યારે તમે સિસ્ટમના વર્તનને સંપૂર્ણ રીતે ચકાસવા માંગતા હો ત્યારે તે મૉક્સ સાથેના યુનિટ ટેસ્ટ્સનો સારો વિકલ્પ હોઈ શકે છે.

નિષ્કર્ષ

મૉક ફંક્શન્સ અસરકારક યુનિટ ટેસ્ટ્સ લખવા માટે એક આવશ્યક સાધન છે, જે તમને યુનિટ્સને અલગ કરવા, વર્તનને નિયંત્રિત કરવા, એરરની પરિસ્થિતિઓનું અનુકરણ કરવા અને એસિંક્રોનસ કોડનું પરીક્ષણ કરવા સક્ષમ બનાવે છે. શ્રેષ્ઠ પદ્ધતિઓનું પાલન કરીને અને વિકલ્પોને સમજીને, તમે વધુ મજબૂત, વિશ્વસનીય અને જાળવણીક્ષમ સોફ્ટવેર બનાવવા માટે મૉક ફંક્શન્સનો લાભ લઈ શકો છો. દરેક પરિસ્થિતિ માટે યોગ્ય પરીક્ષણ તકનીક પસંદ કરવાનું યાદ રાખો અને વ્યાપક અને અસરકારક પરીક્ષણ વ્યૂહરચના બનાવો, ભલે તમે વિશ્વના કોઈપણ ભાગમાંથી નિર્માણ કરી રહ્યા હોવ.