2.1 @మాక్ ఉల్లేఖన
మోకిటోలో మాక్ వస్తువులతో పని చేయడానికి రెండు మార్గాలు ఉన్నాయి. మొదటిది పూర్తిగా వర్చువల్ ఆబ్జెక్ట్ను సృష్టించడం , రెండవది ఇప్పటికే ఉన్న వస్తువును రేపర్లో చుట్టడం. మొదటిదానితో ప్రారంభిద్దాం.
పూర్తిగా వర్చువల్ ఆబ్జెక్ట్ని సృష్టించడానికి, మీరు కోడ్ను వ్రాయాలి:
ClassName variable name = Mockito.mock(ClassName.class);
ఉదాహరణగా మాక్ అర్రేలిస్ట్ క్లాస్ని క్రియేట్ చేద్దాం:
@ExtendWith(MockitoExtension.class)
class MockTest {
@Test
public void whenNotUseMockAnnotation_thenCorrect() {
List mockList = Mockito.mock(ArrayList.class);
//these methods won't do anything - they are stubs
mockList.add("one");
mockList.add("two");
}
}
ఈ ఉదాహరణలో, మేము నకిలీ అర్రేలిస్ట్ని సృష్టించి, దానికి సంబంధించిన సూచనను మాక్లిస్ట్ వేరియబుల్లో నిల్వ చేస్తాము. ఈ వస్తువు యొక్క పద్ధతులు ఏమీ చేయవు.
దీని కోసం ప్రత్యేక ఉల్లేఖన ఉన్నందున, ఈ కోడ్ను మరింత తక్కువగా వ్రాయవచ్చు @Mock
.
@ExtendWith(MockitoExtension.class)
class MockTest {
@Mock
List mockList;
@Test
public void whenNotUseMockAnnotation_thenCorrect() {
//these methods won't do anything - they are stubs
mockList.add("one");
mockList.add("two");
}
}
రెండవ సందర్భంలో, MockitoExtension
ఇది తరగతి కోడ్ను స్వయంగా విశ్లేషిస్తుంది మరియు అవసరమైన స్టబ్లను సృష్టిస్తుంది. మీరు పద్ధతిని కాల్ చేయవలసిన అవసరం లేదు Mockito.mock()
. ఒక ఉల్లేఖనం మరియు వర్చువల్ ఆబ్జెక్ట్ సిద్ధంగా ఉంది. అందం.
2.2 @గూఢచారి ఉల్లేఖనం
మోకిటోలోని రెండవ ముఖ్యమైన రకం వస్తువులు ఇప్పటికే ఉన్న వస్తువులపై రేపర్లు. వారు ఒక వైపు, ఇప్పటికే ఉన్న తరగతులను ఉపయోగించడానికి మరియు మరోవైపు, అటువంటి వస్తువుల యొక్క అన్ని పద్ధతులు మరియు వేరియబుల్స్కు కాల్లను అడ్డగించడానికి అనుమతిస్తారు: అవసరమైన చోట వారి పనిని సరిచేయడానికి. అవి మాక్ వస్తువుల వలె తరచుగా ఉపయోగించబడతాయి.
వస్తువుపై రేపర్ని సృష్టించడానికి, మీరు కోడ్ను వ్రాయాలి:
ClassName variable name = Mockito.spy(an object);
అర్రేలిస్ట్ క్లాస్ చుట్టూ రేపర్తో ఒక ఉదాహరణ:
@ExtendWith(MockitoExtension.class)
class SpyTest {
@Test
public void whenMockAnnotation() {
List<String> mockList = Mockito.spy(new ArrayList<String>());
//these methods will work!
mockList.add("one");
mockList.add("two");
}
}
దాని సరళమైన రూపంలో, ఒక రేపర్ ఆబ్జెక్ట్కు కాల్ చేస్తే కాల్లను అసలు వస్తువుకు దారి మళ్లిస్తుంది, దాని సూచన దానిలోనే ఉంటుంది . ప్రతిదీ అసలు వస్తువుతో సమానంగా పని చేస్తుంది.
మీరు ఉల్లేఖనాన్ని ఉపయోగించి రేపర్ను కూడా సృష్టించవచ్చు - @Spy
.
@ExtendWith(MockitoExtension.class)
class SpyTest {
@Spy
List mockList = new ArrayList<String>();
@Test
public void whenMockAnnotation() {
// these methods will work!
mockList.add("one");
mockList.add("two");
}
}
ఈ రెండు కోడ్ ఉదాహరణలు సమానం.
GO TO FULL VERSION