diff --git a/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerFeignIntegrationTest.java b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerFeignIntegrationTest.java index f2963b9b3..ef5173c8a 100644 --- a/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerFeignIntegrationTest.java +++ b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerFeignIntegrationTest.java @@ -18,7 +18,24 @@ package com.tencent.cloud.polaris.circuitbreaker; +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.util.stream.Collectors; + +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.util.JsonFormat; import com.tencent.cloud.polaris.circuitbreaker.config.PolarisCircuitBreakerFeignClientAutoConfiguration; +import com.tencent.polaris.api.pojo.ServiceKey; +import com.tencent.polaris.circuitbreak.api.CircuitBreakAPI; +import com.tencent.polaris.circuitbreak.factory.CircuitBreakAPIFactory; +import com.tencent.polaris.client.util.Utils; +import com.tencent.polaris.specification.api.v1.fault.tolerance.CircuitBreakerProto; +import com.tencent.polaris.test.common.TestUtils; +import com.tencent.polaris.test.mock.discovery.NamingServer; +import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -26,6 +43,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.autoconfigure.ImportAutoConfiguration; import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.cloud.client.circuitbreaker.NoFallbackAvailableException; import org.springframework.cloud.openfeign.EnableFeignClients; import org.springframework.cloud.openfeign.FallbackFactory; import org.springframework.cloud.openfeign.FeignClient; @@ -36,6 +54,7 @@ import org.springframework.test.context.junit.jupiter.SpringExtension; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam; +import static com.tencent.polaris.test.common.TestUtils.SERVER_ADDRESS_ENV; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT; @@ -55,6 +74,8 @@ import static org.springframework.boot.test.context.SpringBootTest.WebEnvironmen @DirtiesContext public class PolarisCircuitBreakerFeignIntegrationTest { + private static final String TEST_SERVICE_NAME = "test-service-callee"; + @Autowired private EchoService echoService; @@ -67,6 +88,15 @@ public class PolarisCircuitBreakerFeignIntegrationTest { @Autowired private BazService bazService; + private static NamingServer namingServer; + + @AfterAll + public static void afterAll() { + if (null != namingServer) { + namingServer.terminate(); + } + } + @Test public void contextLoads() throws Exception { assertThat(echoService).isNotNull(); @@ -76,16 +106,14 @@ public class PolarisCircuitBreakerFeignIntegrationTest { @Test public void testFeignClient() { assertThat(echoService.echo("test")).isEqualTo("echo fallback"); - assertThat(fooService.echo("test")).isEqualTo("foo fallback"); - + Utils.sleepUninterrupted(2000); assertThatThrownBy(() -> { - barService.bar(); - }).isInstanceOf(Exception.class); - - assertThatThrownBy(() -> { - bazService.baz(); - }).isInstanceOf(Exception.class); - + fooService.echo("test"); + }).isInstanceOf(NoFallbackAvailableException.class); + Utils.sleepUninterrupted(2000); + assertThat(barService.bar()).isEqualTo("\"fallback from polaris server\""); + Utils.sleepUninterrupted(2000); + assertThat(bazService.baz()).isEqualTo("\"fallback from polaris server\""); assertThat(fooService.toString()).isNotEqualTo(echoService.toString()); assertThat(fooService.hashCode()).isNotEqualTo(echoService.hashCode()); assertThat(echoService.equals(fooService)).isEqualTo(Boolean.FALSE); @@ -107,9 +135,31 @@ public class PolarisCircuitBreakerFeignIntegrationTest { return new CustomFallbackFactory(); } + @Bean + public CircuitBreakAPI circuitBreakAPI() throws InvalidProtocolBufferException { + try { + namingServer = NamingServer.startNamingServer(10081); + System.setProperty(SERVER_ADDRESS_ENV, String.format("127.0.0.1:%d", namingServer.getPort())); + } + catch (IOException e) { + + } + ServiceKey serviceKey = new ServiceKey("default", TEST_SERVICE_NAME); + + CircuitBreakerProto.CircuitBreakerRule.Builder circuitBreakerRuleBuilder = CircuitBreakerProto.CircuitBreakerRule.newBuilder(); + InputStream inputStream = PolarisCircuitBreakerMockServerTest.class.getClassLoader().getResourceAsStream("circuitBreakerRule.json"); + String json = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8)).lines().collect(Collectors.joining("")); + JsonFormat.parser().ignoringUnknownFields().merge(json, circuitBreakerRuleBuilder); + CircuitBreakerProto.CircuitBreakerRule circuitBreakerRule = circuitBreakerRuleBuilder.build(); + CircuitBreakerProto.CircuitBreaker circuitBreaker = CircuitBreakerProto.CircuitBreaker.newBuilder().addRules(circuitBreakerRule).build(); + namingServer.getNamingService().setCircuitBreaker(serviceKey, circuitBreaker); + com.tencent.polaris.api.config.Configuration configuration = TestUtils.configWithEnvAddress(); + return CircuitBreakAPIFactory.createCircuitBreakAPIByConfig(configuration); + } + } - @FeignClient(value = "test-service", fallback = EchoServiceFallback.class) + @FeignClient(value = TEST_SERVICE_NAME, contextId = "1", fallback = EchoServiceFallback.class) public interface EchoService { @RequestMapping(path = "echo/{str}") @@ -117,7 +167,7 @@ public class PolarisCircuitBreakerFeignIntegrationTest { } - @FeignClient(value = "foo-service", fallbackFactory = CustomFallbackFactory.class) + @FeignClient(value = TEST_SERVICE_NAME, contextId = "2", fallbackFactory = CustomFallbackFactory.class) public interface FooService { @RequestMapping("echo/{str}") @@ -125,7 +175,7 @@ public class PolarisCircuitBreakerFeignIntegrationTest { } - @FeignClient("bar-service") + @FeignClient(value = TEST_SERVICE_NAME, contextId = "3") public interface BarService { @RequestMapping(path = "bar") @@ -140,7 +190,7 @@ public class PolarisCircuitBreakerFeignIntegrationTest { } - @FeignClient("baz-service") + @FeignClient(value = TEST_SERVICE_NAME, contextId = "4") public interface BazClient extends BazService { } @@ -158,7 +208,7 @@ public class PolarisCircuitBreakerFeignIntegrationTest { @Override public String echo(@RequestParam("str") String param) { - return "foo fallback"; + throw new NoFallbackAvailableException("fallback", new RuntimeException()); } } diff --git a/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerGatewayIntegrationTest.java b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerGatewayIntegrationTest.java index cf0823417..c2a9f1b1f 100644 --- a/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerGatewayIntegrationTest.java +++ b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerGatewayIntegrationTest.java @@ -18,9 +18,25 @@ package com.tencent.cloud.polaris.circuitbreaker; +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; import java.util.HashSet; import java.util.Set; - +import java.util.stream.Collectors; + +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.util.JsonFormat; +import com.tencent.polaris.api.pojo.ServiceKey; +import com.tencent.polaris.circuitbreak.api.CircuitBreakAPI; +import com.tencent.polaris.circuitbreak.factory.CircuitBreakAPIFactory; +import com.tencent.polaris.client.util.Utils; +import com.tencent.polaris.specification.api.v1.fault.tolerance.CircuitBreakerProto; +import com.tencent.polaris.test.common.TestUtils; +import com.tencent.polaris.test.mock.discovery.NamingServer; +import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import reactor.core.publisher.Mono; @@ -40,10 +56,7 @@ import org.springframework.test.web.reactive.server.WebTestClient; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; -import static com.github.tomakehurst.wiremock.client.WireMock.aResponse; -import static com.github.tomakehurst.wiremock.client.WireMock.get; -import static com.github.tomakehurst.wiremock.client.WireMock.stubFor; -import static com.github.tomakehurst.wiremock.client.WireMock.urlEqualTo; +import static com.tencent.polaris.test.common.TestUtils.SERVER_ADDRESS_ENV; import static org.assertj.core.api.Assertions.assertThat; @@ -67,18 +80,23 @@ import static org.assertj.core.api.Assertions.assertThat; @AutoConfigureWebTestClient(timeout = "10000") public class PolarisCircuitBreakerGatewayIntegrationTest { + private static final String TEST_SERVICE_NAME = "test-service-callee"; + @Autowired private WebTestClient webClient; + private static NamingServer namingServer; + + @AfterAll + public static void afterAll() { + if (null != namingServer) { + namingServer.terminate(); + } + } + @Test public void fallback() throws Exception { - stubFor(get(urlEqualTo("/err")) - .willReturn(aResponse() - .withStatus(500) - .withBody("err") - .withFixedDelay(3000))); - webClient .get().uri("/err") .header("Host", "www.circuitbreaker.com") @@ -87,22 +105,20 @@ public class PolarisCircuitBreakerGatewayIntegrationTest { .expectBody() .consumeWith( response -> assertThat(response.getResponseBody()).isEqualTo("fallback".getBytes())); - } - @Test - public void noFallback() throws Exception { + webClient + .get().uri("/err-no-fallback") + .header("Host", "www.circuitbreaker-no-fallback.com") + .exchange() + .expectStatus().isEqualTo(500); - stubFor(get(urlEqualTo("/err-no-fallback")) - .willReturn(aResponse() - .withStatus(500) - .withBody("err") - .withFixedDelay(3000))); + Utils.sleepUninterrupted(2000); webClient .get().uri("/err-no-fallback") .header("Host", "www.circuitbreaker-no-fallback.com") .exchange() - .expectStatus().isEqualTo(500); + .expectStatus().isEqualTo(200); } @@ -110,6 +126,28 @@ public class PolarisCircuitBreakerGatewayIntegrationTest { @EnableAutoConfiguration public static class TestApplication { + @Bean + public CircuitBreakAPI circuitBreakAPI() throws InvalidProtocolBufferException { + try { + namingServer = NamingServer.startNamingServer(10081); + System.setProperty(SERVER_ADDRESS_ENV, String.format("127.0.0.1:%d", namingServer.getPort())); + } + catch (IOException e) { + + } + ServiceKey serviceKey = new ServiceKey("default", TEST_SERVICE_NAME); + + CircuitBreakerProto.CircuitBreakerRule.Builder circuitBreakerRuleBuilder = CircuitBreakerProto.CircuitBreakerRule.newBuilder(); + InputStream inputStream = PolarisCircuitBreakerMockServerTest.class.getClassLoader().getResourceAsStream("circuitBreakerRule.json"); + String json = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8)).lines().collect(Collectors.joining("")); + JsonFormat.parser().ignoringUnknownFields().merge(json, circuitBreakerRuleBuilder); + CircuitBreakerProto.CircuitBreakerRule circuitBreakerRule = circuitBreakerRuleBuilder.build(); + CircuitBreakerProto.CircuitBreaker circuitBreaker = CircuitBreakerProto.CircuitBreaker.newBuilder().addRules(circuitBreakerRule).build(); + namingServer.getNamingService().setCircuitBreaker(serviceKey, circuitBreaker); + com.tencent.polaris.api.config.Configuration configuration = TestUtils.configWithEnvAddress(); + return CircuitBreakAPIFactory.createCircuitBreakAPIByConfig(configuration); + } + @Bean public RouteLocator myRoutes(RouteLocatorBuilder builder) { String httpUri = "http://httpbin.org:80"; @@ -123,13 +161,14 @@ public class PolarisCircuitBreakerGatewayIntegrationTest { .circuitBreaker(config -> config .setStatusCodes(codeSets) .setFallbackUri("forward:/fallback") + .setName(TEST_SERVICE_NAME) )) .uri(httpUri)) .route(p -> p .host("*.circuitbreaker-no-fallback.com") .filters(f -> f .circuitBreaker(config -> config - .setStatusCodes(codeSets) + .setName(TEST_SERVICE_NAME) )) .uri(httpUri)) .build(); diff --git a/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerMockServerTest.java b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerMockServerTest.java index e8315c2e7..36976da74 100644 --- a/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerMockServerTest.java +++ b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerMockServerTest.java @@ -121,7 +121,7 @@ public class PolarisCircuitBreakerMockServerTest { } }, t -> "fallback"); resList.add(res); - Utils.sleepUninterrupted(1000); + Utils.sleepUninterrupted(2000); } assertThat(resList).isEqualTo(Arrays.asList("invoke success", "fallback", "fallback", "fallback", "fallback")); diff --git a/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerRestTemplateIntegrationTest.java b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerRestTemplateIntegrationTest.java new file mode 100644 index 000000000..f2d344d35 --- /dev/null +++ b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/PolarisCircuitBreakerRestTemplateIntegrationTest.java @@ -0,0 +1,191 @@ +/* + * Tencent is pleased to support the open source community by making Spring Cloud Tencent available. + * + * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + */ + +package com.tencent.cloud.polaris.circuitbreaker; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.util.stream.Collectors; + +import com.google.protobuf.InvalidProtocolBufferException; +import com.google.protobuf.util.JsonFormat; +import com.tencent.cloud.polaris.circuitbreaker.config.PolarisCircuitBreakerFeignClientAutoConfiguration; +import com.tencent.cloud.polaris.circuitbreaker.resttemplate.PolarisCircuitBreakerFallback; +import com.tencent.cloud.polaris.circuitbreaker.resttemplate.PolarisCircuitBreakerHttpResponse; +import com.tencent.cloud.polaris.circuitbreaker.resttemplate.PolarisCircuitBreakerRestTemplate; +import com.tencent.polaris.api.pojo.ServiceKey; +import com.tencent.polaris.circuitbreak.api.CircuitBreakAPI; +import com.tencent.polaris.circuitbreak.factory.CircuitBreakAPIFactory; +import com.tencent.polaris.client.util.Utils; +import com.tencent.polaris.specification.api.v1.fault.tolerance.CircuitBreakerProto; +import com.tencent.polaris.test.common.TestUtils; +import com.tencent.polaris.test.mock.discovery.NamingServer; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.autoconfigure.ImportAutoConfiguration; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.cloud.client.loadbalancer.LoadBalanced; +import org.springframework.cloud.openfeign.EnableFeignClients; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.test.annotation.DirtiesContext; +import org.springframework.test.context.junit.jupiter.SpringExtension; +import org.springframework.web.client.RestTemplate; +import org.springframework.web.util.DefaultUriBuilderFactory; + +import static com.tencent.polaris.test.common.TestUtils.SERVER_ADDRESS_ENV; +import static org.assertj.core.api.Assertions.assertThat; +import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT; + +/** + * @author sean yu + */ +@ExtendWith(SpringExtension.class) +@SpringBootTest(webEnvironment = RANDOM_PORT, + classes = PolarisCircuitBreakerRestTemplateIntegrationTest.TestConfig.class, + properties = { + "spring.cloud.gateway.enabled=false", + "feign.circuitbreaker.enabled=true", + "spring.cloud.polaris.namespace=default", + "spring.cloud.polaris.service=Test" + }) +@DirtiesContext +public class PolarisCircuitBreakerRestTemplateIntegrationTest { + + private static final String TEST_SERVICE_NAME = "test-service-callee"; + + private static NamingServer namingServer; + + @AfterAll + public static void afterAll() { + if (null != namingServer) { + namingServer.terminate(); + } + } + + @Autowired + @Qualifier("restTemplateFallbackFromPolaris") + private RestTemplate restTemplateFallbackFromPolaris; + + @Autowired + @Qualifier("restTemplateFallbackFromCode") + private RestTemplate restTemplateFallbackFromCode; + + @Autowired + @Qualifier("restTemplateFallbackFromCode2") + private RestTemplate restTemplateFallbackFromCode2; + + @Test + public void testRestTemplate() { + assertThat(restTemplateFallbackFromCode.getForObject("/example/service/b/info", String.class)).isEqualTo("\"this is a fallback class\""); + Utils.sleepUninterrupted(2000); + assertThat(restTemplateFallbackFromCode.getForObject("/example/service/b/info", String.class)).isEqualTo("\"this is a fallback class\""); + Utils.sleepUninterrupted(2000); + assertThat(restTemplateFallbackFromCode2.getForObject("/example/service/b/info", String.class)).isEqualTo("fallback"); + Utils.sleepUninterrupted(2000); + assertThat(restTemplateFallbackFromCode2.getForObject("/example/service/b/info", String.class)).isEqualTo("fallback"); + Utils.sleepUninterrupted(2000); + assertThat(restTemplateFallbackFromPolaris.getForObject("/example/service/b/info", String.class)).isEqualTo("\"fallback from polaris server\""); + Utils.sleepUninterrupted(2000); + assertThat(restTemplateFallbackFromPolaris.getForObject("/example/service/b/info", String.class)).isEqualTo("\"fallback from polaris server\""); + + } + + @Configuration + @EnableAutoConfiguration + @ImportAutoConfiguration({ PolarisCircuitBreakerFeignClientAutoConfiguration.class }) + @EnableFeignClients + public static class TestConfig { + + @Bean + @LoadBalanced + @PolarisCircuitBreakerRestTemplate + public RestTemplate restTemplateFallbackFromPolaris() { + DefaultUriBuilderFactory uriBuilderFactory = new DefaultUriBuilderFactory("http://" + TEST_SERVICE_NAME); + RestTemplate restTemplate = new RestTemplate(); + restTemplate.setUriTemplateHandler(uriBuilderFactory); + return restTemplate; + } + + @Bean + @LoadBalanced + @PolarisCircuitBreakerRestTemplate(fallbackClass = CustomPolarisCircuitBreakerFallback.class) + public RestTemplate restTemplateFallbackFromCode() { + DefaultUriBuilderFactory uriBuilderFactory = new DefaultUriBuilderFactory("http://" + TEST_SERVICE_NAME); + RestTemplate restTemplate = new RestTemplate(); + restTemplate.setUriTemplateHandler(uriBuilderFactory); + return restTemplate; + } + + @Bean + @LoadBalanced + @PolarisCircuitBreakerRestTemplate(fallback = "fallback") + public RestTemplate restTemplateFallbackFromCode2() { + DefaultUriBuilderFactory uriBuilderFactory = new DefaultUriBuilderFactory("http://" + TEST_SERVICE_NAME); + RestTemplate restTemplate = new RestTemplate(); + restTemplate.setUriTemplateHandler(uriBuilderFactory); + return restTemplate; + } + + @Bean + public CustomPolarisCircuitBreakerFallback customPolarisCircuitBreakerFallback() { + return new CustomPolarisCircuitBreakerFallback(); + } + + @Bean + public CircuitBreakAPI circuitBreakAPI() throws InvalidProtocolBufferException { + try { + namingServer = NamingServer.startNamingServer(10081); + System.setProperty(SERVER_ADDRESS_ENV, String.format("127.0.0.1:%d", namingServer.getPort())); + } + catch (IOException e) { + + } + ServiceKey serviceKey = new ServiceKey("default", TEST_SERVICE_NAME); + + CircuitBreakerProto.CircuitBreakerRule.Builder circuitBreakerRuleBuilder = CircuitBreakerProto.CircuitBreakerRule.newBuilder(); + InputStream inputStream = PolarisCircuitBreakerMockServerTest.class.getClassLoader().getResourceAsStream("circuitBreakerRule.json"); + String json = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8)).lines().collect(Collectors.joining("")); + JsonFormat.parser().ignoringUnknownFields().merge(json, circuitBreakerRuleBuilder); + CircuitBreakerProto.CircuitBreakerRule circuitBreakerRule = circuitBreakerRuleBuilder.build(); + CircuitBreakerProto.CircuitBreaker circuitBreaker = CircuitBreakerProto.CircuitBreaker.newBuilder().addRules(circuitBreakerRule).build(); + namingServer.getNamingService().setCircuitBreaker(serviceKey, circuitBreaker); + com.tencent.polaris.api.config.Configuration configuration = TestUtils.configWithEnvAddress(); + return CircuitBreakAPIFactory.createCircuitBreakAPIByConfig(configuration); + } + + } + + public static class CustomPolarisCircuitBreakerFallback implements PolarisCircuitBreakerFallback { + @Override + public PolarisCircuitBreakerHttpResponse fallback() { + return new PolarisCircuitBreakerHttpResponse( + 200, + "\"this is a fallback class\""); + } + } + + +} diff --git a/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/resources/circuitBreakerRule-method.json b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/resources/circuitBreakerRule-method.json new file mode 100644 index 000000000..749e43479 --- /dev/null +++ b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/resources/circuitBreakerRule-method.json @@ -0,0 +1,59 @@ +{ + "@type": "type.googleapis.com/v1.CircuitBreakerRule", + "id": "5f1601f01823474d9be39c0bbb26ab87", + "name": "test", + "namespace": "TestCircuitBreakerRule", + "enable": true, + "revision": "10b120c08706429f8fdc3fb44a53224b", + "ctime": "1754-08-31 06:49:24", + "mtime": "2023-02-21 17:35:31", + "etime": "", + "description": "", + "level": "METHOD", + "ruleMatcher": { + "source": { + "service": "*", + "namespace": "*" + }, + "destination": { + "service": "*", + "namespace": "*", + "method": {"type": "REGEX", "value": "*"} + } + }, + "errorConditions": [ + { + "inputType": "RET_CODE", + "condition": { + "type": "NOT_EQUALS", + "value": "200", + "valueType": "TEXT" + } + } + ], + "triggerCondition": [ + { + "triggerType": "CONSECUTIVE_ERROR", + "errorCount": 1, + "errorPercent": 1, + "interval": 5, + "minimumRequest": 5 + } + ], + "maxEjectionPercent": 0, + "recoverCondition": { + "sleepWindow": 60, + "consecutiveSuccess": 3 + }, + "faultDetectConfig": { + "enable": true + }, + "fallbackConfig": { + "enable": true, + "response": { + "code": 200, + "headers": [{"key": "xxx", "value": "xxx"}], + "body": "\"fallback from polaris server\"" + } + } +} \ No newline at end of file diff --git a/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/resources/circuitBreakerRule.json b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/resources/circuitBreakerRule.json index 0a1e97f2a..7adef7fba 100644 --- a/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/resources/circuitBreakerRule.json +++ b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/resources/circuitBreakerRule.json @@ -49,11 +49,11 @@ "enable": true }, "fallbackConfig": { - "enable": false, + "enable": true, "response": { - "code": 0, - "headers": [], - "body": "" + "code": 200, + "headers": [{"key": "xxx", "value": "xxx"}], + "body": "\"fallback from polaris server\"" } } } \ No newline at end of file