如何编写与spring cloud netflix和Faign的集成测试

Question

我使用Spring Cloud Netflix在微服务之间进行通信。假设我有两个服务，Foo和Bar，Foo使用Bar的一个RESTendpoint。我使用一个带有@FeignClient注释的界面：

@FeignClient
public interface BarClient {
  @RequestMapping(value = "/some/url", method = "POST")
  void bazzle(@RequestBody BazzleRequest);
}

然后我在Foo中有一个服务类something Service，它调用BarClient。

@Component
public class SomeService {
    @Autowired
    BarClient barClient;

    public String doSomething() {
      try {
        barClient.bazzle(new BazzleRequest(...));
        return "so bazzle my eyes dazzle";
      } catch(FeignException e) {
        return "Not bazzle today!";
      }

    }
}

现在，为了确保服务之间的通信正常工作，我想构建一个测试，使用WireMock之类的东西对假Bar服务器发出真实的HTTP请求。测试应确保feign正确解码服务响应并将其报告给something Service。

public class SomeServiceIntegrationTest {

    @Autowired SomeService someService;

    @Test
    public void shouldSucceed() {
      stubFor(get(urlEqualTo("/some/url"))
        .willReturn(aResponse()
            .withStatus(204);

      String result = someService.doSomething();

      assertThat(result, is("so bazzle my eyes dazzle"));
    }

    @Test
    public void shouldFail() {
      stubFor(get(urlEqualTo("/some/url"))
        .willReturn(aResponse()
            .withStatus(404);

      String result = someService.doSomething();

      assertThat(result, is("Not bazzle today!"));
    }
}

我如何将这样一个WireMock服务器注入到eureka中，以便feign能够找到它并与之通信？我需要什么样的注释魔法？

Answer 1

过去，对微服务应用程序进行集成测试基本上有两种选择：

1. 将服务部署到测试环境并进行端到端测试
2. 模仿其他微服务

第一个选项的明显缺点是部署所有依赖项（其他服务、数据库等）也很麻烦。此外，它的调试速度慢且困难。

第二种选择更快，麻烦更少，但由于可能的代码更改，很容易最终得到与现实不同的存根。因此，当部署到prod时，可能会有成功的测试但失败的应用程序。

更好的解决方案是使用消费者驱动的契约验证，这样可以确保提供者服务的API符合消费者调用。为此，Spring开发者可以使用Spring云契约。对于其他环境，有一个称为PACT的框架。这两种方法也可以用于外国客户。这里有一个关于PACT的例子。

Answer 2

下面是一个示例，如何使用随机端口（基于Spring-Boot github答案）进行飞度和WireMock的布线。

@RunWith(SpringRunner.class)
@SpringBootTest(properties = "google.url=http://google.com") // emulate application.properties
@ContextConfiguration(initializers = PortTest.RandomPortInitializer.class)
@EnableFeignClients(clients = PortTest.Google.class)
public class PortTest {

    @ClassRule
    public static WireMockClassRule wireMockRule = new WireMockClassRule(
        wireMockConfig().dynamicPort()
    );

    @FeignClient(name = "google", url = "${google.url}")
    public interface Google {    
        @RequestMapping(method = RequestMethod.GET, value = "/")
        String request();
    }

    @Autowired
    public Google google;

    @Test
    public void testName() throws Exception {
        stubFor(get(urlEqualTo("/"))
                .willReturn(aResponse()
                        .withStatus(HttpStatus.OK.value())
                        .withBody("Hello")));

        assertEquals("Hello", google.request());
    }


    public static class RandomPortInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
        @Override
        public void initialize(ConfigurableApplicationContext applicationContext) {

            // If the next statement is commented out, 
            // Feign will go to google.com instead of localhost
            TestPropertySourceUtils
                .addInlinedPropertiesToEnvironment(applicationContext,
                    "google.url=" + "http://localhost:" + wireMockRule.port()
            );
        }
    }
}

或者，你可以尝试使用系统。在测试的@BeforeClass方法中设置属性（）。

Answer 3

这是一个使用WireMock测试SpringBoot配置的示例，该示例带有Faign客户端和Hystrix回退。

如果您使用Eureka作为服务器发现，则需要通过设置属性"eureka.client.enabled=false"来禁用它。

首先，我们需要为我们的应用程序启用FIGN/Hystrix配置：

@SpringBootApplication
@EnableFeignClients
@EnableCircuitBreaker
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@FeignClient(
        name = "bookstore-server",
        fallback = BookClientFallback.class,
        qualifier = "bookClient"
)
public interface BookClient {

    @RequestMapping(method = RequestMethod.GET, path = "/book/{id}")
    Book findById(@PathVariable("id") String id);
}

@Component
public class BookClientFallback implements BookClient {

    @Override
    public Book findById(String id) {
        return Book.builder().id("fallback-id").title("default").isbn("default").build();
    }
}

请注意，我们正在为外部客户端指定一个回退类。每次外部客户端调用失败时（例如连接超时），都会调用回退类。

为了让测试正常工作，我们需要配置Ribbon loadbalancer（在发送http请求时将由外部客户端在内部使用）：

@RunWith(SpringRunner.class)
@SpringBootTest(properties = {
        "feign.hystrix.enabled=true"
})
@ContextConfiguration(classes = {BookClientTest.LocalRibbonClientConfiguration.class})
public class BookClientTest {

    @Autowired
    public BookClient bookClient;

    @ClassRule
    public static WireMockClassRule wiremock = new WireMockClassRule(
            wireMockConfig().dynamicPort()));

    @Before
    public void setup() throws IOException {
        stubFor(get(urlEqualTo("/book/12345"))
                .willReturn(aResponse()
                        .withStatus(HttpStatus.OK.value())
                        .withHeader("Content-Type", MediaType.APPLICATION_JSON)
                        .withBody(StreamUtils.copyToString(getClass().getClassLoader().getResourceAsStream("fixtures/book.json"), Charset.defaultCharset()))));
    }

    @Test
    public void testFindById() {
        Book result = bookClient.findById("12345");

        assertNotNull("should not be null", result);
        assertThat(result.getId(), is("12345"));
    }

    @Test
    public void testFindByIdFallback() {
        stubFor(get(urlEqualTo("/book/12345"))
                .willReturn(aResponse().withFixedDelay(60000)));

        Book result = bookClient.findById("12345");

        assertNotNull("should not be null", result);
        assertThat(result.getId(), is("fallback-id"));
    }

    @TestConfiguration
    public static class LocalRibbonClientConfiguration {
        @Bean
        public ServerList<Server> ribbonServerList() {
            return new StaticServerList<>(new Server("localhost", wiremock.port()));
        }
    }
}

Ribbon服务器列表需要与WireMock配置的url（主机和端口）匹配。