Apa perbedaan antara berpura-pura, mengejek, dan mematikan?

706

Saya tahu bagaimana saya menggunakan istilah-istilah ini, tetapi saya bertanya-tanya apakah ada definisi yang diterima untuk memalsukan , mengejek , dan mematikan untuk tes unit? Bagaimana Anda mendefinisikan ini untuk tes Anda? Jelaskan situasi di mana Anda dapat menggunakannya masing-masing.

Inilah cara saya menggunakannya:

Palsu : kelas yang mengimplementasikan antarmuka tetapi berisi data tetap dan tidak ada logika. Cukup kembalikan data "baik" atau "buruk" tergantung pada implementasinya.

Mock : kelas yang mengimplementasikan antarmuka dan memungkinkan kemampuan untuk secara dinamis mengatur nilai untuk kembali / pengecualian untuk membuang dari metode tertentu dan menyediakan kemampuan untuk memeriksa apakah metode tertentu telah dipanggil / tidak dipanggil.

Stub : Seperti kelas tiruan, kecuali itu tidak memberikan kemampuan untuk memverifikasi bahwa metode telah dipanggil / tidak dipanggil.

Mengejek dan bertopik dapat dihasilkan atau dihasilkan oleh kerangka kerja mengejek. Kelas palsu dihasilkan dengan tangan. Saya menggunakan tiruan terutama untuk memverifikasi interaksi antara kelas saya dan kelas dependen. Saya menggunakan bertopik setelah saya memverifikasi interaksi dan sedang menguji jalur alternatif melalui kode saya. Saya menggunakan kelas palsu terutama untuk abstrak keluar ketergantungan data atau ketika mengejek / bertopik terlalu membosankan untuk mengatur setiap kali.

tvanfosson
sumber
6
Yah Anda pada dasarnya mengatakan semuanya dalam "pertanyaan" Anda :) Saya pikir itu adalah definisi istilah-istilah tersebut yang diterima dengan baik
Eran Galperin
2
Definisi Wikipedia tentang Palsu berbeda dari ini, menyatakan bahwa Palsu "digunakan sebagai implementasi yang lebih sederhana, misalnya menggunakan basis data dalam-memori dalam pengujian alih-alih melakukan akses basis data nyata)" Lihat en.wikipedia.org/wiki/Test_double
zumalifeguard
2
Saya belajar banyak dari sumber berikut, dengan penjelasan yang sangat baik oleh Robert C. Martin (Paman Bob): Si Pengejek Kecil di Blog Kode Bersih . Ini menjelaskan perbedaan antara dan kehalusan dummies, tes ganda, bertopik, mata-mata, mock dan palsu (benar). Ini juga menyebutkan Martin Fowler dan menjelaskan sedikit sejarah pengujian perangkat lunak.
Erik
testing.googleblog.com/2013/07/… (ringkasan satu halaman pendek).
ShreevatsaR
Inilah yang saya ambil untuk menjelaskan: Test Doubles: Fakes, Stubs and Mocks (posting blog dengan contoh)
michal-lipski

Jawaban:

548

Anda dapat memperoleh beberapa informasi:

Dari Martin Fowler tentang Mock and Stub

Benda palsu sebenarnya memiliki implementasi yang berfungsi, tetapi biasanya mengambil beberapa jalan pintas yang membuatnya tidak cocok untuk produksi

Rintisan bertopik memberikan jawaban kalengan untuk panggilan yang dilakukan selama tes, biasanya tidak menanggapi apa pun di luar apa yang diprogram dalam tes. Rintisan bertopik juga dapat merekam informasi tentang panggilan, seperti rintisan gateway email yang mengingat pesan yang 'dikirim', atau mungkin hanya berapa banyak pesan yang 'dikirim'.

Mengolok - olok adalah apa yang kita bicarakan di sini: objek diprogram dengan harapan yang membentuk spesifikasi panggilan mereka diharapkan untuk menerima.

Dari xunitpattern :

Palsu : Kami memperoleh atau membangun implementasi yang sangat ringan dengan fungsi yang sama seperti yang disediakan oleh komponen yang menjadi andalan SUT dan memerintahkan SUT untuk menggunakannya alih-alih yang asli.

Stub : Implementasi ini dikonfigurasikan untuk menanggapi panggilan dari SUT dengan nilai (atau pengecualian) yang akan menggunakan Kode yang Belum Diuji (lihat Bug Produksi pada halaman X) dalam SUT. Indikasi kunci untuk menggunakan Test Stub adalah memiliki Kode yang Belum Teruji yang disebabkan oleh ketidakmampuan untuk mengontrol input SUT yang tidak langsung

Objek tiruan yang mengimplementasikan antarmuka yang sama dengan objek tempat SUT (Sistem Diuji) bergantung. Kita dapat menggunakan Objek Mock sebagai titik pengamatan ketika kita perlu melakukan Verifikasi Perilaku untuk menghindari Persyaratan yang Tidak Teruji (lihat Bug Produksi pada halaman X) yang disebabkan oleh ketidakmampuan untuk mengamati efek samping dari metode pemanggilan pada SUT.

Sendiri

Saya mencoba menyederhanakan dengan menggunakan: Mock and Stub. Saya menggunakan Mock ketika itu adalah objek yang mengembalikan nilai yang diatur ke kelas yang diuji. Saya menggunakan rintisan untuk meniru kelas Interface atau Abstrak untuk diuji. Sebenarnya, tidak masalah apa pun sebutan Anda, mereka semua kelas yang tidak digunakan dalam produksi, dan digunakan sebagai kelas utilitas untuk pengujian.

Patrick Desjardins
sumber
9
Menurut saya definisi untuk Stub and Fake terbalik dalam kutipan xUnitPattern dibandingkan dengan kutipan Martin Fowler. Juga, bahwa definisi Stub dan Fake Martin Fowler terbalik dibandingkan dengan definisi dalam pertanyaan asli tvanfosson. Pada kenyataannya, adakah definisi yang diterima secara umum dari kedua istilah itu atau apakah itu hanya tergantung pada siapa Anda berbicara?
Simon Tewsi
3
+1 untuk "Saya mencoba menyederhanakan dengan menggunakan: Mock and Stub". Itu ide yang bagus!
Brad Cupit
4
Tidak dapat melihat bagaimana menggunakan hanya Mock dan Stub adalah ide bagus. Setiap tes ganda memiliki tujuan dan, karenanya, penggunaannya.
Hector Ordonez
1
Saya tidak bisa melihat perbedaan antara Palsu dan Mock dalam definisi MF.
IdontCareAboutReputationPoints
2
@MusuNaji: Dalam definisi MF tidak ada "harapan" dalam hal percakapan untuk Palsu, selain itu memiliki implementasi untuk antarmuka itu. Di sisi lain Mock akan ditantang (apakah metode ini disebut?).
dbalakirev
205

Stub - sebuah objek yang menyediakan jawaban yang telah ditentukan untuk panggilan metode.

Mock - objek tempat Anda menetapkan harapan.

Palsu - objek dengan kemampuan terbatas (untuk keperluan pengujian), mis. Layanan web palsu.

Test Double adalah istilah umum untuk bertopik, mengolok-olok dan palsu. Tetapi secara informal, Anda akan sering mendengar orang hanya menyebut mereka mengejek.

Mike
sumber
4
Adakah yang bisa menjelaskan & menjelaskan kepada saya apa itu "jawaban kalengan" dalam konteks ini?
MasterMastic
14
Nilai eksplisit, bukan nilai yang dihitung.
Mike
Akhirnya! Beberapa definisi yang bisa saya mengerti! Berdasarkan definisi ini, maka, googletest (gtest) / googlemock (gmock) memungkinkan objek yang diejek juga bertopik, karena Anda dapat membuat EXPECT_CALL()s pada metode yang diolok-olok yang memaksa keluaran tertentu berdasarkan input tertentu, dengan menggunakan tipe .WillOnce(Invoke(my_func_or_lambda_func))(atau dengan .WillRepeatedly()) sintaks terlampir pada sebuah EXPECT_CALL(). Beberapa contoh penggunaan Invoke()dapat dilihat dalam konteks berbeda di bagian bawah jawaban panjang saya di sini: stackoverflow.com/a/60905880/4561887 .
Gabriel Staples
Dokumentasi Gmock ada di Invoke()sini: github.com/google/googletest/blob/master/googlemock/docs/… . Lagi pula, kesimpulannya adalah: Google mock (gmock) memungkinkan seseorang untuk dengan mudah membuat tiruan dan bertopik , meskipun sebagian besar tiruan bukan bertopik.
Gabriel Staples
Mock adalah superset dari bertopik, mereka masih bisa mengembalikan jawaban yang telah ditentukan tetapi juga memungkinkan pengembang untuk menetapkan harapan. IMO perpustakaan tertentu di luar sana mengaburkan garis semua boneka pengujian.
Luke
94

Saya terkejut bahwa pertanyaan ini sudah ada sejak lama dan belum ada yang memberikan jawaban berdasarkan "The Art of Unit Testing" karya Roy Osherove .

Dalam "3.1 Introducing stubs" mendefinisikan sebuah rintisan sebagai:

Stub adalah pengganti yang dapat dikontrol untuk ketergantungan yang ada (atau kolaborator) dalam sistem. Dengan menggunakan rintisan, Anda dapat menguji kode Anda tanpa berurusan dengan ketergantungan secara langsung.

Dan mendefinisikan perbedaan antara bertopik dan mengolok-olok sebagai:

Hal utama yang perlu diingat tentang tiruan versus bertopik adalah bahwa tiruan itu seperti bertopik, tetapi Anda menegaskan terhadap objek tiruan, sedangkan Anda tidak menegaskan terhadap rintisan.

Palsu hanyalah nama yang digunakan untuk bertopik dan mengolok-olok. Misalnya ketika Anda tidak peduli tentang perbedaan antara bertopik dan mengolok-olok.

Cara Osherove membedakan antara bertopik dan mengolok-olok, berarti bahwa setiap kelas yang digunakan sebagai palsu untuk pengujian dapat berupa sebuah rintisan atau tiruan. Yang mana untuk tes tertentu tergantung sepenuhnya pada bagaimana Anda menulis cek dalam tes Anda.

  • Ketika tes Anda memeriksa nilai di kelas yang diuji, atau benar-benar di mana saja selain yang palsu, yang palsu itu digunakan sebagai rintisan. Itu hanya memberikan nilai untuk kelas yang diuji untuk digunakan, baik secara langsung melalui nilai yang dikembalikan oleh panggilan di atasnya atau secara tidak langsung melalui efek samping (dalam beberapa keadaan) sebagai hasil dari panggilan di atasnya.
  • Ketika tes Anda memeriksa nilai-nilai palsu, itu digunakan sebagai tiruan.

Contoh tes di mana kelas FakeX digunakan sebagai rintisan:

const pleaseReturn5 = 5;
var fake = new FakeX(pleaseReturn5);
var cut = new ClassUnderTest(fake);

cut.SquareIt;

Assert.AreEqual(25, cut.SomeProperty);

The fakecontoh digunakan sebagai sebuah rintisan karena Asserttidak menggunakan fakesama sekali.

Contoh tes di mana tes kelas X digunakan sebagai tiruan:

const pleaseReturn5 = 5;
var fake = new FakeX(pleaseReturn5);
var cut = new ClassUnderTest(fake);

cut.SquareIt;

Assert.AreEqual(25, fake.SomeProperty);

Dalam hal ini Assertcek nilai pada fake, membuat tiruan itu palsu.

Sekarang, tentu saja contoh-contoh ini sangat dibuat-buat, tetapi saya melihat manfaat besar dalam perbedaan ini. Ini membuat Anda menyadari bagaimana Anda menguji barang-barang Anda dan di mana dependensi tes Anda berada.

Saya setuju dengan Osherove

dari perspektif perawatan murni, dalam pengujian saya menggunakan mock menciptakan lebih banyak masalah daripada tidak menggunakannya. Itu pengalaman saya, tapi saya selalu belajar sesuatu yang baru.

Menegaskan yang palsu adalah sesuatu yang Anda benar-benar ingin hindari karena membuat tes Anda sangat tergantung pada implementasi kelas yang bukan yang diuji sama sekali. Yang berarti bahwa tes untuk kelas ActualClassUnderTestdapat mulai melanggar karena implementasi untuk ClassUsedAsMockdiubah. Dan itu mengirimkan bau busuk kepada saya. Tes untuk ActualClassUnderTestsebaiknya hanya istirahat ketika ActualClassUnderTestdiubah.

Saya menyadari bahwa menulis menegaskan bahwa yang palsu adalah praktik yang umum, terutama ketika Anda adalah tipe pelanggan TDD tiruan. Saya kira saya tegas dengan Martin Fowler di kubu klasik (Lihat Martin Fowler "Mocks tidak bertopik" ) dan seperti Osherove menghindari pengujian interaksi (yang hanya dapat dilakukan dengan menyatakan melawan yang palsu) sebanyak mungkin.

Untuk bersenang-senang membaca mengapa Anda harus menghindari ejekan seperti yang didefinisikan di sini, google untuk "fowler mockist classicist". Anda akan menemukan sejumlah besar pendapat.

Marjan Venema
sumber
30

Seperti disebutkan oleh jawaban terpilih, Martin Fowler membahas perbedaan-perbedaan ini di Mocks Aron't Stubs , dan khususnya subjudul The Difference Between Mocks and Stubs , jadi pastikan untuk membaca artikel itu.

Daripada berfokus pada bagaimana hal-hal ini berbeda, saya pikir itu lebih mencerahkan untuk fokus pada mengapa ini adalah konsep yang berbeda. Masing-masing ada untuk tujuan yang berbeda.

Palsu

Sebuah palsu adalah sebuah implementasi yang berperilaku "alami", tetapi tidak "nyata". Ini adalah konsep yang kabur dan orang yang berbeda memiliki pemahaman yang berbeda tentang apa yang membuat sesuatu menjadi palsu.

Salah satu contoh palsu adalah basis data dalam memori (misalnya menggunakan sqlite dengan :memory:toko). Anda tidak akan pernah menggunakan ini untuk produksi (karena data tidak bertahan), tetapi itu sangat memadai sebagai database untuk digunakan dalam lingkungan pengujian. Ini juga jauh lebih ringan daripada database "nyata".

Sebagai contoh lain, mungkin Anda menggunakan beberapa jenis penyimpanan objek (misalnya Amazon S3) dalam produksi, tetapi dalam pengujian Anda bisa menyimpan objek ke file pada disk; maka implementasi "save to disk" Anda akan menjadi palsu. (Atau Anda bahkan bisa memalsukan operasi "simpan ke disk" dengan menggunakan sistem file di memori sebagai gantinya.)

Sebagai contoh ketiga, bayangkan objek yang menyediakan API cache; sebuah objek yang mengimplementasikan antarmuka yang benar tetapi tidak melakukan caching sama sekali tetapi selalu mengembalikan cache miss akan menjadi semacam palsu.

Tujuan dari suatu kepalsuan bukan untuk mempengaruhi perilaku sistem yang diuji , tetapi untuk menyederhanakan implementasi tes (dengan menghapus ketergantungan yang tidak perlu atau kelas berat).

Rintisan bertopik

Sebuah stub merupakan implementasi yang berperilaku "tidak wajar". Ini sudah dikonfigurasikan sebelumnya (biasanya oleh set tes) untuk menanggapi input spesifik dengan output spesifik.

Tujuan dari rintisan adalah untuk menguji sistem Anda ke keadaan tertentu. Misalnya, jika Anda menulis tes untuk beberapa kode yang berinteraksi dengan REST API, Anda bisa mematikan REST API dengan API yang selalu mengembalikan respons kalengan, atau yang menanggapi permintaan API dengan kesalahan tertentu. Dengan cara ini Anda bisa menulis tes yang membuat pernyataan tentang bagaimana sistem bereaksi terhadap keadaan ini; misalnya, menguji respons yang didapat pengguna Anda jika API mengembalikan kesalahan 404.

Sebuah rintisan biasanya diterapkan untuk hanya menanggapi interaksi persis yang Anda katakan untuk ditanggapi. Tetapi fitur kunci yang membuat sesuatu menjadi rintisan adalah tujuannya : rintisan adalah tentang menyiapkan test case Anda.

Mengejek

Sebuah mock mirip dengan rintisan, tapi dengan verifikasi ditambahkan dalam. Tujuan dari mock adalah untuk membuat pernyataan tentang bagaimana sistem Anda di bawah uji berinteraksi dengan ketergantungan .

Misalnya, jika Anda menulis tes untuk sistem yang mengunggah file ke situs web, Anda bisa membuat tiruan yang menerima file dan yang dapat Anda gunakan untuk menyatakan bahwa file yang diunggah benar. Atau, dalam skala yang lebih kecil, adalah hal biasa untuk menggunakan tiruan dari suatu objek untuk memverifikasi bahwa sistem yang diuji memanggil metode tertentu dari objek yang diejek.

Mock terikat pada pengujian interaksi , yang merupakan metodologi pengujian khusus. Orang-orang yang lebih suka menguji keadaan sistem daripada interaksi sistem akan menggunakan ejekan hemat jika sama sekali.

Tes ganda

Palsu, bertopik, dan mengolok-olok semuanya termasuk dalam kategori tes ganda . Tes ganda adalah objek atau sistem apa pun yang Anda gunakan dalam ujian alih-alih yang lain. Sebagian besar pengujian perangkat lunak otomatis melibatkan penggunaan uji ganda atau sejenisnya. Beberapa jenis lain dari ganda tes meliputi nilai-nilai boneka , mata-mata , dan I / O Blackholes .

Daniel Pryden
sumber
11

Untuk mengilustrasikan penggunaan bertopik dan mengolok-olok, saya ingin juga menyertakan contoh berdasarkan " The Art of Unit Testing " karya Roy Osherove .

Bayangkan, kami memiliki aplikasi LogAnalyzer yang memiliki fungsi tunggal untuk mencetak log. Itu tidak hanya perlu berbicara dengan layanan web, tetapi jika layanan web membuat kesalahan, LogAnalyzer harus mencatat kesalahan ke ketergantungan eksternal yang berbeda, mengirimkannya melalui email ke administrator layanan web.

Inilah logika yang ingin kami uji di dalam LogAnalyzer:

if(fileName.Length<8)
{
 try
  {
    service.LogError("Filename too short:" + fileName);
  }
 catch (Exception e)
  {
    email.SendEmail("a","subject",e.Message);
  }
}

Bagaimana Anda menguji bahwa LogAnalyzer memanggil layanan email dengan benar ketika layanan web mengeluarkan pengecualian? Inilah beberapa pertanyaan yang kami hadapi:

  • Bagaimana kita bisa mengganti layanan web?

  • Bagaimana kita bisa mensimulasikan pengecualian dari layanan web sehingga kita dapat menguji panggilan ke layanan email?

  • Bagaimana kita tahu bahwa layanan email dipanggil dengan benar atau tidak sama sekali?

Kami dapat menangani dua pertanyaan pertama dengan menggunakan rintisan untuk layanan web . Untuk mengatasi masalah ketiga, kita bisa menggunakan objek tiruan untuk layanan email .

Palsu adalah istilah umum yang dapat digunakan untuk menggambarkan stub atau mock. Dalam pengujian kami, kami akan mendapatkan dua pemalsuan. Salah satunya adalah tiruan layanan email, yang akan kami gunakan untuk memverifikasi bahwa parameter yang benar dikirim ke layanan email. Yang lainnya akan menjadi sebuah rintisan yang akan kita gunakan untuk mensimulasikan pengecualian yang dilemparkan dari layanan web. Itu sebuah rintisan karena kami tidak akan menggunakan layanan web palsu untuk memverifikasi hasil tes, hanya untuk memastikan tes berjalan dengan benar. Layanan email adalah tiruan karena kami akan menyatakan bahwa itu disebut dengan benar.

[TestFixture]
public class LogAnalyzer2Tests
{
[Test]
 public void Analyze_WebServiceThrows_SendsEmail()
 {
   StubService stubService = new StubService();
   stubService.ToThrow= new Exception("fake exception");
   MockEmailService mockEmail = new MockEmailService();

   LogAnalyzer2 log = new LogAnalyzer2();
   log.Service = stubService
   log.Email=mockEmail;
   string tooShortFileName="abc.ext";
   log.Analyze(tooShortFileName);

   Assert.AreEqual("a",mockEmail.To); //MOCKING USED
   Assert.AreEqual("fake exception",mockEmail.Body); //MOCKING USED
   Assert.AreEqual("subject",mockEmail.Subject);
 }
}
nanospeck
sumber
9

hal yang Anda tegaskan di atasnya, disebut objek tiruan dan segala sesuatu yang hanya membantu uji coba, adalah sebuah rintisan .

Arezoo Bagherzadi
sumber
1
sementara jawaban lain memiliki detail yang sangat bagus dan sangat bagus. yang ini membuatnya sangat jelas dan mudah untuk membuat perbedaan, sulit untuk tidak mengalah. gj!
Mario Garcia
6

Ini masalah membuat tes ekspresif. Saya menetapkan harapan pada Mock jika saya ingin tes untuk menggambarkan hubungan antara dua objek. Saya rintisan nilai kembali jika saya menyiapkan objek pendukung untuk membawa saya ke perilaku yang menarik dalam ujian.

Steve Freeman
sumber
6

Jika Anda terbiasa dengan Arrange-Act-Assert, maka salah satu cara untuk menjelaskan perbedaan antara rintisan dan tiruan yang mungkin berguna bagi Anda, adalah bahwa rintisan milik bagian pengaturan, karena mereka untuk mengatur keadaan input, dan tiruan milik bagian asert karena mereka untuk menyatakan hasil melawan.

Dummies tidak melakukan apa pun. Mereka hanya untuk mengisi daftar parameter, sehingga Anda tidak mendapatkan kesalahan yang tidak terdefinisi atau nol. Mereka juga ada untuk memuaskan pemeriksa tipe dalam bahasa yang diketik dengan ketat, sehingga Anda dapat diizinkan untuk mengkompilasi dan menjalankan.

Sammi
sumber
3

Stub, Fakes, dan Mock memiliki arti berbeda di berbagai sumber. Saya menyarankan Anda untuk memperkenalkan ketentuan internal tim Anda dan menyetujui maknanya.

Saya pikir penting untuk membedakan antara dua pendekatan: - validasi perilaku (menyiratkan penggantian perilaku) - validasi keadaan akhir (menyiratkan emulasi perilaku)

Pertimbangkan pengiriman email jika terjadi kesalahan. Ketika melakukan validasi perilaku - Anda memeriksa bahwa metode Senddari IEmailSenderdieksekusi sekali. Dan Anda perlu meniru hasil dari metode ini, mengembalikan ID dari pesan yang dikirim. Jadi Anda berkata: "Saya berharap itu Sendakan dipanggil. Dan saya hanya akan mengembalikan nomor dummy (atau acak) untuk panggilan apa pun" . Ini adalah validasi perilaku: emailSender.Expect(es=>es.Send(anyThing)).Return((subject,body) => "dummyId")

Saat melakukan validasi negara, Anda harus membuat TestEmailSenderalat itu IEmailSender. Dan menerapkan Sendmetode - dengan menyimpan input ke beberapa struktur data yang akan digunakan untuk verifikasi keadaan di masa depan seperti array dari beberapa objek SentEmailsdan kemudian menguji Anda akan memeriksa yang SentEmailsberisi email yang diharapkan. Ini adalah validasi keadaan: Assert.AreEqual(1, emailSender.SentEmails.Count)

Dari bacaan saya, saya mengerti bahwa validasi Perilaku biasanya disebut Mocks . Dan validasi Negara biasanya disebut Rintisan bertopik atau Palsu .

Marat Gallyamov
sumber
Benar-benar detail dan definisi yang jernih.
shyam sundar singh tomar
2

stub dan fake adalah objek di mana mereka dapat memvariasikan respons mereka berdasarkan parameter input. perbedaan utama di antara mereka adalah bahwa Palsu lebih dekat dengan implementasi dunia nyata daripada rintisan. Rintisan bertopik pada dasarnya berisi tanggapan kode-keras terhadap permintaan yang diharapkan. Mari kita lihat sebuah contoh:

public class MyUnitTest {

 @Test
 public void testConcatenate() {
  StubDependency stubDependency = new StubDependency();
  int result = stubDependency.toNumber("one", "two");
  assertEquals("onetwo", result);
 }
}

public class StubDependency() {
 public int toNumber(string param) {
  if (param == “one”) {
   return 1;
  }
  if (param == “two”) {
   return 2;
  }
 }
}

Sebuah mock adalah langkah dari palsu dan stub. Mock menyediakan fungsi yang sama dengan bertopik tetapi lebih kompleks. Mereka dapat memiliki aturan yang ditentukan untuk mereka yang menentukan bagaimana metode pemesanan pada API mereka harus dipanggil. Kebanyakan pengejek dapat melacak berapa kali suatu metode dipanggil dan dapat bereaksi berdasarkan informasi itu. Mengolok-olok umumnya mengetahui konteks setiap panggilan dan dapat bereaksi secara berbeda dalam situasi yang berbeda. Karena itu, mengejek membutuhkan pengetahuan tentang kelas yang mereka cemooh. sebuah rintisan umumnya tidak dapat melacak berapa kali suatu metode dipanggil atau dalam urutan apa urutan metode dipanggil. Mock terlihat seperti:

public class MockADependency {

 private int ShouldCallTwice;
 private boolean ShouldCallAtEnd;
 private boolean ShouldCallFirst;

 public int StringToInteger(String s) {
  if (s == "abc") {
   return 1;
  }
  if (s == "xyz") {
   return 2;
  }
  return 0;
 }

 public void ShouldCallFirst() {
  if ((ShouldCallTwice > 0) || ShouldCallAtEnd)
   throw new AssertionException("ShouldCallFirst not first thod called");
  ShouldCallFirst = true;
 }

 public int ShouldCallTwice(string s) {
  if (!ShouldCallFirst)
   throw new AssertionException("ShouldCallTwice called before ShouldCallFirst");
  if (ShouldCallAtEnd)
   throw new AssertionException("ShouldCallTwice called after ShouldCallAtEnd");
  if (ShouldCallTwice >= 2)
   throw new AssertionException("ShouldCallTwice called more than twice");
  ShouldCallTwice++;
  return StringToInteger(s);
 }

 public void ShouldCallAtEnd() {
  if (!ShouldCallFirst)
   throw new AssertionException("ShouldCallAtEnd called before ShouldCallFirst");
  if (ShouldCallTwice != 2) throw new AssertionException("ShouldCallTwice not called twice");
  ShouldCallAtEnd = true;
 }

}
Alireza Rahmani Khalili
sumber
1

fake objectadalah implementasi nyata dari antarmuka (protokol) atau perluasan menggunakan pewarisan atau pendekatan lain yang dapat digunakan untuk membuat - adalah ketergantungan. Biasanya ini dibuat oleh pengembang sebagai solusi paling sederhana untuk menggantikan beberapa ketergantungan

stub objectadalah objek telanjang (0, nihil dan metode tanpa logika) dengan dan ekstra dan telah ditetapkan (oleh pengembang) negara untuk menentukan nilai kembali. Biasanya itu dibuat oleh framework

mock objectsangat mirip dengan stub objecttetapi keadaan tambahan diubah selama eksekusi program untuk memeriksa apakah sesuatu terjadi (metode dipanggil).

yoAlex5
sumber