Java 为什么在编写UnitTest时得到空响应

我正在学习为SpringBoot Restcontroller编写单元测试，编写了此测试并通过了测试

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {FhirApp.class, TestSecurityConfiguration.class})
@AutoConfigureMockMvc
public class ObservationControllerTest {

    private ObjectMapper objectMapper = new ObjectMapper();

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private ObservationService observationService;

    @Test
    public void createObservationResource() throws Exception {

        given(observationService.createObservation(ResourceStringProvider.observationsource()))
                .willReturn(responseDocument);

        String jsonString = objectMapper.writeValueAsString(
                          ResourceStringProvider.observationsource());

        mockMvc.perform(post("/Observation")
            .contentType(MediaType.APPLICATION_JSON)
            .content(jsonString))
            .andExpect(status()
            .isOk());
}

但是作为和，我也得到了响应的空响应。getContentAsString（）：

我已经尝试过他们提供的解决方案：

1: Using Mockito.any(String.class) 
2: webEnvironment = SpringBootTest.WebEnvironment.MOCK
3: using thenCallRealMethod instead of thenReturn(responseDocument)

但不幸的是，它不起作用，已经尝试了不同的可能性，我也尝试使用MockitoJunitRunner：

@RunWith(MockitoJUnitRunner.class)
@SpringBootTest(classes = {FhirApp.class, TestSecurityConfiguration.class})
@AutoConfigureMockMvc
public class ObservationControllerTest {

private MockMvc mockMvc;

@Mock
private ObservationService observationService;

@Mock
private RequestFilter requestFilter;

@InjectMocks
private ObservationController observationController;

@Before
public void setup() {
    Resource resource = Utility.convertFromStringToFhirResource(Observation.class,ResourceStringProvider.observationResponse());
    responseDocument=Utility.convertFromFhirResourceToMongoInsertibleDoc(resource);

    //these line enabled for MockitoJUnitRunner only 
    this.mockMvc = MockMvcBuilders.standaloneSetup(observationController)
        .setControllerAdvice(new FhirRuntimeException("Error Happened"))
        .addFilters(requestFilter)
        .build();
}

@Test
public void createObservationResource()throws Exception{
    Mockito.when(observationService.createObservation(ResourceStringProvider.observationsource())).thenReturn(responseDocument);

    String jsonString = objectMapper.writeValueAsString(ResourceStringProvider.observationsource());
    MockHttpServletResponse response = mockMvc.perform(
        post("/Observation")
        .contentType(MediaType.APPLICATION_JSON)
        .content(jsonString))
        .andReturn()
        .getResponse();

    assertThat(response.getContentAsString()).isEqualTo(new ObjectMapper().writeValueAsString(responseDocument));
}

我认为，由于并没有多少人经历过这样的问题，所以这个问题并没有得到太多的讨论。当响应状态为ok时，空响应的原因可能是什么

控制器代码：

@RestController
@RequestMapping("/api")
public class ObservationController {

    @Autowired
    private ObservationService observationService;


    @GetMapping("/Observation/{id}")
    public ResponseEntity<Document> getObservationByID(
        @RequestParam("_pretty") Optional<String> pretty,
        @PathVariable("id") String id) {
        Document resultDoc = observationService.getObservationById(id);
        return new ResponseEntity<>(resultDoc, HttpStatus.OK);
    }


    @PostMapping(path = "/Observation", consumes = {"application/json", "application/fhir+json"},
        produces = {"application/json", "application/fhir+json"})
    public ResponseEntity<Document> createObservationResource(@RequestBody String fhirResource) {
        Document fhirDoc = observationService.createObservation(fhirResource);
        return new ResponseEntity<>(fhirDoc,
            Utility.createHeaders(fhirDoc),
            HttpStatus.CREATED);
    }

    //other methods
}

@RestController
@请求映射（“/api”）
公共类观测控制器{
@自动连线
私人观测服务观测服务；
@GetMapping（“/Observation/{id}”）
公共响应getObservationByID(
@RequestParam（“_pretty”）可选pretty，
@路径变量（“id”）字符串id）{
Document resultDoc=observationService.getObservationById（id）；
返回新的响应状态（resultDoc、HttpStatus.OK）；
}
@PostMapping（path=“/Observation”，consumes={“application/json”，“application/fhir+json”}，
products={“application/json”，“application/fhir+json”}）
public ResponseEntity createObservationResource（@RequestBody String FHINDEROURCE）{
文档fhirDoc=observationService.createObservation（fhirdource）；
返回新响应（fhirDoc，
实用程序.createHeaders（fhirDoc），
HttpStatus.CREATED）；
}
//其他方法
}

---

我意识到在测试中对post的调用应该是/api/Observation，但这没有任何区别。提前感谢。

将完整答案与导入一起发布在此处，以便对某人有所帮助（实际上，我们不需要上面的任何注释，这是运行它的一种方式，在我的发现过程中，我发现了这一点，这有助于解决如果您继续使用@InjectMocks方法可能出现的设计问题）

---

当你调试你的测试时，你发现什么是错误的？若结果为空，那个么返回给客户机的任何内容都是空的。但是你没有发布你的服务器端代码，所以我们不知道。我已经更新了控制器的代码。实际上，整个项目都是使用Jhipster生成的Spring引导项目？您能否验证

文档fhirDoc

是否不为空。这可能是因为

ResourceStringProvider.observationsource（）

创建了不同的对象，而当您在模拟中使用它们时，这些对象不匹配。您可以尝试重写equals方法。根据您的注释，我使用Mockito.verify（）检查了您的注释，并且控制器本身没有被调用。这个创业板也帮了大忙。不知道为什么一个有效的计划被否决了？

@RestController
@RequestMapping("/api")
public class ObservationController {

    @Autowired
    private ObservationService observationService;


    @GetMapping("/Observation/{id}")
    public ResponseEntity<Document> getObservationByID(
        @RequestParam("_pretty") Optional<String> pretty,
        @PathVariable("id") String id) {
        Document resultDoc = observationService.getObservationById(id);
        return new ResponseEntity<>(resultDoc, HttpStatus.OK);
    }


    @PostMapping(path = "/Observation", consumes = {"application/json", "application/fhir+json"},
        produces = {"application/json", "application/fhir+json"})
    public ResponseEntity<Document> createObservationResource(@RequestBody String fhirResource) {
        Document fhirDoc = observationService.createObservation(fhirResource);
        return new ResponseEntity<>(fhirDoc,
            Utility.createHeaders(fhirDoc),
            HttpStatus.CREATED);
    }

    //other methods
}

import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;

import com.comitemd.emr.datalayer.fhir.service.ObservationService;
import com.comitemd.emr.datalayer.fhir.utility.ResourceStringProvider;
import com.comitemd.emr.datalayer.fhir.utility.Utility;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.bson.Document;
import org.hl7.fhir.r4.model.Observation;
import org.hl7.fhir.r4.model.Resource;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.result.MockMvcResultHandlers;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;

//@RunWith(MockitoJUnitRunner.class)
public class ObservationControllerStandaloneTest {

    private MockMvc mockMvc;
    @Mock
    private ObservationService observationService;
    @InjectMocks
    private ObservationController observationController;

    private Document responseDocument;
    @Before
    public void setup() {
       MockitoAnnotations.initMocks(this);// enable this or MockitoJUnitRunner.class
        Resource resource = Utility
            .convertFromStringToFhirResource(Observation.class, ResourceStringProvider.observationResponse());
         responseDocument=Utility.convertFromFhirResourceToMongoInsertibleDoc(resource);
        this.mockMvc = MockMvcBuilders.standaloneSetup(observationController).build();
    }

    @Test
    public void createObservationResource()throws Exception{
        Mockito.when(observationService.createObservation(ResourceStringProvider.observationsource()))
            .thenReturn(responseDocument);

        MockHttpServletResponse response = mockMvc.perform(
            post("/api/Observation")
                .contentType(MediaType.APPLICATION_JSON)
                .content(ResourceStringProvider.observationsource()))
            .andDo(MockMvcResultHandlers.print())
            .andReturn()
            .getResponse();

        verify(observationService, times(1)).createObservation(Mockito.any());
        assertThat(response.getContentAsString()).isEqualTo(new ObjectMapper().writeValueAsString(responseDocument));
    }
}