วิธีการจำลองโมฆะด้วย Mockito

วิธีการเยาะเย้ยวิธีการที่มีประเภทผลตอบแทนเป็นโมฆะ?

ฉันใช้รูปแบบการสังเกตการณ์ แต่ไม่สามารถเยาะเย้ยกับ Mockito ได้เพราะฉันไม่รู้ว่าจะทำอย่างไร

และฉันพยายามค้นหาตัวอย่างบนอินเทอร์เน็ต แต่ไม่ประสบความสำเร็จ

ชั้นเรียนของฉันมีลักษณะเช่นนี้:

public class World {

    List<Listener> listeners;

    void addListener(Listener item) {
        listeners.add(item);
    }

    void doAction(Action goal,Object obj) {
        setState("i received");
        goal.doAction(obj);
        setState("i finished");
    }

    private string state;
    //setter getter state
} 

public class WorldTest implements Listener {

    @Test public void word{
    World  w= mock(World.class);
    w.addListener(this);
    ...
    ...

    }
}

interface Listener {
    void doAction();
}

ระบบไม่ถูกกระตุ้นด้วยการเยาะเย้ย

ฉันต้องการที่จะแสดงสถานะของระบบดังกล่าวข้างต้น และยืนยันตามที่พวกเขา

ลองดูที่ Mockito เอกสาร API เป็นเอกสารที่เชื่อมโยงกล่าว (จุด # 12) คุณสามารถใช้ใด ๆ ของdoThrow(), doAnswer(), doNothing(), doReturn()ครอบครัวของวิธีการจากกรอบ Mockito จะเยาะเย้ยวิธีการเป็นโมฆะ

ตัวอย่างเช่น,

Mockito.doThrow(new Exception()).when(instance).methodName();

หรือถ้าคุณต้องการที่จะรวมมันกับพฤติกรรมการติดตาม

Mockito.doThrow(new Exception()).doNothing().when(instance).methodName();

ทะนงว่าคุณกำลังมองหาที่เยาะเย้ยหมาsetState(String s)ในระดับโลกดังต่อไปนี้คือการใช้รหัสวิธีการในการเยาะเย้ยdoAnswersetState

World  mockWorld = mock(World.class); 
doAnswer(new Answer<Void>() {
    public Void answer(InvocationOnMock invocation) {
      Object[] args = invocation.getArguments();
      System.out.println("called with arguments: " + Arrays.toString(args));
      return null;
    }
}).when(mockWorld).setState(anyString());

ฉันคิดว่าฉันพบคำตอบที่ง่ายกว่าสำหรับคำถามนั้นเพื่อเรียกวิธีการที่แท้จริงเพียงวิธีเดียว (แม้ว่าจะได้รับคืนเป็นโมฆะ) คุณสามารถทำได้:

Mockito.doCallRealMethod().when(<objectInstance>).<method>();
<objectInstance>.<method>();

หรือคุณสามารถเรียกวิธีการจริงสำหรับวิธีการทั้งหมดของชั้นเรียนที่ทำสิ่งนี้:

<Object> <objectInstance> = mock(<Object>.class, Mockito.CALLS_REAL_METHODS);

การเพิ่มสิ่งที่ @sateesh พูดเมื่อคุณเพียงแค่ต้องการจำลองวิธีการโมฆะเพื่อป้องกันไม่ให้การทดสอบเรียกคุณสามารถใช้Spyวิธีนี้:

World world = new World();
World spy = Mockito.spy(world);
Mockito.doNothing().when(spy).methodToMock();

เมื่อคุณต้องการเรียกใช้การทดสอบของคุณให้แน่ใจว่าคุณเรียกวิธีการในการทดสอบกับspyวัตถุและไม่ได้อยู่ในworldวัตถุ ตัวอย่างเช่น:

assertEquals(0,spy.methodToTestThatShouldReturnZero());

วิธีการแก้ปัญหาที่เรียกว่าปัญหาที่เกิดขึ้นคือการใช้spy Mockito.spy ( ... )แทนการmock Mockito.mock ( .. )

Spy ช่วยให้เราสามารถเยาะเย้ยบางส่วน Mockito เก่งในเรื่องนี้ เนื่องจากคุณมีชั้นเรียนที่ไม่สมบูรณ์ด้วยวิธีนี้คุณจำลองสถานที่ที่จำเป็นในชั้นนี้

ก่อนอื่น: คุณควรนำเข้า mockito คงที่วิธีนี้รหัสจะสามารถอ่านได้มากขึ้น (และใช้งานง่าย):

import static org.mockito.Mockito.*;

สำหรับการเยาะเย้ยบางส่วนและยังคงรักษาฟังก์ชั่นดั้งเดิมในส่วนที่เหลือ mockito เสนอ "Spy"

คุณสามารถใช้มันได้ดังต่อไปนี้:

private World world = spy(World.class);

ในการกำจัดวิธีการที่ถูกดำเนินการคุณสามารถใช้สิ่งนี้:

doNothing().when(someObject).someMethod(anyObject());

เพื่อให้พฤติกรรมที่กำหนดเองบางอย่างกับวิธีการใช้ "เมื่อ" กับ "แล้วกลับ":

doReturn("something").when(this.world).someMethod(anyObject());

สำหรับตัวอย่างเพิ่มเติมโปรดค้นหาตัวอย่าง mockito ที่ยอดเยี่ยมในเอกสาร

วิธีการจำลองวิธีการโมฆะด้วย mockito - มีสองตัวเลือก:

1. doAnswer - หากเราต้องการวิธีการเยาะเย้ยโมฆะ (เยาะเย้ยพฤติกรรมแม้จะเป็นโมฆะ)
2. doThrow- Mockito.doThrow()ถ้าคุณต้องการที่จะโยนข้อยกเว้นจากวิธีการเยาะเย้ยเป็นโมฆะ

ต่อไปนี้เป็นตัวอย่างของวิธีการใช้งาน (ไม่ใช่ usecase ในอุดมคติ แต่ต้องการแสดงการใช้งานพื้นฐาน)

@Test
public void testUpdate() {

    doAnswer(new Answer<Void>() {

        @Override
        public Void answer(InvocationOnMock invocation) throws Throwable {
            Object[] arguments = invocation.getArguments();
            if (arguments != null && arguments.length > 1 && arguments[0] != null && arguments[1] != null) {

                Customer customer = (Customer) arguments[0];
                String email = (String) arguments[1];
                customer.setEmail(email);

            }
            return null;
        }
    }).when(daoMock).updateEmail(any(Customer.class), any(String.class));

    // calling the method under test
    Customer customer = service.changeEmail("old@test.com", "new@test.com");

    //some asserts
    assertThat(customer, is(notNullValue()));
    assertThat(customer.getEmail(), is(equalTo("new@test.com")));

}

@Test(expected = RuntimeException.class)
public void testUpdate_throwsException() {

    doThrow(RuntimeException.class).when(daoMock).updateEmail(any(Customer.class), any(String.class));

    // calling the method under test
    Customer customer = service.changeEmail("old@test.com", "new@test.com");

}
}

คุณสามารถหารายละเอียดเพิ่มเติมเกี่ยวกับวิธีการเยาะเย้ยและทดสอบ วิธีการโมฆะด้วย Mockito ในโพสต์ของฉันวิธีการเยาะเย้ยกับ Mockito (คู่มือที่ครอบคลุมพร้อมตัวอย่าง)

กำลังเพิ่มคำตอบให้กับกลุ่มอื่น (ไม่ได้ตั้งใจให้เล่นสำนวน) ...

คุณต้องเรียกใช้วิธีการ doAnswer หากคุณไม่สามารถ \ ไม่ต้องการใช้สายลับ แต่คุณไม่จำเป็นต้องที่จะม้วนของคุณเองคำตอบ มีการใช้งานเริ่มต้นหลายอย่าง ยวดCallsRealMethods

ในทางปฏิบัติมันมีลักษณะดังนี้:

doAnswer(new CallsRealMethods()).when(mock)
        .voidMethod(any(SomeParamClass.class));

หรือ:

doAnswer(Answers.CALLS_REAL_METHODS.get()).when(mock)
        .voidMethod(any(SomeParamClass.class));

ใน Java 8 คุณสามารถทำความสะอาดได้เล็กน้อยโดยสมมติว่าคุณมีการนำเข้าแบบคงที่สำหรับorg.mockito.Mockito.doAnswer:

doAnswer(i -> {
  // Do stuff with i.getArguments() here
  return null;
}).when(*mock*).*method*(*methodArguments*);

เป็นสิ่งสำคัญและไม่ได้รวบรวมจะล้มเหลวกับข้อผิดพลาดปิดบังบางอย่างเป็นธรรมขณะที่มันจะไม่สามารถที่จะหาแทนที่เหมาะสำหรับreturn null;doAnswer

ตัวอย่างเช่นการExecutorServiceดำเนินการใด ๆ ที่Runnableส่งผ่านไปทันทีexecute()สามารถนำมาใช้โดยใช้:

doAnswer(i -> {
  ((Runnable) i.getArguments()[0]).run();
  return null;
}).when(executor).execute(any());

ฉันคิดว่าปัญหาของคุณเกิดจากโครงสร้างการทดสอบของคุณ ฉันพบว่ามันยากที่จะผสมการเยาะเย้ยกับวิธีดั้งเดิมของการใช้อินเทอร์เฟซในชั้นทดสอบ (ตามที่คุณทำที่นี่)

หากคุณใช้ฟังเป็น Mock คุณสามารถตรวจสอบการโต้ตอบ

Listener listener = mock(Listener.class);
w.addListener(listener);
world.doAction(..);
verify(listener).doAction();

สิ่งนี้จะทำให้คุณพึงพอใจว่า 'โลก' กำลังทำสิ่งที่ถูกต้อง

ใช้ Mockito.doThrow เช่นเดียวกับใน:

Mockito.doThrow(new Exception()).when(instance).methodName();

คุณสามารถลองตัวอย่างที่ดีนี้:

public void testCloseStreamOnException() throws Exception {
    OutputStream outputStream = Mockito.mock(OutputStream.class);
    IFileOutputStream ifos = new IFileOutputStream(outputStream);
    Mockito.doThrow(new IOException("Dummy Exception")).when(outputStream).flush();
    try {
      ifos.close();
      fail("IOException is not thrown");
    } catch (IOException ioe) {
      assertEquals("Dummy Exception", ioe.getMessage());
    }
    Mockito.verify(outputStream).close();
  }

ที่มา: http://apisonar.com/java-examples/org.mockito.Mockito.doThrow.html#Example-19