Cara mengejek kelas terakhir dengan mockito

Saya memiliki kelas terakhir, sesuatu seperti ini:

public final class RainOnTrees{

   public void startRain(){

        // some code here
   }
}

Saya menggunakan kelas ini di beberapa kelas lain seperti ini:

public class Seasons{

   RainOnTrees rain = new RainOnTrees();

   public void findSeasonAndRain(){

        rain.startRain();

    }
}

dan di kelas tes JUnit saya karena Seasons.javasaya ingin mengejek RainOnTreeskelas. Bagaimana saya bisa melakukan ini dengan Mockito?

Mengejek final / kelas statis / metode hanya dimungkinkan dengan Mockito v2.

tambahkan ini dalam file gradle Anda:

testImplementation 'org.mockito:mockito-inline:2.13.0'

Ini tidak mungkin dengan Mockito v1, dari FAQ Mockito :

Apa keterbatasan Mockito

• Membutuhkan java 1.5+

• Tidak bisa mengejek kelas akhir

...

Mockito 2 sekarang mendukung kelas dan metode akhir !

Tetapi untuk sekarang itu fitur "inkubasi". Dibutuhkan beberapa langkah untuk mengaktifkannya yang dijelaskan dalam What's New in Mockito 2 :

Mengejek kelas akhir dan metode adalah fitur inkubasi , opt-in. Ini menggunakan kombinasi instrumentasi agen Java dan subclassing untuk memungkinkan mockability jenis ini. Karena ini bekerja secara berbeda dengan mekanisme kami saat ini dan ini memiliki keterbatasan yang berbeda dan karena kami ingin mengumpulkan pengalaman dan umpan balik pengguna, fitur ini harus diaktifkan secara eksplisit agar tersedia; itu dapat dilakukan melalui mekanisme ekstensi mockito dengan membuat file yang src/test/resources/mockito-extensions/org.mockito.plugins.MockMakerberisi satu baris:

mock-maker-inline

Setelah Anda membuat file ini, Mockito akan secara otomatis menggunakan mesin baru ini dan Anda dapat melakukannya:

 final class FinalClass {
   final String finalMethod() { return "something"; }
 }

 FinalClass concrete = new FinalClass(); 

 FinalClass mock = mock(FinalClass.class);
 given(mock.finalMethod()).willReturn("not anymore");

 assertThat(mock.finalMethod()).isNotEqualTo(concrete.finalMethod());

Dalam tonggak berikutnya, tim akan membawa cara terprogram untuk menggunakan fitur ini. Kami akan mengidentifikasi dan memberikan dukungan untuk semua skenario yang tidak dapat digerakkan. Tetap disini dan beri tahu kami pendapat Anda tentang fitur ini!

Anda tidak dapat mengejek kelas terakhir dengan Mockito, karena Anda tidak dapat melakukannya sendiri.

Apa yang saya lakukan, adalah membuat kelas non-final untuk membungkus kelas akhir dan digunakan sebagai delegasi. Contoh dari ini adalah TwitterFactorykelas, dan ini adalah kelas saya yang bisa dipermainkan:

public class TwitterFactory {

    private final twitter4j.TwitterFactory factory;

    public TwitterFactory() {
        factory = new twitter4j.TwitterFactory();
    }

    public Twitter getInstance(User user) {
        return factory.getInstance(accessToken(user));
    }

    private AccessToken accessToken(User user) {
        return new AccessToken(user.getAccessToken(), user.getAccessTokenSecret());
    }

    public Twitter getInstance() {
        return factory.getInstance();
    }
}

Kerugiannya adalah ada banyak kode boilerplate; keuntungannya adalah Anda dapat menambahkan beberapa metode yang mungkin terkait dengan bisnis aplikasi Anda (seperti getInstance yang mengambil pengguna alih-alih accessToken, dalam kasus di atas).

Dalam kasus Anda, saya akan membuat kelas non-final RainOnTreesyang mendelegasikan ke kelas akhir. Atau, jika Anda bisa membuatnya non-final, itu akan lebih baik.

tambahkan ini dalam file gradle Anda:

testImplementation 'org.mockito:mockito-inline:2.13.0'

ini adalah konfigurasi untuk membuat mockito berfungsi dengan kelas akhir

Gunakan Powermock. Tautan ini menunjukkan, bagaimana melakukannya: https://github.com/jayway/powermock/wiki/MockFinal

Hanya untuk menindaklanjuti. Silakan tambahkan baris ini ke file gradle Anda:

testCompile group: 'org.mockito', name: 'mockito-inline', version: '2.8.9'

Saya sudah mencoba berbagai versi mockito-core dan mockito-all. Tak satu pun dari mereka bekerja.

Saya kira Anda membuatnya finalkarena Anda ingin mencegah kelas lain dari perluasan RainOnTrees. Seperti yang disarankan oleh Java Efektif (item 15), ada cara lain untuk menjaga kelas tetap dekat dengan ekstensi tanpa membuatnya final:

1. Hapus finalkata kunci;

2. Buat konstruktornya private. Tidak ada kelas yang dapat memperpanjangnya karena tidak akan dapat memanggil superkonstruktor;

3. Buat metode pabrik statis untuk membuat instance kelas Anda.

   // No more final keyword here.
   public class RainOnTrees {
   
       public static RainOnTrees newInstance() {
           return new RainOnTrees();
       }
   
   
       private RainOnTrees() {
           // Private constructor.
       }
   
       public void startRain() {
   
           // some code here
       }
   }

Dengan menggunakan strategi ini, Anda akan dapat menggunakan Mockito dan menutup kelas Anda untuk ekstensi dengan sedikit kode boilerplate.

Saya memiliki masalah yang sama. Karena kelas yang saya coba mengejek adalah kelas yang sederhana, saya hanya membuat instance dan mengembalikannya.

Cobalah ini:

Mockito.mock(SomeMockableType.class,AdditionalAnswers.delegatesTo(someInstanceThatIsNotMockableOrSpyable));

Ini berhasil untuk saya. "SomeMockableType.class" adalah kelas induk dari apa yang Anda ingin tiru atau mata-mata, dan beberapaInstanceThatIsNotMockableOrSpyable adalah kelas aktual yang Anda ingin tiru atau mata-mata.

Untuk lebih jelasnya lihat di sini

Solusi lain, yang mungkin berlaku dalam beberapa kasus, adalah membuat antarmuka yang diimplementasikan oleh kelas akhir itu, mengubah kode untuk menggunakan antarmuka, bukan kelas beton dan kemudian mengejek antarmuka. Ini memungkinkan Anda memisahkan kontrak (antarmuka) dari implementasi (kelas akhir). Tentu saja, jika yang Anda inginkan benar-benar mengikat ke kelas akhir, ini tidak akan berlaku.

Sebenarnya ada satu cara, yang saya gunakan untuk memata-matai. Ini akan bekerja untuk Anda hanya jika dua prasyarat dipenuhi:

1. Anda menggunakan semacam DI untuk menyuntikkan instance kelas akhir
2. Kelas akhir mengimplementasikan antarmuka

Harap ingat Butir 16 dari Java Efektif . Anda dapat membuat pembungkus (bukan final) dan meneruskan semua panggilan ke turunan dari kelas akhir:

public final class RainOnTrees implement IRainOnTrees {
    @Override public void startRain() { // some code here }
}

public class RainOnTreesWrapper implement IRainOnTrees {
    private IRainOnTrees delegate;
    public RainOnTreesWrapper(IRainOnTrees delegate) {this.delegate = delegate;}
    @Override public void startRain() { delegate.startRain(); }
}

Sekarang Anda tidak hanya dapat mengejek kelas akhir Anda tetapi juga memata-matai:

public class Seasons{
    RainOnTrees rain;
    public Seasons(IRainOnTrees rain) { this.rain = rain; };
    public void findSeasonAndRain(){
        rain.startRain();
   }
}

IRainOnTrees rain = spy(new RainOnTreesWrapper(new RainOnTrees()) // or mock(IRainOnTrees.class)
doNothing().when(rain).startRain();
new Seasons(rain).findSeasonAndRain();

Di Mockito 3 dan lebih banyak lagi saya memiliki masalah yang sama dan memperbaikinya dari tautan ini

Mock Kelas Akhir dan Metode dengan Mockito sebagai berikut

Sebelum Mockito dapat digunakan untuk mengejek kelas dan metode final, ia perlu> dikonfigurasikan.

Kita perlu menambahkan file teks ke direktori src / test / resources / mockito-extensions proyek bernama org.mockito.plugins.MockMaker dan menambahkan satu baris teks:

mock-maker-inline

Mockito memeriksa direktori ekstensi untuk file-file konfigurasi ketika itu dimuat. File ini memungkinkan mengejek metode dan kelas akhir.

Penghemat waktu untuk orang-orang yang menghadapi masalah yang sama (Mockito + Kelas Akhir) di Android + Kotlin. Seperti dalam kelas Kotlin adalah final secara default. Saya menemukan solusi di salah satu sampel Android Google dengan komponen Arsitektur. Solusi dipilih dari sini: https://github.com/googlesamples/android-architecture-components/blob/master/GithubBrowserSample

Buat anotasi berikut:

/**
 * This annotation allows us to open some classes for mocking purposes while they are final in
 * release builds.
 */
@Target(AnnotationTarget.ANNOTATION_CLASS)
annotation class OpenClass

/**
 * Annotate a class with [OpenForTesting] if you want it to be extendable in debug builds.
 */
@OpenClass
@Target(AnnotationTarget.CLASS)
annotation class OpenForTesting

Ubah file gradle Anda. Ambil contoh dari sini: https://github.com/googlesamples/android-architecture-components/blob/master/GithubBrowserSample/app/build.gradle

apply plugin: 'kotlin-allopen'

allOpen {
    // allows mocking for classes w/o directly opening them for release builds
    annotation 'com.android.example.github.testing.OpenClass'
}

Sekarang Anda dapat membuat anotasi kelas apa saja untuk membuatnya terbuka untuk pengujian:

@OpenForTesting
class RepoRepository 

Ini dapat dilakukan jika Anda menggunakan Mockito2, dengan fitur inkubasi baru yang mendukung mengejek kelas akhir & metode.

Poin-poin penting yang perlu diperhatikan:
1. Buat file sederhana dengan nama "org.mockito.plugins.MockMaker" dan letakkan di folder bernama "mockito-extensions". Folder ini harus tersedia di classpath.
2. Konten file yang dibuat di atas harus satu baris seperti yang diberikan di bawah ini:
mock-maker-inline

Dua langkah di atas diperlukan untuk mengaktifkan mekanisme ekstensi mockito dan menggunakan fitur opt-in ini.

Kelas sampel adalah sebagai berikut: -

FinalClass.java

public final class FinalClass {

public final String hello(){
    System.out.println("Final class says Hello!!!");
    return "0";
}

}

Foo.java

public class Foo {

public String executeFinal(FinalClass finalClass){
    return finalClass.hello();
}

}

FooTest.java

public class FooTest {

@Test
public void testFinalClass(){
    // Instantiate the class under test.
    Foo foo = new Foo();

    // Instantiate the external dependency
    FinalClass realFinalClass = new FinalClass();

    // Create mock object for the final class. 
    FinalClass mockedFinalClass = mock(FinalClass.class);

    // Provide stub for mocked object.
    when(mockedFinalClass.hello()).thenReturn("1");

    // assert
    assertEquals("0", foo.executeFinal(realFinalClass));
    assertEquals("1", foo.executeFinal(mockedFinalClass));

}

}

Semoga ini bisa membantu.

Artikel lengkap hadir di sini mengejek-unmockable .

Ya masalah yang sama di sini, kita tidak bisa mengejek kelas terakhir dengan Mockito. Agar akurat, Mockito tidak dapat mengejek / memata-matai berikut:

• kelas akhir
• kelas anonim
• tipe primitif

Tetapi menggunakan kelas pembungkus menurut saya harga yang harus dibayar, jadi dapatkan PowerMockito sebagai gantinya.

Saya pikir Anda perlu berpikir lebih pada prinsipnya. Sebagai gantinya Anda kelas akhir menggunakan antarmuka dan antarmuka tiruan sebagai gantinya.

Untuk ini:

 public class RainOnTrees{

   fun startRain():Observable<Boolean>{

        // some code here
   }
}

Menambahkan

interface iRainOnTrees{
  public void startRain():Observable<Boolean>
}

dan mengejek antarmuka Anda:

 @Before
    fun setUp() {
        rainService= Mockito.mock(iRainOnTrees::class.java)

        `when`(rainService.startRain()).thenReturn(
            just(true).delay(3, TimeUnit.SECONDS)
        )

    }

Silakan lihat JMockit . Ini memiliki dokumentasi yang luas dengan banyak contoh. Di sini Anda memiliki contoh solusi dari masalah Anda (untuk menyederhanakan saya telah menambahkan konstruktor Seasonsuntuk menyuntikkan RainOnTreescontoh mocked ):

package jmockitexample;

import mockit.Mocked;
import mockit.Verifications;
import mockit.integration.junit4.JMockit;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(JMockit.class)
public class SeasonsTest {

    @Test
    public void shouldStartRain(@Mocked final RainOnTrees rain) {
        Seasons seasons = new Seasons(rain);

        seasons.findSeasonAndRain();

        new Verifications() {{
            rain.startRain();
        }};
    }

    public final class RainOnTrees {
        public void startRain() {
            // some code here
        }

    }

    public class Seasons {

        private final RainOnTrees rain;

        public Seasons(RainOnTrees rain) {
            this.rain = rain;
        }

        public void findSeasonAndRain() {
            rain.startRain();
        }

    }
}

Solusi yang diberikan oleh RC dan Luigi R. Viggiano bersama mungkin adalah ide terbaik.

Meskipun Mockito tidak bisa , dengan desain, mengejek kelas akhir, pendekatan delegasi dimungkinkan . Ini memiliki kelebihan:

1. Anda tidak dipaksa untuk mengubah kelas Anda menjadi non-final jika itu yang menjadi tujuan API Anda (kelas akhir memiliki manfaatnya ).
2. Anda sedang menguji kemungkinan dekorasi di sekitar API Anda.

Dalam kasus pengujian Anda, Anda dengan sengaja meneruskan panggilan ke sistem yang sedang diuji. Karenanya, secara desain, dekorasi Anda tidak melakukan apa-apa.

Karenanya, Anda menguji juga dapat menunjukkan bahwa pengguna hanya dapat menghias API alih-alih memperpanjangnya.

Pada catatan yang lebih subyektif: Saya lebih suka menjaga kerangka kerja seminimal mungkin, itulah sebabnya JUnit dan Mockito biasanya cukup untuk saya. Bahkan, dengan membatasi cara ini kadang-kadang memaksa saya untuk refactor untuk selamanya juga.

Jika Anda mencoba menjalankan unit-test di bawah folder tes , solusi teratas baik-baik saja. Cukup ikuti itu menambahkan ekstensi.

Tetapi jika Anda ingin menjalankannya dengan kelas terkait Android seperti konteks atau aktivitas yang berada di bawah folder androidtest , jawabannya adalah untuk Anda.

Tambahkan dependensi ini untuk menjalankan mockito dengan sukses:

testImplementation 'org.mockito: mockito-core: 2.24.5'
testImplementation "org.mockito: mockito-inline: 2.24.5"

Seperti yang telah dinyatakan orang lain, ini tidak akan berhasil dengan Mockito. Saya akan menyarankan menggunakan refleksi untuk mengatur bidang spesifik pada objek yang sedang digunakan oleh kode yang diuji. Jika Anda sering melakukan hal ini, Anda dapat membungkus fungsi ini di perpustakaan.

Sebagai tambahan, jika Anda adalah satu-satunya yang menandai kelas final, berhentilah melakukannya. Saya mengalami pertanyaan ini karena saya bekerja dengan API di mana semuanya ditandai sebagai final untuk mencegah kebutuhan sah saya untuk ekstensi (mengejek), dan saya berharap bahwa pengembang tidak berasumsi bahwa saya tidak akan pernah perlu memperluas kelas.

Bagi kami, itu karena kami mengecualikan mockito-inline dari koin-test. Satu modul gradle sebenarnya membutuhkan ini dan karena alasan hanya gagal pada rilis build (debug build di IDE berfungsi) :-P

Untuk kelas akhir, tambahkan di bawah ini untuk mengejek dan memanggil statis atau non-statis.

1- tambahkan ini di tingkat kelas @SuppressStatucInitializationFor (value = {nama kelas dengan paket})
2- PowerMockito.mockStatic (classname.class) akan mengolok-olok kelas
3- lalu gunakan pernyataan when Anda untuk mengembalikan objek tiruan saat memanggil metode kelas ini.

Nikmati

Tidak mencoba final, tetapi untuk pribadi, menggunakan refleksi menghapus pengubah bekerja! sudah diperiksa lebih lanjut, tidak berfungsi untuk final.