దృఢమైన మరియు నమ్మకమైన సాఫ్ట్‌వేర్ అభివృద్ధి కోసం మీ టెస్టింగ్ వ్యూహంలో మాక్ ఫంక్షన్‌లను ఎలా సమర్థవంతంగా ఉపయోగించాలో తెలుసుకోండి. ఈ గైడ్ ఆచరణాత్మక ఉదాహరణలతో మాక్‌లను ఎప్పుడు, ఎందుకు, మరియు ఎలా అమలు చేయాలో వివరిస్తుంది.
మాక్ ఫంక్షన్‌లు: డెవలపర్‌ల కోసం ఒక సమగ్ర గైడ్
సాఫ్ట్‌వేర్ అభివృద్ధి ప్రపంచంలో, దృఢమైన మరియు నమ్మకమైన కోడ్ రాయడం చాలా ముఖ్యం. ఈ లక్ష్యాన్ని సాధించడానికి సమగ్రమైన టెస్టింగ్ చాలా కీలకం. ముఖ్యంగా, యూనిట్ టెస్టింగ్ అనేది వ్యక్తిగత కాంపోనెంట్లను లేదా ఫంక్షన్‌లను విడిగా టెస్ట్ చేయడంపై దృష్టి పెడుతుంది. అయితే, వాస్తవ-ప్రపంచ అప్లికేషన్‌లు తరచుగా సంక్లిష్టమైన డిపెండెన్సీలను కలిగి ఉంటాయి, ఇది యూనిట్లను పూర్తిగా విడిగా టెస్ట్ చేయడాన్ని సవాలుగా మారుస్తుంది. ఇక్కడే మాక్ ఫంక్షన్‌లు ఉపయోగపడతాయి.
మాక్ ఫంక్షన్‌లు అంటే ఏమిటి?
మాక్ ఫంక్షన్ అనేది మీ టెస్ట్‌లలో మీరు ఉపయోగించగల నిజమైన ఫంక్షన్ యొక్క అనుకరణ వెర్షన్. అసలు ఫంక్షన్ యొక్క లాజిక్‌ను అమలు చేయడానికి బదులుగా, మాక్ ఫంక్షన్ దాని ప్రవర్తనను నియంత్రించడానికి, అది ఎలా కాల్ చేయబడుతుందో గమనించడానికి, మరియు దాని రిటర్న్ విలువలను నిర్వచించడానికి మిమ్మల్ని అనుమతిస్తుంది. అవి ఒక రకమైన టెస్ట్ డబుల్.
ఇలా ఆలోచించండి: మీరు ఒక కారు ఇంజిన్‌ను (టెస్ట్ చేయబడుతున్న యూనిట్) టెస్ట్ చేస్తున్నారని ఊహించుకోండి. ఇంజిన్ ఫ్యూయల్ ఇంజెక్షన్ సిస్టమ్ మరియు కూలింగ్ సిస్టమ్ వంటి వివిధ ఇతర కాంపోనెంట్లపై ఆధారపడి ఉంటుంది. ఇంజిన్ టెస్ట్ సమయంలో అసలైన ఫ్యూయల్ ఇంజెక్షన్ మరియు కూలింగ్ సిస్టమ్‌లను నడపడానికి బదులుగా, మీరు వాటి ప్రవర్తనను అనుకరించే మాక్ సిస్టమ్‌లను ఉపయోగించవచ్చు. ఇది ఇంజిన్‌ను విడదీసి, ప్రత్యేకంగా దాని పనితీరుపై దృష్టి పెట్టడానికి మిమ్మల్ని అనుమతిస్తుంది.
మాక్ ఫంక్షన్‌లు వీటికి శక్తివంతమైన సాధనాలు:
- యూనిట్లను విడదీయడం: ఒకే ఫంక్షన్ లేదా కాంపోనెంట్ యొక్క ప్రవర్తనపై దృష్టి పెట్టడానికి బాహ్య డిపెండెన్సీలను తొలగించడం.
- ప్రవర్తనను నియంత్రించడం: టెస్టింగ్ సమయంలో నిర్దిష్ట రిటర్న్ విలువలను నిర్వచించడం, ఎర్రర్‌లను త్రో చేయడం లేదా కస్టమ్ లాజిక్‌ను అమలు చేయడం.
- ఇంటరాక్షన్‌లను గమనించడం: ఒక ఫంక్షన్ ఎన్నిసార్లు కాల్ చేయబడింది, దానికి ఏ ఆర్గ్యుమెంట్లు అందాయి, మరియు అది ఏ క్రమంలో కాల్ చేయబడింది అని ట్రాక్ చేయడం.
- ఎడ్జ్ కేసులను అనుకరించడం: నిజమైన వాతావరణంలో పునరుత్పత్తి చేయడం కష్టంగా లేదా అసాధ్యంగా ఉండే దృశ్యాలను (ఉదా., నెట్‌వర్క్ వైఫల్యాలు, డేటాబేస్ ఎర్రర్‌లు) సులభంగా సృష్టించడం.
మాక్ ఫంక్షన్‌లను ఎప్పుడు ఉపయోగించాలి
ఈ పరిస్థితులలో మాక్‌లు చాలా ఉపయోగకరంగా ఉంటాయి:1. బాహ్య డిపెండెన్సీలతో యూనిట్లను విడదీయడం
మీరు టెస్ట్ చేస్తున్న యూనిట్ బాహ్య సేవలు, డేటాబేస్‌లు, APIలు లేదా ఇతర కాంపోనెంట్లపై ఆధారపడినప్పుడు, టెస్టింగ్ సమయంలో నిజమైన డిపెండెన్సీలను ఉపయోగించడం వలన అనేక సమస్యలు తలెత్తవచ్చు:
- నెమ్మదిగా ఉండే టెస్ట్‌లు: నిజమైన డిపెండెన్సీలను సెటప్ చేయడానికి మరియు అమలు చేయడానికి నెమ్మదిగా ఉండవచ్చు, ఇది టెస్ట్ ఎగ్జిక్యూషన్ సమయాన్ని గణనీయంగా పెంచుతుంది.
- నమ్మదగని టెస్ట్‌లు: బాహ్య డిపెండెన్సీలు అనూహ్యంగా మరియు వైఫల్యాలకు గురయ్యే అవకాశం ఉంది, ఇది ఫ్లేకీ టెస్ట్‌లకు దారితీస్తుంది.
- సంక్లిష్టత: నిజమైన డిపెండెన్సీలను నిర్వహించడం మరియు కాన్ఫిగర్ చేయడం మీ టెస్ట్ సెటప్‌కు అనవసరమైన సంక్లిష్టతను జోడించగలదు.
- ఖర్చు: బాహ్య సేవలను ఉపయోగించడం వలన తరచుగా ఖర్చులు ఉంటాయి, ముఖ్యంగా విస్తృతమైన టెస్టింగ్ కోసం.
ఉదాహరణ: మీరు రిమోట్ API నుండి యూజర్ డేటాను పొందే ఒక ఫంక్షన్‌ను టెస్ట్ చేస్తున్నారని ఊహించుకోండి. టెస్టింగ్ సమయంలో వాస్తవ API కాల్స్ చేయడానికి బదులుగా, మీరు API స్పందనను అనుకరించడానికి ఒక మాక్ ఫంక్షన్‌ను ఉపయోగించవచ్చు. ఇది బాహ్య API లభ్యత లేదా పనితీరుపై ఆధారపడకుండా ఫంక్షన్ యొక్క లాజిక్‌ను టెస్ట్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. APIకి రేట్ పరిమితులు లేదా ప్రతి అభ్యర్థనకు సంబంధిత ఖర్చులు ఉన్నప్పుడు ఇది చాలా ముఖ్యం.
2. సంక్లిష్ట ఇంటరాక్షన్‌లను టెస్ట్ చేయడం
కొన్ని సందర్భాల్లో, మీరు టెస్ట్ చేస్తున్న యూనిట్ ఇతర కాంపోనెంట్లతో సంక్లిష్ట మార్గాల్లో ఇంటరాక్ట్ కావచ్చు. మాక్ ఫంక్షన్‌లు ఈ ఇంటరాక్షన్‌లను గమనించి, ధృవీకరించడానికి మిమ్మల్ని అనుమతిస్తాయి.
ఉదాహరణ: చెల్లింపు లావాదేవీలను ప్రాసెస్ చేసే ఫంక్షన్‌ను పరిగణించండి. ఈ ఫంక్షన్ పేమెంట్ గేట్‌వే, డేటాబేస్, మరియు నోటిఫికేషన్ సేవతో ఇంటరాక్ట్ కావచ్చు. మాక్ ఫంక్షన్‌లను ఉపయోగించి, ఫంక్షన్ సరైన లావాదేవీ వివరాలతో పేమెంట్ గేట్‌వేని కాల్ చేసిందని, లావాదేవీ స్థితితో డేటాబేస్‌ను అప్‌డేట్ చేసిందని, మరియు యూజర్‌కు నోటిఫికేషన్ పంపిందని మీరు ధృవీకరించవచ్చు.
3. ఎర్రర్ పరిస్థితులను అనుకరించడం
మీ అప్లికేషన్ యొక్క దృఢత్వాన్ని నిర్ధారించడానికి ఎర్రర్ హ్యాండ్లింగ్‌ను టెస్ట్ చేయడం చాలా ముఖ్యం. మాక్ ఫంక్షన్‌లు నిజమైన వాతావరణంలో పునరుత్పత్తి చేయడం కష్టంగా లేదా అసాధ్యంగా ఉండే ఎర్రర్ పరిస్థితులను అనుకరించడాన్ని సులభతరం చేస్తాయి.
ఉదాహరణ: మీరు క్లౌడ్ స్టోరేజ్ సర్వీస్‌కు ఫైల్‌లను అప్‌లోడ్ చేసే ఫంక్షన్‌ను టెస్ట్ చేస్తున్నారని అనుకుందాం. అప్‌లోడ్ ప్రక్రియలో నెట్‌వర్క్ ఎర్రర్‌ను అనుకరించడానికి మీరు ఒక మాక్ ఫంక్షన్‌ను ఉపయోగించవచ్చు. ఇది ఫంక్షన్ ఎర్రర్‌ను సరిగ్గా హ్యాండిల్ చేసిందా, అప్‌లోడ్‌ను మళ్లీ ప్రయత్నించిందా, లేదా యూజర్‌కు తెలియజేసిందా అని ధృవీకరించడానికి మిమ్మల్ని అనుమతిస్తుంది.
4. అసమకాలిక కోడ్‌ను టెస్ట్ చేయడం
కాల్‌బ్యాక్‌లు, ప్రామిస్‌లు లేదా async/await ఉపయోగించే కోడ్ వంటి అసమకాలిక కోడ్‌ను టెస్ట్ చేయడం సవాలుగా ఉంటుంది. మాక్ ఫంక్షన్‌లు అసమకాలిక ఆపరేషన్‌ల టైమింగ్ మరియు ప్రవర్తనను నియంత్రించడంలో మీకు సహాయపడతాయి.
ఉదాహరణ: మీరు అసమకాలిక అభ్యర్థనను ఉపయోగించి సర్వర్ నుండి డేటాను పొందే ఫంక్షన్‌ను టెస్ట్ చేస్తున్నారని ఊహించుకోండి. మీరు సర్వర్ స్పందనను అనుకరించడానికి మరియు స్పందన ఎప్పుడు తిరిగి వస్తుందో నియంత్రించడానికి ఒక మాక్ ఫంక్షన్‌ను ఉపయోగించవచ్చు. ఇది ఫంక్షన్ వివిధ స్పందన దృశ్యాలను మరియు టైమ్‌అవుట్‌లను ఎలా హ్యాండిల్ చేస్తుందో టెస్ట్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.
5. అనుకోని సైడ్ ఎఫెక్ట్‌లను నివారించడం
కొన్నిసార్లు, టెస్టింగ్ సమయంలో నిజమైన ఫంక్షన్‌ను కాల్ చేయడం వలన డేటాబేస్‌ను మార్చడం, ఈమెయిల్‌లు పంపడం లేదా బాహ్య ప్రక్రియలను ట్రిగ్గర్ చేయడం వంటి అనుకోని సైడ్ ఎఫెక్ట్‌లు ఉండవచ్చు. మాక్ ఫంక్షన్‌లు నిజమైన ఫంక్షన్‌ను నియంత్రిత అనుకరణతో భర్తీ చేయడం ద్వారా ఈ సైడ్ ఎఫెక్ట్‌లను నివారిస్తాయి.
ఉదాహరణ: మీరు కొత్త యూజర్‌లకు స్వాగత ఈమెయిల్‌లను పంపే ఫంక్షన్‌ను టెస్ట్ చేస్తున్నారు. మాక్ ఈమెయిల్ సర్వీస్‌ను ఉపయోగించి, మీ టెస్ట్ సూట్ రన్ సమయంలో ఈమెయిల్ పంపే ఫంక్షనాలిటీ నిజమైన యూజర్‌లకు ఈమెయిల్‌లను పంపకుండా మీరు నిర్ధారించుకోవచ్చు. బదులుగా, ఫంక్షన్ సరైన సమాచారంతో ఈమెయిల్ పంపడానికి ప్రయత్నించిందని మీరు ధృవీకరించవచ్చు.
మాక్ ఫంక్షన్‌లను ఎలా ఉపయోగించాలి
మాక్ ఫంక్షన్‌లను ఉపయోగించడానికి నిర్దిష్ట దశలు మీరు ఉపయోగిస్తున్న ప్రోగ్రామింగ్ భాష మరియు టెస్టింగ్ ఫ్రేమ్‌వర్క్‌పై ఆధారపడి ఉంటాయి. అయితే, సాధారణ ప్రక్రియలో సాధారణంగా ఈ క్రింది దశలు ఉంటాయి:
- డిపెండెన్సీలను గుర్తించండి: మీరు ఏ బాహ్య డిపెండెన్సీలను మాక్ చేయాలో నిర్ణయించండి.
- మాక్ ఆబ్జెక్ట్‌లను సృష్టించండి: నిజమైన డిపెండెన్సీలను భర్తీ చేయడానికి మాక్ ఆబ్జెక్ట్‌లు లేదా ఫంక్షన్‌లను సృష్టించండి. ఈ మాక్‌లలో తరచుగా `called`, `returnValue`, మరియు `callArguments` వంటి ప్రాపర్టీలు ఉంటాయి.
- మాక్ ప్రవర్తనను కాన్ఫిగర్ చేయండి: మాక్ ఫంక్షన్‌ల ప్రవర్తనను, వాటి రిటర్న్ విలువలు, ఎర్రర్ పరిస్థితులు, మరియు కాల్ కౌంట్ వంటివి నిర్వచించండి.
- మాక్‌లను ఇంజెక్ట్ చేయండి: మీరు టెస్ట్ చేస్తున్న యూనిట్‌లో నిజమైన డిపెండెన్సీలను మాక్ ఆబ్జెక్ట్‌లతో భర్తీ చేయండి. ఇది తరచుగా డిపెండెన్సీ ఇంజెక్షన్ ఉపయోగించి చేయబడుతుంది.
- టెస్ట్‌ను అమలు చేయండి: మీ టెస్ట్‌ను రన్ చేసి, మీరు టెస్ట్ చేస్తున్న యూనిట్ మాక్ ఫంక్షన్‌లతో ఎలా ఇంటరాక్ట్ అవుతుందో గమనించండి.
- ఇంటరాక్షన్‌లను ధృవీకరించండి: మాక్ ఫంక్షన్‌లు ఊహించిన ఆర్గ్యుమెంట్లు, రిటర్న్ విలువలు, మరియు కాల్స్ సంఖ్యతో కాల్ చేయబడ్డాయని ధృవీకరించండి.
- అసలు ఫంక్షనాలిటీని పునరుద్ధరించండి: టెస్ట్ తర్వాత, మాక్ ఆబ్జెక్ట్‌లను తీసివేసి, నిజమైన డిపెండెన్సీలకు తిరిగి వెళ్లడం ద్వారా అసలు ఫంక్షనాలిటీని పునరుద్ధరించండి. ఇది ఇతర టెస్ట్‌లపై సైడ్ ఎఫెక్ట్‌లను నివారించడంలో సహాయపడుతుంది.
వివిధ భాషలలో మాక్ ఫంక్షన్ ఉదాహరణలు
ప్రముఖ ప్రోగ్రామింగ్ భాషలు మరియు టెస్టింగ్ ఫ్రేమ్‌వర్క్‌లలో మాక్ ఫంక్షన్‌లను ఉపయోగించే ఉదాహరణలు ఇక్కడ ఉన్నాయి:జావాస్క్రిప్ట్ తో Jest
Jest ఒక ప్రముఖ జావాస్క్రిప్ట్ టెస్టింగ్ ఫ్రేమ్‌వర్క్, ఇది మాక్ ఫంక్షన్‌లకు అంతర్నిర్మిత మద్దతును అందిస్తుంది.
// టెస్ట్ చేయవలసిన ఫంక్షన్
function fetchData(callback) {
setTimeout(() => {
callback('Data from server');
}, 100);
}
// టెస్ట్ కేస్
test('fetchData కాల్‌బ్యాక్‌ను సరైన డేటాతో కాల్ చేస్తుంది', (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('యూజర్ పేరును ప్రదర్శించాలి', 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
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() {
// ఒక మాక్ 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()` ఊహించిన ఆర్గ్యుమెంట్లతో మాక్ కాల్ చేయబడిందని ధృవీకరించడానికి ఉపయోగించబడుతుంది.
మాక్ ఫంక్షన్‌లను ఉపయోగించడానికి ఉత్తమ పద్ధతులు
- తక్కువగా మాక్ చేయండి: నిజంగా బాహ్యంగా ఉన్న లేదా గణనీయమైన సంక్లిష్టతను పరిచయం చేసే డిపెండెన్సీలను మాత్రమే మాక్ చేయండి. ఇంప్లిమెంటేషన్ వివరాలను మాక్ చేయడం మానుకోండి.
- మాక్‌లను సరళంగా ఉంచండి: మీ టెస్ట్‌లలో బగ్స్‌ను పరిచయం చేయకుండా ఉండటానికి మాక్ ఫంక్షన్‌లు సాధ్యమైనంత సరళంగా ఉండాలి.
- డిపెండెన్సీ ఇంజెక్షన్‌ను ఉపయోగించండి: నిజమైన డిపెండెన్సీలను మాక్ ఆబ్జెక్ట్‌లతో భర్తీ చేయడాన్ని సులభతరం చేయడానికి డిపెండెన్సీ ఇంజెక్షన్‌ను ఉపయోగించండి. కన్‌స్ట్రక్టర్ ఇంజెక్షన్ ప్రాధాన్యత ఇవ్వబడుతుంది, ఎందుకంటే ఇది డిపెండెన్సీలను స్పష్టంగా చేస్తుంది.
- ఇంటరాక్షన్‌లను ధృవీకరించండి: మీరు టెస్ట్ చేస్తున్న యూనిట్ మాక్ ఫంక్షన్‌లతో ఊహించిన విధంగా ఇంటరాక్ట్ అవుతుందని ఎల్లప్పుడూ ధృవీకరించండి.
- అసలు ఫంక్షనాలిటీని పునరుద్ధరించండి: ప్రతి టెస్ట్ తర్వాత, మాక్ ఆబ్జెక్ట్‌లను తీసివేసి, నిజమైన డిపెండెన్సీలకు తిరిగి వెళ్లడం ద్వారా అసలు ఫంక్షనాలిటీని పునరుద్ధరించండి.
- మాక్‌లను డాక్యుమెంట్ చేయండి: మీ మాక్ ఫంక్షన్‌ల ప్రయోజనం మరియు ప్రవర్తనను వివరించడానికి వాటిని స్పష్టంగా డాక్యుమెంట్ చేయండి.
- అతి-స్పెసిఫికేషన్‌ను నివారించండి: ప్రతి ఒక్క ఇంటరాక్షన్‌పై నిర్ధారించవద్దు, మీరు టెస్ట్ చేస్తున్న ప్రవర్తనకు అవసరమైన కీలక ఇంటరాక్షన్‌లపై దృష్టి పెట్టండి.
- ఇంటిగ్రేషన్ టెస్ట్‌లను పరిగణించండి: మాక్‌లతో యూనిట్ టెస్ట్‌లు ముఖ్యమైనవి అయినప్పటికీ, నిజమైన కాంపోనెంట్ల మధ్య ఇంటరాక్షన్‌లను ధృవీకరించే ఇంటిగ్రేషన్ టెస్ట్‌లతో వాటిని పూర్తి చేయడం గుర్తుంచుకోండి.
మాక్ ఫంక్షన్‌లకు ప్రత్యామ్నాయాలు
మాక్ ఫంక్షన్‌లు శక్తివంతమైన సాధనం అయినప్పటికీ, అవి ఎల్లప్పుడూ ఉత్తమ పరిష్కారం కాదు. కొన్ని సందర్భాల్లో, ఇతర పద్ధతులు మరింత సముచితంగా ఉండవచ్చు:
- స్టబ్స్: స్టబ్స్ మాక్‌ల కంటే సరళమైనవి. అవి ఫంక్షన్ కాల్స్‌కు ముందే నిర్వచించిన స్పందనలను అందిస్తాయి, కానీ ఆ కాల్స్ ఎలా చేయబడ్డాయో సాధారణంగా ధృవీకరించవు. మీరు మీ యూనిట్ టెస్ట్ ఇన్‌పుట్‌ను మాత్రమే నియంత్రించవలసి వచ్చినప్పుడు ఇవి ఉపయోగపడతాయి.
- స్పైస్: స్పైస్ ఒక నిజమైన ఫంక్షన్ యొక్క అసలు లాజిక్‌ను అమలు చేయడానికి అనుమతిస్తూనే దాని ప్రవర్తనను గమనించడానికి మిమ్మల్ని అనుమతిస్తాయి. మీరు ఒక ఫంక్షన్ నిర్దిష్ట ఆర్గ్యుమెంట్లతో లేదా నిర్దిష్ట సంఖ్యలో కాల్ చేయబడిందని ధృవీకరించాలనుకున్నప్పుడు, దాని ఫంక్షనాలిటీని పూర్తిగా భర్తీ చేయకుండా ఇవి ఉపయోగపడతాయి.
- ఫేక్స్: ఫేక్స్ ఒక డిపెండెన్సీ యొక్క పని చేసే ఇంప్లిమెంటేషన్‌లు, కానీ టెస్టింగ్ ప్రయోజనాల కోసం సరళీకృతం చేయబడినవి. ఒక ఇన్-మెమరీ డేటాబేస్ ఒక ఫేక్‌కు ఉదాహరణ.
- ఇంటిగ్రేషన్ టెస్ట్‌లు: ఇంటిగ్రేషన్ టెస్ట్‌లు బహుళ కాంపోనెంట్ల మధ్య ఇంటరాక్షన్‌లను ధృవీకరిస్తాయి. మీరు ఒక సిస్టమ్ యొక్క ప్రవర్తనను మొత్తంగా టెస్ట్ చేయాలనుకున్నప్పుడు మాక్‌లతో యూనిట్ టెస్ట్‌లకు ఇవి మంచి ప్రత్యామ్నాయం కావచ్చు.
ముగింపు
మాక్ ఫంక్షన్‌లు సమర్థవంతమైన యూనిట్ టెస్ట్‌లు రాయడానికి ఒక ముఖ్యమైన సాధనం, ఇవి యూనిట్లను విడదీయడానికి, ప్రవర్తనను నియంత్రించడానికి, ఎర్రర్ పరిస్థితులను అనుకరించడానికి, మరియు అసమకాలిక కోడ్‌ను టెస్ట్ చేయడానికి మిమ్మల్ని అనుమతిస్తాయి. ఉత్తమ పద్ధతులను అనుసరించడం మరియు ప్రత్యామ్నాయాలను అర్థం చేసుకోవడం ద్వారా, మీరు మరింత దృఢమైన, నమ్మకమైన, మరియు నిర్వహించదగిన సాఫ్ట్‌వేర్‌ను రూపొందించడానికి మాక్ ఫంక్షన్‌లను ఉపయోగించుకోవచ్చు. మీరు ప్రపంచంలో ఏ ప్రాంతం నుండి నిర్మిస్తున్నప్పటికీ, ప్రతి పరిస్థితికి సరైన టెస్టింగ్ టెక్నిక్‌ను ఎంచుకోవడానికి ట్రేడ్-ఆఫ్‌లను పరిగణనలోకి తీసుకుని, సమగ్రమైన మరియు సమర్థవంతమైన టెస్టింగ్ వ్యూహాన్ని సృష్టించడం గుర్తుంచుకోండి.