Mockito — bu nima, asosiy tushunchalar va ishlash prinsipi

Mockito nima?

Mockito — Java, Kotlin va boshqa JVM tillarida modul testlarida mock-obyektlar (soxta obyektlar) yaratish uchun ochiq kodli kutubxona. JUnit testlarni ishga tushirish uchun javobgar bo'lsa, Mockito ajratish muammosini hal qiladi — test qilinayotgan sinfning real bog'liqliklarini oldindan bashorat qilinadigan obyektlar bilan almashtiradi.

Moklarsiz, ma'lumotlar bazasiga yoki tashqi API ga murojaat qiladigan metodni test qilish real muhitni sozlashni talab qiladi — DB ni o'rnatish, serverni ishga tushirish. Mockito bu bog'liqliklarni barqaror xatti-harakatga ega obyektlar bilan almashtiradi: repository.findById(1) metodi ma'lumotlar bazasiga murojaat qilmasdan har doim ma'lum User obyektini qaytaradi.

Mockito arxitekturasi Proxy naqshiga asoslanadi (interfeyslar va sinflar uchun). Kutubxona belgilangan tur uchun osti sinf yoki proksi yaratadi va barcha metod chaqiruvlarini ushlab, standart qiymatlarni yoki when().thenReturn() orqali belgilangan qiymatlarni qaytaradi.

Mockito qanday ishlaydi

Ishlash prinsipi Mockito uchta asosiy operatsiyaga asoslanadi: mock yaratish, xatti-harakatni sozlash (stubbing) va chaqiruvlarni tekshirish (verification). Har bir operatsiya Maven Central statistikasiga ko'ra Java ekotizimidagi eng ko'p yuklanadigan sinf bo'lgan org.mockito.Mockito sinfidan statik metodlardan foydalanadi. Mockning barcha metod chaqiruvlari xotiraga yoziladi, bu esa ularni verify orqali tekshirish imkonini beradi.

Mockito bilan testning uch bosqichi

Mockito bilan odatdagi test uch bosqichdan iborat: Arrange — moklarni yaratish va stublarni when().thenReturn() bilan sozlash, Act — test qilinayotgan metodni chaqirish, Assert — natijani assertEquals va verify(mock) bilan tekshirish. Bu yondashuv AAA (Arrange-Act-Assert) deb ataladi.

Repozitoriy moki bilan asosiy misol

Mockito foydalanuvchi repozitoriysini almashtiradigan sodda testni ko'rib chiqaylik. when().thenReturn() metodi mockni findById chaqiruvi oldindan tayyorlangan User obyektini qaytaradigan qilib sozlaydi.

// Repozitoriy mokini yaratamiz
UserRepository mockRepo = mock(UserRepository.class);

// Xatti-harakatni sozlaymiz: findById(1) da foydalanuvchini qaytar
when(mockRepo.findById(1)).thenReturn(new User("Alice"));

// Metodning haqiqatan chaqirilganligini tekshiramiz
User result = mockRepo.findById(1);
assertEquals("Alice", result.getName());
verify(mockRepo).findById(1);

Mock-obyektlarni yaratish

Mockito mock yaratishning ikki usulini taqdim etadi: statik mock(Class) metodi va MockitoAnnotations.openMocks() orqali ishga tushiriladigan @Mock annotatsiyasi. Birinchi usul bir-ikkita mock uchun ixcham, ikkinchisi esa bog'liqliklar ko'p bo'lganda qulay — annotatsiyalar boilerplate kodni kamaytiradi.

Statik mock() metodi orqali

mock() metodi sinfni qabul qiladi va when().thenReturn() orqali sozlanishi mumkin bo'lgan soxta obyektni qaytaradi. Sozlanmagan metodlar standart qiymatlarni qaytaradi: sonlar uchun 0, boolean uchun false, obyektlar uchun null.

ApiClient apiClient = mock(ApiClient.class);
Database database = mock(Database.class);

@Mock annotatsiyasi bilan JUnit 5 da

@Mock annotatsiyasi @ExtendWith(MockitoExtension.class) bilan birgalikda test sinfining barcha maydonlari uchun avtomatik moklar yaratadi. MockitoExtension kengaytmasi har bir testdan oldin ishga tushirish uchun javobgardir.

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @Test
    void getUserShouldReturnUserFromRepo() {
        when(userRepository.findById(1)).thenReturn(new User("Alice"));
        User result = userService.getUser(1);
        assertEquals("Alice", result.getName());
    }
}

Stubbing: mock xatti-harakatini sozlash

Stubbing — ma'lum argumentlar bilan chaqirilganda mock metodi nimani qaytarishi kerakligini aniqlash jarayoni. Asosiy sintaksis: when(mock.method(args)).thenReturn(value). Turli stsenariylar uchun Mockito bir nechta then-metod variantlarini taklif qiladi.

thenAnswer orqali dinamik javob

Qaytariladigan qiymat chaqiruv argumentlariga bog'liq bo'lganda, lambda bilan thenAnswer ishlatiladi. Bu haqiqiy ma'lumotlar bilan ishlashni taqlid qilish uchun foydali — masalan, uzatilgan obyekt asosida ID generatsiyasi.

when(repository.save(any())).thenAnswer(invocation -> {
    User user = invocation.getArgument(0);
    user.setId(42);
    return user;
});

Verify: mock bilan o'zaro aloqalarni tekshirish

Verify — Mockito-ning noyob imkoniyati bo'lib, eski mock-obyekt kutubxonalari (EasyMock, jMock) buni ta'minlamaydi.

Verify testlarni ishonchliroq qiladi, chunki u faqat qaytarilgan qiymatni emas, balki yon ta'sirlarni — natija qaytarmaydigan metod chaqiruvlarini (void metodlari) ham tekshiradi. verify(mock).methodName(args) metodi ma'lum mock metodining belgilangan argumentlar bilan chaqirilgan yoki chaqirilmaganligini tekshiradi. Bu nafaqat natijani, balki jarayonni — bog'liqlikka murojaat faktini ham test qilish imkonini beradi.

Chaqiruvlar sonini tekshirish

Standart bo'yicha verify metodning aniq bir marta chaqirilganligini tekshiradi. Agar boshqa son kerak bo'lsa — times(n), atLeast(n), never() va Mockito sinfidagi boshqa modifikatorlardan foydalaniladi.

// Chaqiruvlar sonini tekshirish
verify(repository, times(3)).save(any());
verify(repository, never()).delete(any());
verify(repository, atLeastOnce()).findById(1);

// Chaqiruvlar tartibini tekshirish
InOrder inOrder = inOrder(repository);
inOrder.verify(repository).save(any());
inOrder.verify(repository).flush();

Argumentlarni olish uchun ArgumentCaptor

Metod qaysi obyekt bilan chaqirilganligini tekshirish kerak bo'lganda, ArgumentCaptor ishlatiladi. U chaqiruv vaqtida argument qiymatini ushlab oladi va uning maydonlarini alohida tekshirish imkonini beradi. ArgumentCaptor ayniqsa test qilinayotgan kod ichki obyekt yaratib, uni bog'liqlikka uzatganda foydalidir — bu obyektni boshqa yo'l bilan tekshirib bo'lmaydi.

ArgumentCaptor<User> captor = ArgumentCaptor.forClass(User.class);
verify(repository).save(captor.capture());
assertEquals("Alice", captor.getValue().getName());

@Mock va @InjectMocks annotatsiyalari

@Mock va @InjectMocks — Mockito-ning ikkita asosiy annotatsiyasi bo'lib, ular boilerplate kodni sezilarli darajada kamaytiradi. @Mock maydon uchun mock yaratadi, @InjectMocks esa test sinfidagi barcha moklarni test qilinayotgan obyektga konstruktor, setter yoki maydon orqali joylashtiradi.

@InjectMocks mexanizmi bog'liqliklarni quyidagi tartibda joylashtirishga harakat qiladi: eng ko'p argumentga ega konstruktor, tur bo'yicha setter, xususiy maydon. Agar hech qanday usul ishlamasa — obyekt null bog'liqliklari bilan qoladi va test NullPointerException bilan ishlamay qoladi.

@InjectMocks dan foydalanish qoidalari

Tushunish muhim: @InjectMocks maydon turlarini tahlil qilmaydi — turga mos keladigan har qanday mockni joylashtiradi. Agar sinfda bir xil turdagi ikkita maydon bo'lsa — Mockito noto'g'ri mockni joylashtirishi mumkin. Bunday hollarda moklarni uzatish bilan aniq konstruktordan foydalanish tavsiya etiladi.

Android loyihalarida Mockito

Android rivojlanishida Mockito JUnit bilan birgalikda ViewModel, Repository va UseCase ni test qilish uchun ishlatiladi. Bu sinflar Android kontekstisiz JVM da ishlagani uchun Mockito ularning bog'liqliklarini — Room DAO, Retrofit API, SharedPreferences — oldindan bashorat qilinadigan stubalar bilan almashtiradi.

Mockito uchun Gradle sozlamalari

Mockito-ni Android loyihasiga qo'shish uchun mockito-core yoki mockito-inline bog'liqligini qo'shish kifoya (ikkinchisi final sinflar va statik metodlarni mock qilishni qo'llab-quvvatlaydi). 5.12.0 versiyasi (2024) Java 21 qo'llab-quvvatlash va JUnit 5 bilan yaxshilangan integratsiyani o'z ichiga oladi.

// build.gradle.kts (modul)
dependencies {
    testImplementation("org.mockito:mockito-core:5.12.0")
    testImplementation("org.mockito:mockito-junit-jupiter:5.12.0")
}

Mockito va PowerMock: eskirgan amaliyot

Ilgari statik metodlar va konstruktorlarni mock qilish uchun baytkod instrumentatsiyasi orqali ishlaydigan PowerMock kengaytmasi talab qilingan. Mockito 5.x dan mockito-inline bilan bu funksiya to'g'ridan-to'g'ri o'rnatilgan: mockStatic(ClassName.class) qo'shimcha kutubxonalarsiz statik metodlarni mock qilish imkonini beradi.

ViewModel ni Mockito bilan test qilish

Odatdagi stsenariy: ViewModel repozitoriy metodini chaqiradi va natijani UI holatiga aylantiradi. Mockito repozitoriyni almashtiradi va test ViewModel ning muvaffaqiyatli javob va xatoni to'g'ri qayta ishlashini tekshiradi. Clean Architecture dan foydalanilganda, har bir qatlam uchun moklar yaratiladi: DataSource, Repository va UseCase — bu har bir qatlamni alohida test qilish imkonini beradi.

• success case — when(repo.getData()).thenReturn(Result.success(data)) → state = Success(data) ni tekshiramiz.
• error case — when(repo.getData()).thenReturn(Result.error(exception)) → state = Error(message) ni tekshiramiz.
• loading state — verify, ViewModel repozitoriy chaqirishdan oldin isLoading = true o'rnatganligini tekshiramiz.