మోకిటోతో అధునాతన పరీక్ష

1.1 మోకిటో లైబ్రరీ

ఈ రోజు మనం అధునాతన పరీక్షతో పరిచయం పొందుతాము. మరింత ప్రత్యేకంగా, మోకిటో లైబ్రరీతో . ఈ వ్యాపారం నుండి బయటపడాలని కూడా ఆలోచించవద్దు.

ముందుగా, ఈ లైబ్రరీ స్ప్రింగ్ టెస్టింగ్‌లో ఒక ప్రమాణం . వాస్తవానికి జావా బ్యాకెండ్ డెవలప్‌మెంట్ పరిశ్రమలో ఇది ప్రమాణం.

రెండవది, మీరు మీ స్ప్రింగ్ కోడ్ కోసం పరీక్షలు వ్రాయవలసి ఉంటుంది . మీరు వ్రాసిన బ్యాకెండ్ పని చేస్తుందని అర్థం చేసుకోవడానికి ఏకైక మార్గం దాని API యొక్క పద్ధతులను కాల్ చేయడం . మరియు పరీక్షలు లేకుండా చేయడం కంటే 10 రెట్లు సులభం. మీరే చూస్తారు.

pom.xmlమీరు కోడ్‌ని ఉపయోగించి మోకిటో లైబ్రరీని మీ దానికి జోడించవచ్చు :

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <version>4.2.0</version>
    <scope>test</scope>
</dependency>

Mockito ప్రాజెక్ట్ కోసం మొత్తం సోర్స్ కోడ్ GitHub లో కనుగొనబడుతుంది .

1.2 మాక్ వస్తువులు

ఇంతకీ ఈ మోకిటో అంటే ఏమిటి మరియు ఇది ఎందుకు మంచిది?

పరీక్ష అభివృద్ధి మరియు అభివృద్ధి ప్రక్రియలో, చాలా తరచుగా నిజమైన వస్తువుకు బదులుగా కోడ్‌లోకి ఒక రకమైన "స్టబ్" ను జారడం అవసరం.

ఉదాహరణకు, డేటాబేస్తో పనిచేసే కోడ్ పరీక్షించబడుతుంది మరియు అక్కడ ఏదో మారుస్తుంది. ప్రతి పరీక్షకు ముందు ఈ డేటాబేస్ యొక్క స్థితి ఒకేలా ఉండటం మంచిది (లేకపోతే పరీక్షలు భిన్నంగా ఉంటాయి). మరియు ఈ స్థితులను త్వరగా వెనక్కి తీసుకురావడానికి బేస్ సరళంగా ఉండాలని నేను కోరుకుంటున్నాను.

లేదా, ఉదాహరణకు, మీరు ఉపయోగకరమైన SMSని పంపే కోడ్‌ని పరీక్షిస్తున్నారు. మరియు డైరెక్ట్ మెయిలింగ్‌ల కోసం, అతను ఒక రకమైన చెల్లింపు SMS గేట్‌వేని ఉపయోగిస్తాడు. అపారమయిన వ్యక్తులకు వందలాది SMSలను పంపకుండా, కోడ్‌ని పరీక్షించడానికి కొన్ని వర్చువల్ గేట్‌వేని దానిలోకి జారడం మంచిది.

లేదా మీ కోడ్ పరీక్ష సర్వర్‌లో అందుబాటులో లేని ఇతర వెబ్ సర్వర్‌ల నుండి డేటాను అభ్యర్థిస్తోంది. లేదా మీరు ఆన్‌లైన్ చెల్లింపుల కోసం 50 సార్లు పరీక్షించాల్సిన కోడ్‌ను వ్రాసి, ఆపై మాత్రమే నిజమైన ఆర్థిక ఛానెల్‌లలో ఉపయోగించడానికి అనుమతించబడతారు.

మీరు అర్థం చేసుకున్నారని అనుకుంటున్నాను... వర్చువల్ ఆబ్జెక్ట్‌లు, లేదా వాటిని స్టబ్ ఆబ్జెక్ట్‌లు అని కూడా అంటారు, చాలా ఉపయోగకరమైన విషయం.

మరియు ఇక్కడ ఇబ్బంది వస్తుంది - జావాలో స్టాటిక్ టైపింగ్ ఉంది. దీనర్థం ఏమిటంటే, ReadDatabaseఆబ్జెక్ట్‌కు సూచనను టైప్ యొక్క ఆబ్జెక్ట్‌కు బదులుగా వేరియబుల్‌కి కేటాయించడానికి , మీరు నుండి VirtualDatabaseతరగతిని వారసత్వంగా పొందాలి .VirtualDatabaseRealDatabase

అప్పుడు తరగతి RealDatabaseఇతర వాస్తవ వస్తువులకు సూచనలను నిల్వ చేసే ప్రైవేట్ పద్ధతులు మరియు వేరియబుల్‌ల సమూహాన్ని కలిగి ఉందని మరియు మీరు ఈ విధంగా సాధారణ స్టబ్‌ను వ్రాయలేరు. సిద్ధాంతంలో ఇది మంచిదే, కానీ ఆచరణలో అది అంతంతమాత్రమే.

మరియు ఇక్కడ రెస్క్యూ వస్తుంది ( మీరు DynamicProxyమరింత వివరంగా చదవగలరు ), ఇది జావా 5 లో తిరిగి కనిపించింది. ఇది కంపైలర్ గురించి ఎటువంటి ఫిర్యాదులు లేని వర్చువల్ వస్తువులను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది.

ఇటువంటి వర్చువల్ వస్తువులను మాక్స్ అని పిలుస్తారు (మాక్ - లేఅవుట్ అనే పదం నుండి). మొకిటో లైబ్రరీ ఈ మాక్‌లతో పనిని అపూర్వమైన ఎత్తుకు తీసుకెళ్లగలిగింది. అందువల్ల, మార్గం ద్వారా, లైబ్రరీ పేరు.

1.3 @ExtendWith ఉల్లేఖన

జూనిట్‌తో మోకిటో లైబ్రరీ గొప్పగా పనిచేస్తుంది, దాని పొడిగింపుగా కూడా పరిగణించవచ్చు.

మీ యూనిట్ పరీక్షలలో మోకిటో లైబ్రరీని ఎనేబుల్ చేయడానికి రెండు మార్గాలు ఉన్నాయి. ప్రత్యేక ఉల్లేఖనాన్ని జోడించడం మొదటి మార్గం:

@ExtendWith(MockitoExtension.class)
public class MockitoAnnotationTest {
    ...
}

పద్ధతిని కాల్ చేయడం ద్వారా దాని పనిని ప్రారంభించడం రెండవ మార్గం openMocks():

public class MockitoAnnotationTest {
    @BeforeEach
    public void init() {
        MockitoAnnotations.openMocks(this);
   }
}

చాలా తరచుగా, మీరు మొదటి ఎంపికను చూస్తారు, కానీ కొన్నిసార్లు రెండవది ఉందని తెలుసుకోవడం ఉపయోగకరంగా ఉంటుంది.