Mockito: Bir yöntem içinde oluşturulan bir nesnede yöntemin çağrılması nasıl yapılır?

Mockito'da yeniyim.

Aşağıdaki sınıf göz önüne alındığında, someMethodtam olarak bir kez fooçağrıldıktan sonra çağrıldığını doğrulamak için Mockito'yu nasıl kullanabilirim ?

public class Foo
{
    public void foo(){
        Bar bar = new Bar();
        bar.someMethod();
    }
}

Aşağıdaki doğrulama çağrısını yapmak istiyorum,

verify(bar, times(1)).someMethod();

burada barbir alay örneğidir Bar.

Bağımlılık Enjeksiyonu

Bar örneğini veya Bar örneğini (veya bunu yapmanın diğer 483 yolundan birini) oluşturmak için kullanılan bir fabrikayı enjekte ederseniz, testi gerçekleştirmek için gereken erişiminiz olur.

Fabrika Örnek:

Böyle bir Foo sınıfı verildiğinde:

public class Foo {
  private BarFactory barFactory;

  public Foo(BarFactory factory) {
    this.barFactory = factory;
  }

  public void foo() {
    Bar bar = this.barFactory.createBar();
    bar.someMethod();
  }
}

Test yönteminizde böyle bir BarFactory enjekte edebilirsiniz:

@Test
public void testDoFoo() {
  Bar bar = mock(Bar.class);
  BarFactory myFactory = new BarFactory() {
    public Bar createBar() { return bar;}
  };

  Foo foo = new Foo(myFactory);
  foo.foo();

  verify(bar, times(1)).someMethod();
}

Bonus: Bu, TDD'nin kodunuzun tasarımını nasıl yönlendirebileceğinin bir örneğidir.

Klasik yanıt, "Yapmazsın." FooDahili API'sini değil , genel API'sını test edersiniz .

FooEtkilenen nesnenin (veya ortamdaki diğer nesnelerin daha az iyi) davranışları var mı foo()? Varsa, test edin. Ve değilse, yöntem ne yapar?

DI veya Fabrikalar kullanmak istemiyorsanız. Sınıfınızı biraz zor bir şekilde yeniden düzenleyebilirsiniz:

public class Foo {
    private Bar bar;

    public void foo(Bar bar){
        this.bar = (bar != null) ? bar : new Bar();
        bar.someMethod();
        this.bar = null;  // for simulating local scope
    }
}

Ve test sınıfınız:

@RunWith(MockitoJUnitRunner.class)
public class FooTest {
    @Mock Bar barMock;
    Foo foo;

    @Test
    public void testFoo() {
       foo = new Foo();
       foo.foo(barMock);
       verify(barMock, times(1)).someMethod();
    }
}

Daha sonra foo yönteminizi çağıran sınıf bunu şu şekilde yapacaktır:

public class thirdClass {

   public void someOtherMethod() {
      Foo myFoo = new Foo();
      myFoo.foo(null);
   }
}

Yöntemi bu şekilde çağırırken görebileceğiniz gibi, Bar sınıfını, istediğiniz bir şey olan foo yönteminizi çağıran başka bir sınıfa aktarmanız gerekmez.

Tabii ki dezavantajı, arayanın Çubuk Nesnesini ayarlamasına izin vermenizdir.

Umarım yardımcı olur.

Örnek kodunuz için çözüm PowerMockito.whenNew

• mockito-tüm 1.10.8
• powermock-çekirdek 1.6.1
• powermock-modül-junit4 1.6.1
• powermock-api-mockito 1.6.1
• haziran 4.12

FooTest.java

package foo;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

//Both @PrepareForTest and @RunWith are needed for `whenNew` to work 
@RunWith(PowerMockRunner.class)
@PrepareForTest({ Foo.class })
public class FooTest {

    // Class Under Test
    Foo cut;

    @Mock
    Bar barMock;

    @Before
    public void setUp() throws Exception {
        cut = new Foo();

    }

    @After
    public void tearDown() {
        cut = null;

    }

    @Test
    public void testFoo() throws Exception {

        // Setup
        PowerMockito.whenNew(Bar.class).withNoArguments()
                .thenReturn(this.barMock);

        // Test
        cut.foo();

        // Validations
        Mockito.verify(this.barMock, Mockito.times(1)).someMethod();

    }

}

JUnit Çıkışı

Sanırım Mockito @InjectMocksbu iş için bir yol.

Niyetinize bağlı olarak şunları kullanabilirsiniz:

1. Yapıcı enjeksiyonu
2. Özellik ayarlayıcı enjeksiyonu
3. Alan enjeksiyonu

Dokümanlar'da daha fazla bilgi

Alan enjeksiyonlu bir örnek aşağıdadır:

Sınıflar:

public class Foo
{
    private Bar bar = new Bar();

    public void foo() 
    {
        bar.someMethod();
    }
}

public class Bar
{
    public void someMethod()
    {
         //something
    }
}

Ölçek:

@RunWith(MockitoJUnitRunner.class)
public class FooTest
{
    @Mock
    Bar bar;

    @InjectMocks
    Foo foo;

    @Test
    public void FooTest()
    {
        doNothing().when( bar ).someMethod();
        foo.foo();
        verify(bar, times(1)).someMethod();
    }
}

Evet, gerçekten yapmak / yapmanız gerekiyorsa PowerMock'u kullanabilirsiniz. Bu son çare olarak kabul edilmelidir. PowerMock ile çağrıyı yapıcıya bir sahte geri döndürmesine neden olabilirsiniz. Sonra sahte doğrulayın. Bununla birlikte, csturtz "doğru" cevaptır.

İşte yeni nesnelerin sahte yapımına bağlantı

Başka bir basit yol, bar.someMethod () öğesine bazı günlük ifadeleri eklemek ve daha sonra testiniz yürütüldüğünde söz konusu mesajı görebileceğinizi tespit etmek, buradaki örneklere bakın: Bir günlükçüdeki bir mesajda bir JUnit iddiası nasıl yapılır

Bu özellikle Bar.someMethod () cihazınız olduğunda kullanışlıdır private.