嘲笑连续的REST呼叫

我有一个服务/ dao层。服务层方法调用我从中获得响应的dao的第一个方法，并调用dao中的第二个方法来传递一些参数，包括1st dao方法的响应中的值。我尝试使用模拟，但它与空指针失败。伪代码是一样的东西如下：嘲笑连续的REST呼叫

Service{ 
serviceMethod(some_args){ 
response1 = dao.method1(some_args); 
someItem = response1.get("someItem"); 

/* do some logic on someitem to create otherItem*/ 
request2.setArgs(someItem); 
response2 = dao.method2(request2); 
} 
}

我曾尝试如下嘲笑，但它不工作。

@Test 
     public void testPass(){ 
     mockResponse1 = new Response1(); 
     mockRequest2 = new MockRequest2(); 
     when(dao.method1(some_args)).thenReturn(mockResponse1) 
     mockResponse1.setArgs(some_args); 
     mockRequest2.setArgs(mockResponse1.getargs()); 
     mockResponse2 = new Response2(); 
     when(dao.method2(mockRequest2)).thenReturn(mockResponse2) 
     service.serviceMethod(some_args) 
     }

来源

2016-05-12 user 8838

这是一个真正的Java代码，或只是一个伪代码？我看到mockResponse1是一个实际的实例，mockResponse2也是一个实际的实例。如果你打电话给这些嘲笑，我期待像模拟（Response1.class）和模拟（Response2.class）。如果你真的没有注意到这一点，那么你的问题。 –

''代码是''可能会让你难以发现问题，当你不包含实际的模拟创建代码（= dao'），并且还包括代码将模拟注入到服务类中的代码。此外'mockRequest2'没有在你的测试代码中的任何地方定义 –

这是伪代码 –

你可以使用一个ArgumentCaptor来获取传递到dao.method2(...)值，然后使上断言。

例如，说我有这个DAO ...

public interface DAO { 
    Response method1(Request request);  
    Response method2(Request request); 
}

而这个服务...

public class Service { 

    private DAO dao; 

    public void setDao(DAO dao) { 
     this.dao = dao; 
    } 

    public Response serviceMethod(Request someArgs) { 
     Response response1 = dao.method1(someArgs); 
     String someItem = response1.getTheResponse(); 
     Request request2 = new Request(someItem); 
     return dao.method2(request2); 
    } 
}

，此服务的测试可能是......

import static org.fest.assertions.Assertions.assertThat; 
import static org.mockito.Matchers.any; 
import static org.mockito.Mockito.verify; 
import static org.mockito.Mockito.when; 

import org.junit.Before; 
import org.junit.Test; 
import org.mockito.ArgumentCaptor; 
import org.mockito.Captor; 
import org.mockito.InjectMocks; 
import org.mockito.Mock; 
import org.mockito.MockitoAnnotations; 

public class ServiceTest { 

    @Mock 
    private Request request; 

    @Mock 
    private Response response; 

    @Mock 
    private Response serviceResponse; 

    @Mock 
    private DAO dao; 

    @InjectMocks 
    private Service service; 

    @Captor 
    private ArgumentCaptor<Request> requestCaptor; 

    @Before 
    public void setup() { 
     MockitoAnnotations.initMocks(this); 
    } 

    @Test 
    public void shouldDoServiceMethod() { 
     // Set up 
     when(dao.method1(request)).thenReturn(response); 
     when(response.getTheResponse()).thenReturn("[ARGUMENT]"); 
     when(dao.method2(any(Request.class))).thenReturn(serviceResponse); 

     // Code under test 
     Response actualResponse = service.serviceMethod(request); 

     // Verification 
     assertThat(actualResponse).isSameAs(serviceResponse); 

     verify(dao).method2(requestCaptor.capture()); 

     Request actualSecondRequest = requestCaptor.getValue(); 

     assertThat(actualSecondRequest.getArgs()).isEqualTo("[ARGUMENT]"); 
    } 
}

重点行...

verify(dao).method2(requestCaptor.capture());

这验证了method2被调用并捕获了它被调用的值。

那么你得到的价值...

Request actualSecondRequest = requestCaptor.getValue();

...然后你可以验证相关的信息被设置...

assertThat(actualSecondRequest.getArgs()).isEqualTo("[ARGUMENT]");

希望这有助于。

为了完整起见，这里的Request和Response ...

public class Request { 

    private String args; 

    public Request(String args) { 
     this.args = args; 
    } 

    public String getArgs() { 
     return args; 
    } 
} 

public class Response { 

    private String theResponse; 

    public Response(String theResponse) { 
     this.theResponse = theResponse; 
    } 

    public String getTheResponse() { 
     return theResponse; 
    } 
}

来源

2016-05-24 14:48:21 BretC

嘲笑连续的REST呼叫

回答

相关问题