Soyut sınıfları test etmek için Mockito kullanma

Soyut bir sınıfı test etmek istiyorum. Tabii, el ile sınıftan miras bir sahte yazabilirsiniz .

Bunu alayımı el yapımı yerine alaycı bir çerçeve (Mockito kullanıyorum) kullanarak yapabilir miyim? Nasıl?

Aşağıdaki öneri let bir "gerçek" alt sınıf yaratmadan soyut sınıflar testi var - Sahte olduğu alt sınıf.

kullanın Mockito.mock(My.class, Mockito.CALLS_REAL_METHODS), sonra çağrılan soyut yöntemleri alay edin.

Misal:

public abstract class My {
  public Result methodUnderTest() { ... }
  protected abstract void methodIDontCareAbout();
}

public class MyTest {
    @Test
    public void shouldFailOnNullIdentifiers() {
        My my = Mockito.mock(My.class, Mockito.CALLS_REAL_METHODS);
        Assert.assertSomething(my.methodUnderTest());
    }
}

Not: Bu çözümün güzelliği kalmamasıdır var yeter ki çağrılan asla gibi soyut yöntemler uygulamak.

Dürüst görüşüme göre, bu bir casus kullanmaktan daha temizdir, çünkü bir casus bir örnek gerektirir, bu da soyut sınıfınızın anlık bir alt sınıfını oluşturmanız gerektiği anlamına gelir.

Bazı somut yöntemlerden bazılarına herhangi bir özete dokunmadan test etmeniz gerekirse, kullanabilirsiniz CALLS_REAL_METHODS( Morten'in cevabına bakın ), ancak test edilen somut yöntem bazı özetleri veya uygulanmayan arayüz yöntemlerini çağırırsa, bu işe yaramaz. - Mockito şikayet edecek "Java arayüzü gerçek yöntem çağrılamaz."

(Evet, berbat bir tasarım, ancak bazı çerçeveler, örneğin Goblen 4, bunu size zorlar.)

Çözüm, bu yaklaşımı tersine çevirmektir - sıradan sahte davranışı kullanın (yani, her şey alay konusu / saplanmış) ve doCallRealMethod()test edilen somut yöntemi açıkça çağırmak için kullanın . Örneğin

public abstract class MyClass {
    @SomeDependencyInjectionOrSomething
    public abstract MyDependency getDependency();

    public void myMethod() {
        MyDependency dep = getDependency();
        dep.doSomething();
    }
}

public class MyClassTest {
    @Test
    public void myMethodDoesSomethingWithDependency() {
        MyDependency theDependency = mock(MyDependency.class);

        MyClass myInstance = mock(MyClass.class);

        // can't do this with CALLS_REAL_METHODS
        when(myInstance.getDependency()).thenReturn(theDependency);

        doCallRealMethod().when(myInstance).myMethod();
        myInstance.myMethod();

        verify(theDependency, times(1)).doSomething();
    }
}

Eklemek için güncellendi:

Geçersiz olmayan yöntemler için thenCallRealMethod()bunun yerine kullanmanız gerekir , örneğin:

when(myInstance.myNonVoidMethod(someArgument)).thenCallRealMethod();

Aksi takdirde Mockito "Bitmemiş stubbing tespit edildi."

Bunu bir casus kullanarak başarabilirsiniz (Mockito 1.8+ 'nın en son sürümünü kullanın).

public abstract class MyAbstract {
  public String concrete() {
    return abstractMethod();
  }
  public abstract String abstractMethod();
}

public class MyAbstractImpl extends MyAbstract {
  public String abstractMethod() {
    return null;
  }
}

// your test code below

MyAbstractImpl abstractImpl = spy(new MyAbstractImpl());
doReturn("Blah").when(abstractImpl).abstractMethod();
assertTrue("Blah".equals(abstractImpl.concrete()));

Alaycı çerçeveler, test ettiğiniz sınıfın bağımlılıklarını alay etmeyi kolaylaştırmak için tasarlanmıştır. Bir sınıfı alay etmek için alaycı bir çerçeve kullandığınızda, çoğu çerçeve dinamik olarak bir alt sınıf oluşturur ve yöntem uygulamasını bir yöntemin ne zaman çağrıldığını ve sahte bir değer döndürdüğünü algılayan kodla değiştirir.

Soyut bir sınıfı test ederken, Test Altında Öznenin (SUT) soyut olmayan yöntemlerini uygulamak istersiniz, bu nedenle alaycı bir çerçeve istediğiniz şey değildir.

Karışıklığın bir kısmı, bağlantılı olduğunuz sorunun cevabının soyut sınıfınızdan uzanan bir sahte el işi yapmaktır. Böyle bir sınıfa sahte demezdim. Bir alay, bağımlılığın yerine geçen, beklentilerle programlanan ve bu beklentilerin karşılanıp karşılanmadığını görmek için sorgulanabilen bir sınıftır.

Bunun yerine, testinizde soyut sınıfınızın soyut olmayan bir alt sınıfını tanımlamanızı öneririm. Bu, çok fazla kodla sonuçlanırsa, sınıfınızın genişletilmesinin zor olduğunun bir işareti olabilir.

Alternatif bir çözüm, test durumunuzu SUT oluşturmak için soyut bir yöntemle soyut yapmaktır (başka bir deyişle, test durumu Şablon Yöntemi tasarım desenini kullanır).

Özel bir cevap kullanmayı deneyin.

Örneğin:

import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

public class CustomAnswer implements Answer<Object> {

    public Object answer(InvocationOnMock invocation) throws Throwable {

        Answer<Object> answer = null;

        if (isAbstract(invocation.getMethod().getModifiers())) {

            answer = Mockito.RETURNS_DEFAULTS;

        } else {

            answer = Mockito.CALLS_REAL_METHODS;
        }

        return answer.answer(invocation);
    }
}

Soyut yöntemler için alaycılığı döndürecek ve somut yöntemler için gerçek yöntemi çağıracaktır.

Soyut sınıfları alay etme konusunda beni gerçekten kötü hissettiren şey, ne varsayılan kurucunuz YourAbstractClass () öğesinin (sahte olarak super () eksik) çağrılması ya da Mockito'da sahte özellikleri başlatmak için herhangi bir yol olmadığı gerçeğidir (örn. List özellikleri) boş ArrayList veya LinkedList ile).

Benim soyut sınıf (temelde sınıf kaynak kodu oluşturulur) liste öğeleri için bir bağımlılık ayarlayıcı enjeksiyon veya liste öğelerini başlattığı bir yapıcı (elle eklemeye çalıştım) sağlamaz.

Yalnızca sınıf öznitelikleri varsayılan başlatmayı kullanır: private List dep1 = new ArrayList; özel Liste dep2 = yeni ArrayList

Bu nedenle, gerçek bir nesne uygulaması (örn. Birim test sınıfında iç sınıf tanımı, soyut yöntemleri geçersiz kılma) kullanmadan ve gerçek nesneyi (doğru alan başlatması yapan) casusluk yapmadan soyut bir sınıfı taklit etmenin YOK yolu yoktur.

Sadece PowerMock'un burada daha fazla yardımcı olması çok kötü.

Test sınıflarınızın, test altındaki sınıflarınızla aynı pakette (farklı bir kaynak kök altında) olduğu varsayılarak, alay oluşturabilirsiniz:

YourClass yourObject = mock(YourClass.class);

ve test etmek istediğiniz yöntemleri, tıpkı diğer yöntemleri yaptığınız gibi arayın.

Süper yöntemi çağıran herhangi bir somut yöntem beklentisiyle çağrılan her yöntem için beklentiler sağlamanız gerekir - bunu Mockito ile nasıl yapacağınızdan emin değilim, ancak EasyMock ile mümkün olduğuna inanıyorum.

Tüm yapmanız gereken, somut bir örnek oluşturmak YouClassve her bir soyut yöntemin boş uygulamalarını sağlama çabasından tasarruf etmektir.

Bir kenara, soyut sınıf tarafından sağlanan işlevselliğe bağlı olmasına rağmen, genel sınıfı genel arayüzüyle test ettiğim örnek bir uygulama olarak hizmet ettiği testimde soyut sınıfı uygulamayı yararlı buluyorum.

Soyut sınıfı testinizde anonim bir sınıfla genişletebilirsiniz. Örneğin (Junit 4'ü kullanarak):

private AbstractClassName classToTest;

@Before
public void preTestSetup()
{
    classToTest = new AbstractClassName() { };
}

// Test the AbstractClassName methods.

Mockito, @Mockaçıklama yoluyla soyut sınıfların alay edilmesine izin verir :

public abstract class My {

    public abstract boolean myAbstractMethod();

    public void myNonAbstractMethod() {
        // ...
    }
}

@RunWith(MockitoJUnitRunner.class)
public class MyTest {

    @Mock(answer = Answers.CALLS_REAL_METHODS)
    private My my;

    @Test
    private void shouldPass() {
        BDDMockito.given(my.myAbstractMethod()).willReturn(true);
        my.myNonAbstractMethod();
        // ...
    }
}

Dezavantajı yapıcı parametrelerine ihtiyacınız varsa kullanılamaz olmasıdır.

Anonim bir sınıf başlatabilir, alaylarınızı enjekte edebilir ve daha sonra bu sınıfı test edebilirsiniz.

@RunWith(MockitoJUnitRunner.class)
public class ClassUnderTest_Test {

    private ClassUnderTest classUnderTest;

    @Mock
    MyDependencyService myDependencyService;

    @Before
    public void setUp() throws Exception {
        this.classUnderTest = getInstance();
    }

    private ClassUnderTest getInstance() {
        return new ClassUnderTest() {

            private ClassUnderTest init(
                    MyDependencyService myDependencyService
            ) {
                this.myDependencyService = myDependencyService;
                return this;
            }

            @Override
            protected void myMethodToTest() {
                return super.myMethodToTest();
            }
        }.init(myDependencyService);
    }
}

Görünürlüğün soyut sınıfın protectedmülkiyeti için olması gerektiğini unutmayın .myDependencyServiceClassUnderTest

PowerMock'lar Whitebox.invokeMethod(..)bu durumda kullanışlı olabilir.