M

MLOG

മലയാളം

ശക്തവും വിശ്വസനീയവുമായ സോഫ്റ്റ്‌വെയർ ഡെവലപ്‌മെൻ്റിനായി നിങ്ങളുടെ ടെസ്റ്റിംഗ് സ്ട്രാറ്റജിയിൽ മോക്ക് ഫംഗ്ഷനുകൾ എങ്ങനെ ഫലപ്രദമായി ഉപയോഗിക്കാമെന്ന് മനസിലാക്കുക. എപ്പോൾ, എന്തുകൊണ്ട്, എങ്ങനെ മോക്കുകൾ നടപ്പിലാക്കാമെന്ന് ഈ ഗൈഡ് പ്രായോഗിക ഉദാഹരണങ്ങളിലൂടെ വ്യക്തമാക്കുന്നു.

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

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

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

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

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

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

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

ഈ സാഹചര്യങ്ങളിൽ മോക്കുകൾ ഏറ്റവും ഉപയോഗപ്രദമാണ്:

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);
});

ഈ ഉദാഹരണത്തിൽ, `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();
  });
});

ഇവിടെ, `./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()

ഈ ഉദാഹരണം `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"

`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");
    }
}

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

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

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

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

ഉപസംഹാരം

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