Apa kerangka kerja mock terbaik untuk Java? [Tutup]

Apa kerangka kerja terbaik untuk membuat objek tiruan di Jawa? Mengapa? Apa pro dan kontra dari setiap kerangka kerja?

Saya sudah sukses menggunakan Mockito .

Ketika saya mencoba belajar tentang JMock dan EasyMock, saya menemukan kurva belajar agak curam (meskipun mungkin itu hanya saya).

Saya suka Mockito karena sintaksisnya yang sederhana dan bersih yang dapat saya pahami dengan cepat. Sintaks minimal dirancang untuk mendukung kasus-kasus umum dengan sangat baik, walaupun beberapa kali saya perlu melakukan sesuatu yang lebih rumit, saya menemukan apa yang saya inginkan didukung dan mudah dipahami.

Inilah contoh (ringkas) dari beranda Mockito:

import static org.mockito.Mockito.*;

List mockedList = mock(List.class);
mockedList.clear();
verify(mockedList).clear();

Itu tidak menjadi jauh lebih sederhana dari itu.

Satu-satunya downside utama yang dapat saya pikirkan adalah bahwa itu tidak akan mengejek metode statis.

Saya pencipta PowerMock jadi jelas saya harus merekomendasikan itu! :-)

PowerMock memperluas EasyMock dan Mockito dengan kemampuan untuk mengejek metode statis , final dan bahkan metode pribadi. Dukungan EasyMock sudah selesai, tetapi plugin Mockito membutuhkan lebih banyak pekerjaan. Kami berencana untuk menambahkan dukungan JMock juga.

PowerMock tidak dimaksudkan untuk menggantikan kerangka kerja lain, melainkan dapat digunakan dalam situasi sulit ketika kerangka kerja lain tidak memungkinkan mengejek. PowerMock juga mengandung fitur berguna lainnya seperti menekan inisialisasi statis dan konstruktor.

Situs proyek JMockit berisi banyak informasi komparatif untuk toolkit mengejek saat ini.

Secara khusus, periksa matriks perbandingan fitur , yang mencakup EasyMock, jMock, Mockito, Unitils Mock, PowerMock, dan tentu saja JMockit. Saya berusaha untuk tetap akurat dan mutakhir, sebanyak mungkin.

Saya sudah sukses dengan JMockit .

Ini cukup baru, jadi sedikit mentah dan kurang didokumentasikan. Ia menggunakan ASM untuk secara dinamis mendefinisikan kembali bytecode kelas, sehingga ia dapat mencemooh semua metode termasuk statis, privat, konstruktor, dan penginisialisasi statis. Sebagai contoh:

import mockit.Mockit;

...
Mockit.redefineMethods(MyClassWithStaticInit.class,
                       MyReplacementClass.class);
...
class MyReplacementClass {
  public void $init() {...} // replace default constructor
  public static void $clinit{...} // replace static initializer
  public static void myStatic{...} // replace static method
  // etc...
}

Ini memiliki antarmuka Ekspektasi yang memungkinkan skenario rekaman / pemutaran juga:

import mockit.Expectations;
import org.testng.annotations.Test;

public class ExpecationsTest {
  private MyClass obj;

  @Test
  public void testFoo() {
    new Expectations(true) {
      MyClass c;
      {
        obj = c;
        invokeReturning(c.getFoo("foo", false), "bas");
      }
    };

    assert "bas".equals(obj.getFoo("foo", false));

    Expectations.assertSatisfied();
  }

  public static class MyClass {
    public String getFoo(String str, boolean bool) {
      if (bool) {
        return "foo";
      } else {
        return "bar";
      }
    }
  }
}

Kelemahannya adalah itu membutuhkan Java 5/6.

Anda juga bisa melihat pengujian menggunakan Groovy. Di Groovy Anda dapat dengan mudah mengejek antarmuka Java menggunakan operator 'as':

def request = [isUserInRole: { roleName -> roleName == "testRole"}] as HttpServletRequest 

Terlepas dari fungsi dasar ini, Groovy menawarkan lebih banyak hal untuk mengejek, termasuk kelas yang tangguh MockFordan StubForberkelas.

http://docs.codehaus.org/display/GROOVY/Groovy+Mocks

Saya mulai menggunakan ejekan dengan EasyMock . Cukup mudah dimengerti, tetapi langkah replay agak menjengkelkan. Mockito menghapus ini, juga memiliki sintaks yang lebih bersih karena sepertinya keterbacaan adalah salah satu tujuan utamanya. Saya tidak bisa cukup menekankan betapa pentingnya hal ini, karena sebagian besar pengembang akan menghabiskan waktu mereka membaca dan memelihara kode yang ada, tidak membuatnya.

Hal lain yang menyenangkan adalah antarmuka dan kelas implementasi ditangani dengan cara yang sama, tidak seperti di EasyMock di mana Anda masih perlu mengingat (dan memeriksa) untuk menggunakan Ekstensi Kelas EasyMock.

Saya telah mengambil pandangan cepat di JMockit baru-baru ini, dan sementara daftar fitur binatu cukup komprehensif, saya pikir harga ini dapat dibaca dari kode yang dihasilkan, dan harus menulis lebih banyak.

Bagi saya, Mockito menyentuh sweet spot, mudah menulis dan membaca, dan berurusan dengan sebagian besar situasi yang paling dibutuhkan kode. Menggunakan Mockito dengan PowerMock akan menjadi pilihan saya.

Satu hal yang perlu dipertimbangkan adalah bahwa alat yang akan Anda pilih jika Anda mengembangkan sendiri, atau dalam tim kecil, mungkin bukan yang terbaik untuk perusahaan besar dengan pengembang dari berbagai tingkat keterampilan. Keterbacaan, kemudahan penggunaan dan kesederhanaan akan membutuhkan lebih banyak pertimbangan dalam kasus terakhir. Tidak masuk akal untuk mendapatkan kerangka kerja ejekan utama jika banyak orang yang akhirnya tidak menggunakannya atau tidak melakukan tes.

Kami banyak menggunakan EasyMock dan Ekstensi Kelas EasyMock di tempat kerja dan cukup senang dengannya. Ini pada dasarnya memberi Anda semua yang Anda butuhkan. Lihatlah dokumentasi, ada contoh yang sangat bagus yang menunjukkan kepada Anda semua fitur EasyMock.

Saya menggunakan JMock lebih awal. Saya sudah mencoba Mockito di proyek terakhir saya dan menyukainya. Lebih ringkas, lebih bersih. PowerMock mencakup semua kebutuhan yang tidak ada di Mockito, seperti mengejek kode statis, mengejek pembuatan instance, mengejek kelas dan metode akhir. Jadi saya memiliki semua yang saya butuhkan untuk melakukan pekerjaan saya.

Saya suka JMock karena Anda dapat mengatur harapan. Ini sama sekali berbeda dari memeriksa apakah suatu metode dipanggil ditemukan di beberapa perpustakaan tiruan. Menggunakan JMock Anda dapat menulis harapan yang sangat canggih. Lihat jmock cheat-sheat .

Ya, Mockito adalah kerangka kerja yang hebat. Saya menggunakannya bersama dengan hamcrest dan Google guice untuk mengatur tes saya.

Solusi terbaik untuk mengejek adalah membuat mesin melakukan semua pekerjaan dengan pengujian berbasis spesifikasi otomatis. Untuk Java, lihat ScalaCheck dan kerangka kerja Reductio yang termasuk dalam perpustakaan Java Fungsional . Dengan kerangka kerja pengujian berbasis spesifikasi otomatis, Anda memberikan spesifikasi metode yang diuji (properti tentang hal itu yang seharusnya benar) dan kerangka kerja menghasilkan tes serta benda tiruan, secara otomatis.

Sebagai contoh, properti berikut menguji metode Math.sqrt untuk melihat apakah akar kuadrat dari setiap bilangan positif n kuadrat sama dengan n.

val propSqrt = forAll { (n: Int) => (n >= 0) ==> scala.Math.sqrt(n*n) == n }

Ketika Anda menelepon propSqrt.check(), ScalaCheck menghasilkan ratusan bilangan bulat dan memeriksa properti Anda untuk masing-masing, juga secara otomatis memastikan bahwa kasing tepi tertutup dengan baik.

Meskipun ScalaCheck ditulis dalam Scala, dan membutuhkan Scala Compiler, mudah untuk menguji kode Java dengannya. Kerangka kerja Reductio di Java Fungsional adalah implementasi Java murni dari konsep yang sama.

Mockito juga menyediakan opsi metode stubbing, argumen yang cocok (seperti anyInt () dan anyString ()), memverifikasi jumlah doa (kali (3), atLeastOnce (), never ()), dan banyak lagi .

Saya juga menemukan bahwa Mockito sederhana dan bersih .

Satu hal yang saya tidak suka dari Mockito adalah Anda tidak bisa mematikan metode statis .

Untuk sesuatu yang sedikit berbeda, Anda bisa menggunakan JRuby dan Mocha yang digabungkan dalam JtestR untuk menulis tes untuk kode Java Anda dalam Ruby ekspresif dan ringkas. Ada beberapa contoh mengejek yang berguna dengan JtestR di sini . Salah satu keuntungan dari pendekatan ini adalah bahwa kelas beton mengejek sangat mudah.

Saya mulai menggunakan mock melalui JMock, tetapi akhirnya beralih menggunakan EasyMock. EasyMock hanya itu, - lebih mudah - dan memberikan sintaks yang terasa lebih alami. Saya belum beralih sejak.