Spy — шта је то, Mockito.spy() и верификација позива

Шта је Spy и по чему се разликује од Mock-а?

Spy — је омотач око стварног објекта који пресреће све позиве метода и бележи их. Стварна логика објекта се извршава: ако метод чува податке, израчунава вредност или прави захтев — све се дешава као и обично. Додатно, spy бележи метаподатке: име метода, аргументе, број позива, време извршења. Термин је део класификације Meszaros (2007) и детаљно је описан у чланку Martin Fowler-а „Mocks Aren't Stubs”.

Кључна разлика од Mock-а — mock у потпуности замењује објекат тест заглушком, сви методи подразумевано ништа не раде. Spy омотава постојећи објекат: сви методи подразумевано раде као и обично, али се истовремено бележе. Ова разлика је принципијелна: mock изолује тестирани код од стварности, spy чува стварност и омогућава посматрање. Избор између њих зависи од тога шта се тестира.

Када је Spy прави избор

Spy — прави избор — ако тестирани код мења стање стварног објекта, а тест треба и да провери резултат (стање) и да се увери да су позиви направљени у правилном редоследу. Mock није прикладан јер не извршава стварну имплементацију. Stub није прикладан јер не бележи позиве. Spy је једини test double који истовремено чува стварну логику и пружа информације о позивима.

Spy vs Mock: када користити шпијуна

Mock — потпуна изолација. Ако тест не треба да зависи од имплементације стварног објекта (на пример, база података или мрежни клијент), користите mock. Mock гарантује да ниједан позив неће стићи до стварне компоненте. Ово је безбедно и предвидљиво. Недостатак: mock не извршава стварну логику, па ако се тестирани код ослања на повратну вредност — треба је експлицитно подесити кроз when/stub.

Spy — стварна логика + посматрање. Ако тестирани код интерагује са објектом чија је логика важна за тест, а не само подаци — користите spy. На пример, AnalyticsTracker који прикупља догађаје и периодично их шаље. Тест проверава да ли су догађаји додати у бафер и да ли је након слања бафер очишћен. Mock не може ово да провери јер не извршава стварну логику tracker-а.

Антиобразац: spy за све

Spy за све — користити spy уместо mock-а за све тестове је грешка. Spy извршава стварни код који може имати споредне ефекте: упис у датотеку, слање HTTP-а, промена глобалног стања. Ако тестирани модул позива метод spy-објекта који шаље HTTP захтев, тест постаје интеграциони, а не јединични тест. Правило: ако spy омотава објекат са I/O операцијама — то више није јединични тест. Користите mock за изолацију I/O, spy — само за in-memory објекте без спољних ефеката.

Mockito.spy() и spy у MockK на Android-у

Mockito.spy() — класични начин стварања шпијуна у Java/Kotlin пројектима. spy() прима стварни објекат и враћа омотач. Сви позиви се подразумевано делегирају стварном објекту, а резултати се бележе. Након извршења теста, путем verify() се може проверити број позива и аргументи. За методе које треба да врате тест податке, користи се doReturn/when — то се назива „делимично стабловање” (partial mocking).

class AnalyticsReporterTest {

    private val realTracker = AnalyticsTracker()
    private val spyTracker = Mockito.spy(realTracker)

    fun test_event_tracked() {
        val event = AnalyticsEvent("login")
        spyTracker.track(event)

        Mockito.verify(spyTracker).track(event)
        assertEquals(1, spyTracker.getBufferedCount())
    }

    fun test_track_with_exception() {
        Mockito.doThrow(RuntimeException("network"))
            .when(spyTracker).flush()

        spyTracker.track(AnalyticsEvent("login"))
        assertTrue(spyTracker.hasPendingEvents())
    }
}

MockK.spyk() — алтернатива за Kotlin пројекте са бољом подршком за корутине и sealed класе. MockK.spyk() ствара шпијуна, аналогно Mockito.spy(). Подржава coVerify за suspend функције и every за делимично стабловање. За разлику од Mockito-а, MockK не подржава spy за final класе (све класе у Kotlin-у су подразумевано final) — потребно је или отворити класу (open) или користити интерфејс.

class LoginUseCaseTest {

    private val realRepo = UserRepository()
    private val spyRepo = spyk(realRepo)

    private val useCase = LoginUseCase(spyRepo)

    fun test_login_calls_save() = runTest {
        every { spyRepo.getUser(any()) } returns User("test")

        val result = useCase.login("test", "pass")

        coVerify { spyRepo.saveLoginTime(any()) }
        assertTrue(result.isSuccess)
    }
}

Делимично стабловање кроз spy

Делимично стабловање — моћна, али опасна техника. Можете направити spy објекта и прегазити (stub) само неке методе, остављајући остале стварним. Пример: spy-репозиторијум чији getUser() враћа тест податке, а saveUser() стварно чува у in-memory листу. Ово омогућава комбиновање предности stub-ова (контролисани подаци) и spy (стварна логика). Недостатак: сложеност читања теста — није очигледно који методи су стварни, а који су stub.

Имплементација Spy на iOS-у са OCMock и протоколима

OCMock за Objective-C — библиотека која подржава стварање spy-објеката кроз niceMock. OCMock пресреће позиве метода користећи Objective-C runtime и бележи их. Након извршења теста позива се verify. OCMock подржава spy за било који објекат (у Objective-C-у су сви методи динамички), што даје предност у односу на Swift, где је spy могућ само кроз протоколе.

// Креирање spy-а за стварни објекат
AnalyticsTracker *realTracker = [[AnalyticsTracker alloc] init];
AnalyticsTracker *spy = [OCMockObject partialMockForObject:realTracker];

// Извршење теста
[spy trackEvent:@"login"];

// Верификација
[[spy verify] trackEvent:@"login"];
XCTAssertEqual([realTracker eventCount], 1);

Swift protocol-based spy — у Swift-у не постоји runtime рефлексија Objective-C-а, па се spy креира ручно. Тест структура имплементира протокол и изнутра позива стварни објекат, истовремено бележећи позиве. Ово је више кода, али потпуно контролисано и type-safe. Ручни шпијуни не захтевају спољне библиотеке и не користе runtime — све се проверава у фази компилације.

protocol AnalyticsProtocol {
    func trackEvent(name: String)
}

final class SpyAnalytics: AnalyticsProtocol {
    private let real: AnalyticsProtocol
    private var events: [String] = []

    init(real: AnalyticsProtocol) {
        self.real = real
    }

    func trackEvent(name: String) {
        events.append(name)
        real.trackEvent(name: name)
    }

    func verifyTracked(name: String) -> Bool {
        return events.contains(name)
    }
}

Када користити OCMock vs ручни spy — за Objective-C код користите OCMock (мање boilerplate-а). За Swift — пожељни су ручни шпијуни кроз протоколе. Ручни spy пружа потпуну контролу над бележењем позива, не захтева рефлексију и ради са value-типовима (struct). Једини недостатак: потребно је одржавати код spy класе синхронизованим са протоколом при додавању нових метода.

Типични сценарији примене Spy

Провера аналитике — најчешћи сценариј употребе spy-а. У продукцијском коду, позиви аналитике су раштркани по целој апликацији: login, logout, purchase, error. Тест креира spy-омотач за AnalyticsTracker, извршава сценариј (пријава, преглед производа, додавање у корпу, куповина) и проверава да су сви потребни догађаји послати у правилном редоследу. Mock није прикладан јер AnalyticsTracker садржи логику баферисања и слања.

Тајмери и планирачи — тестирање кода који користи Handler (Android) или Timer (iOS) је тешко због стварног времена. Spy-омотач за Scheduler бележи који задаци су планирани и са којим кашњењем. Тест креира spy стварног Handler-а, извршава акцију и проверава да ли је Handler.postDelayed(runnable, delay) позван са правилним кашњењем. Стварни задатак се при томе не извршава — spy пресреће и бележи позив.

Логовање и debug информације — у продукцији, логови могу бити искључени или уписани у датотеку. Spy-омотач за Logger бележи све поруке у in-memory листу коју тест проверава након извршења. Ово омогућава проверу да ли се при грешци пише исправна порука, без затрпавања конзоле. Ручни шпијуни за Logger су посебно корисни на iOS-у, где OSLog нема тест API.

Провера редоследа позива — неки сценарији захтевају строги редослед операција: отвори везу, пошаљи податке, затвори везу. Mockito омогућава проверу редоследа кроз InOrder.verify(). Spy ради исто, али чува стварно извршење. Ако је важан не само редослед, већ и резултат сваког корака (веза се стварно отворила) — користите spy, а не mock.