മോക്ക് ഫംഗ്ഷനുകൾ: ഡെവലപ്പർമാർക്കുള്ള ഒരു സമഗ്ര ഗൈഡ്

സോഫ്റ്റ്‌വെയർ ഡെവലപ്‌മെൻ്റിൻ്റെ ലോകത്ത്, ശക്തവും വിശ്വസനീയവുമായ കോഡ് എഴുതുന്നത് പരമപ്രധാനമാണ്. ഈ ലക്ഷ്യം കൈവരിക്കുന്നതിന് സമഗ്രമായ ടെസ്റ്റിംഗ് അത്യാവശ്യമാണ്. യൂണിറ്റ് ടെസ്റ്റിംഗ്, പ്രത്യേകിച്ചും, ഓരോ ഘടകങ്ങളെയോ ഫംഗ്ഷനുകളെയോ ഒറ്റയ്ക്ക് ടെസ്റ്റ് ചെയ്യുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. എന്നിരുന്നാലും, യഥാർത്ഥ ആപ്ലിക്കേഷനുകളിൽ പലപ്പോഴും സങ്കീർണ്ണമായ ഡിപൻഡൻസികൾ ഉൾപ്പെടുന്നു, ഇത് യൂണിറ്റുകളെ പൂർണ്ണമായും ഒറ്റയ്ക്ക് ടെസ്റ്റ് ചെയ്യുന്നത് വെല്ലുവിളിയാക്കുന്നു. ഇവിടെയാണ് മോക്ക് ഫംഗ്ഷനുകൾ പ്രയോജനപ്പെടുന്നത്.

എന്താണ് മോക്ക് ഫംഗ്ഷനുകൾ?

ഒരു മോക്ക് ഫംഗ്ഷൻ എന്നത് നിങ്ങളുടെ ടെസ്റ്റുകളിൽ ഉപയോഗിക്കാൻ കഴിയുന്ന ഒരു യഥാർത്ഥ ഫംഗ്ഷൻ്റെ സിമുലേറ്റഡ് പതിപ്പാണ്. യഥാർത്ഥ ഫംഗ്ഷൻ്റെ ലോജിക്ക് പ്രവർത്തിപ്പിക്കുന്നതിന് പകരം, ഒരു മോക്ക് ഫംഗ്ഷൻ അതിൻ്റെ സ്വഭാവം നിയന്ത്രിക്കാനും അത് എങ്ങനെ വിളിക്കപ്പെടുന്നുവെന്ന് നിരീക്ഷിക്കാനും അതിൻ്റെ റിട്ടേൺ മൂല്യങ്ങൾ നിർവചിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു. അവ ടെസ്റ്റ് ഡബിൾ-ൻ്റെ ഒരു തരമാണ്.

ഇതിനെക്കുറിച്ച് ഇങ്ങനെ ചിന്തിക്കുക: നിങ്ങൾ ഒരു കാറിൻ്റെ എഞ്ചിൻ (ടെസ്റ്റ് ചെയ്യപ്പെടുന്ന യൂണിറ്റ്) ടെസ്റ്റ് ചെയ്യുകയാണെന്ന് കരുതുക. എഞ്ചിൻ, ഫ്യൂവൽ ഇൻജക്ഷൻ സിസ്റ്റം, കൂളിംഗ് സിസ്റ്റം തുടങ്ങിയ മറ്റ് ഘടകങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു. എഞ്ചിൻ ടെസ്റ്റിനിടെ യഥാർത്ഥ ഫ്യൂവൽ ഇൻജക്ഷൻ, കൂളിംഗ് സിസ്റ്റങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നതിനുപകരം, അവയുടെ പ്രവർത്തനം അനുകരിക്കുന്ന മോക്ക് സിസ്റ്റങ്ങൾ നിങ്ങൾക്ക് ഉപയോഗിക്കാം. ഇത് എഞ്ചിനെ വേർതിരിക്കാനും അതിൻ്റെ പ്രകടനത്തിൽ പ്രത്യേകമായി ശ്രദ്ധ കേന്ദ്രീകരിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു.

മോക്ക് ഫംഗ്ഷനുകൾ ഇതിനെല്ലാമുള്ള ശക്തമായ ടൂളുകളാണ്:

• യൂണിറ്റുകളെ വേർതിരിക്കുക: ഒരൊറ്റ ഫംഗ്ഷൻ്റെയോ ഘടകത്തിൻ്റെയോ സ്വഭാവത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നതിന് ബാഹ്യ ഡിപൻഡൻസികളെ നീക്കംചെയ്യുന്നു.
• സ്വഭാവം നിയന്ത്രിക്കുക: ടെസ്റ്റിംഗിനിടെ നിർദ്ദിഷ്ട റിട്ടേൺ മൂല്യങ്ങൾ നിർവചിക്കുക, എററുകൾ ഉണ്ടാക്കുക, അല്ലെങ്കിൽ ഇഷ്ടാനുസൃത ലോജിക്ക് പ്രവർത്തിപ്പിക്കുക.
• ഇടപെടലുകൾ നിരീക്ഷിക്കുക: ഒരു ഫംഗ്ഷൻ എത്ര തവണ വിളിക്കപ്പെട്ടു, അതിന് എന്ത് ആർഗ്യുമെൻ്റുകൾ ലഭിച്ചു, ഏത് ക്രമത്തിലാണ് അത് വിളിക്കപ്പെട്ടത് എന്നിവ ട്രാക്ക് ചെയ്യുക.
• എഡ്ജ് കേസുകൾ അനുകരിക്കുക: ഒരു യഥാർത്ഥ പരിതസ്ഥിതിയിൽ പുനഃസൃഷ്ടിക്കാൻ പ്രയാസകരമോ അസാധ്യമോ ആയ സാഹചര്യങ്ങൾ എളുപ്പത്തിൽ ഉണ്ടാക്കുക (ഉദാഹരണത്തിന്, നെറ്റ്‌വർക്ക് പരാജയങ്ങൾ, ഡാറ്റാബേസ് എററുകൾ).

എപ്പോഴാണ് മോക്ക് ഫംഗ്ഷനുകൾ ഉപയോഗിക്കേണ്ടത്

1. ബാഹ്യ ഡിപൻഡൻസികളുള്ള യൂണിറ്റുകളെ വേർതിരിക്കുമ്പോൾ

നിങ്ങൾ ടെസ്റ്റ് ചെയ്യുന്ന യൂണിറ്റ് ബാഹ്യ സേവനങ്ങൾ, ഡാറ്റാബേസുകൾ, എപിഐകൾ, അല്ലെങ്കിൽ മറ്റ് ഘടകങ്ങളെ ആശ്രയിക്കുമ്പോൾ, ടെസ്റ്റിംഗിനിടെ യഥാർത്ഥ ഡിപൻഡൻസികൾ ഉപയോഗിക്കുന്നത് നിരവധി പ്രശ്നങ്ങൾക്ക് കാരണമാകും:

• വേഗത കുറഞ്ഞ ടെസ്റ്റുകൾ: യഥാർത്ഥ ഡിപൻഡൻസികൾ സജ്ജീകരിക്കാനും പ്രവർത്തിപ്പിക്കാനും സമയമെടുക്കും, ഇത് ടെസ്റ്റ് എക്സിക്യൂഷൻ സമയം ഗണ്യമായി വർദ്ധിപ്പിക്കുന്നു.
• വിശ്വസനീയമല്ലാത്ത ടെസ്റ്റുകൾ: ബാഹ്യ ഡിപൻഡൻസികൾ പ്രവചനാതീതവും പരാജയപ്പെടാൻ സാധ്യതയുള്ളതുമാകാം, ഇത് ടെസ്റ്റുകൾ സ്ഥിരതയില്ലാത്തതാക്കാൻ ഇടയാക്കും.
• സങ്കീർണ്ണത: യഥാർത്ഥ ഡിപൻഡൻസികൾ കൈകാര്യം ചെയ്യുന്നതും കോൺഫിഗർ ചെയ്യുന്നതും നിങ്ങളുടെ ടെസ്റ്റ് സെറ്റപ്പിൽ അനാവശ്യമായ സങ്കീർണ്ണത കൂട്ടിച്ചേർക്കും.
• ചെലവ്: ബാഹ്യ സേവനങ്ങൾ ഉപയോഗിക്കുന്നത് പലപ്പോഴും ചെലവേറിയതാണ്, പ്രത്യേകിച്ചും വിപുലമായ ടെസ്റ്റിംഗിന്.

ഉദാഹരണം: ഒരു റിമോട്ട് എപിഐയിൽ നിന്ന് ഉപയോക്തൃ ഡാറ്റ വീണ്ടെടുക്കുന്ന ഒരു ഫംഗ്ഷൻ നിങ്ങൾ ടെസ്റ്റ് ചെയ്യുകയാണെന്ന് സങ്കൽപ്പിക്കുക. ടെസ്റ്റിംഗിനിടെ യഥാർത്ഥ എപിഐ കോളുകൾ ചെയ്യുന്നതിനുപകരം, എപിഐ പ്രതികരണം അനുകരിക്കാൻ നിങ്ങൾക്ക് ഒരു മോക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കാം. ഇത് ബാഹ്യ എപിഐയുടെ ലഭ്യതയെയോ പ്രകടനത്തെയോ ആശ്രയിക്കാതെ ഫംഗ്ഷൻ്റെ ലോജിക്ക് ടെസ്റ്റ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഓരോ അഭ്യർത്ഥനയ്ക്കും എപിഐയ്ക്ക് നിരക്ക് പരിധികളോ അനുബന്ധ ചെലവുകളോ ഉള്ളപ്പോൾ ഇത് വളരെ പ്രധാനമാണ്.

2. സങ്കീർണ്ണമായ ഇടപെടലുകൾ ടെസ്റ്റ് ചെയ്യുമ്പോൾ

ചില സന്ദർഭങ്ങളിൽ, നിങ്ങൾ ടെസ്റ്റ് ചെയ്യുന്ന യൂണിറ്റ് മറ്റ് ഘടകങ്ങളുമായി സങ്കീർണ്ണമായ രീതികളിൽ ഇടപഴകിയേക്കാം. ഈ ഇടപെടലുകൾ നിരീക്ഷിക്കാനും പരിശോധിക്കാനും മോക്ക് ഫംഗ്ഷനുകൾ നിങ്ങളെ അനുവദിക്കുന്നു.

ഉദാഹരണം: പേയ്‌മെൻ്റ് ഇടപാടുകൾ പ്രോസസ്സ് ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ പരിഗണിക്കുക. ഈ ഫംഗ്ഷൻ ഒരു പേയ്‌മെൻ്റ് ഗേറ്റ്‌വേ, ഒരു ഡാറ്റാബേസ്, ഒരു നോട്ടിഫിക്കേഷൻ സർവീസ് എന്നിവയുമായി ഇടപഴകിയേക്കാം. മോക്ക് ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച്, ഫംഗ്ഷൻ ശരിയായ ഇടപാട് വിശദാംശങ്ങൾ ഉപയോഗിച്ച് പേയ്‌മെൻ്റ് ഗേറ്റ്‌വേയെ വിളിക്കുന്നുണ്ടെന്നും, ഇടപാട് നില ഉപയോഗിച്ച് ഡാറ്റാബേസ് അപ്‌ഡേറ്റ് ചെയ്യുന്നുണ്ടെന്നും, ഉപയോക്താവിന് ഒരു അറിയിപ്പ് അയയ്‌ക്കുന്നുണ്ടെന്നും നിങ്ങൾക്ക് പരിശോധിക്കാൻ കഴിയും.

3. എറർ സാഹചര്യങ്ങൾ അനുകരിക്കുമ്പോൾ

നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ കരുത്ത് ഉറപ്പാക്കുന്നതിന് എറർ ഹാൻഡ്‌ലിംഗ് ടെസ്റ്റ് ചെയ്യേണ്ടത് അത്യാവശ്യമാണ്. യഥാർത്ഥ പരിതസ്ഥിതിയിൽ പുനർനിർമ്മിക്കാൻ പ്രയാസമുള്ളതോ അസാധ്യമോ ആയ എറർ സാഹചര്യങ്ങൾ അനുകരിക്കാൻ മോക്ക് ഫംഗ്ഷനുകൾ എളുപ്പമാക്കുന്നു.

ഉദാഹരണം: ഒരു ക്ലൗഡ് സ്റ്റോറേജ് സേവനത്തിലേക്ക് ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ നിങ്ങൾ ടെസ്റ്റ് ചെയ്യുകയാണെന്ന് കരുതുക. അപ്‌ലോഡ് പ്രക്രിയയ്ക്കിടെ ഒരു നെറ്റ്‌വർക്ക് എറർ അനുകരിക്കാൻ നിങ്ങൾക്ക് ഒരു മോക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കാം. ഫംഗ്ഷൻ എറർ ശരിയായി കൈകാര്യം ചെയ്യുന്നുണ്ടോ, അപ്‌ലോഡ് വീണ്ടും ശ്രമിക്കുന്നുണ്ടോ, അല്ലെങ്കിൽ ഉപയോക്താവിനെ അറിയിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

4. അസിൻക്രണസ് കോഡ് ടെസ്റ്റ് ചെയ്യുമ്പോൾ

കോൾബാക്കുകൾ, പ്രോമിസുകൾ, അല്ലെങ്കിൽ async/await ഉപയോഗിക്കുന്ന കോഡ് പോലുള്ള അസിൻക്രണസ് കോഡ് ടെസ്റ്റ് ചെയ്യാൻ വെല്ലുവിളിയാകാം. അസിൻക്രണസ് ഓപ്പറേഷനുകളുടെ സമയവും സ്വഭാവവും നിയന്ത്രിക്കാൻ മോക്ക് ഫംഗ്ഷനുകൾ നിങ്ങളെ സഹായിക്കും.

ഉദാഹരണം: ഒരു അസിൻക്രണസ് അഭ്യർത്ഥന ഉപയോഗിച്ച് ഒരു സെർവറിൽ നിന്ന് ഡാറ്റ ലഭ്യമാക്കുന്ന ഒരു ഫംഗ്ഷൻ നിങ്ങൾ ടെസ്റ്റ് ചെയ്യുകയാണെന്ന് സങ്കൽപ്പിക്കുക. സെർവർ പ്രതികരണം അനുകരിക്കാനും പ്രതികരണം എപ്പോൾ തിരികെ നൽകണമെന്ന് നിയന്ത്രിക്കാനും നിങ്ങൾക്ക് ഒരു മോക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കാം. വ്യത്യസ്ത പ്രതികരണ സാഹചര്യങ്ങളും സമയപരിധിയും ഫംഗ്ഷൻ എങ്ങനെ കൈകാര്യം ചെയ്യുന്നുവെന്ന് ടെസ്റ്റ് ചെയ്യാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

5. ഉദ്ദേശിക്കാത്ത പാർശ്വഫലങ്ങൾ തടയുന്നതിന്

ചിലപ്പോൾ, ടെസ്റ്റിംഗിനിടെ ഒരു യഥാർത്ഥ ഫംഗ്ഷൻ വിളിക്കുന്നത് ഡാറ്റാബേസ് മാറ്റുന്നത്, ഇമെയിലുകൾ അയക്കുന്നത്, അല്ലെങ്കിൽ ബാഹ്യ പ്രോസസ്സുകൾ ട്രിഗർ ചെയ്യുന്നത് പോലുള്ള ഉദ്ദേശിക്കാത്ത പാർശ്വഫലങ്ങൾ ഉണ്ടാക്കാം. യഥാർത്ഥ ഫംഗ്ഷനെ ഒരു നിയന്ത്രിത സിമുലേഷൻ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാൻ അനുവദിക്കുന്നതിലൂടെ മോക്ക് ഫംഗ്ഷനുകൾ ഈ പാർശ്വഫലങ്ങൾ തടയുന്നു.

ഉദാഹരണം: പുതിയ ഉപയോക്താക്കൾക്ക് സ്വാഗത ഇമെയിലുകൾ അയക്കുന്ന ഒരു ഫംഗ്ഷൻ നിങ്ങൾ ടെസ്റ്റ് ചെയ്യുകയാണ്. ഒരു മോക്ക് ഇമെയിൽ സേവനം ഉപയോഗിക്കുന്നതിലൂടെ, നിങ്ങളുടെ ടെസ്റ്റ് സ്യൂട്ട് പ്രവർത്തിക്കുമ്പോൾ ഇമെയിൽ അയയ്‌ക്കുന്ന പ്രവർത്തനം യഥാർത്ഥ ഉപയോക്താക്കൾക്ക് ഇമെയിലുകൾ അയയ്‌ക്കുന്നില്ലെന്ന് ഉറപ്പാക്കാൻ കഴിയും. പകരം, ശരിയായ വിവരങ്ങൾ ഉപയോഗിച്ച് ഇമെയിൽ അയയ്‌ക്കാൻ ഫംഗ്ഷൻ ശ്രമിക്കുന്നുണ്ടോ എന്ന് നിങ്ങൾക്ക് പരിശോധിക്കാൻ കഴിയും.

മോക്ക് ഫംഗ്ഷനുകൾ എങ്ങനെ ഉപയോഗിക്കാം

മോക്ക് ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നതിനുള്ള നിർദ്ദിഷ്ട ഘട്ടങ്ങൾ നിങ്ങൾ ഉപയോഗിക്കുന്ന പ്രോഗ്രാമിംഗ് ഭാഷയെയും ടെസ്റ്റിംഗ് ഫ്രെയിംവർക്കിനെയും ആശ്രയിച്ചിരിക്കുന്നു. എന്നിരുന്നാലും, പൊതുവായ പ്രക്രിയയിൽ സാധാരണയായി ഇനിപ്പറയുന്ന ഘട്ടങ്ങൾ ഉൾപ്പെടുന്നു:

1. ഡിപൻഡൻസികൾ തിരിച്ചറിയുക: നിങ്ങൾ മോക്ക് ചെയ്യേണ്ട ബാഹ്യ ഡിപൻഡൻസികൾ ഏതൊക്കെയാണെന്ന് നിർണ്ണയിക്കുക.
2. മോക്ക് ഒബ്ജക്റ്റുകൾ ഉണ്ടാക്കുക: യഥാർത്ഥ ഡിപൻഡൻസികൾക്ക് പകരം മോക്ക് ഒബ്ജക്റ്റുകളോ ഫംഗ്ഷനുകളോ ഉണ്ടാക്കുക. ഈ മോക്കുകൾക്ക് പലപ്പോഴും `called`, `returnValue`, `callArguments` തുടങ്ങിയ പ്രോപ്പർട്ടികൾ ഉണ്ടാകും.
3. മോക്ക് സ്വഭാവം കോൺഫിഗർ ചെയ്യുക: മോക്ക് ഫംഗ്ഷനുകളുടെ റിട്ടേൺ മൂല്യങ്ങൾ, എറർ സാഹചര്യങ്ങൾ, കോൾ കൗണ്ട് തുടങ്ങിയ സ്വഭാവം നിർവചിക്കുക.
4. മോക്കുകൾ ഇൻജെക്റ്റ് ചെയ്യുക: നിങ്ങൾ ടെസ്റ്റ് ചെയ്യുന്ന യൂണിറ്റിലെ യഥാർത്ഥ ഡിപൻഡൻസികളെ മോക്ക് ഒബ്ജക്റ്റുകൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുക. ഇത് പലപ്പോഴും ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ ഉപയോഗിച്ചാണ് ചെയ്യുന്നത്.
5. ടെസ്റ്റ് പ്രവർത്തിപ്പിക്കുക: നിങ്ങളുടെ ടെസ്റ്റ് പ്രവർത്തിപ്പിച്ച്, ടെസ്റ്റ് ചെയ്യുന്ന യൂണിറ്റ് മോക്ക് ഫംഗ്ഷനുകളുമായി എങ്ങനെ ഇടപഴകുന്നു എന്ന് നിരീക്ഷിക്കുക.
6. ഇടപെടലുകൾ പരിശോധിക്കുക: പ്രതീക്ഷിച്ച ആർഗ്യുമെൻ്റുകൾ, റിട്ടേൺ മൂല്യങ്ങൾ, തവണകളുടെ എണ്ണം എന്നിവ ഉപയോഗിച്ച് മോക്ക് ഫംഗ്ഷനുകൾ വിളിക്കപ്പെട്ടുവെന്ന് ഉറപ്പാക്കുക.
7. യഥാർത്ഥ പ്രവർത്തനം പുനഃസ്ഥാപിക്കുക: ടെസ്റ്റിന് ശേഷം, മോക്ക് ഒബ്ജക്റ്റുകൾ നീക്കംചെയ്ത് യഥാർത്ഥ ഡിപൻഡൻസികളിലേക്ക് മടങ്ങുന്നതിലൂടെ യഥാർത്ഥ പ്രവർത്തനം പുനഃസ്ഥാപിക്കുക. മറ്റ് ടെസ്റ്റുകളിൽ പാർശ്വഫലങ്ങൾ ഒഴിവാക്കാൻ ഇത് സഹായിക്കുന്നു.

വിവിധ ഭാഷകളിലെ മോക്ക് ഫംഗ്ഷൻ ഉദാഹരണങ്ങൾ

ജാവാസ്ക്രിപ്റ്റ്, ജെസ്റ്റ് ഉപയോഗിച്ച്

മോക്ക് ഫംഗ്ഷനുകൾക്കായി ബിൽറ്റ്-ഇൻ പിന്തുണ നൽകുന്ന ഒരു പ്രശസ്തമായ ജാവാസ്ക്രിപ്റ്റ് ടെസ്റ്റിംഗ് ഫ്രെയിംവർക്കാണ് ജെസ്റ്റ്.

            // Function to test
function fetchData(callback) {
  setTimeout(() => {
    callback('Data from server');
  }, 100);
}

// Test case
test('fetchData calls callback with correct data', (done) => {
  const mockCallback = jest.fn();
  fetchData(mockCallback);

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

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, `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) {
  // Simulate API call
  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 () => {
    // Mock the getUserDataFromAPI function
    const mockGetUserData = jest.spyOn(api, 'getUserDataFromAPI');
    mockGetUserData.mockResolvedValue({ id: 123, name: 'Mocked Name' });

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

    // Restore the original function
    mockGetUserData.mockRestore();
  });
});

            

              
                Copy
              
            
          

ഇവിടെ, `./api` മൊഡ്യൂളിൽ നിന്ന് ഇംപോർട്ട് ചെയ്ത `getUserDataFromAPI` ഫംഗ്ഷനായി ഒരു മോക്ക് ഫംഗ്ഷൻ ഉണ്ടാക്കാൻ `jest.spyOn` ഉപയോഗിക്കുന്നു. മോക്കിൻ്റെ റിട്ടേൺ മൂല്യം വ്യക്തമാക്കാൻ `mockResolvedValue` ഉപയോഗിക്കുന്നു. മറ്റ് ടെസ്റ്റുകൾ അബദ്ധത്തിൽ മോക്ക് ചെയ്ത പതിപ്പ് ഉപയോഗിക്കുന്നത് ഒഴിവാക്കാൻ `mockRestore` അത്യാവശ്യമാണ്.

പൈത്തൺ, പൈടെസ്റ്റ്, unittest.mock എന്നിവ ഉപയോഗിച്ച്

പൈത്തൺ മോക്കിംഗിനായി നിരവധി ലൈബ്രറികൾ വാഗ്ദാനം ചെയ്യുന്നു, `unittest.mock` (ബിൽറ്റ്-ഇൻ), പൈടെസ്റ്റിനൊപ്പം ലളിതമായ ഉപയോഗത്തിനായി `pytest-mock` പോലുള്ള ലൈബ്രറികൾ എന്നിവയുൾപ്പെടെ.

            # Function to test
def get_data_from_api(url):
    # In a real scenario, this would make an API call
    # For simplicity, we simulate an API call
    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"

# Test case using unittest.mock
import unittest
from unittest.mock import patch

class TestProcessData(unittest.TestCase):
    @patch('__main__.get_data_from_api') # Replace get_data_from_api in the main module
    def test_process_data_success(self, mock_get_data_from_api):
        # Configure the mock
        mock_get_data_from_api.return_value = {"data": "Mocked data"}

        # Call the function being tested
        result = process_data("https://example.com/api")

        # Assert the result
        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()

            

              
                Copy
              
            
          

ഈ ഉദാഹരണം `get_data_from_api` ഫംഗ്ഷനെ ഒരു മോക്ക് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാൻ `unittest.mock.patch` ഉപയോഗിക്കുന്നു. ഒരു നിർദ്ദിഷ്ട മൂല്യം തിരികെ നൽകാൻ ടെസ്റ്റ് മോക്കിനെ കോൺഫിഗർ ചെയ്യുന്നു, തുടർന്ന് `process_data` ഫംഗ്ഷൻ പ്രതീക്ഷിച്ച ഫലം നൽകുന്നുണ്ടോ എന്ന് ഉറപ്പാക്കുന്നു.

ഇവിടെ `pytest-mock` ഉപയോഗിച്ചുള്ള അതേ ഉദാഹരണം നൽകുന്നു:

            # pytest version
import pytest

def get_data_from_api(url):
    # In a real scenario, this would make an API call
    # For simplicity, we simulate an API call
    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"

            

              
                Copy
              
            
          

`pytest-mock` ലൈബ്രറി ഒരു `mocker` ഫിക്സ്ചർ നൽകുന്നു, ഇത് പൈടെസ്റ്റ് ടെസ്റ്റുകൾക്കുള്ളിൽ മോക്കുകളുടെ നിർമ്മാണവും കോൺഫിഗറേഷനും ലളിതമാക്കുന്നു.

ജാവ, മോക്കിറ്റോ ഉപയോഗിച്ച്

ജാവയ്ക്കുള്ള ഒരു പ്രശസ്തമായ മോക്കിംഗ് ഫ്രെയിംവർക്കാണ് മോക്കിറ്റോ.

            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() {
        // Create a mock DataFetcher
        DataFetcher mockDataFetcher = mock(DataFetcher.class);

        // Configure the mock
        when(mockDataFetcher.fetchData("https://example.com/api")).thenReturn("API Data");

        // Create the DataProcessor with the mock
        DataProcessor dataProcessor = new DataProcessor(mockDataFetcher);

        // Call the function being tested
        String result = dataProcessor.processData("https://example.com/api");

        // Assert the result
        assertEquals("Processed: API Data", result);

        // Verify that the mock was called
        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");
    }
}

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, `Mockito.mock()` `DataFetcher` ഇൻ്റർഫേസിനായി ഒരു മോക്ക് ഒബ്ജക്റ്റ് ഉണ്ടാക്കുന്നു. മോക്കിൻ്റെ റിട്ടേൺ മൂല്യം കോൺഫിഗർ ചെയ്യാൻ `when()` ഉപയോഗിക്കുന്നു, പ്രതീക്ഷിച്ച ആർഗ്യുമെൻ്റുകളോടെ മോക്ക് വിളിക്കപ്പെട്ടുവെന്ന് ഉറപ്പാക്കാൻ `verify()` ഉപയോഗിക്കുന്നു.

മോക്ക് ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നതിനുള്ള മികച്ച രീതികൾ

• മിതമായി മോക്ക് ചെയ്യുക: ശരിക്കും ബാഹ്യമോ കാര്യമായ സങ്കീർണ്ണത ഉണ്ടാക്കുന്നതോ ആയ ഡിപൻഡൻസികൾ മാത്രം മോക്ക് ചെയ്യുക. ഇംപ്ലിമെൻ്റേഷൻ വിശദാംശങ്ങൾ മോക്ക് ചെയ്യുന്നത് ഒഴിവാക്കുക.
• മോക്കുകൾ ലളിതമായി സൂക്ഷിക്കുക: നിങ്ങളുടെ ടെസ്റ്റുകളിൽ ബഗുകൾ ഉണ്ടാകാതിരിക്കാൻ മോക്ക് ഫംഗ്ഷനുകൾ കഴിയുന്നത്ര ലളിതമായിരിക്കണം.
• ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ ഉപയോഗിക്കുക: യഥാർത്ഥ ഡിപൻഡൻസികളെ മോക്ക് ഒബ്ജക്റ്റുകൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നത് എളുപ്പമാക്കാൻ ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ ഉപയോഗിക്കുക. ഡിപൻഡൻസികളെ വ്യക്തമാക്കുന്നതിനാൽ കൺസ്ട്രക്റ്റർ ഇഞ്ചക്ഷനാണ് അഭികാമ്യം.
• ഇടപെടലുകൾ പരിശോധിക്കുക: നിങ്ങൾ ടെസ്റ്റ് ചെയ്യുന്ന യൂണിറ്റ് പ്രതീക്ഷിച്ച രീതിയിൽ മോക്ക് ഫംഗ്ഷനുകളുമായി ഇടപഴകുന്നുണ്ടോ എന്ന് എപ്പോഴും പരിശോധിക്കുക.
• യഥാർത്ഥ പ്രവർത്തനം പുനഃസ്ഥാപിക്കുക: ഓരോ ടെസ്റ്റിനു ശേഷവും, മോക്ക് ഒബ്ജക്റ്റുകൾ നീക്കം ചെയ്ത് യഥാർത്ഥ ഡിപൻഡൻസികളിലേക്ക് മടങ്ങുന്നതിലൂടെ യഥാർത്ഥ പ്രവർത്തനം പുനഃസ്ഥാപിക്കുക.
• മോക്കുകൾ ഡോക്യുമെൻ്റ് ചെയ്യുക: നിങ്ങളുടെ മോക്ക് ഫംഗ്ഷനുകളുടെ ഉദ്ദേശ്യവും സ്വഭാവവും വിശദീകരിക്കാൻ അവ വ്യക്തമായി ഡോക്യുമെൻ്റ് ചെയ്യുക.
• അമിത-നിർവചനം ഒഴിവാക്കുക: ഓരോ ഇടപെടലിലും ഊന്നിപ്പറയരുത്, നിങ്ങൾ ടെസ്റ്റ് ചെയ്യുന്ന സ്വഭാവത്തിന് അത്യാവശ്യമായ പ്രധാന ഇടപെടലുകളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുക.
• ഇൻ്റഗ്രേഷൻ ടെസ്റ്റുകൾ പരിഗണിക്കുക: മോക്കുകളുള്ള യൂണിറ്റ് ടെസ്റ്റുകൾ പ്രധാനമാണെങ്കിലും, യഥാർത്ഥ ഘടകങ്ങൾ തമ്മിലുള്ള ഇടപെടലുകൾ ഉറപ്പാക്കുന്ന ഇൻ്റഗ്രേഷൻ ടെസ്റ്റുകൾ ഉപയോഗിച്ച് അവയെ പൂരകമാക്കാൻ ഓർമ്മിക്കുക.

മോക്ക് ഫംഗ്ഷനുകൾക്കുള്ള ബദലുകൾ

മോക്ക് ഫംഗ്ഷനുകൾ ഒരു ശക്തമായ ഉപകരണമാണെങ്കിലും, അവ എല്ലായ്പ്പോഴും മികച്ച പരിഹാരമല്ല. ചില സാഹചര്യങ്ങളിൽ, മറ്റ് ടെക്നിക്കുകൾ കൂടുതൽ അനുയോജ്യമായേക്കാം:

• സ്റ്റബ്സ്: സ്റ്റബ്സ് മോക്കുകളേക്കാൾ ലളിതമാണ്. അവ ഫംഗ്ഷൻ കോളുകൾക്ക് മുൻകൂട്ടി നിശ്ചയിച്ച പ്രതികരണങ്ങൾ നൽകുന്നു, പക്ഷേ ആ കോളുകൾ എങ്ങനെയാണ് നടത്തിയതെന്ന് സാധാരണയായി പരിശോധിക്കുന്നില്ല. നിങ്ങൾ ടെസ്റ്റ് ചെയ്യുന്ന യൂണിറ്റിലേക്കുള്ള ഇൻപുട്ട് മാത്രം നിയന്ത്രിക്കേണ്ടിവരുമ്പോൾ അവ ഉപയോഗപ്രദമാണ്.
• സ്പൈസ്: യഥാർത്ഥ ഫംഗ്ഷൻ അതിൻ്റെ യഥാർത്ഥ ലോജിക്ക് പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുമ്പോൾ തന്നെ അതിൻ്റെ സ്വഭാവം നിരീക്ഷിക്കാൻ സ്പൈസ് നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു ഫംഗ്ഷൻ്റെ പ്രവർത്തനം പൂർണ്ണമായും മാറ്റിസ്ഥാപിക്കാതെ, നിർദ്ദിഷ്ട ആർഗ്യുമെൻ്റുകളോടെയോ അല്ലെങ്കിൽ ഒരു നിശ്ചിത എണ്ണം തവണയോ വിളിക്കപ്പെട്ടുവെന്ന് ഉറപ്പാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ അവ ഉപയോഗപ്രദമാണ്.
• ഫേക്കുകൾ: ഫേക്കുകൾ ഒരു ഡിപൻഡൻസിയുടെ പ്രവർത്തിക്കുന്ന ഇംപ്ലിമെൻ്റേഷനുകളാണ്, പക്ഷേ ടെസ്റ്റിംഗ് ആവശ്യങ്ങൾക്കായി ലളിതമാക്കിയവയാണ്. ഒരു ഇൻ-മെമ്മറി ഡാറ്റാബേസ് ഒരു ഫേക്കിന് ഉദാഹരണമാണ്.
• ഇൻ്റഗ്രേഷൻ ടെസ്റ്റുകൾ: ഇൻ്റഗ്രേഷൻ ടെസ്റ്റുകൾ ഒന്നിലധികം ഘടകങ്ങൾ തമ്മിലുള്ള ഇടപെടലുകൾ പരിശോധിക്കുന്നു. ഒരു സിസ്റ്റത്തിൻ്റെ മൊത്തത്തിലുള്ള സ്വഭാവം ടെസ്റ്റ് ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ, മോക്കുകളുള്ള യൂണിറ്റ് ടെസ്റ്റുകൾക്ക് അവ ഒരു നല്ല ബദലാണ്.

ഉപസംഹാരം

യൂണിറ്റുകളെ വേർതിരിക്കാനും, സ്വഭാവം നിയന്ത്രിക്കാനും, എറർ സാഹചര്യങ്ങൾ അനുകരിക്കാനും, അസിൻക്രണസ് കോഡ് ടെസ്റ്റ് ചെയ്യാനും നിങ്ങളെ പ്രാപ്‌തമാക്കുന്ന, ഫലപ്രദമായ യൂണിറ്റ് ടെസ്റ്റുകൾ എഴുതുന്നതിനുള്ള ഒരു പ്രധാന ഉപകരണമാണ് മോക്ക് ഫംഗ്ഷനുകൾ. മികച്ച രീതികൾ പിന്തുടരുകയും ബദലുകൾ മനസ്സിലാക്കുകയും ചെയ്യുന്നതിലൂടെ, കൂടുതൽ കരുത്തുറ്റതും വിശ്വസനീയവും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ സോഫ്റ്റ്‌വെയർ നിർമ്മിക്കാൻ നിങ്ങൾക്ക് മോക്ക് ഫംഗ്ഷനുകൾ പ്രയോജനപ്പെടുത്താം. നിങ്ങൾ ലോകത്തിൻ്റെ ഏത് ഭാഗത്ത് നിന്നാണ് നിർമ്മിക്കുന്നതെന്നത് പരിഗണിക്കാതെ, സമഗ്രവും ഫലപ്രദവുമായ ഒരു ടെസ്റ്റിംഗ് സ്ട്രാറ്റജി ഉണ്ടാക്കുന്നതിനായി ഓരോ സാഹചര്യത്തിനും ശരിയായ ടെസ്റ്റിംഗ് ടെക്നിക്ക് തിരഞ്ഞെടുക്കാനും അതിൻ്റെ ഗുണദോഷങ്ങൾ പരിഗണിക്കാനും ഓർമ്മിക്കുക.