SpringCloud升级之路2020.0.x版-40. spock 单元测试封装的 WebClie

番茄西红柿发布于2021-11-22 14:56 / 2997人阅读

摘要：在上面打开一个微服务某个实例的一个路径的断路器之后，我们调用其他的路径，无论多少次，都成功并且调用负载均衡器获取服务实例的次数等于调用次数，代表没有重试，也就是没有断路器异常。

SpringCloud升级之路2020.0.x版-40.

本系列代码地址：https://github.com/JoJoTec/spring-cloud-parent

我们来测试下前面封装好的 WebClient，这里开始，我们使用 spock 编写 groovy 单元测试，这种编写出来的单元测试，代码更加简洁，同时更加灵活，我们在接下来的单元测试代码中就能看出来。

编写基于 spock 的 spring-boot context 测试

我们加入前面设计的配置，编写测试类：

@SpringBootTest(
        properties = [
                "webclient.configs.testServiceWithCannotConnect.baseUrl=http://testServiceWithCannotConnect",
                "webclient.configs.testServiceWithCannotConnect.serviceName=testServiceWithCannotConnect",
                "webclient.configs.testService.baseUrl=http://testService",
                "webclient.configs.testService.serviceName=testService",
                "webclient.configs.testService.responseTimeout=1s",
                "webclient.configs.testService.retryablePaths[0]=/delay/3",
                "webclient.configs.testService.retryablePaths[1]=/status/4*",
                "spring.cloud.loadbalancer.zone=zone1",
                "resilience4j.retry.configs.default.maxAttempts=3",
                "resilience4j.circuitbreaker.configs.default.failureRateThreshold=50",
                "resilience4j.circuitbreaker.configs.default.slidingWindowType=TIME_BASED",
                "resilience4j.circuitbreaker.configs.default.slidingWindowSize=5",
                //因为重试是 3 次，为了防止断路器打开影响测试，设置为正好比重试多一次的次数，防止触发
                //同时我们在测试的时候也需要手动清空断路器统计
                "resilience4j.circuitbreaker.configs.default.minimumNumberOfCalls=4",
                "resilience4j.circuitbreaker.configs.default.recordExceptions=java.lang.Exception"
        ],
        classes = MockConfig
)
class WebClientUnitTest extends Specification {
    @SpringBootApplication
    static class MockConfig {
    }
}

我们加入三个服务实例供单元测试调用：

class WebClientUnitTest extends Specification {
    def zone1Instance1 = new DefaultServiceInstance(instanceId: "instance1", host: "www.httpbin.org", port: 80, metadata: Map.ofEntries(Map.entry("zone", "zone1")))
    def zone1Instance2 = new DefaultServiceInstance(instanceId: "instance2", host: "www.httpbin.org", port: 8081, metadata: Map.ofEntries(Map.entry("zone", "zone1")))
    def zone1Instance3 = new DefaultServiceInstance(instanceId: "instance3", host: "httpbin.org", port: 80, metadata: Map.ofEntries(Map.entry("zone", "zone1")))
}

我们要动态的指定负载均衡获取服务实例列表的响应，即去 Mock 负载均衡器的 ServiceInstanceListSupplier 并覆盖：

class WebClientUnitTest extends Specification {

    @Autowired
    private Tracer tracer
    @Autowired
    private ServiceInstanceMetrics serviceInstanceMetrics
    
    RoundRobinWithRequestSeparatedPositionLoadBalancer loadBalancerClientFactoryInstance = Spy();
    ServiceInstanceListSupplier serviceInstanceListSupplier = Spy();
    
    //所有测试的方法执行前会调用的方法
    def setup() {
        //初始化 loadBalancerClientFactoryInstance 负载均衡器
        loadBalancerClientFactoryInstance.setTracer(tracer)
        loadBalancerClientFactoryInstance.setServiceInstanceMetrics(serviceInstanceMetrics)
        loadBalancerClientFactoryInstance.setServiceInstanceListSupplier(serviceInstanceListSupplier)
    }
}

之后，我们可以通过下面的 groovy 代码，动态指定微服务返回实例：

//指定 testService 微服务的 LoadBalancer 为 loadBalancerClientFactoryInstance
loadBalancerClientFactory.getInstance("testService") >> loadBalancerClientFactoryInstance
//指定 testService 微服务实例列表为 zone1Instance1, zone1Instance3
serviceInstanceListSupplier.get() >> Flux.just(Lists.newArrayList(zone1Instance1, zone1Instance3))

测试断路器异常重试以及断路器级别

我们需要验证：

对于断路器打开的异常，由于没有请求发出去，所以需要直接重试其他的实例。我们可以设立一个微服务，包含两个实例，将其中一个实例的某个路径断路器打开，之后多次调用这个微服务的这个路径接口，看是否都调用成功（由于有重试，所以每次调用都会成功）。同时验证，对于负载均衡器获取服务实例的调用，多于调用次数（每次重试都会调用负载均衡器获取一个新的实例用于调用）
某个路径断路器打开的时候，其他路径断路器不会打开。在上面打开一个微服务某个实例的一个路径的断路器之后，我们调用其他的路径，无论多少次，都成功并且调用负载均衡器获取服务实例的次数等于调用次数，代表没有重试，也就是没有断路器异常。

编写代码：

@SpringBootTest(
    properties = [
        "webclient.configs.testServiceWithCannotConnect.baseUrl=http://testServiceWithCannotConnect",
        "webclient.configs.testServiceWithCannotConnect.serviceName=testServiceWithCannotConnect",
        "webclient.configs.testService.baseUrl=http://testService",
        "webclient.configs.testService.serviceName=testService",
        "webclient.configs.testService.responseTimeout=1s",
        "webclient.configs.testService.retryablePaths[0]=/delay/3",
        "webclient.configs.testService.retryablePaths[1]=/status/4*",
        "spring.cloud.loadbalancer.zone=zone1",
        "resilience4j.retry.configs.default.maxAttempts=3",
        "resilience4j.circuitbreaker.configs.default.failureRateThreshold=50",
        "resilience4j.circuitbreaker.configs.default.slidingWindowType=TIME_BASED",
        "resilience4j.circuitbreaker.configs.default.slidingWindowSize=5",
        //因为重试是 3 次，为了防止断路器打开影响测试，设置为正好比重试多一次的次数，防止触发
        //同时我们在测试的时候也需要手动清空断路器统计
        "resilience4j.circuitbreaker.configs.default.minimumNumberOfCalls=4",
        "resilience4j.circuitbreaker.configs.default.recordExceptions=java.lang.Exception"
    ],
    classes = MockConfig
)
class WebClientUnitTest extends Specification {
  @SpringBootApplication
  static class MockConfig {
  }
  @SpringBean
  private LoadBalancerClientFactory loadBalancerClientFactory = Mock()

  @Autowired
  private CircuitBreakerRegistry circuitBreakerRegistry
  @Autowired
  private Tracer tracer
  @Autowired
  private ServiceInstanceMetrics serviceInstanceMetrics
  @Autowired
  private WebClientNamedContextFactory webClientNamedContextFactory

  //不同的测试方法的类对象不是同一个对象，会重新生成，保证互相没有影响
  def zone1Instance1 = new DefaultServiceInstance(instanceId: "instance1", host: "www.httpbin.org", port: 80, metadata: Map.ofEntries(Map.entry("zone", "zone1")))
  def zone1Instance2 = new DefaultServiceInstance(instanceId: "instance2", host: "www.httpbin.org", port: 8081, metadata: Map.ofEntries(Map.entry("zone", "zone1")))
  def zone1Instance3 = new DefaultServiceInstance(instanceId: "instance3", host: "httpbin.org", port: 80, metadata: Map.ofEntries(Map.entry("zone", "zone1")))
  RoundRobinWithRequestSeparatedPositionLoadBalancer loadBalancerClientFactoryInstance = Spy();
  ServiceInstanceListSupplier serviceInstanceListSupplier = Spy();

  //所有测试的方法执行前会调用的方法
  def setup() {
    //初始化 loadBalancerClientFactoryInstance 负载均衡器
    loadBalancerClientFactoryInstance.setTracer(tracer)
    loadBalancerClientFactoryInstance.setServiceInstanceMetrics(serviceInstanceMetrics)
    loadBalancerClientFactoryInstance.setServiceInstanceListSupplier(serviceInstanceListSupplier)
  }

  def "测试断路器异常重试以及断路器级别"() {
    given: "设置 testService 的实例都是正常实例"
      loadBalancerClientFactory.getInstance("testService") >> loadBalancerClientFactoryInstance
      serviceInstanceListSupplier.get() >> Flux.just(Lists.newArrayList(zone1Instance1, zone1Instance3))
    when: "断路器打开"
      //清除断路器影响
      circuitBreakerRegistry.getAllCircuitBreakers().forEach({ c -> c.reset() })
      loadBalancerClientFactoryInstance = (RoundRobinWithRequestSeparatedPositionLoadBalancer) loadBalancerClientFactory.getInstance("testService")
      def breaker
      try {
        breaker = circuitBreakerRegistry.circuitBreaker("httpbin.org:80/anything", "testService")
      } catch (ConfigurationNotFoundException e) {
        breaker = circuitBreakerRegistry.circuitBreaker("httpbin.org:80/anything")
      }
      //打开实例 3 的断路器
      breaker.transitionToOpenState()
      //调用 10 次
      for (i in 0..<10) {
        Mono stringMono = webClientNamedContextFactory.getWebClient("testService")
                                    .get().uri("/anything").retrieve()
                                    .bodyToMono(String.class)
        println(stringMono.block())
      }
    then:"调用至少 10 次负载均衡器且没有异常即成功"
      (10.._) * loadBalancerClientFactoryInstance.getInstanceResponseByRoundRobin(*_)
    when: "调用不同的路径，验证断路器在这个路径上都是关闭"
      //调用 10 次
      for (i in 0..<10) {
        Mono stringMono = webClientNamedContextFactory.getWebClient("testService")
                                    .get().uri("/status/200").retrieve()
                                    .bodyToMono(String.class)
        println(stringMono.block())
      }
    then: "调用必须为正好 10 次代表没有重试，一次成功，断路器之间相互隔离"
      10 * loadBalancerClientFactoryInstance.getInstanceResponseByRoundRobin(*_)
  }
}

测试针对 connectTimeout 重试

对于连接超时，我们需要验证：无论是否可以重试的方法或者路径，都必须重试，因为请求并没有真的发出去。可以这样验证：设置微服务 testServiceWithCannotConnect 一个实例正常，另一个实例会连接超时，我们配置了重试 3 次，所以每次请求应该都能成功，并且随着程序运行，后面的调用不可用的实例还会被断路，照样可以成功调用。

@SpringBootTest(
    properties = [
        "webclient.configs.testServiceWithCannotConnect.baseUrl=http://testServiceWithCannotConnect",
        "webclient.configs.testServiceWithCannotConnect.serviceName=testServiceWithCannotConnect",
        "webclient.configs.testService.baseUrl=http://testService",
        "webclient.configs.testService.serviceName=testService",
        "webclient.configs.testService.responseTimeout=1s",
        "webclient.configs.testService.retryablePaths[0]=/delay/3",
        "webclient.configs.testService.retryablePaths[1]=/status/4*",
        "spring.cloud.loadbalancer.zone=zone1",
        "resilience4j.retry.configs.default.maxAttempts=3",
        "resilience4j.circuitbreaker.configs.default.failureRateThreshold=50",
        "resilience4j.circuitbreaker.configs.default.slidingWindowType=TIME_BASED",
        "resilience4j.circuitbreaker.configs.default.slidingWindowSize=5",
        //因为重试是 3 次，为了防止断路器打开影响测试，设置为正好比重试多一次的次数，防止触发
        //同时我们在测试的时候也需要手动清空断路器统计
        "resilience4j.circuitbreaker.configs.default.minimumNumberOfCalls=4",
        "resilience4j.circuitbreaker.configs.default.recordExceptions=java.lang.Exception"
    ],
    classes = MockConfig
)
class WebClientUnitTest extends Specification {
  @SpringBootApplication
  static class MockConfig {
  }
  @SpringBean
  private LoadBalancerClientFactory loadBalancerClientFactory = Mock()

  @Autowired
  private CircuitBreakerRegistry circuitBreakerRegistry
  @Autowired
  private Tracer tracer
  @Autowired
  private ServiceInstanceMetrics serviceInstanceMetrics
  @Autowired
  private WebClientNamedContextFactory webClientNamedContextFactory

  //不同的测试方法的类对象不是同一个对象，会重新生成，保证互相没有影响
  def zone1Instance1 = new DefaultServiceInstance(instanceId: "instance1", host: "www.httpbin.org", port: 80, metadata: Map.ofEntries(Map.entry("zone", "zone1")))
  def zone1Instance2 = new DefaultServiceInstance(instanceId: "instance2", host: "www.httpbin.org", port: 8081, metadata: Map.ofEntries(Map.entry("zone", "zone1")))
  def zone1Instance3 = new DefaultServiceInstance(instanceId: "instance3", host: "httpbin.org", port: 80, metadata: Map.ofEntries(Map.entry("zone", "zone1")))
  RoundRobinWithRequestSeparatedPositionLoadBalancer loadBalancerClientFactoryInstance = Spy();
  ServiceInstanceListSupplier serviceInstanceListSupplier = Spy();

  //所有测试的方法执行前会调用的方法
  def setup() {
    //初始化 loadBalancerClientFactoryInstance 负载均衡器
    loadBalancerClientFactoryInstance.setTracer(tracer)
    loadBalancerClientFactoryInstance.setServiceInstanceMetrics(serviceInstanceMetrics)
    loadBalancerClientFactoryInstance.setServiceInstanceListSupplier(serviceInstanceListSupplier)
  }

  def "测试针对 connectTimeout 重试"() {
    given: "设置微服务 testServiceWithCannotConnect 一个实例正常，另一个实例会连接超时"
      loadBalancerClientFactory.getInstance("testServiceWithCannotConnect") >> loadBalancerClientFactoryInstance
      serviceInstanceListSupplier.get() >> Flux.just(Lists.newArrayList(zone1Instance1, zone1Instance2))
    when:
      //由于我们针对 testService 返回了两个实例，一个可以正常连接，一个不可以，但是我们配置了重试 3 次，所以每次请求应该都能成功，并且随着程序运行，后面的调用不可用的实例还会被断路
      //这里主要测试针对 connect time out 还有 断路器打开的情况都会重试，并且无论是 GET 方法还是其他的
      Span span = tracer.nextSpan()
      for (i in 0..<10) {
        Tracer.SpanInScope cleared = tracer.withSpanInScope(span)
        try {
          //测试 get 方法（默认 get 方法会重试）
          Mono stringMono = webClientNamedContextFactory.getWebClient("testServiceWithCannotConnect")
                                      .get().uri("/anything").retrieve()
                                      .bodyToMono(String.class)
          println(stringMono.block())
          //测试 post 方法（默认 post 方法针对请求已经发出的不会重试，这里没有发出请求所以还是会重试的）
          stringMono = webClientNamedContextFactory.getWebClient("testServiceWithCannotConnect")
                               .post().uri("/anything").retrieve()
                               .bodyToMono(String.class)
          println(stringMono.block())
        }
        finally {
          cleared.close()
        }
      }
    then:"调用至少 20 次负载均衡器且没有异常即成功"
      (20.._) * loadBalancerClientFactoryInstance.getInstanceResponseByRoundRobin(*_)
  }
}

微信搜索“我的编程喵”关注公众号，每日一刷，轻松提升技术，斩获各种offer：

SpringCloud升级之路2020.0.x版-40.

GPU云服务器云服务器单元测试单元测试规范单元测试图片测试java php单元测试’

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/124242.html

SpringCloud升级之路2020.0.x版-40. spock 单元测试封装的 WebClie

摘要：本系列代码地址我们继续上一节，继续使用测试我们自己封装的测试针对重试测试针对重试针对响应超时，我们需要验证重试仅针对可以重试的方法包括方法以及配置的可重试方法，针对不可重试的方法没有重试。本系列代码地址：https://github.com/JoJoTec/spring-cloud-parent我们继续上一节，继续使用 spock 测试我们自己封装的 WebClient测试针对 readTi...

番茄西红柿 2021-11-23 09:51 评论0 收藏2637
SpringCloud升级之路2020.0.x版-37. 实现异步的客户端封装配置管理的意义与设计

摘要：对于异步的请求，使用的是异步客户端即。要实现的配置设计以及使用举例要实现的配置设计以及使用举例首先，我们要实现的，其包含三个重试重试的要在负载均衡之前，因为重试的时候，我们会从负载均衡器获取另一个实例进行重试，而不是在同一个实例上重试多次。本系列代码地址：https://github.com/JoJoTec/spring-cloud-parent 为何需要封装异步 HT...

fxp 2021-11-19 11:29 评论0 收藏0
SpringCloud升级之路2020.0.x版-36. 验证断路器正确性

摘要：本系列代码地址上一节我们通过单元测试验证了线程隔离的正确性，这一节我们来验证我们断路器的正确性，主要包括验证配置正确加载即我们在配置例如中的加入的的配置被正确加载应用了。本系列代码地址：https://github.com/JoJoTec/spring-cloud-parent上一节我们通过单元测试验证了线程隔离的正确性，这一节我们来验证我们断路器的正确性，主要包括：验证配置正确加载：即我们...

NotFound 2021-11-18 10:07 评论0 收藏0
SpringCloud升级之路2020.0.x版-41. SpringCloudGateway 基本

摘要：将请求封装成将请求封装成的接口定义是但是最外层传进来的参数是和，需要将他们封装成，这个工作就是在中做的。其实主要任务就是将各种参数封装成除了和本次请求相关的和，还有会话管理器，编码解码器配置，国际化配置还有用于扩展。本系列代码地址：https://github.com/JoJoTec/spring-cloud-parent接下来，将进入我们升级之路的又一大模块，即网关模块。网关模块我们废弃了...

不知名网友 2021-11-25 09:43 评论0 收藏0
SpringCloud升级之路2020.0.x版-41. SpringCloudGateway 基本

摘要：在这里，会将上下文中载入的拼接成，然后调用其方法的，它是的处理请求业务的起点。添加相关依赖之后，会有这个。路由权重相关配置功能相关实现类，这个我们这里不关心。本系列代码地址：https://github.com/JoJoTec/spring-cloud-parent我们继续分析上一节提到的 WebHandler，经过将请求封装成 ServerWebExchange 的 HttpWebHand...

不知名网友 2021-11-26 11:11 评论0 收藏0