Sahte, alaycı ve stubbing arasındaki fark nedir?

Bu terimleri nasıl kullandığımı biliyorum, ancak birim testleri için taklit , alay ve saplama için kabul edilen tanımlar olup olmadığını merak ediyorum ? Testleriniz için bunları nasıl tanımlıyorsunuz? Her birini kullanabileceğiniz durumları açıklayın.

Bunları nasıl kullanacağım:

Sahte : bir arabirim uygulayan ancak sabit veri içeren ve mantık içermeyen bir sınıf. Sadece uygulamaya bağlı olarak "iyi" veya "kötü" verileri döndürür.

Mock : bir arabirimi uygulayan ve belirli yöntemlerden atmak için değerleri / istisnaları dinamik olarak ayarlayabilen ve belirli yöntemlerin çağrılıp çağrılmadığını kontrol etme olanağı sağlayan bir sınıf.

Saplama : Bir sahte sınıf gibi, ancak yöntemlerin çağrıldığını / çağrılmadığını doğrulama yeteneği sağlamaz.

Alaycılar ve taslaklar bir alaycı çerçeve tarafından elle üretilebilir veya üretilebilir. Sahte sınıflar elle oluşturulur. Alayları öncelikle sınıfım ile bağımlı sınıflar arasındaki etkileşimleri doğrulamak için kullanıyorum. Etkileşimleri doğruladıktan sonra kodlarımı kullanıyorum ve kodum aracılığıyla alternatif yolları test ediyorum. Sahte sınıfları öncelikle veri bağımlılıklarını belirlemek için ya da alaylar / saplamalar her seferinde kurulamayacak kadar sıkıcı olduğunda kullanırım.

Bazı bilgiler alabilirsiniz:

Gönderen Mock ve Saplamasının hakkında Martin Fowler

Sahte nesnelerin aslında çalışma uygulamaları vardır, ancak genellikle üretime uygun olmayan bazı kısayollar alırlar

Saplamalar , test sırasında yapılan çağrılara, genellikle test için programlananların dışındaki hiçbir şeye cevap vermeyecek hazır yanıtlar sağlar. Saplamalar ayrıca, 'gönderdiği' mesajları hatırlayan bir e-posta ağ geçidi saplaması veya belki de yalnızca kaç mesaj gönderdiğini gibi aramalarla ilgili bilgileri de kaydedebilir.

Alaylar burada bahsettiğimiz şeydir: beklentileri ile önceden programlanmış nesneler, almaları beklenen çağrıların bir özelliğini oluşturur.

Xunitpattern Gönderen :

Sahte : SUT'un bağlı olduğu bir bileşenin sağladığı işlevsellik ile ilgili çok hafif bir uygulama edinir veya oluşturur ve SUT'a gerçek yerine onu kullanmasını söyleriz.

Saplama : Bu uygulama, SUT'tan gelen çağrılara SUT'ta Test Edilmemiş Kodu (bkz. Üretim Hataları, sayfa X) uygulayacak değerlerle (veya istisnalarla) yanıt verecek şekilde yapılandırılmıştır. Test Saplaması kullanmak için önemli bir gösterge, SUT'un dolaylı girişlerini kontrol edememesinden kaynaklanan Test Edilmemiş Kod'a sahip olmaktır

SUT'un (Test Altında Sistem) bağlı olduğu bir nesne ile aynı arabirimi uygulayan Mock Object . SUT'ta yöntemlerin çağrılmasının yan etkilerini gözlemleyememesinden kaynaklanan Test Edilmemiş Bir Gereksinim (sayfa X'daki Üretim Hataları) bölümüne bakmak için Davranış Doğrulaması yapmamız gerektiğinde bir Mock Nesnesi gözlem noktası olarak kullanabiliriz.

Şahsen

Aşağıdakileri kullanarak basitleştirmeye çalışıyorum: Mock and Stub. Test edilen sınıfa ayarlanmış bir değer döndüren bir nesne olduğunda Mock kullanıyorum. Test edilecek bir Interface veya Abstract sınıfını taklit etmek için Stub kullanıyorum. Aslında, ona ne dediğin önemli değil, hepsi üretimde kullanılmayan sınıflar ve test için yardımcı sınıflar olarak kullanılıyor.

Stub - yöntem çağrılarına önceden tanımlanmış cevaplar sağlayan bir nesne.

Mock - Beklentilerinizi belirlediğiniz bir nesne.

Sahte - sınırlı yeteneklere sahip bir nesne (test amacıyla), örneğin sahte bir web hizmeti.

Test Double, taslaklar, alaylar ve sahte ürünler için genel terimdir. Ancak gayri resmi olarak, insanların onlara sadece alay dediklerini duyacaksınız.

Bu sorunun bu kadar uzun süredir var olmasına şaşırdım ve henüz hiç kimse Roy Osherove'un "Birim Testi Sanatı" na dayanan bir cevap sunmadı .

"3.1 Saplamaların tanıtılması" nda bir saplama şekli şu şekilde tanımlanır:

Saplama, sistemdeki mevcut bir bağımlılık (veya ortak çalışan) için denetlenebilir bir alternatiftir. Bir saplama kullanarak, kodunuzu doğrudan bağımlılıkla uğraşmadan test edebilirsiniz.

Ve saplamalar ile alaylar arasındaki farkı şu şekilde tanımlar:

Taklitler ve saplamalar hakkında hatırlanması gereken en önemli şey, taklitlerin tıpkı taslaklar gibi olmalarıdır, ancak sahte nesneye karşı iddiada bulunurken, bir saplamaya karşı iddiada bulunmazsınız.

Sahte, sadece taslaklar ve alaylar için kullanılan addır. Örneğin, taslaklar ve alaylar arasındaki farkı umursamadığınızda.

Osherove'un taslaklar ve alaylar arasındaki ayrım şekli, test için sahte olarak kullanılan herhangi bir sınıfın hem saplama hem de alay olabileceği anlamına gelir. Belirli bir test için hangisi tamamen, kontrolleri testinize nasıl yazdığınıza bağlıdır.

• Testiniz test edilen sınıftaki veya gerçekte sahte olan herhangi bir yerde değerleri kontrol ettiğinde, sahte bir saplama olarak kullanıldı. Sadece test edilen sınıf için, doğrudan çağrılar tarafından döndürülen değerler aracılığıyla veya dolaylı olarak, çağrıların bir sonucu olarak yan etkilere (bazı durumlarda) neden olarak değerler sağlamıştır.
• Testiniz sahte değerleri kontrol ettiğinde, sahte olarak kullanıldı.

FakeX sınıfının saplama olarak kullanıldığı bir test örneği:

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

cut.SquareIt;

Assert.AreEqual(25, cut.SomeProperty);

fakeÇünkü örnek bir çubuk olarak kullanılır Assertkullanmaz fakehiç.

Test sınıfı X'in sahte olarak kullanıldığı bir test örneği:

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

cut.SquareIt;

Assert.AreEqual(25, fake.SomeProperty);

Bu durumda, Assertbir değeri denetler fake, bu sahte bir sahte yapar.

Şimdi, elbette bu örnekler oldukça çelişkilidir, ancak bu ayrımda büyük bir değer görüyorum. Eşyalarınızı nasıl test ettiğinizi ve testinizin bağımlılıklarının nerede olduğunu bilmenizi sağlar.

Osherove ile aynı fikirdeyim

saf bir sürdürülebilirlik perspektifinden bakıldığında, sahte testlerimde bunları kullanmamaktan daha fazla sorun yaratır. Bu benim deneyimimdi, ama her zaman yeni bir şeyler öğreniyorum.

Sahte iddiada bulunmak, testlerinizi hiç test edilmeyen bir sınıfın uygulanmasına son derece bağımlı hale getirdiğinden, gerçekten kaçınmak istediğiniz bir şeydir. Bu, sınıfın testlerinin ActualClassUnderTestkırılmaya başlayabileceği anlamına gelir çünkü uygulama ClassUsedAsMockdeğişti. Ve bu bana kötü bir koku gönderiyor. Testler ActualClassUnderTesttercihen sadece ActualClassUnderTestdeğiştirildiğinde değiştirilmelidir.

Sahte yazmanın, özellikle alaycı bir TDD abonesi olduğunuzda, yaygın bir uygulama olduğunu anlıyorum. Sanırım klasikcı kamptaki Martin Fowler'la sıkı sıkıya bağlıyım (Bkz. Martin Fowler'ın " Alaylar Saplama " ) ve Osherove gibi etkileşim testlerinden kaçının (bu sadece sahte iddiada bulunarak yapılabilir).

Burada tanımlandığı gibi neden alaylardan kaçınmanız gerektiğine dair eğlenceli okumalar için, "fowler mockist classicist" için google. Çok sayıda fikir bulacaksınız.

En çok oy alan cevaptan da bahsedildiği gibi, Martin Fowler, Mocks Arıtsız Saplamalarda ve özellikle Alaylar ve Saplamalar arasındaki Fark alt başlığında bu ayrımları tartışıyor , bu yüzden bu makaleyi okuduğunuzdan emin olun.

Aksine odaklanmak yerine nasıl bu durum farklı, bunu daha odaklanmak aydınlatarak düşünüyorum neden bu farklı kavramlardır. Her biri farklı bir amaç için var.

sahte

Bir sahte olduğunu davranacağını "doğal" bir uygulama olduğunu, ancak "gerçek" değildir. Bunlar bulanık kavramlar ve bu yüzden farklı insanlar şeyleri sahte yapan şeyleri farklı anlıyorlar.

Sahte bir örnek, bir bellek içi veritabanı (örn :memory:. Mağaza ile sqlite kullanarak ). Bunu asla üretim için kullanmazsınız (veriler kalıcı olmadığından), ancak test ortamında kullanmak için veritabanı olarak mükemmel bir şekilde yeterlidir. Ayrıca "gerçek" bir veritabanından çok daha hafiftir.

Başka bir örnek olarak, belki de üretimde bir çeşit nesne deposu (örneğin Amazon S3) kullanıyorsunuz, ancak bir testte nesneleri diskteki dosyalara kaydedebilirsiniz; "diske kaydet" uygulamanız sahte olur. (Ya da bunun yerine bellek içi bir dosya sistemi kullanarak "diske kaydet" işlemini taklit edebilirsiniz.)

Üçüncü örnek olarak, bir önbellek API'si sağlayan bir nesne düşünün; doğru arabirimi uygulayan ancak önbelleğe alma işlemi gerçekleştirmeyen, ancak her zaman önbellek kaybını döndüren bir nesne bir tür sahte olur.

Sahte amacı olmayan test edilen sistemin davranışını etkilemek için değil, karşı uygulanmasını kolaylaştırmak (gereksiz ya ağır bağımlılıkları kaldırarak) testin.

koçanları

Bir saplama "doğal olmayan" davranır bir uygulamasıdır. Belirli çıkışlara sahip belirli girişlere yanıt vermek için önceden yapılandırılmıştır (genellikle test kurulumu tarafından).

Bir saplamanın amacı, sisteminizi belirli bir duruma test etmektir. Örneğin, REST API ile etkileşimde bulunduğunda, sen ki bazı kod için bir test yazıyorsanız eğer saplama her zaman belirli bir hata ile bir API isteğine hazır yanıtını veya bu kişi yanıt döndüren bir API ile REST API. Bu şekilde sistemin bu durumlara nasıl tepki verdiğine dair iddialarda bulunan testler yazabilirsiniz; örneğin, API bir 404 hatası döndürürse kullanıcılarınızın aldıkları yanıtı test etmek.

Bir saplama genellikle yalnızca yanıt vermesini istediğiniz etkileşimlere yanıt vermek için uygulanır. Ancak bir şeyi bir saplama yapan temel özellik onun amacıdır :

Mocks

Bir sahte bir saplamaya benzer, ancak doğrulama eklenmiştir. Bir sahte alayın amacı, test altındaki sisteminizin bağımlılık ile nasıl etkileşime girdiğine dair iddialarda bulunmaktır .

Örneğin, bir web sitesine dosya yükleyen bir sistem için bir test yazıyorsanız, bir dosyayı kabul eden ve yüklenen dosyanın doğru olduğunu iddia etmek için kullanabileceğiniz bir alay oluşturabilirsiniz. Ya da, daha küçük bir ölçekte, test altındaki sistemin alay konusu nesnenin belirli yöntemlerini çağırdığını doğrulamak için bir nesne sahte kullanmak yaygındır.

Alaylar, belirli bir test metodolojisi olan etkileşim testine bağlıdır . Sistem etkileşimleri yerine sistem durumunu test etmeyi tercih edenler, alaycı bir şekilde kullanacaklardır.

Test iki katına çıkar

Sahte, taslak ve alayların tümü test çiftleri kategorisine aittir . Test çifti, testte başka bir şey yerine kullandığınız herhangi bir nesne veya sistemdir . Çoğu otomatik yazılım testi, bir tür test çiftinin kullanılmasını içerir. Diğer bazı test çiftleri arasında kukla değerler , casuslar ve G / Ç kara delikleri bulunur .

Saplamaların ve alaycıların kullanımını göstermek için Roy Osherove'un " Birim Testi Sanatı " na dayalı bir örnek de eklemek istiyorum .

Düşünün, sadece günlük kaydı işlevine sahip bir LogAnalyzer uygulamamız var. Sadece bir web servisi ile konuşmakla kalmaz, web servisi bir hata verirse, LogAnalyzer hatayı farklı bir harici bağımlılığa günlüğe kaydetmeli ve web servis yöneticisine e-posta ile göndermelidir.

İşte LogAnalyzer içinde test etmek istediğimiz mantık:

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

Web hizmeti bir istisna attığında LogAnalyzer'ın e-posta hizmetini doğru aradığını nasıl test edersiniz? Karşılaştığımız sorular:

• Web hizmetini nasıl değiştirebiliriz?

• E-posta hizmetine yapılan aramayı test edebilmemiz için web hizmetinden bir istisnayı nasıl taklit edebiliriz?

• E-posta hizmetinin doğru bir şekilde veya hiç arandığını nasıl bileceğiz?

İlk iki soru ile web hizmeti için bir saplama kullanarak başa çıkabiliriz . Üçüncü sorunu çözmek için, e-posta hizmeti için sahte bir nesne kullanabiliriz .

Sahte, bir saplama ya da bir alayı tanımlamak için kullanılabilecek genel bir terimdir.Testimizde iki sahte olacak. Bunlardan biri, e-posta hizmetine doğru parametrelerin gönderildiğini doğrulamak için kullanacağımız e-posta hizmeti sahte olacaktır. Diğeri, web hizmetinden atılan bir istisnayı simüle etmek için kullanacağımız bir saplama olacaktır. Bu bir saplama çünkü test sonucunu doğrulamak için web hizmeti sahte kullanmıyoruz, sadece testin doğru çalıştığından emin olmak için. E-posta hizmeti bir sahte çünkü doğru şekilde çağrıldığını iddia edeceğiz.

[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);
 }
}

üzerinde iddia ettiğiniz şey, sahte nesne olarak adlandırılır ve test çalışmasına yardımcı olan diğer her şey bir saplamadır .

Testleri etkileyici hale getirme meselesi. Testin iki nesne arasındaki bir ilişkiyi tanımlamasını istersem bir taklit beklerim. Beni testteki ilginç davranışa götürmek için destekleyici bir nesne ayarlıyorsam dönüş değerlerini saplıyorum.

Arrange-Act-Assert hakkında bilginiz varsa, sizin için yararlı olabilecek saplama ve alay arasındaki farkı açıklamanın bir yolu, saplamaların giriş durumunu düzenlemek için olduğu gibi düzenleme bölümüne ait olması ve alayların iddia bölümü, sonuçları doğrulamak içindir.

Aptallar hiçbir şey yapmazlar. Bunlar sadece parametre listelerini doldurmak içindir, böylece tanımlanmamış veya boş hatalar almazsınız. Ayrıca, tür denetleyicisini kesinlikle yazılan dillerde karşılamak için varlar, böylece derlemenize ve çalıştırmanıza izin verilebilir.

Stub, Fakes ve Mock'lar farklı kaynaklar arasında farklı anlamlara sahiptir. Ekibinizin iç koşullarını tanıtmanızı ve anlamları konusunda anlaşmanızı öneririm.

Bence iki yaklaşımı birbirinden ayırmak önemlidir: - davranış validasyonu (davranış ikamesi anlamına gelir) - son durum validasyonu (davranış öykünmesi anlamına gelir)

Hata durumunda e-posta göndermeyi düşünün. Davranış doğrulama yaparken - Bunu yöntemini kontrol Sendait IEmailSenderbir kez idam edildi. Ve bu yöntemin dönüş sonucunu taklit etmeniz, gönderilen iletinin kimliğini döndürmeniz gerekir. Diyorsunuz ki: "Bunun Sendçağrılmasını bekliyorum . Ve herhangi bir çağrı için sadece kukla (veya rastgele) Id döndüreceğim" . Bu davranış doğrulamasıdır: emailSender.Expect(es=>es.Send(anyThing)).Return((subject,body) => "dummyId")

Durum doğrulaması yaparken, TestEmailSenderbu uygulamaları oluşturmanız gerekir IEmailSender. Ve uygulamak Sendyöntemi - bazı nesnelerin dizisi gibi gelecekteki durum doğrulaması için kullanılacak bazı veri yapısına girdi kaydederek SentEmailsve sonra SentEmailsbeklenen e-posta içeren kontrol edecek test . Bu durum doğrulamasıdır: Assert.AreEqual(1, emailSender.SentEmails.Count)

Okumalarımdan Davranış doğrulamasının genellikle Mocks adını verdiğini anladım . Ve devlet doğrulaması genellikle Stubs veya Fakes olarak adlandırılır .

saplama ve sahte , giriş parametrelerine göre yanıtlarını değiştirebilecekleri nesnelerdir. aralarındaki temel fark, bir Sahte'nin gerçek dünyadaki bir uygulamaya bir saplamadan daha yakın olmasıdır. Saplamalar temel olarak beklenen bir isteğe sabit kodlanmış yanıtlar içerir. Bir örnek görelim:

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;
  }
 }
}

Bir sahte sahte ve koçanları bir adım. Alaylar, taslaklarla aynı işlevselliği sağlar, ancak daha karmaşıktır. API'larında hangi sipariş yöntemlerinin çağrılması gerektiğini belirleyen kurallar tanımlanmış olabilirler. Çoğu alay, bir yöntemin kaç kez çağrıldığını izleyebilir ve bu bilgilere dayanarak tepki verebilir. Alaycılar genellikle her aramanın içeriğini bilir ve farklı durumlarda farklı tepki verebilir. Bu nedenle, alaycıların alay ettikleri sınıf hakkında bilgi sahibi olmaları gerekir. bir saplama genellikle bir yöntemin kaç kez çağrıldığını veya bir sırayla yöntem sırasının çağrıldığını izleyemez. Bir sahte şuna benzer:

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;
 }

}

fake object- arayüz (protokol) gerçek bir uygulama ya da bir miras veya oluşturmak için kullanılabilecek diğer yaklaşımlar kullanılarak uzanan bir olan bağımlılığı. Genellikle geliştirici tarafından bazı bağımlılıkları değiştirmek için en basit çözüm olarak oluşturulur

stub objectdöndürülen değerleri tanımlamak için ekstra ve önceden tanımlanmış (geliştirici tarafından) durumuna sahip çıplak bir nesnedir (0, nil ve mantıksız yöntemler) . Genellikle çerçeve ile oluşturulur

mock objectçok benzer, stub objectancak bir şey olup olmadığını kontrol etmek için program yürütülürken fazladan durum değiştirilir (yöntem çağrıldı).