TDD'de yeniden tasarlandıktan sonra bu yöntem özel olduğunda yöntemlerin testlerinde ne olur?

Diyelim ki diğer karakterlere ve bu tür şeylere saldıran karakterlerle bir rol oyunu geliştirmeye başladım.

TDD'yi uygulayarak, mantık içinde Character.receiveAttack(Int)yöntemini test etmek için bazı test durumları yapmak . Bunun gibi bir şey:

@Test
fun healthIsReducedWhenCharacterIsAttacked() {
    val c = Character(100) //arg is the health
    c.receiveAttack(50) //arg is the suffered attack damage
    assertThat(c.health, is(50));
}

Diyelim ki 10 yöntem test receiveAttackyöntemim var. Şimdi bir yöntem ekliyorum Character.attack(Character)( yöntem çağırıyor receiveAttack) ve bazı TDD döngüleri test ettikten sonra bir karar vereceğim: Character.receiveAttack(Int)olmalıdır private.

Önceki 10 test vakasında ne olur? Onları silmeli miyim? Yöntemi saklamalı mıyım public(sanmıyorum)?

Bu soru, özel yöntemlerin nasıl test edileceği ile ilgili değildir, ancak TDD uygulanırken yeniden tasarlandıktan sonra bunlarla nasıl başa çıkılacağıyla ilgilidir

TDD'de, testler tasarımınızın çalıştırılabilir dokümantasyonu olarak hizmet eder. Tasarımınız değişti, bu yüzden de belgeniz de öyle olmalı!

TDD'de, attackyöntemin ortaya çıkmasının tek yolunun, başarısız bir test geçişi yapmasının sonucudur. Bu, attackbaşka bir test tarafından test edildiği anlamına gelir . Bunun anlamı dolaylı receiveAttack olarak attacktestlerin kapsamıdır. İdeal olarak, yapılacak değişikliklerin testlerden receiveAttacken az birini kırması gerekir attack.

Ve değilse, o zaman receiveAttackartık gerekli olmayan ve artık olmaması gereken bir işlevsellik var!

Bu nedenle, receiveAttackzaten test edildiğinden attack, testlerinizi yapıp yapmamanız önemli değil. Eğer sizin test çerçevesi kolaylaştırır özel yöntemler test etmek ve eğer sen özel yöntemler test etmeye karar, o zaman tutabilirsiniz. Ancak, test kapsamını ve güvenini kaybetmeden de silebilirsiniz.

Yöntem teste ihtiyaç duyacak kadar karmaşıksa, bazı sınıflarda genel olmalıdır. Demek siz refactor:

public class X {
  private int complexity(...) {
    ...
  }
  public void somethingElse() {
    int c = complexity(...);
  }
}

için:

public class Complexity {
  public int calculate(...) {
    ...
  }
}

public class X {
  private Complexity complexity;
  public X(Complexity complexity) { // dependency injection happiness
    this.complexity = complexity;
  }

  public void something() {
    int c = complexity.calculate(...);
  }
}

X.complexity için geçerli testi ComplexityTest'e taşıyın. Ardından, karmaşıklıkla alay ederek bir şeyler yaz.

Tecrübelerime göre, daha küçük sınıflara doğru yeniden yapılanma ve daha kısa yöntemler çok büyük faydalar sağlıyor. Anlaşmaları daha kolay, test etmek daha kolay ve sonuçta beklenenden daha fazla tekrar kullanılmaya başlandılar.

Diyelim ki 10 yöntem metot alıp test ettim. Şimdi, bir yöntem Character.attack (Character) (almaAttack yöntemini çağıran) ekliyorum ve bazı TDD döngüleri test ettikten sonra bir karar verdim: Character.receiveAttack (Int) özel olmalı.

Burada akılda tutulması gereken bir şey, verdiğiniz kararın API'den bir yöntemi kaldırmak olduğudur . Geriye dönük uyumluluk nezaketleri

1. Kaldırmanız gerekmiyorsa, API’de bırakın.
2. Henüz çıkarmanız gerekmiyorsa , kullanımdan kaldırılacağı zaman mümkünse işaretleyin ve mümkünse belgeyi işaretleyin.
3. Kaldırmanız gerekirse, büyük bir sürüm değişikliğine sahipsiniz.

API'niz artık yöntemi desteklemediğinde, testler kaldırıldı veya değiştirildi. Bu noktada, özel yöntem yeniden gözden geçirmeniz gereken bir uygulama detayıdır.

Bu noktada, test takımınızın uygulamalara doğrudan erişip erişmediği, tamamen genel API üzerinden etkileşimde bulunup bulunmadığı konusunda standart soruya geri döndünüz. Özel bir yöntem, test odasına girmeden değiştirmemiz gereken bir şeydir . Bu yüzden testlerden çiftin uzaklara gitmesini beklerdim - ya emekli oluyorlar ya da uygulamayla birlikte test edilebilir bir bileşene geçiyorlardı.