Pangunahing Mockito Anotasyon

2.1 @Mock na anotasyon

Mayroong dalawang paraan upang gumana sa mga mock na bagay sa Mockito. Ang una ay upang lumikha ng isang ganap na virtual na bagay , ang pangalawa ay upang balutin ang isang umiiral na bagay sa isang wrapper. Magsimula tayo sa una.

Upang lumikha ng isang ganap na virtual na bagay, kailangan mong isulat ang code:

ClassName variable name = Mockito.mock(ClassName.class);

Gumawa tayo ng mock ArrayList class bilang isang halimbawa:

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

Sa halimbawang ito, gumagawa kami ng pekeng ArrayList at nag-iimbak ng reference dito sa mockList variable. Ang mga pamamaraan ng bagay na ito ay walang ginagawa.

Sa pamamagitan ng paraan, ang code na ito ay maaaring maisulat nang mas maikli, dahil mayroong isang espesyal na anotasyon para dito @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");
    }
}

Sa pangalawang kaso, MockitoExtensionsusuriin nito ang class code mismo at gagawa ng mga kinakailangang stub. Hindi mo kailangang tawagan ang pamamaraan Mockito.mock(). Isang anotasyon at ang virtual na bagay ay handa na. kagandahan.

2.2 @Spy annotation

Ang pangalawang mahalagang uri ng mga bagay sa Mockito ay mga pambalot sa mga umiiral na bagay. Pinapayagan nila, sa isang banda, na gumamit ng mga umiiral na klase, at sa kabilang banda, upang harangin ang mga tawag sa lahat ng mga pamamaraan at mga variable ng naturang mga bagay: upang itama ang kanilang trabaho kung kinakailangan. Ginagamit ang mga ito nang kasingdalas ng mga bagay na Mock.

Upang lumikha ng isang wrapper sa ibabaw ng isang bagay, kailangan mong isulat ang code:

ClassName variable name = Mockito.spy(an object);

Isang halimbawa na may wrapper sa paligid ng klase ng ArrayList:

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

Sa pinakasimpleng anyo nito, ang isang tawag sa isang bagay ng wrapper ay nagre-redirect lang ng mga tawag sa orihinal na bagay, ang reference kung saan ito nananatili sa loob mismo . Lahat ay gagana tulad ng sa orihinal na bagay.

Maaari ka ring gumawa ng wrapper gamit ang annotation - @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");
    }
}

Ang dalawang halimbawa ng code na ito ay katumbas.