ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳು: ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ಒಂದು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ

ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ಜಗತ್ತಿನಲ್ಲಿ, ದೃಢವಾದ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಕೋಡ್ ಬರೆಯುವುದು ಅತ್ಯಂತ ಮುಖ್ಯವಾಗಿದೆ. ಈ ಗುರಿಯನ್ನು ಸಾಧಿಸಲು ಸಂಪೂರ್ಣ ಪರೀಕ್ಷೆಯು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ, ಯೂನಿಟ್ ಟೆಸ್ಟಿಂಗ್, ಪ್ರತ್ಯೇಕ ಕಾಂಪೊನೆಂಟ್‌ಗಳು ಅಥವಾ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಪರೀಕ್ಷಿಸುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಸಂಕೀರ್ಣ ಅವಲಂಬನೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ, ಇದು ಯೂನಿಟ್‌ಗಳನ್ನು ಸಂಪೂರ್ಣ ಪ್ರತ್ಯೇಕತೆಯಲ್ಲಿ ಪರೀಕ್ಷಿಸಲು ಸವಾಲಾಗಿ ಮಾಡುತ್ತದೆ. ಇಲ್ಲಿಯೇ ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳು ಬರುತ್ತವೆ.

ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳು ಎಂದರೇನು?

ಮಾಕ್ ಫಂಕ್ಷನ್ ಎನ್ನುವುದು ನಿಜವಾದ ಫಂಕ್ಷನ್‌ನ ಸಿಮ್ಯುಲೇಟೆಡ್ ಆವೃತ್ತಿಯಾಗಿದ್ದು, ಅದನ್ನು ನೀವು ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಬಳಸಬಹುದು. ನಿಜವಾದ ಫಂಕ್ಷನ್‌ನ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಬದಲು, ಮಾಕ್ ಫಂಕ್ಷನ್ ನಿಮಗೆ ಅದರ ನಡವಳಿಕೆಯನ್ನು ನಿಯಂತ್ರಿಸಲು, ಅದನ್ನು ಹೇಗೆ ಕರೆಯಲಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಲು ಮತ್ತು ಅದರ ರಿಟರ್ನ್ ಮೌಲ್ಯಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಅವು ಟೆಸ್ಟ್ ಡಬಲ್ ನ ಒಂದು ವಿಧವಾಗಿದೆ.

ಇದನ್ನು ಹೀಗೆ ಯೋಚಿಸಿ: ನೀವು ಕಾರಿನ ಇಂಜಿನ್ (ಪರೀಕ್ಷೆಯ ಅಡಿಯಲ್ಲಿರುವ ಘಟಕ) ಪರೀಕ್ಷಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಇಂಜಿನ್ ಇಂಧನ ಇಂಜೆಕ್ಷನ್ ಸಿಸ್ಟಮ್ ಮತ್ತು ಕೂಲಿಂಗ್ ಸಿಸ್ಟಮ್‌ನಂತಹ ವಿವಿಧ ಇತರ ಘಟಕಗಳನ್ನು ಅವಲಂಬಿಸಿದೆ. ಇಂಜಿನ್ ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ನಿಜವಾದ ಇಂಧನ ಇಂಜೆಕ್ಷನ್ ಮತ್ತು ಕೂಲಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ಚಲಾಯಿಸುವ ಬದಲು, ನೀವು ಅವುಗಳ ನಡವಳಿಕೆಯನ್ನು ಅನುಕರಿಸುವ ಮಾಕ್ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಇದು ಇಂಜಿನ್ ಅನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಮತ್ತು ನಿರ್ದಿಷ್ಟವಾಗಿ ಅದರ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳು ಇದಕ್ಕಾಗಿ ಶಕ್ತಿಯುತ ಸಾಧನಗಳಾಗಿವೆ:

• ಘಟಕಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುವುದು: ಒಂದೇ ಫಂಕ್ಷನ್ ಅಥವಾ ಕಾಂಪೊನೆಂಟ್‌ನ ನಡವಳಿಕೆಯ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಲು ಬಾಹ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು.
• ನಡವಳಿಕೆಯನ್ನು ನಿಯಂತ್ರಿಸುವುದು: ನಿರ್ದಿಷ್ಟ ರಿಟರ್ನ್ ಮೌಲ್ಯಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು, ಎರರ್‌ಗಳನ್ನು ಎಸೆಯುವುದು, ಅಥವಾ ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ಕಸ್ಟಮ್ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು.
• ಪರಸ್ಪರ ಕ್ರಿಯೆಗಳನ್ನು ಗಮನಿಸುವುದು: ಒಂದು ಫಂಕ್ಷನ್ ಅನ್ನು ಎಷ್ಟು ಬಾರಿ ಕರೆಯಲಾಗಿದೆ, ಅದು ಯಾವ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಪಡೆಯುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಯಾವ ಕ್ರಮದಲ್ಲಿ ಕರೆಯಲಾಗಿದೆ ಎಂಬುದನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು.
• ಎಡ್ಜ್ ಕೇಸ್‌ಗಳನ್ನು ಅನುಕರಿಸುವುದು: ನೈಜ ಪರಿಸರದಲ್ಲಿ ಪುನರುತ್ಪಾದಿಸಲು ಕಷ್ಟಕರವಾದ ಅಥವಾ ಅಸಾಧ್ಯವಾದ ಸನ್ನಿವೇಶಗಳನ್ನು (ಉದಾ., ನೆಟ್‌ವರ್ಕ್ ವೈಫಲ್ಯಗಳು, ಡೇಟಾಬೇಸ್ ದೋಷಗಳು) ಸುಲಭವಾಗಿ ರಚಿಸುವುದು.

ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಯಾವಾಗ ಬಳಸಬೇಕು

ಮಾಕ್‌ಗಳು ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ ಹೆಚ್ಚು ಉಪಯುಕ್ತವಾಗಿವೆ:

1. ಬಾಹ್ಯ ಅವಲಂಬನೆಗಳೊಂದಿಗೆ ಘಟಕಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುವುದು

ನಿಮ್ಮ ಪರೀಕ್ಷೆಯ ಅಡಿಯಲ್ಲಿರುವ ಘಟಕವು ಬಾಹ್ಯ ಸೇವೆಗಳು, ಡೇಟಾಬೇಸ್‌ಗಳು, APIಗಳು ಅಥವಾ ಇತರ ಘಟಕಗಳನ್ನು ಅವಲಂಬಿಸಿದಾಗ, ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ನೈಜ ಅವಲಂಬನೆಗಳನ್ನು ಬಳಸುವುದು ಹಲವಾರು ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು:

• ನಿಧಾನ ಪರೀಕ್ಷೆಗಳು: ನೈಜ ಅವಲಂಬನೆಗಳನ್ನು ಹೊಂದಿಸಲು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಧಾನವಾಗಬಹುದು, ಇದು ಪರೀಕ್ಷೆಯ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಹೆಚ್ಚಿಸುತ್ತದೆ.
• ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲದ ಪರೀಕ್ಷೆಗಳು: ಬಾಹ್ಯ ಅವಲಂಬನೆಗಳು ಅನಿರೀಕ್ಷಿತ ಮತ್ತು ವೈಫಲ್ಯಗಳಿಗೆ ಗುರಿಯಾಗಬಹುದು, ಇದು ಅಸ್ಥಿರ ಪರೀಕ್ಷೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
• ಸಂಕೀರ್ಣತೆ: ನೈಜ ಅವಲಂಬನೆಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ನಿಮ್ಮ ಪರೀಕ್ಷಾ ಸೆಟಪ್‌ಗೆ ಅನಗತ್ಯ ಸಂಕೀರ್ಣತೆಯನ್ನು ಸೇರಿಸಬಹುದು.
• ವೆಚ್ಚ: ಬಾಹ್ಯ ಸೇವೆಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಆಗಾಗ್ಗೆ ವೆಚ್ಚಗಳು ಉಂಟಾಗುತ್ತವೆ, ವಿಶೇಷವಾಗಿ ವ್ಯಾಪಕವಾದ ಪರೀಕ್ಷೆಗಾಗಿ.

ಉದಾಹರಣೆ: ನೀವು ರಿಮೋಟ್ API ನಿಂದ ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ಹಿಂಪಡೆಯುವ ಫಂಕ್ಷನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ನಿಜವಾದ API ಕರೆಗಳನ್ನು ಮಾಡುವ ಬದಲು, API ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಅನುಕರಿಸಲು ನೀವು ಮಾಕ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸಬಹುದು. ಇದು ಬಾಹ್ಯ API ನ ಲಭ್ಯತೆ ಅಥವಾ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅವಲಂಬಿಸದೆ ಫಂಕ್ಷನ್‌ನ ತರ್ಕವನ್ನು ಪರೀಕ್ಷಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. API ದರ ಮಿತಿಗಳನ್ನು ಹೊಂದಿರುವಾಗ ಅಥವಾ ಪ್ರತಿ ವಿನಂತಿಗೆ ಸಂಬಂಧಿಸಿದ ವೆಚ್ಚಗಳಿದ್ದಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ.

2. ಸಂಕೀರ್ಣ ಪರಸ್ಪರ ಕ್ರಿಯೆಗಳನ್ನು ಪರೀಕ್ಷಿಸುವುದು

ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ನಿಮ್ಮ ಪರೀಕ್ಷೆಯ ಅಡಿಯಲ್ಲಿರುವ ಘಟಕವು ಇತರ ಘಟಕಗಳೊಂದಿಗೆ ಸಂಕೀರ್ಣ ರೀತಿಯಲ್ಲಿ ಸಂವಹನ ನಡೆಸಬಹುದು. ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳು ಈ ಪರಸ್ಪರ ಕ್ರಿಯೆಗಳನ್ನು ಗಮನಿಸಲು ಮತ್ತು ಪರಿಶೀಲಿಸಲು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ.

ಉದಾಹರಣೆ: ಪಾವತಿ ವಹಿವಾಟುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಫಂಕ್ಷನ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ಈ ಫಂಕ್ಷನ್ ಪಾವತಿ ಗೇಟ್‌ವೇ, ಡೇಟಾಬೇಸ್ ಮತ್ತು ಅಧಿಸೂಚನೆ ಸೇವೆಯೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಬಹುದು. ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ಫಂಕ್ಷನ್ ಸರಿಯಾದ ವಹಿವಾಟು ವಿವರಗಳೊಂದಿಗೆ ಪಾವತಿ ಗೇಟ್‌ವೇಯನ್ನು ಕರೆಯುತ್ತದೆ, ವಹಿವಾಟಿನ ಸ್ಥಿತಿಯೊಂದಿಗೆ ಡೇಟಾಬೇಸ್ ಅನ್ನು ನವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಬಳಕೆದಾರರಿಗೆ ಅಧಿಸೂಚನೆಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ ಎಂದು ನೀವು ಪರಿಶೀಲಿಸಬಹುದು.

3. ದೋಷದ ಸ್ಥಿತಿಗಳನ್ನು ಅನುಕರಿಸುವುದು

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ದೃಢತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಪರೀಕ್ಷಿಸುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ನೈಜ ಪರಿಸರದಲ್ಲಿ ಪುನರುತ್ಪಾದಿಸಲು ಕಷ್ಟಕರವಾದ ಅಥವಾ ಅಸಾಧ್ಯವಾದ ದೋಷದ ಸ್ಥಿತಿಗಳನ್ನು ಅನುಕರಿಸಲು ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳು ಸುಲಭವಾಗಿಸುತ್ತವೆ.

ಉದಾಹರಣೆ: ನೀವು ಕ್ಲೌಡ್ ಸ್ಟೋರೇಜ್ ಸೇವೆಗೆ ಫೈಲ್‌ಗಳನ್ನು ಅಪ್‌ಲೋಡ್ ಮಾಡುವ ಫಂಕ್ಷನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸೋಣ. ಅಪ್‌ಲೋಡ್ ಪ್ರಕ್ರಿಯೆಯ ಸಮಯದಲ್ಲಿ ನೆಟ್‌ವರ್ಕ್ ದೋಷವನ್ನು ಅನುಕರಿಸಲು ನೀವು ಮಾಕ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸಬಹುದು. ಫಂಕ್ಷನ್ ದೋಷವನ್ನು ಸರಿಯಾಗಿ ನಿಭಾಯಿಸುತ್ತದೆ, ಅಪ್‌ಲೋಡ್ ಅನ್ನು ಮರುಪ್ರಯತ್ನಿಸುತ್ತದೆ ಅಥವಾ ಬಳಕೆದಾರರಿಗೆ ಸೂಚನೆ ನೀಡುತ್ತದೆ ಎಂದು ಪರಿಶೀಲಿಸಲು ಇದು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

4. ಅಸಿಂಕ್ರೋನಸ್ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವುದು

ಕಾಲ್ಬ್ಯಾಕ್‌ಗಳು, ಪ್ರಾಮಿಸಸ್, ಅಥವಾ async/await ಬಳಸುವ ಕೋಡ್‌ನಂತಹ ಅಸಿಂಕ್ರೋನಸ್ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುವುದು ಸವಾಲಿನದಾಗಿರಬಹುದು. ಅಸಿಂಕ್ರೋನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಸಮಯ ಮತ್ತು ನಡವಳಿಕೆಯನ್ನು ನಿಯಂತ್ರಿಸಲು ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಬಹುದು.

ಉದಾಹರಣೆ: ನೀವು ಅಸಿಂಕ್ರೋನಸ್ ವಿನಂತಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಸರ್ವರ್‌ನಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯುವ ಫಂಕ್ಷನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುತ್ತಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಸರ್ವರ್ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಅನುಕರಿಸಲು ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಯಾವಾಗ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನಿಯಂತ್ರಿಸಲು ನೀವು ಮಾಕ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸಬಹುದು. ಫಂಕ್ಷನ್ ವಿವಿಧ ಪ್ರತಿಕ್ರಿಯೆ ಸನ್ನಿವೇಶಗಳು ಮತ್ತು ಟೈಮ್‌ಔಟ್‌ಗಳನ್ನು ಹೇಗೆ ನಿಭಾಯಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಪರೀಕ್ಷಿಸಲು ಇದು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

5. ಅನಪೇಕ್ಷಿತ ಅಡ್ಡ ಪರಿಣಾಮಗಳನ್ನು ತಡೆಯುವುದು

ಕೆಲವೊಮ್ಮೆ, ಪರೀಕ್ಷೆಯ ಸಮಯದಲ್ಲಿ ನಿಜವಾದ ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆಯುವುದು ಡೇಟಾಬೇಸ್ ಅನ್ನು ಮಾರ್ಪಡಿಸುವುದು, ಇಮೇಲ್‌ಗಳನ್ನು ಕಳುಹಿಸುವುದು, ಅಥವಾ ಬಾಹ್ಯ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪ್ರಚೋದಿಸುವಂತಹ ಅನಪೇಕ್ಷಿತ ಅಡ್ಡ ಪರಿಣಾಮಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು. ನೈಜ ಫಂಕ್ಷನ್ ಅನ್ನು ನಿಯಂತ್ರಿತ ಸಿಮ್ಯುಲೇಶನ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಮೂಲಕ ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳು ಈ ಅಡ್ಡ ಪರಿಣಾಮಗಳನ್ನು ತಡೆಯುತ್ತವೆ.

ಉದಾಹರಣೆ: ನೀವು ಹೊಸ ಬಳಕೆದಾರರಿಗೆ ಸ್ವಾಗತ ಇಮೇಲ್‌ಗಳನ್ನು ಕಳುಹಿಸುವ ಫಂಕ್ಷನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸುತ್ತಿದ್ದೀರಿ. ಮಾಕ್ ಇಮೇಲ್ ಸೇವೆಯನ್ನು ಬಳಸಿಕೊಂಡು, ನಿಮ್ಮ ಪರೀಕ್ಷಾ ಸ್ಯೂಟ್ ಚಾಲನೆಯ ಸಮಯದಲ್ಲಿ ಇಮೇಲ್ ಕಳುಹಿಸುವ ಕಾರ್ಯವು ನಿಜವಾದ ಬಳಕೆದಾರರಿಗೆ ಇಮೇಲ್‌ಗಳನ್ನು ಕಳುಹಿಸುವುದಿಲ್ಲ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು. ಬದಲಾಗಿ, ಫಂಕ್ಷನ್ ಸರಿಯಾದ ಮಾಹಿತಿಯೊಂದಿಗೆ ಇಮೇಲ್ ಕಳುಹಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಎಂದು ನೀವು ಪರಿಶೀಲಿಸಬಹುದು.

ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬಳಸುವುದು ಹೇಗೆ

ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬಳಸುವ ನಿರ್ದಿಷ್ಟ ಹಂತಗಳು ನೀವು ಬಳಸುತ್ತಿರುವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಮತ್ತು ಟೆಸ್ಟಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಸಾಮಾನ್ಯ ಪ್ರಕ್ರಿಯೆಯು ಸಾಮಾನ್ಯವಾಗಿ ಈ ಕೆಳಗಿನ ಹಂತಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ:

1. ಅವಲಂಬನೆಗಳನ್ನು ಗುರುತಿಸಿ: ನೀವು ಯಾವ ಬಾಹ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ಮಾಕ್ ಮಾಡಬೇಕೆಂದು ನಿರ್ಧರಿಸಿ.
2. ಮಾಕ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಿ: ನೈಜ ಅವಲಂಬನೆಗಳನ್ನು ಬದಲಾಯಿಸಲು ಮಾಕ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಅಥವಾ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ರಚಿಸಿ. ಈ ಮಾಕ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ `called`, `returnValue`, ಮತ್ತು `callArguments` ನಂತಹ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.
3. ಮಾಕ್ ನಡವಳಿಕೆಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ: ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳ ನಡವಳಿಕೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ, ಉದಾಹರಣೆಗೆ ಅವುಗಳ ರಿಟರ್ನ್ ಮೌಲ್ಯಗಳು, ದೋಷದ ಸ್ಥಿತಿಗಳು ಮತ್ತು ಕರೆಗಳ ಸಂಖ್ಯೆ.
4. ಮಾಕ್‌ಗಳನ್ನು ಇಂಜೆಕ್ಟ್ ಮಾಡಿ: ನಿಮ್ಮ ಪರೀಕ್ಷೆಯ ಅಡಿಯಲ್ಲಿರುವ ಘಟಕದಲ್ಲಿ ನೈಜ ಅವಲಂಬನೆಗಳನ್ನು ಮಾಕ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸಿ. ಇದನ್ನು ಹೆಚ್ಚಾಗಿ ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಬಳಸಿ ಮಾಡಲಾಗುತ್ತದೆ.
5. ಪರೀಕ್ಷೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ: ನಿಮ್ಮ ಪರೀಕ್ಷೆಯನ್ನು ಚಲಾಯಿಸಿ ಮತ್ತು ಪರೀಕ್ಷೆಯ ಅಡಿಯಲ್ಲಿರುವ ಘಟಕವು ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳೊಂದಿಗೆ ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
6. ಪರಸ್ಪರ ಕ್ರಿಯೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿ: ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ನಿರೀಕ್ಷಿತ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು, ರಿಟರ್ನ್ ಮೌಲ್ಯಗಳು ಮತ್ತು ಕರೆಗಳ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಕರೆಯಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ.
7. ಮೂಲ ಕಾರ್ಯವನ್ನು ಮರುಸ್ಥಾಪಿಸಿ: ಪರೀಕ್ಷೆಯ ನಂತರ, ಮಾಕ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕಿ ಮತ್ತು ನೈಜ ಅವಲಂಬನೆಗಳಿಗೆ ಹಿಂತಿರುಗುವ ಮೂಲಕ ಮೂಲ ಕಾರ್ಯವನ್ನು ಮರುಸ್ಥಾಪಿಸಿ. ಇದು ಇತರ ಪರೀಕ್ಷೆಗಳ ಮೇಲೆ ಅಡ್ಡ ಪರಿಣಾಮಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ವಿವಿಧ ಭಾಷೆಗಳಲ್ಲಿ ಮಾಕ್ ಫಂಕ್ಷನ್ ಉದಾಹರಣೆಗಳು

ಇಲ್ಲಿ ಜನಪ್ರಿಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಮತ್ತು ಟೆಸ್ಟಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳಲ್ಲಿ ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳಿವೆ:

JavaScript ಜೆಸ್ಟ್ (Jest) ಜೊತೆಗೆ

ಜೆಸ್ಟ್ (Jest) ಒಂದು ಜನಪ್ರಿಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೆಸ್ಟಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದ್ದು, ಇದು ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಅಂತರ್ನಿರ್ಮಿತ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ.

// 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` ಅತ್ಯಗತ್ಯ.

ಪೈಥಾನ್, pytest ಮತ್ತು unittest.mock ಜೊತೆಗೆ

ಪೈಥಾನ್ ಮಾಕಿಂಗ್‌ಗಾಗಿ ಹಲವಾರು ಲೈಬ್ರರಿಗಳನ್ನು ನೀಡುತ್ತದೆ, ಇದರಲ್ಲಿ `unittest.mock` (ಅಂತರ್ನಿರ್ಮಿತ) ಮತ್ತು pytest ನೊಂದಿಗೆ ಸರಳೀಕೃತ ಬಳಕೆಗಾಗಿ `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` ಫಿಕ್ಸ್ಚರ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು pytest ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಮಾಕ್‌ಗಳ ರಚನೆ ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.

ಜಾವಾ, Mockito ಜೊತೆಗೆ

Mockito ಜಾವಾಕ್ಕಾಗಿ ಒಂದು ಜನಪ್ರಿಯ ಮಾಕಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದೆ.

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()` ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

• ವಿರಳವಾಗಿ ಮಾಕ್ ಮಾಡಿ: ನಿಜವಾಗಿಯೂ ಬಾಹ್ಯವಾಗಿರುವ ಅಥವಾ ಗಮನಾರ್ಹ ಸಂಕೀರ್ಣತೆಯನ್ನು ಪರಿಚಯಿಸುವ ಅವಲಂಬನೆಗಳನ್ನು ಮಾತ್ರ ಮಾಕ್ ಮಾಡಿ. ಅನುಷ್ಠಾನದ ವಿವರಗಳನ್ನು ಮಾಕ್ ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸಿ.
• ಮಾಕ್‌ಗಳನ್ನು ಸರಳವಾಗಿಡಿ: ನಿಮ್ಮ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಬಗ್‌ಗಳನ್ನು ಪರಿಚಯಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳು ಸಾಧ್ಯವಾದಷ್ಟು ಸರಳವಾಗಿರಬೇಕು.
• ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಬಳಸಿ: ನೈಜ ಅವಲಂಬನೆಗಳನ್ನು ಮಾಕ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸುವುದನ್ನು ಸುಲಭಗೊಳಿಸಲು ಡಿಪೆಂಡೆನ್ಸಿ ಇಂಜೆಕ್ಷನ್ ಬಳಸಿ. ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಇಂಜೆಕ್ಷನ್‌ಗೆ ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ ಅದು ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಪಷ್ಟಪಡಿಸುತ್ತದೆ.
• ಪರಸ್ಪರ ಕ್ರಿಯೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿ: ನಿಮ್ಮ ಪರೀಕ್ಷೆಯ ಅಡಿಯಲ್ಲಿರುವ ಘಟಕವು ನಿರೀಕ್ಷಿತ ರೀತಿಯಲ್ಲಿ ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತದೆ ಎಂದು ಯಾವಾಗಲೂ ಪರಿಶೀಲಿಸಿ.
• ಮೂಲ ಕಾರ್ಯವನ್ನು ಮರುಸ್ಥಾಪಿಸಿ: ಪ್ರತಿ ಪರೀಕ್ಷೆಯ ನಂತರ, ಮಾಕ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕಿ ಮತ್ತು ನೈಜ ಅವಲಂಬನೆಗಳಿಗೆ ಹಿಂತಿರುಗುವ ಮೂಲಕ ಮೂಲ ಕಾರ್ಯವನ್ನು ಮರುಸ್ಥಾಪಿಸಿ.
• ಮಾಕ್‌ಗಳನ್ನು ದಾಖಲಿಸಿ: ನಿಮ್ಮ ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳ ಉದ್ದೇಶ ಮತ್ತು ನಡವಳಿಕೆಯನ್ನು ವಿವರಿಸಲು ಅವುಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ದಾಖಲಿಸಿ.
• ಅತಿಯಾದ ನಿರ್ದಿಷ್ಟತೆಯನ್ನು ತಪ್ಪಿಸಿ: ಪ್ರತಿಯೊಂದು ಸಂವಹನದ ಮೇಲೆಯೂ ಖಚಿತಪಡಿಸಬೇಡಿ, ನೀವು ಪರೀಕ್ಷಿಸುತ್ತಿರುವ ನಡವಳಿಕೆಗೆ ಅತ್ಯಗತ್ಯವಾದ ಪ್ರಮುಖ ಸಂವಹನಗಳ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಿ.
• ಇಂಟಿಗ್ರೇಷನ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಪರಿಗಣಿಸಿ: ಮಾಕ್‌ಗಳೊಂದಿಗೆ ಯೂನಿಟ್ ಪರೀಕ್ಷೆಗಳು ಮುಖ್ಯವಾಗಿದ್ದರೂ, ನೈಜ ಘಟಕಗಳ ನಡುವಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಇಂಟಿಗ್ರೇಷನ್ ಪರೀಕ್ಷೆಗಳೊಂದಿಗೆ ಅವುಗಳನ್ನು ಪೂರಕಗೊಳಿಸಲು ಮರೆಯದಿರಿ.

ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಪರ್ಯಾಯಗಳು

ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳು ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿದ್ದರೂ, ಅವು ಯಾವಾಗಲೂ ಉತ್ತಮ ಪರಿಹಾರವಾಗಿರುವುದಿಲ್ಲ. ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಇತರ ತಂತ್ರಗಳು ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿರಬಹುದು:

• Stubs: ಸ್ಟಬ್‌ಗಳು ಮಾಕ್‌ಗಳಿಗಿಂತ ಸರಳವಾಗಿವೆ. ಅವು ಫಂಕ್ಷನ್ ಕರೆಗಳಿಗೆ ಪೂರ್ವನಿರ್ಧರಿತ ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ, ಆದರೆ ಆ ಕರೆಗಳನ್ನು ಹೇಗೆ ಮಾಡಲಾಗಿದೆ ಎಂಬುದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಪರಿಶೀಲಿಸುವುದಿಲ್ಲ. ನಿಮ್ಮ ಪರೀಕ್ಷೆಯ ಅಡಿಯಲ್ಲಿರುವ ಘಟಕಕ್ಕೆ ಇನ್‌ಪುಟ್ ಅನ್ನು ನಿಯಂತ್ರಿಸಬೇಕಾದಾಗ ಇವು ಉಪಯುಕ್ತವಾಗಿವೆ.
• Spies: ಸ್ಪೈಗಳು ನೈಜ ಫಂಕ್ಷನ್‌ನ ಮೂಲ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅನುಮತಿಸುವಾಗ ಅದರ ನಡವಳಿಕೆಯನ್ನು ಗಮನಿಸಲು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ. ಒಂದು ಫಂಕ್ಷನ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳೊಂದಿಗೆ ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಬಾರಿ ಕರೆಯಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ನೀವು ಬಯಸಿದಾಗ, ಅದರ ಕಾರ್ಯವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬದಲಾಯಿಸದೆ, ಇವು ಉಪಯುಕ್ತವಾಗಿವೆ.
• Fakes: ಫೇಕ್‌ಗಳು ಒಂದು ಅವಲಂಬನೆಯ ಕಾರ್ಯನಿರ್ವಹಣೆಯ ಅನುಷ್ಠಾನಗಳಾಗಿವೆ, ಆದರೆ ಪರೀಕ್ಷೆಯ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಸರಳೀಕರಿಸಲಾಗಿದೆ. ಇನ್-ಮೆಮೊರಿ ಡೇಟಾಬೇಸ್ ಫೇಕ್‌ಗೆ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.
• ಇಂಟಿಗ್ರೇಷನ್ ಪರೀಕ್ಷೆಗಳು: ಇಂಟಿಗ್ರೇಷನ್ ಪರೀಕ್ಷೆಗಳು ಬಹು ಘಟಕಗಳ ನಡುವಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತವೆ. ನೀವು ಒಂದು ಸಿಸ್ಟಮ್‌ನ ನಡವಳಿಕೆಯನ್ನು ಒಟ್ಟಾರೆಯಾಗಿ ಪರೀಕ್ಷಿಸಲು ಬಯಸಿದಾಗ, ಮಾಕ್‌ಗಳೊಂದಿಗೆ ಯೂನಿಟ್ ಪರೀಕ್ಷೆಗಳಿಗೆ ಇವು ಉತ್ತಮ ಪರ್ಯಾಯವಾಗಿರಬಹುದು.

ತೀರ್ಮಾನ

ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳು ಪರಿಣಾಮಕಾರಿ ಯೂನಿಟ್ ಪರೀಕ್ಷೆಗಳನ್ನು ಬರೆಯಲು ಅತ್ಯಗತ್ಯ ಸಾಧನವಾಗಿದ್ದು, ಘಟಕಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು, ನಡವಳಿಕೆಯನ್ನು ನಿಯಂತ್ರಿಸಲು, ದೋಷದ ಸ್ಥಿತಿಗಳನ್ನು ಅನುಕರಿಸಲು ಮತ್ತು ಅಸಿಂಕ್ರೋನಸ್ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ ಮತ್ತು ಪರ್ಯಾಯಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಹೆಚ್ಚು ದೃಢವಾದ, ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಮಾಕ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. ನೀವು ಜಗತ್ತಿನ ಯಾವುದೇ ಭಾಗದಿಂದ ನಿರ್ಮಿಸುತ್ತಿದ್ದರೂ, ಸಮಗ್ರ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಪರೀಕ್ಷಾ ತಂತ್ರವನ್ನು ರಚಿಸಲು, ಪ್ರತಿ ಸನ್ನಿವೇಶಕ್ಕೂ ಸರಿಯಾದ ಪರೀಕ್ಷಾ ತಂತ್ರವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಮತ್ತು ಅದರ ಸಾಧಕ-ಬಾಧಕಗಳನ್ನು ಪರಿಗಣಿಸಲು ಮರೆಯದಿರಿ.