diff --git a/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/reporter/SuccessCircuitBreakerReporterTest.java b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/reporter/SuccessCircuitBreakerReporterTest.java index 9ecb9378b..8d751590c 100644 --- a/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/reporter/SuccessCircuitBreakerReporterTest.java +++ b/spring-cloud-starter-tencent-polaris-circuitbreaker/src/test/java/com/tencent/cloud/polaris/circuitbreaker/reporter/SuccessCircuitBreakerReporterTest.java @@ -20,6 +20,8 @@ package com.tencent.cloud.polaris.circuitbreaker.reporter; import java.net.URI; import com.tencent.cloud.common.metadata.MetadataContext; +import com.tencent.cloud.common.metadata.StaticMetadataManager; +import com.tencent.cloud.common.metadata.config.MetadataLocalProperties; import com.tencent.cloud.common.util.ApplicationContextAwareUtils; import com.tencent.cloud.rpc.enhancement.config.RpcEnhancementReporterProperties; import com.tencent.cloud.rpc.enhancement.plugin.EnhancedPluginContext; @@ -40,6 +42,7 @@ import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.cloud.client.DefaultServiceInstance; +import org.springframework.context.ApplicationContext; import org.springframework.http.HttpMethod; import static com.tencent.polaris.test.common.Consts.NAMESPACE_TEST; @@ -74,6 +77,12 @@ public class SuccessCircuitBreakerReporterTest { mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + RpcEnhancementReporterProperties reporterProperties = mock(RpcEnhancementReporterProperties.class); + doReturn(reporterProperties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); } @AfterAll diff --git a/spring-cloud-tencent-plugin-starters/spring-cloud-starter-tencent-tsf-adapter-plugin/pom.xml b/spring-cloud-tencent-plugin-starters/spring-cloud-starter-tencent-tsf-adapter-plugin/pom.xml index 9fe8b4f2f..0c0deb4f1 100644 --- a/spring-cloud-tencent-plugin-starters/spring-cloud-starter-tencent-tsf-adapter-plugin/pom.xml +++ b/spring-cloud-tencent-plugin-starters/spring-cloud-starter-tencent-tsf-adapter-plugin/pom.xml @@ -16,23 +16,12 @@ - - com.tencent.cloud - spring-cloud-tencent-polaris-context - com.tencent.cloud spring-cloud-tencent-rpc-enhancement - - - com.tencent.polaris - polaris-assembly-factory - - - org.springframework.boot spring-boot-starter-test diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/config/RpcEnhancementAutoConfiguration.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/config/RpcEnhancementAutoConfiguration.java index 1c656675e..3a5d1b712 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/config/RpcEnhancementAutoConfiguration.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/config/RpcEnhancementAutoConfiguration.java @@ -90,7 +90,7 @@ public class RpcEnhancementAutoConfiguration { @Lazy public EnhancedPluginRunner enhancedFeignPluginRunner( @Autowired(required = false) List enhancedPlugins, - @Autowired(required = false) @Lazy Registration registration, + @Autowired(required = false) Registration registration, SDKContext sdkContext) { return new DefaultEnhancedPluginRunner(enhancedPlugins, registration, sdkContext); } @@ -139,7 +139,7 @@ public class RpcEnhancementAutoConfiguration { @Configuration(proxyBeanMethods = false) @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET) - protected static class MetadataServletFilterConfig { + protected static class RpcEnhancementServletFilterConfig { @Bean public FilterRegistrationBean metadataServletFilterRegistrationBean( @@ -160,7 +160,7 @@ public class RpcEnhancementAutoConfiguration { @Configuration(proxyBeanMethods = false) @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.REACTIVE) - protected static class MetadataReactiveFilterConfig { + protected static class RpcEnhancementReactiveFilterConfig { @Bean public EnhancedReactiveFilter enhancedReactiveFilter(@Lazy EnhancedPluginRunner pluginRunner) { diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/PolarisEnhancedPluginUtils.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/PolarisEnhancedPluginUtils.java index f4af60583..02b6e4446 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/PolarisEnhancedPluginUtils.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/PolarisEnhancedPluginUtils.java @@ -44,6 +44,7 @@ import org.apache.commons.lang.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.springframework.beans.BeansException; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpStatus; import org.springframework.lang.Nullable; @@ -160,36 +161,29 @@ public final class PolarisEnhancedPluginUtils { if (Objects.isNull(httpStatus)) { return false; } - else { - RpcEnhancementReporterProperties reportProperties = ApplicationContextAwareUtils.getApplicationContext().getBean(RpcEnhancementReporterProperties.class); - // statuses > series - List status = reportProperties.getStatuses(); - - if (status.isEmpty()) { - List series = reportProperties.getSeries(); - // Check INTERNAL_SERVER_ERROR (500) status. - if (reportProperties.isIgnoreInternalServerError() && Objects.equals(httpStatus, INTERNAL_SERVER_ERROR)) { - return false; - } - if (series.isEmpty()) { - return HTTP_STATUSES.contains(httpStatus); - } - else { - try { - return series.contains(HttpStatus.Series.valueOf(httpStatus)); - } - catch (Exception e) { - LOG.warn("Decode http status failed.", e); - } - } + RpcEnhancementReporterProperties reportProperties; + try { + reportProperties = ApplicationContextAwareUtils.getApplicationContext().getBean(RpcEnhancementReporterProperties.class); + } + catch (BeansException e) { + LOG.error("get RpcEnhancementReporterProperties bean err", e); + reportProperties = new RpcEnhancementReporterProperties(); + } + // statuses > series + List status = reportProperties.getStatuses(); + if (status.isEmpty()) { + List series = reportProperties.getSeries(); + // Check INTERNAL_SERVER_ERROR (500) status. + if (reportProperties.isIgnoreInternalServerError() && Objects.equals(httpStatus, INTERNAL_SERVER_ERROR)) { + return false; } - else { - // Use the user-specified fuse status code. - return status.contains(httpStatus); + if (series.isEmpty()) { + return HTTP_STATUSES.contains(httpStatus); } + return series.contains(httpStatus.series()); } - // DEFAULT RETURN FALSE. - return false; + // Use the user-specified fuse status code. + return status.contains(httpStatus); } public static RetStatus getRetStatusFromRequest(HttpHeaders headers, Integer statusCode, Throwable exception) { diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/AssemblyRequestContext.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/AssemblyRequestContext.java index 235994b3a..c5a8befa8 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/AssemblyRequestContext.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/AssemblyRequestContext.java @@ -18,8 +18,15 @@ package com.tencent.cloud.rpc.enhancement.plugin.assembly; import java.net.URI; +import java.util.ArrayList; +import java.util.Arrays; import java.util.Collection; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import com.google.common.net.HttpHeaders; import com.tencent.cloud.rpc.enhancement.plugin.EnhancedRequestContext; import com.tencent.polaris.api.pojo.ServiceKey; import com.tencent.polaris.api.rpc.RequestContext; @@ -39,10 +46,25 @@ public class AssemblyRequestContext implements RequestContext { private final String callerIp; + private final Map cookies; + public AssemblyRequestContext(EnhancedRequestContext requestContext, ServiceKey callerService, String callerIp) { this.requestContext = requestContext; this.callerService = callerService; this.callerIp = callerIp; + this.cookies = new HashMap<>(); + List allCookies = + Optional.ofNullable(requestContext.getHttpHeaders().get(HttpHeaders.COOKIE)) + .orElse(new ArrayList<>()) + .stream() + .flatMap(it -> Arrays.stream(it.split(";"))) + .toList(); + allCookies.forEach(cookie -> { + String[] cookieKV = cookie.split("="); + if (cookieKV.length == 2) { + cookies.put(cookieKV[0], cookieKV[1]); + } + }); } @Override @@ -72,17 +94,17 @@ public class AssemblyRequestContext implements RequestContext { @Override public String getCookie(String key) { - return null; + return this.cookies.get(key); } @Override public void setCookie(String key, String value) { - + this.cookies.put(key, value); } @Override public Collection listCookieKeys() { - return null; + return this.cookies.keySet(); } @Override diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/AssemblyResponseContext.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/AssemblyResponseContext.java index 6abf09d7f..4dbfa81d7 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/AssemblyResponseContext.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/AssemblyResponseContext.java @@ -20,9 +20,12 @@ package com.tencent.cloud.rpc.enhancement.plugin.assembly; import java.util.Collection; import com.tencent.cloud.rpc.enhancement.plugin.EnhancedResponseContext; +import com.tencent.cloud.rpc.enhancement.plugin.PolarisEnhancedPluginUtils; import com.tencent.polaris.api.pojo.RetStatus; import com.tencent.polaris.api.rpc.ResponseContext; +import org.springframework.lang.Nullable; + /** * AssemblyResponseContext. * @@ -30,47 +33,52 @@ import com.tencent.polaris.api.rpc.ResponseContext; */ public class AssemblyResponseContext implements ResponseContext { - private EnhancedResponseContext responseContext; - - private Throwable throwable; + private final EnhancedResponseContext responseContext; - private RetStatus retStatus; + private final Throwable throwable; - public AssemblyResponseContext() { - } + private final RetStatus retStatus; - public AssemblyResponseContext(EnhancedResponseContext responseContext) { + public AssemblyResponseContext(@Nullable EnhancedResponseContext responseContext, @Nullable Throwable throwable) { this.responseContext = responseContext; + this.throwable = throwable; + if (responseContext == null) { + this.retStatus = PolarisEnhancedPluginUtils.getRetStatusFromRequest(null, null, throwable); + } + else { + this.retStatus = PolarisEnhancedPluginUtils.getRetStatusFromRequest(responseContext.getHttpHeaders(), responseContext.getHttpStatus(), throwable); + } } @Override public Object getRetCode() { + if (responseContext == null) { + return null; + } return this.responseContext.getHttpStatus(); } @Override public String getHeader(String key) { + if (responseContext == null) { + return null; + } return this.responseContext.getHttpHeaders().getFirst(key); } @Override public Collection listHeaders() { + if (responseContext == null) { + return null; + } return this.responseContext.getHttpHeaders().keySet(); } - public void setThrowable(Throwable throwable) { - this.throwable = throwable; - } - @Override public Throwable getThrowable() { return this.throwable; } - public void setRetStatus(RetStatus retStatus) { - this.retStatus = retStatus; - } - @Override public RetStatus getRetStatus() { return this.retStatus; diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/client/AssemblyClientExceptionHook.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/client/AssemblyClientExceptionHook.java index 30b19b4a6..12107c4f3 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/client/AssemblyClientExceptionHook.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/client/AssemblyClientExceptionHook.java @@ -50,7 +50,7 @@ public class AssemblyClientExceptionHook implements EnhancedPlugin { } @Override - public void run(EnhancedPluginContext context) throws Throwable { + public void run(EnhancedPluginContext context) { AfterRequest afterRequest = new AfterRequest(); afterRequest.setTargetService(new ServiceKey(MetadataContext.LOCAL_NAMESPACE, context.getTargetServiceInstance().getServiceId())); RequestContext requestContext = new AssemblyRequestContext( @@ -59,9 +59,8 @@ public class AssemblyClientExceptionHook implements EnhancedPlugin { context.getLocalServiceInstance().getHost() ); afterRequest.setRequestContext(requestContext); - AssemblyResponseContext responseContext = new AssemblyResponseContext(); - responseContext.setThrowable(context.getThrowable()); - responseContext.setRetStatus(PolarisEnhancedPluginUtils.getRetStatusFromRequest(null, null, context.getThrowable())); + + AssemblyResponseContext responseContext = new AssemblyResponseContext(null, context.getThrowable()); afterRequest.setResponseContext(responseContext); assemblyAPI.afterCallService(afterRequest); diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/client/AssemblyClientPostHook.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/client/AssemblyClientPostHook.java index 7e40c97cb..e78817139 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/client/AssemblyClientPostHook.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/client/AssemblyClientPostHook.java @@ -50,7 +50,7 @@ public class AssemblyClientPostHook implements EnhancedPlugin { } @Override - public void run(EnhancedPluginContext context) throws Throwable { + public void run(EnhancedPluginContext context) { AfterRequest afterRequest = new AfterRequest(); afterRequest.setTargetService(new ServiceKey(MetadataContext.LOCAL_NAMESPACE, context.getTargetServiceInstance().getServiceId())); RequestContext requestContext = new AssemblyRequestContext( @@ -59,8 +59,8 @@ public class AssemblyClientPostHook implements EnhancedPlugin { context.getLocalServiceInstance().getHost() ); afterRequest.setRequestContext(requestContext); - AssemblyResponseContext responseContext = new AssemblyResponseContext(context.getResponse()); - responseContext.setRetStatus(PolarisEnhancedPluginUtils.getRetStatusFromRequest(context.getResponse().getHttpHeaders(), context.getResponse().getHttpStatus(), null)); + + AssemblyResponseContext responseContext = new AssemblyResponseContext(context.getResponse(), null); afterRequest.setResponseContext(responseContext); assemblyAPI.afterCallService(afterRequest); diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/client/AssemblyClientPreHook.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/client/AssemblyClientPreHook.java index 489a98fda..aa6795860 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/client/AssemblyClientPreHook.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/client/AssemblyClientPreHook.java @@ -48,7 +48,7 @@ public class AssemblyClientPreHook implements EnhancedPlugin { } @Override - public void run(EnhancedPluginContext context) throws Throwable { + public void run(EnhancedPluginContext context) { BeforeRequest beforeRequest = new BeforeRequest(); beforeRequest.setTargetService(new ServiceKey(MetadataContext.LOCAL_NAMESPACE, context.getTargetServiceInstance().getServiceId())); RequestContext requestContext = new AssemblyRequestContext( diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/server/AssemblyServerExceptionHook.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/server/AssemblyServerExceptionHook.java index 1bd530bb2..508546dea 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/server/AssemblyServerExceptionHook.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/server/AssemblyServerExceptionHook.java @@ -46,11 +46,11 @@ public class AssemblyServerExceptionHook implements EnhancedPlugin { @Override public EnhancedPluginType getType() { - return EnhancedPluginType.Server.POST; + return EnhancedPluginType.Server.EXCEPTION; } @Override - public void run(EnhancedPluginContext context) throws Throwable { + public void run(EnhancedPluginContext context) { AfterRequest afterRequest = new AfterRequest(); RequestContext requestContext = new AssemblyRequestContext( context.getRequest(), @@ -58,9 +58,8 @@ public class AssemblyServerExceptionHook implements EnhancedPlugin { context.getLocalServiceInstance().getHost() ); afterRequest.setRequestContext(requestContext); - AssemblyResponseContext responseContext = new AssemblyResponseContext(); - responseContext.setThrowable(context.getThrowable()); - responseContext.setRetStatus(PolarisEnhancedPluginUtils.getRetStatusFromRequest(null, null, context.getThrowable())); + + AssemblyResponseContext responseContext = new AssemblyResponseContext(null, context.getThrowable()); afterRequest.setResponseContext(responseContext); assemblyAPI.afterProcess(afterRequest); diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/server/AssemblyServerPostHook.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/server/AssemblyServerPostHook.java index b7162b1d7..891aff83d 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/server/AssemblyServerPostHook.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/server/AssemblyServerPostHook.java @@ -50,7 +50,7 @@ public class AssemblyServerPostHook implements EnhancedPlugin { } @Override - public void run(EnhancedPluginContext context) throws Throwable { + public void run(EnhancedPluginContext context) { AfterRequest afterRequest = new AfterRequest(); RequestContext requestContext = new AssemblyRequestContext( context.getRequest(), @@ -58,8 +58,8 @@ public class AssemblyServerPostHook implements EnhancedPlugin { context.getLocalServiceInstance().getHost() ); afterRequest.setRequestContext(requestContext); - AssemblyResponseContext responseContext = new AssemblyResponseContext(context.getResponse()); - responseContext.setRetStatus(PolarisEnhancedPluginUtils.getRetStatusFromRequest(context.getResponse().getHttpHeaders(), context.getResponse().getHttpStatus(), null)); + + AssemblyResponseContext responseContext = new AssemblyResponseContext(context.getResponse(), null); afterRequest.setResponseContext(responseContext); assemblyAPI.afterProcess(afterRequest); diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/server/AssemblyServerPreHook.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/server/AssemblyServerPreHook.java index f40adbd84..a678d68a6 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/server/AssemblyServerPreHook.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/plugin/assembly/server/AssemblyServerPreHook.java @@ -48,7 +48,7 @@ public class AssemblyServerPreHook implements EnhancedPlugin { } @Override - public void run(EnhancedPluginContext context) throws Throwable { + public void run(EnhancedPluginContext context) { BeforeRequest beforeRequest = new BeforeRequest(); RequestContext requestContext = new AssemblyRequestContext( context.getRequest(), diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignBeanPostProcessorTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignBeanPostProcessorTest.java index 40e09a94e..6481518bc 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignBeanPostProcessorTest.java +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignBeanPostProcessorTest.java @@ -22,10 +22,12 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.BeanFactory; +import org.springframework.beans.factory.ObjectProvider; import org.springframework.cloud.client.loadbalancer.LoadBalancerProperties; import org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient; import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory; import org.springframework.cloud.openfeign.loadbalancer.FeignBlockingLoadBalancerClient; +import org.springframework.cloud.openfeign.loadbalancer.LoadBalancerFeignRequestTransformer; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; @@ -63,6 +65,9 @@ public class EnhancedFeignBeanPostProcessorTest { } return null; }).when(beanFactory).getBean(any(Class.class)); + ObjectProvider objectProvider = mock(ObjectProvider.class); + doReturn(new PolarisLoadBalancerFeignRequestTransformer()).when(objectProvider).getObject(); + doReturn(objectProvider).when(beanFactory).getBeanProvider(LoadBalancerFeignRequestTransformer.class); enhancedFeignBeanPostProcessor.setBeanFactory(beanFactory); // isNeedWrap(bean) == false diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/feign/PolarisLoadBalancerFeignRequestTransformerTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/feign/PolarisLoadBalancerFeignRequestTransformerTest.java new file mode 100644 index 000000000..e40e2a454 --- /dev/null +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/feign/PolarisLoadBalancerFeignRequestTransformerTest.java @@ -0,0 +1,72 @@ +package com.tencent.cloud.rpc.enhancement.feign; + +import com.tencent.cloud.common.metadata.MetadataContext; +import com.tencent.cloud.common.metadata.MetadataContextHolder; +import com.tencent.cloud.common.metadata.StaticMetadataManager; +import com.tencent.cloud.common.metadata.config.MetadataLocalProperties; +import com.tencent.cloud.common.util.ApplicationContextAwareUtils; +import feign.Request; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.MockedStatic; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import org.springframework.cloud.client.ServiceInstance; +import org.springframework.context.ApplicationContext; + +import static com.tencent.cloud.rpc.enhancement.resttemplate.PolarisLoadBalancerRequestTransformer.LOAD_BALANCER_SERVICE_INSTANCE; +import static com.tencent.polaris.test.common.Consts.NAMESPACE_TEST; +import static com.tencent.polaris.test.common.Consts.SERVICE_PROVIDER; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +@ExtendWith(MockitoExtension.class) +public class PolarisLoadBalancerFeignRequestTransformerTest { + + private static MockedStatic mockedApplicationContextAwareUtils; + + private PolarisLoadBalancerFeignRequestTransformer transformer = new PolarisLoadBalancerFeignRequestTransformer(); + + @Mock + private Request clientRequest; + + @Mock + private ServiceInstance serviceInstance; + + @BeforeAll + static void beforeAll() { + mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); + mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) + .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + MetadataLocalProperties metadataLocalProperties = mock(MetadataLocalProperties.class); + StaticMetadataManager staticMetadataManager = mock(StaticMetadataManager.class); + doReturn(metadataLocalProperties).when(applicationContext).getBean(MetadataLocalProperties.class); + doReturn(staticMetadataManager).when(applicationContext).getBean(StaticMetadataManager.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext).thenReturn(applicationContext); + } + + @AfterAll + static void afterAll() { + mockedApplicationContextAwareUtils.close(); + } + + @BeforeEach + void setUp() { + MetadataContext.LOCAL_NAMESPACE = NAMESPACE_TEST; + MetadataContext.LOCAL_SERVICE = SERVICE_PROVIDER; + } + + @Test + public void test() throws Throwable { + transformer.transformRequest(clientRequest, serviceInstance); + assertThat(MetadataContextHolder.get().getLoadbalancerMetadata().get(LOAD_BALANCER_SERVICE_INSTANCE)).isEqualTo(serviceInstance); + } +} diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyClientExceptionHookTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyClientExceptionHookTest.java new file mode 100644 index 000000000..e887fc676 --- /dev/null +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyClientExceptionHookTest.java @@ -0,0 +1,121 @@ +package com.tencent.cloud.rpc.enhancement.plugin; + +import java.net.URI; + +import com.tencent.cloud.common.metadata.MetadataContext; +import com.tencent.cloud.common.util.ApplicationContextAwareUtils; +import com.tencent.cloud.rpc.enhancement.config.RpcEnhancementReporterProperties; +import com.tencent.cloud.rpc.enhancement.plugin.assembly.client.AssemblyClientExceptionHook; +import com.tencent.polaris.assembly.api.AssemblyAPI; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockedStatic; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import org.springframework.cloud.client.DefaultServiceInstance; +import org.springframework.context.ApplicationContext; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; + +import static com.tencent.polaris.test.common.Consts.NAMESPACE_TEST; +import static com.tencent.polaris.test.common.Consts.SERVICE_PROVIDER; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +@ExtendWith(MockitoExtension.class) +public class AssemblyClientExceptionHookTest { + + private static MockedStatic mockedApplicationContextAwareUtils; + @InjectMocks + private AssemblyClientExceptionHook assemblyClientExceptionHook; + @Mock + private AssemblyAPI assemblyAPI; + + @BeforeAll + static void beforeAll() { + mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); + mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) + .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + RpcEnhancementReporterProperties reporterProperties = mock(RpcEnhancementReporterProperties.class); + doReturn(reporterProperties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); + } + + @AfterAll + static void afterAll() { + mockedApplicationContextAwareUtils.close(); + } + + @BeforeEach + void setUp() { + MetadataContext.LOCAL_NAMESPACE = NAMESPACE_TEST; + MetadataContext.LOCAL_SERVICE = SERVICE_PROVIDER; + } + + @Test + public void testGetName() { + assertThat(assemblyClientExceptionHook.getName()).isEqualTo(AssemblyClientExceptionHook.class.getName()); + } + + @Test + public void testType() { + assertThat(assemblyClientExceptionHook.getType()).isEqualTo(EnhancedPluginType.Client.EXCEPTION); + } + + @Test + public void testRun() { + EnhancedPluginContext pluginContext = new EnhancedPluginContext(); + EnhancedRequestContext request = EnhancedRequestContext.builder() + .httpMethod(HttpMethod.GET) + .url(URI.create("http://0.0.0.0/")) + .httpHeaders(new HttpHeaders()) + .build(); + request.toString(); + EnhancedResponseContext response = EnhancedResponseContext.builder() + .httpStatus(200) + .build(); + response.toString(); + + DefaultServiceInstance targetServiceInstance = new DefaultServiceInstance(); + targetServiceInstance.setServiceId(SERVICE_PROVIDER); + + DefaultServiceInstance localServiceInstance = new DefaultServiceInstance(); + localServiceInstance.setServiceId(SERVICE_PROVIDER); + + pluginContext.setRequest(request); + pluginContext.setResponse(response); + pluginContext.setTargetServiceInstance(targetServiceInstance); + pluginContext.setLocalServiceInstance(localServiceInstance); + pluginContext.setThrowable(new RuntimeException()); + + assemblyClientExceptionHook.run(pluginContext); + assemblyClientExceptionHook.getOrder(); + assemblyClientExceptionHook.getName(); + assemblyClientExceptionHook.getType(); + } + + @Test + public void testHandlerThrowable() { + // mock request + EnhancedRequestContext request = mock(EnhancedRequestContext.class); + // mock response + EnhancedResponseContext response = mock(EnhancedResponseContext.class); + + EnhancedPluginContext context = new EnhancedPluginContext(); + context.setRequest(request); + context.setResponse(response); + assemblyClientExceptionHook.handlerThrowable(context, new RuntimeException("Mock exception.")); + } + +} diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyClientPostHookTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyClientPostHookTest.java new file mode 100644 index 000000000..2753d8b40 --- /dev/null +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyClientPostHookTest.java @@ -0,0 +1,121 @@ +package com.tencent.cloud.rpc.enhancement.plugin; + +import java.net.URI; + +import com.tencent.cloud.common.metadata.MetadataContext; +import com.tencent.cloud.common.util.ApplicationContextAwareUtils; +import com.tencent.cloud.rpc.enhancement.config.RpcEnhancementReporterProperties; +import com.tencent.cloud.rpc.enhancement.plugin.assembly.client.AssemblyClientPostHook; +import com.tencent.polaris.assembly.api.AssemblyAPI; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockedStatic; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import org.springframework.cloud.client.DefaultServiceInstance; +import org.springframework.context.ApplicationContext; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; + +import static com.tencent.polaris.test.common.Consts.NAMESPACE_TEST; +import static com.tencent.polaris.test.common.Consts.SERVICE_PROVIDER; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +@ExtendWith(MockitoExtension.class) +public class AssemblyClientPostHookTest { + + private static MockedStatic mockedApplicationContextAwareUtils; + @InjectMocks + private AssemblyClientPostHook assemblyClientPostHook; + @Mock + private AssemblyAPI assemblyAPI; + + @BeforeAll + static void beforeAll() { + mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); + mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) + .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + RpcEnhancementReporterProperties reporterProperties = mock(RpcEnhancementReporterProperties.class); + doReturn(reporterProperties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); + } + + @AfterAll + static void afterAll() { + mockedApplicationContextAwareUtils.close(); + } + + @BeforeEach + void setUp() { + MetadataContext.LOCAL_NAMESPACE = NAMESPACE_TEST; + MetadataContext.LOCAL_SERVICE = SERVICE_PROVIDER; + } + + @Test + public void testGetName() { + assertThat(assemblyClientPostHook.getName()).isEqualTo(AssemblyClientPostHook.class.getName()); + } + + @Test + public void testType() { + assertThat(assemblyClientPostHook.getType()).isEqualTo(EnhancedPluginType.Client.POST); + } + + @Test + public void testRun() { + EnhancedPluginContext pluginContext = new EnhancedPluginContext(); + EnhancedRequestContext request = EnhancedRequestContext.builder() + .httpMethod(HttpMethod.GET) + .url(URI.create("http://0.0.0.0/")) + .httpHeaders(new HttpHeaders()) + .build(); + request.toString(); + EnhancedResponseContext response = EnhancedResponseContext.builder() + .httpStatus(200) + .build(); + response.toString(); + + DefaultServiceInstance targetServiceInstance = new DefaultServiceInstance(); + targetServiceInstance.setServiceId(SERVICE_PROVIDER); + + DefaultServiceInstance localServiceInstance = new DefaultServiceInstance(); + localServiceInstance.setServiceId(SERVICE_PROVIDER); + + pluginContext.setRequest(request); + pluginContext.setResponse(response); + pluginContext.setTargetServiceInstance(targetServiceInstance); + pluginContext.setLocalServiceInstance(localServiceInstance); + pluginContext.setThrowable(new RuntimeException()); + + assemblyClientPostHook.run(pluginContext); + assemblyClientPostHook.getOrder(); + assemblyClientPostHook.getName(); + assemblyClientPostHook.getType(); + } + + @Test + public void testHandlerThrowable() { + // mock request + EnhancedRequestContext request = mock(EnhancedRequestContext.class); + // mock response + EnhancedResponseContext response = mock(EnhancedResponseContext.class); + + EnhancedPluginContext context = new EnhancedPluginContext(); + context.setRequest(request); + context.setResponse(response); + assemblyClientPostHook.handlerThrowable(context, new RuntimeException("Mock exception.")); + } + +} diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyClientPreHookTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyClientPreHookTest.java new file mode 100644 index 000000000..84c732a8f --- /dev/null +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyClientPreHookTest.java @@ -0,0 +1,121 @@ +package com.tencent.cloud.rpc.enhancement.plugin; + +import java.net.URI; + +import com.tencent.cloud.common.metadata.MetadataContext; +import com.tencent.cloud.common.util.ApplicationContextAwareUtils; +import com.tencent.cloud.rpc.enhancement.config.RpcEnhancementReporterProperties; +import com.tencent.cloud.rpc.enhancement.plugin.assembly.client.AssemblyClientPreHook; +import com.tencent.polaris.assembly.api.AssemblyAPI; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockedStatic; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import org.springframework.cloud.client.DefaultServiceInstance; +import org.springframework.context.ApplicationContext; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; + +import static com.tencent.polaris.test.common.Consts.NAMESPACE_TEST; +import static com.tencent.polaris.test.common.Consts.SERVICE_PROVIDER; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +@ExtendWith(MockitoExtension.class) +public class AssemblyClientPreHookTest { + + private static MockedStatic mockedApplicationContextAwareUtils; + @InjectMocks + private AssemblyClientPreHook assemblyClientPreHook; + @Mock + private AssemblyAPI assemblyAPI; + + @BeforeAll + static void beforeAll() { + mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); + mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) + .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + RpcEnhancementReporterProperties reporterProperties = mock(RpcEnhancementReporterProperties.class); + doReturn(reporterProperties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); + } + + @AfterAll + static void afterAll() { + mockedApplicationContextAwareUtils.close(); + } + + @BeforeEach + void setUp() { + MetadataContext.LOCAL_NAMESPACE = NAMESPACE_TEST; + MetadataContext.LOCAL_SERVICE = SERVICE_PROVIDER; + } + + @Test + public void testGetName() { + assertThat(assemblyClientPreHook.getName()).isEqualTo(AssemblyClientPreHook.class.getName()); + } + + @Test + public void testType() { + assertThat(assemblyClientPreHook.getType()).isEqualTo(EnhancedPluginType.Client.PRE); + } + + @Test + public void testRun() { + EnhancedPluginContext pluginContext = new EnhancedPluginContext(); + EnhancedRequestContext request = EnhancedRequestContext.builder() + .httpMethod(HttpMethod.GET) + .url(URI.create("http://0.0.0.0/")) + .httpHeaders(new HttpHeaders()) + .build(); + request.toString(); + EnhancedResponseContext response = EnhancedResponseContext.builder() + .httpStatus(200) + .build(); + response.toString(); + + DefaultServiceInstance targetServiceInstance = new DefaultServiceInstance(); + targetServiceInstance.setServiceId(SERVICE_PROVIDER); + + DefaultServiceInstance localServiceInstance = new DefaultServiceInstance(); + localServiceInstance.setServiceId(SERVICE_PROVIDER); + + pluginContext.setRequest(request); + pluginContext.setResponse(response); + pluginContext.setTargetServiceInstance(targetServiceInstance); + pluginContext.setLocalServiceInstance(localServiceInstance); + pluginContext.setThrowable(new RuntimeException()); + + assemblyClientPreHook.run(pluginContext); + assemblyClientPreHook.getOrder(); + assemblyClientPreHook.getName(); + assemblyClientPreHook.getType(); + } + + @Test + public void testHandlerThrowable() { + // mock request + EnhancedRequestContext request = mock(EnhancedRequestContext.class); + // mock response + EnhancedResponseContext response = mock(EnhancedResponseContext.class); + + EnhancedPluginContext context = new EnhancedPluginContext(); + context.setRequest(request); + context.setResponse(response); + assemblyClientPreHook.handlerThrowable(context, new RuntimeException("Mock exception.")); + } + +} diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyRequestContextTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyRequestContextTest.java new file mode 100644 index 000000000..fc2565253 --- /dev/null +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyRequestContextTest.java @@ -0,0 +1,61 @@ +package com.tencent.cloud.rpc.enhancement.plugin; + +import java.net.URI; +import java.util.Arrays; +import java.util.HashSet; + +import com.tencent.cloud.rpc.enhancement.plugin.assembly.AssemblyRequestContext; +import com.tencent.polaris.api.pojo.ServiceKey; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; + +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; + +import static org.assertj.core.api.Assertions.assertThat; + +@ExtendWith(MockitoExtension.class) +public class AssemblyRequestContextTest { + + @Test + public void testAssemblyRequestContext() { + URI uri = URI.create("http://0.0.0.0/"); + + HttpHeaders httpHeaders = new HttpHeaders(); + httpHeaders.add("a", "a"); + httpHeaders.add(HttpHeaders.COOKIE, "cookies-k1=cookies-v1;cookies-k2=cookies-v2"); + + EnhancedRequestContext enhancedRequestContext = EnhancedRequestContext.builder() + .httpMethod(HttpMethod.GET) + .url(uri) + .httpHeaders(httpHeaders) + .build(); + + ServiceKey callerService = new ServiceKey("test", "test"); + AssemblyRequestContext assemblyRequestContext = new AssemblyRequestContext( + enhancedRequestContext, + callerService, + "0.0.0.0" + ); + + assertThat(assemblyRequestContext.getURI()).isEqualTo(uri); + + assertThat(assemblyRequestContext.getHeader("a")).isEqualTo("a"); + assemblyRequestContext.setHeader("b", "b"); + assertThat(assemblyRequestContext.listHeaderKeys()).isEqualTo(new HashSet<>(Arrays.asList(HttpHeaders.COOKIE, "a", "b"))); + + assertThat(assemblyRequestContext.getMethod()).isEqualTo(HttpMethod.GET.toString()); + assemblyRequestContext.setMethod(HttpMethod.OPTIONS.name()); + assertThat(assemblyRequestContext.getMethod()).isEqualTo(HttpMethod.OPTIONS.toString()); + + assertThat(assemblyRequestContext.getCookie("cookies-k1")).isEqualTo("cookies-v1"); + assertThat(assemblyRequestContext.getCookie("cookies-k2")).isEqualTo("cookies-v2"); + assemblyRequestContext.setCookie("cookies-k3", "cookies-v3"); + assertThat(assemblyRequestContext.listCookieKeys()).isEqualTo(new HashSet<>(Arrays.asList("cookies-k1", "cookies-k2", "cookies-k3"))); + + assertThat(assemblyRequestContext.getCallerService()).isEqualTo(callerService); + assertThat(assemblyRequestContext.getCallerIp()).isEqualTo("0.0.0.0"); + } + +} diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyResponseContextTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyResponseContextTest.java new file mode 100644 index 000000000..84eae6bb1 --- /dev/null +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyResponseContextTest.java @@ -0,0 +1,79 @@ +package com.tencent.cloud.rpc.enhancement.plugin; + +import java.net.SocketTimeoutException; +import java.util.HashSet; +import java.util.List; + +import com.tencent.cloud.common.util.ApplicationContextAwareUtils; +import com.tencent.cloud.rpc.enhancement.config.RpcEnhancementReporterProperties; +import com.tencent.cloud.rpc.enhancement.plugin.assembly.AssemblyResponseContext; +import com.tencent.polaris.api.pojo.RetStatus; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.MockedStatic; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import org.springframework.context.ApplicationContext; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +@ExtendWith(MockitoExtension.class) +public class AssemblyResponseContextTest { + + private static MockedStatic mockedApplicationContextAwareUtils; + + @BeforeAll + static void beforeAll() { + mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); + mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) + .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + RpcEnhancementReporterProperties reporterProperties = mock(RpcEnhancementReporterProperties.class); + doReturn(reporterProperties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); + } + + @AfterAll + static void afterAll() { + mockedApplicationContextAwareUtils.close(); + } + + @Test + public void testAssemblyResponseContext() { + + HttpHeaders httpHeaders = new HttpHeaders(); + httpHeaders.add("a", "a"); + + EnhancedResponseContext enhancedResponseContext = EnhancedResponseContext.builder() + .httpHeaders(httpHeaders) + .httpStatus(HttpStatus.OK.value()) + .build(); + + AssemblyResponseContext assemblyResponseContext = new AssemblyResponseContext(enhancedResponseContext, null); + assertThat(assemblyResponseContext.getHeader("a")).isEqualTo("a"); + assertThat(assemblyResponseContext.getRetCode()).isEqualTo(HttpStatus.OK.value()); + assertThat(assemblyResponseContext.getThrowable()).isEqualTo(null); + assertThat(assemblyResponseContext.getRetStatus()).isEqualTo(RetStatus.RetSuccess); + assertThat(assemblyResponseContext.listHeaders()).isEqualTo(new HashSet<>(List.of("a"))); + + Throwable e = new SocketTimeoutException(); + assemblyResponseContext = new AssemblyResponseContext(null, e); + assertThat(assemblyResponseContext.getHeader("a")).isEqualTo(null); + assertThat(assemblyResponseContext.getRetCode()).isEqualTo(null); + assertThat(assemblyResponseContext.getThrowable()).isEqualTo(e); + assertThat(assemblyResponseContext.getRetStatus()).isEqualTo(RetStatus.RetTimeout); + assertThat(assemblyResponseContext.listHeaders()).isEqualTo(null); + + } + +} diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyServerExceptionHookTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyServerExceptionHookTest.java new file mode 100644 index 000000000..eb2026417 --- /dev/null +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyServerExceptionHookTest.java @@ -0,0 +1,121 @@ +package com.tencent.cloud.rpc.enhancement.plugin; + +import java.net.URI; + +import com.tencent.cloud.common.metadata.MetadataContext; +import com.tencent.cloud.common.util.ApplicationContextAwareUtils; +import com.tencent.cloud.rpc.enhancement.config.RpcEnhancementReporterProperties; +import com.tencent.cloud.rpc.enhancement.plugin.assembly.server.AssemblyServerExceptionHook; +import com.tencent.polaris.assembly.api.AssemblyAPI; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockedStatic; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import org.springframework.cloud.client.DefaultServiceInstance; +import org.springframework.context.ApplicationContext; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; + +import static com.tencent.polaris.test.common.Consts.NAMESPACE_TEST; +import static com.tencent.polaris.test.common.Consts.SERVICE_PROVIDER; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +@ExtendWith(MockitoExtension.class) +public class AssemblyServerExceptionHookTest { + + private static MockedStatic mockedApplicationContextAwareUtils; + @InjectMocks + private AssemblyServerExceptionHook assemblyServerExceptionHook; + @Mock + private AssemblyAPI assemblyAPI; + + @BeforeAll + static void beforeAll() { + mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); + mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) + .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + RpcEnhancementReporterProperties reporterProperties = mock(RpcEnhancementReporterProperties.class); + doReturn(reporterProperties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); + } + + @AfterAll + static void afterAll() { + mockedApplicationContextAwareUtils.close(); + } + + @BeforeEach + void setUp() { + MetadataContext.LOCAL_NAMESPACE = NAMESPACE_TEST; + MetadataContext.LOCAL_SERVICE = SERVICE_PROVIDER; + } + + @Test + public void testGetName() { + assertThat(assemblyServerExceptionHook.getName()).isEqualTo(AssemblyServerExceptionHook.class.getName()); + } + + @Test + public void testType() { + assertThat(assemblyServerExceptionHook.getType()).isEqualTo(EnhancedPluginType.Server.EXCEPTION); + } + + @Test + public void testRun() { + EnhancedPluginContext pluginContext = new EnhancedPluginContext(); + EnhancedRequestContext request = EnhancedRequestContext.builder() + .httpMethod(HttpMethod.GET) + .url(URI.create("http://0.0.0.0/")) + .httpHeaders(new HttpHeaders()) + .build(); + request.toString(); + EnhancedResponseContext response = EnhancedResponseContext.builder() + .httpStatus(200) + .build(); + response.toString(); + + DefaultServiceInstance targetServiceInstance = new DefaultServiceInstance(); + targetServiceInstance.setServiceId(SERVICE_PROVIDER); + + DefaultServiceInstance localServiceInstance = new DefaultServiceInstance(); + localServiceInstance.setServiceId(SERVICE_PROVIDER); + + pluginContext.setRequest(request); + pluginContext.setResponse(response); + pluginContext.setTargetServiceInstance(targetServiceInstance); + pluginContext.setLocalServiceInstance(localServiceInstance); + pluginContext.setThrowable(new RuntimeException()); + + assemblyServerExceptionHook.run(pluginContext); + assemblyServerExceptionHook.getOrder(); + assemblyServerExceptionHook.getName(); + assemblyServerExceptionHook.getType(); + } + + @Test + public void testHandlerThrowable() { + // mock request + EnhancedRequestContext request = mock(EnhancedRequestContext.class); + // mock response + EnhancedResponseContext response = mock(EnhancedResponseContext.class); + + EnhancedPluginContext context = new EnhancedPluginContext(); + context.setRequest(request); + context.setResponse(response); + assemblyServerExceptionHook.handlerThrowable(context, new RuntimeException("Mock exception.")); + } + +} diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyServerPostHookTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyServerPostHookTest.java new file mode 100644 index 000000000..74533b336 --- /dev/null +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyServerPostHookTest.java @@ -0,0 +1,121 @@ +package com.tencent.cloud.rpc.enhancement.plugin; + +import java.net.URI; + +import com.tencent.cloud.common.metadata.MetadataContext; +import com.tencent.cloud.common.util.ApplicationContextAwareUtils; +import com.tencent.cloud.rpc.enhancement.config.RpcEnhancementReporterProperties; +import com.tencent.cloud.rpc.enhancement.plugin.assembly.server.AssemblyServerPostHook; +import com.tencent.polaris.assembly.api.AssemblyAPI; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockedStatic; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import org.springframework.cloud.client.DefaultServiceInstance; +import org.springframework.context.ApplicationContext; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; + +import static com.tencent.polaris.test.common.Consts.NAMESPACE_TEST; +import static com.tencent.polaris.test.common.Consts.SERVICE_PROVIDER; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +@ExtendWith(MockitoExtension.class) +public class AssemblyServerPostHookTest { + + private static MockedStatic mockedApplicationContextAwareUtils; + @InjectMocks + private AssemblyServerPostHook assemblyServerPostHook; + @Mock + private AssemblyAPI assemblyAPI; + + @BeforeAll + static void beforeAll() { + mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); + mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) + .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + RpcEnhancementReporterProperties reporterProperties = mock(RpcEnhancementReporterProperties.class); + doReturn(reporterProperties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); + } + + @AfterAll + static void afterAll() { + mockedApplicationContextAwareUtils.close(); + } + + @BeforeEach + void setUp() { + MetadataContext.LOCAL_NAMESPACE = NAMESPACE_TEST; + MetadataContext.LOCAL_SERVICE = SERVICE_PROVIDER; + } + + @Test + public void testGetName() { + assertThat(assemblyServerPostHook.getName()).isEqualTo(AssemblyServerPostHook.class.getName()); + } + + @Test + public void testType() { + assertThat(assemblyServerPostHook.getType()).isEqualTo(EnhancedPluginType.Server.POST); + } + + @Test + public void testRun() { + EnhancedPluginContext pluginContext = new EnhancedPluginContext(); + EnhancedRequestContext request = EnhancedRequestContext.builder() + .httpMethod(HttpMethod.GET) + .url(URI.create("http://0.0.0.0/")) + .httpHeaders(new HttpHeaders()) + .build(); + request.toString(); + EnhancedResponseContext response = EnhancedResponseContext.builder() + .httpStatus(200) + .build(); + response.toString(); + + DefaultServiceInstance targetServiceInstance = new DefaultServiceInstance(); + targetServiceInstance.setServiceId(SERVICE_PROVIDER); + + DefaultServiceInstance localServiceInstance = new DefaultServiceInstance(); + localServiceInstance.setServiceId(SERVICE_PROVIDER); + + pluginContext.setRequest(request); + pluginContext.setResponse(response); + pluginContext.setTargetServiceInstance(targetServiceInstance); + pluginContext.setLocalServiceInstance(localServiceInstance); + pluginContext.setThrowable(new RuntimeException()); + + assemblyServerPostHook.run(pluginContext); + assemblyServerPostHook.getOrder(); + assemblyServerPostHook.getName(); + assemblyServerPostHook.getType(); + } + + @Test + public void testHandlerThrowable() { + // mock request + EnhancedRequestContext request = mock(EnhancedRequestContext.class); + // mock response + EnhancedResponseContext response = mock(EnhancedResponseContext.class); + + EnhancedPluginContext context = new EnhancedPluginContext(); + context.setRequest(request); + context.setResponse(response); + assemblyServerPostHook.handlerThrowable(context, new RuntimeException("Mock exception.")); + } + +} diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyServerPreHookTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyServerPreHookTest.java new file mode 100644 index 000000000..d6a6651f8 --- /dev/null +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/AssemblyServerPreHookTest.java @@ -0,0 +1,121 @@ +package com.tencent.cloud.rpc.enhancement.plugin; + +import java.net.URI; + +import com.tencent.cloud.common.metadata.MetadataContext; +import com.tencent.cloud.common.util.ApplicationContextAwareUtils; +import com.tencent.cloud.rpc.enhancement.config.RpcEnhancementReporterProperties; +import com.tencent.cloud.rpc.enhancement.plugin.assembly.server.AssemblyServerPreHook; +import com.tencent.polaris.assembly.api.AssemblyAPI; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockedStatic; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import org.springframework.cloud.client.DefaultServiceInstance; +import org.springframework.context.ApplicationContext; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; + +import static com.tencent.polaris.test.common.Consts.NAMESPACE_TEST; +import static com.tencent.polaris.test.common.Consts.SERVICE_PROVIDER; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +@ExtendWith(MockitoExtension.class) +public class AssemblyServerPreHookTest { + + private static MockedStatic mockedApplicationContextAwareUtils; + @InjectMocks + private AssemblyServerPreHook assemblyServerPreHook; + @Mock + private AssemblyAPI assemblyAPI; + + @BeforeAll + static void beforeAll() { + mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); + mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) + .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + RpcEnhancementReporterProperties reporterProperties = mock(RpcEnhancementReporterProperties.class); + doReturn(reporterProperties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); + } + + @AfterAll + static void afterAll() { + mockedApplicationContextAwareUtils.close(); + } + + @BeforeEach + void setUp() { + MetadataContext.LOCAL_NAMESPACE = NAMESPACE_TEST; + MetadataContext.LOCAL_SERVICE = SERVICE_PROVIDER; + } + + @Test + public void testGetName() { + assertThat(assemblyServerPreHook.getName()).isEqualTo(AssemblyServerPreHook.class.getName()); + } + + @Test + public void testType() { + assertThat(assemblyServerPreHook.getType()).isEqualTo(EnhancedPluginType.Server.PRE); + } + + @Test + public void testRun() { + EnhancedPluginContext pluginContext = new EnhancedPluginContext(); + EnhancedRequestContext request = EnhancedRequestContext.builder() + .httpMethod(HttpMethod.GET) + .url(URI.create("http://0.0.0.0/")) + .httpHeaders(new HttpHeaders()) + .build(); + request.toString(); + EnhancedResponseContext response = EnhancedResponseContext.builder() + .httpStatus(200) + .build(); + response.toString(); + + DefaultServiceInstance targetServiceInstance = new DefaultServiceInstance(); + targetServiceInstance.setServiceId(SERVICE_PROVIDER); + + DefaultServiceInstance localServiceInstance = new DefaultServiceInstance(); + localServiceInstance.setServiceId(SERVICE_PROVIDER); + + pluginContext.setRequest(request); + pluginContext.setResponse(response); + pluginContext.setTargetServiceInstance(targetServiceInstance); + pluginContext.setLocalServiceInstance(localServiceInstance); + pluginContext.setThrowable(new RuntimeException()); + + assemblyServerPreHook.run(pluginContext); + assemblyServerPreHook.getOrder(); + assemblyServerPreHook.getName(); + assemblyServerPreHook.getType(); + } + + @Test + public void testHandlerThrowable() { + // mock request + EnhancedRequestContext request = mock(EnhancedRequestContext.class); + // mock response + EnhancedResponseContext response = mock(EnhancedResponseContext.class); + + EnhancedPluginContext context = new EnhancedPluginContext(); + context.setRequest(request); + context.setResponse(response); + assemblyServerPreHook.handlerThrowable(context, new RuntimeException("Mock exception.")); + } + +} diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/EnhancedPluginContextTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/EnhancedPluginContextTest.java index 84ca2525c..b1c593f3f 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/EnhancedPluginContextTest.java +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/EnhancedPluginContextTest.java @@ -25,6 +25,9 @@ import com.tencent.cloud.common.util.ApplicationContextAwareUtils; import com.tencent.cloud.rpc.enhancement.config.RpcEnhancementReporterProperties; import com.tencent.cloud.rpc.enhancement.plugin.reporter.ExceptionPolarisReporter; import com.tencent.cloud.rpc.enhancement.plugin.reporter.SuccessPolarisReporter; +import com.tencent.polaris.api.config.Configuration; +import com.tencent.polaris.api.config.global.APIConfig; +import com.tencent.polaris.api.config.global.GlobalConfig; import com.tencent.polaris.api.core.ConsumerAPI; import com.tencent.polaris.client.api.SDKContext; import org.junit.jupiter.api.AfterAll; @@ -38,6 +41,8 @@ import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.cloud.client.DefaultServiceInstance; +import org.springframework.cloud.client.serviceregistry.Registration; +import org.springframework.context.annotation.Bean; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; @@ -65,6 +70,8 @@ public class EnhancedPluginContextTest { private SDKContext sdkContext; @Mock private ConsumerAPI consumerAPI; + @Mock + private Registration registration; @BeforeAll static void beforeAll() { @@ -122,12 +129,26 @@ public class EnhancedPluginContextTest { EnhancedPlugin enhancedPlugin = new SuccessPolarisReporter(reporterProperties, consumerAPI); EnhancedPlugin enhancedPlugin1 = new ExceptionPolarisReporter(reporterProperties, consumerAPI); - EnhancedPluginRunner enhancedPluginRunner = new DefaultEnhancedPluginRunner(Arrays.asList(enhancedPlugin, enhancedPlugin1), null, sdkContext); + EnhancedPluginRunner enhancedPluginRunner = new DefaultEnhancedPluginRunner(Arrays.asList(enhancedPlugin, enhancedPlugin1), registration, sdkContext); enhancedPluginRunner.run(EnhancedPluginType.Client.POST, enhancedPluginContext); + assertThat(enhancedPluginRunner.getLocalServiceInstance()).isEqualTo(registration); + EnhancedPlugin enhancedPlugin2 = mock(EnhancedPlugin.class); doThrow(new RuntimeException()).when(enhancedPlugin2).run(any()); doReturn(EnhancedPluginType.Client.POST).when(enhancedPlugin2).getType(); + + APIConfig apiConfig = mock(APIConfig.class); + doReturn("0.0.0.0").when(apiConfig).getBindIP(); + + GlobalConfig globalConfig = mock(GlobalConfig.class); + doReturn(apiConfig).when(globalConfig).getAPI(); + + Configuration configuration = mock(Configuration.class); + doReturn(globalConfig).when(configuration).getGlobal(); + + doReturn(configuration).when(sdkContext).getConfig(); + enhancedPluginRunner = new DefaultEnhancedPluginRunner(Arrays.asList(enhancedPlugin2), null, sdkContext); enhancedPluginRunner.run(EnhancedPluginType.Client.POST, enhancedPluginContext); } diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/ExceptionPolarisReporterTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/ExceptionPolarisReporterTest.java index 7e1fcde61..840c5d498 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/ExceptionPolarisReporterTest.java +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/ExceptionPolarisReporterTest.java @@ -23,11 +23,7 @@ import com.tencent.cloud.common.metadata.MetadataContext; import com.tencent.cloud.common.util.ApplicationContextAwareUtils; import com.tencent.cloud.rpc.enhancement.config.RpcEnhancementReporterProperties; import com.tencent.cloud.rpc.enhancement.plugin.reporter.ExceptionPolarisReporter; -import com.tencent.polaris.api.config.Configuration; -import com.tencent.polaris.api.config.global.APIConfig; -import com.tencent.polaris.api.config.global.GlobalConfig; import com.tencent.polaris.api.core.ConsumerAPI; -import com.tencent.polaris.client.api.SDKContext; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; @@ -40,6 +36,7 @@ import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.cloud.client.DefaultServiceInstance; +import org.springframework.context.ApplicationContext; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; @@ -63,8 +60,6 @@ public class ExceptionPolarisReporterTest { private static MockedStatic mockedApplicationContextAwareUtils; @Mock private RpcEnhancementReporterProperties reporterProperties; - @Mock - private SDKContext sdkContext; @InjectMocks private ExceptionPolarisReporter exceptionPolarisReporter; @Mock @@ -75,6 +70,12 @@ public class ExceptionPolarisReporterTest { mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + RpcEnhancementReporterProperties reporterProperties = mock(RpcEnhancementReporterProperties.class); + doReturn(reporterProperties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); } @AfterAll @@ -107,26 +108,17 @@ public class ExceptionPolarisReporterTest { doReturn(true).when(reporterProperties).isEnabled(); - APIConfig apiConfig = mock(APIConfig.class); - doReturn("0.0.0.0").when(apiConfig).getBindIP(); - - GlobalConfig globalConfig = mock(GlobalConfig.class); - doReturn(apiConfig).when(globalConfig).getAPI(); - - Configuration configuration = mock(Configuration.class); - doReturn(globalConfig).when(configuration).getGlobal(); - - doReturn(configuration).when(sdkContext).getConfig(); - EnhancedPluginContext pluginContext = new EnhancedPluginContext(); EnhancedRequestContext request = EnhancedRequestContext.builder() .httpMethod(HttpMethod.GET) .url(URI.create("http://0.0.0.0/")) .httpHeaders(new HttpHeaders()) .build(); + request.toString(); EnhancedResponseContext response = EnhancedResponseContext.builder() .httpStatus(200) .build(); + response.toString(); DefaultServiceInstance serviceInstance = new DefaultServiceInstance(); serviceInstance.setServiceId(SERVICE_PROVIDER); diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/PolarisEnhancedPluginUtilsTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/PolarisEnhancedPluginUtilsTest.java index 46a6556b5..295846bfa 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/PolarisEnhancedPluginUtilsTest.java +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/PolarisEnhancedPluginUtilsTest.java @@ -20,6 +20,7 @@ package com.tencent.cloud.rpc.enhancement.plugin; import java.net.SocketTimeoutException; import java.net.URI; import java.net.URISyntaxException; +import java.util.Arrays; import com.tencent.cloud.common.constant.HeaderConstant; import com.tencent.cloud.common.constant.RouterConstant; @@ -43,6 +44,7 @@ import org.mockito.MockedStatic; import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.context.ApplicationContext; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpStatus; @@ -71,6 +73,12 @@ public class PolarisEnhancedPluginUtilsTest { mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + RpcEnhancementReporterProperties reporterProperties = mock(RpcEnhancementReporterProperties.class); + doReturn(reporterProperties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); } @AfterAll @@ -86,16 +94,6 @@ public class PolarisEnhancedPluginUtilsTest { @Test public void testServiceCallResult() throws URISyntaxException { - APIConfig apiConfig = mock(APIConfig.class); - doReturn("0.0.0.0").when(apiConfig).getBindIP(); - - GlobalConfig globalConfig = mock(GlobalConfig.class); - doReturn(apiConfig).when(globalConfig).getAPI(); - - Configuration configuration = mock(Configuration.class); - doReturn(globalConfig).when(configuration).getGlobal(); - - doReturn(configuration).when(sdkContext).getConfig(); ServiceCallResult serviceCallResult; @@ -201,12 +199,33 @@ public class PolarisEnhancedPluginUtilsTest { public void testApplyWithDefaultConfig() { RpcEnhancementReporterProperties properties = new RpcEnhancementReporterProperties(); + ApplicationContext applicationContext = mock(ApplicationContext.class); + doReturn(properties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); // Assert assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.OK)).isEqualTo(false); assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.INTERNAL_SERVER_ERROR)).isEqualTo(false); assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.BAD_GATEWAY)).isEqualTo(true); } + @Test + public void testApplyWithHttpStatus() { + RpcEnhancementReporterProperties properties = new RpcEnhancementReporterProperties(); + properties.setStatuses(Arrays.asList(HttpStatus.BAD_GATEWAY, HttpStatus.INTERNAL_SERVER_ERROR)); + ApplicationContext applicationContext = mock(ApplicationContext.class); + doReturn(properties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); + // Assert + assertThat(PolarisEnhancedPluginUtils.apply(null)).isEqualTo(false); + assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.OK)).isEqualTo(false); + assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.INTERNAL_SERVER_ERROR)).isEqualTo(true); + assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.BAD_GATEWAY)).isEqualTo(true); + } + @Test public void testApplyWithoutIgnoreInternalServerError() { RpcEnhancementReporterProperties properties = new RpcEnhancementReporterProperties(); @@ -214,6 +233,12 @@ public class PolarisEnhancedPluginUtilsTest { properties.getStatuses().clear(); properties.setIgnoreInternalServerError(false); + ApplicationContext applicationContext = mock(ApplicationContext.class); + doReturn(properties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); + // Assert assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.OK)).isEqualTo(false); assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.INTERNAL_SERVER_ERROR)).isEqualTo(true); @@ -227,6 +252,12 @@ public class PolarisEnhancedPluginUtilsTest { properties.getStatuses().clear(); properties.setIgnoreInternalServerError(true); + ApplicationContext applicationContext = mock(ApplicationContext.class); + doReturn(properties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); + // Assert assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.OK)).isEqualTo(false); assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.INTERNAL_SERVER_ERROR)).isEqualTo(false); @@ -240,6 +271,12 @@ public class PolarisEnhancedPluginUtilsTest { properties.getStatuses().clear(); properties.getSeries().clear(); + ApplicationContext applicationContext = mock(ApplicationContext.class); + doReturn(properties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); + // Assert assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.OK)).isEqualTo(false); assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.INTERNAL_SERVER_ERROR)).isEqualTo(false); @@ -254,6 +291,12 @@ public class PolarisEnhancedPluginUtilsTest { properties.getSeries().clear(); properties.getSeries().add(HttpStatus.Series.CLIENT_ERROR); + ApplicationContext applicationContext = mock(ApplicationContext.class); + doReturn(properties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); + // Assert assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.OK)).isEqualTo(false); assertThat(PolarisEnhancedPluginUtils.apply(HttpStatus.INTERNAL_SERVER_ERROR)).isEqualTo(false); @@ -264,11 +307,6 @@ public class PolarisEnhancedPluginUtilsTest { @Test public void testGetRetStatusFromRequest() { - RpcEnhancementReporterProperties properties = new RpcEnhancementReporterProperties(); - // Mock Condition - properties.getStatuses().clear(); - properties.getSeries().clear(); - properties.getSeries().add(HttpStatus.Series.CLIENT_ERROR); HttpHeaders headers = new HttpHeaders(); RetStatus ret = PolarisEnhancedPluginUtils.getRetStatusFromRequest(headers, RetStatus.RetFail); @@ -285,11 +323,6 @@ public class PolarisEnhancedPluginUtilsTest { @Test public void testGetActiveRuleNameFromRequest() { - RpcEnhancementReporterProperties properties = new RpcEnhancementReporterProperties(); - // Mock Condition - properties.getStatuses().clear(); - properties.getSeries().clear(); - properties.getSeries().add(HttpStatus.Series.CLIENT_ERROR); HttpHeaders headers = new HttpHeaders(); String ruleName = PolarisEnhancedPluginUtils.getActiveRuleNameFromRequest(headers); diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/SuccessPolarisReporterTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/SuccessPolarisReporterTest.java index aaa27df41..5af25a89b 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/SuccessPolarisReporterTest.java +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/plugin/SuccessPolarisReporterTest.java @@ -23,11 +23,7 @@ import com.tencent.cloud.common.metadata.MetadataContext; import com.tencent.cloud.common.util.ApplicationContextAwareUtils; import com.tencent.cloud.rpc.enhancement.config.RpcEnhancementReporterProperties; import com.tencent.cloud.rpc.enhancement.plugin.reporter.SuccessPolarisReporter; -import com.tencent.polaris.api.config.Configuration; -import com.tencent.polaris.api.config.global.APIConfig; -import com.tencent.polaris.api.config.global.GlobalConfig; import com.tencent.polaris.api.core.ConsumerAPI; -import com.tencent.polaris.client.api.SDKContext; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; @@ -40,6 +36,7 @@ import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.cloud.client.DefaultServiceInstance; +import org.springframework.context.ApplicationContext; import org.springframework.http.HttpMethod; import static com.tencent.polaris.test.common.Consts.NAMESPACE_TEST; @@ -60,8 +57,6 @@ import static org.mockito.Mockito.verify; public class SuccessPolarisReporterTest { private static MockedStatic mockedApplicationContextAwareUtils; @Mock - private SDKContext sdkContext; - @Mock private RpcEnhancementReporterProperties reporterProperties; @InjectMocks private SuccessPolarisReporter successPolarisReporter; @@ -73,6 +68,12 @@ public class SuccessPolarisReporterTest { mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + RpcEnhancementReporterProperties reporterProperties = mock(RpcEnhancementReporterProperties.class); + doReturn(reporterProperties) + .when(applicationContext).getBean(RpcEnhancementReporterProperties.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext) + .thenReturn(applicationContext); } @AfterAll @@ -105,25 +106,17 @@ public class SuccessPolarisReporterTest { verify(context, times(0)).getRequest(); doReturn(true).when(reporterProperties).isEnabled(); - APIConfig apiConfig = mock(APIConfig.class); - doReturn("0.0.0.0").when(apiConfig).getBindIP(); - - GlobalConfig globalConfig = mock(GlobalConfig.class); - doReturn(apiConfig).when(globalConfig).getAPI(); - - Configuration configuration = mock(Configuration.class); - doReturn(globalConfig).when(configuration).getGlobal(); - - doReturn(configuration).when(sdkContext).getConfig(); EnhancedPluginContext pluginContext = new EnhancedPluginContext(); EnhancedRequestContext request = EnhancedRequestContext.builder() .httpMethod(HttpMethod.GET) .url(URI.create("http://0.0.0.0/")) .build(); + request.toString(); EnhancedResponseContext response = EnhancedResponseContext.builder() .httpStatus(200) .build(); + response.toString(); DefaultServiceInstance serviceInstance = new DefaultServiceInstance(); serviceInstance.setServiceId(SERVICE_PROVIDER); diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/resttemplate/EnhancedRestTemplateInterceptorTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/resttemplate/EnhancedRestTemplateInterceptorTest.java index eb0e32838..10bcbab69 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/resttemplate/EnhancedRestTemplateInterceptorTest.java +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/resttemplate/EnhancedRestTemplateInterceptorTest.java @@ -40,6 +40,7 @@ import org.mockito.MockedStatic; import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.cloud.client.serviceregistry.Registration; import org.springframework.context.ApplicationContext; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; @@ -65,6 +66,8 @@ public class EnhancedRestTemplateInterceptorTest { @Mock private SDKContext sdkContext; @Mock + Registration registration; + @Mock private ClientHttpRequestExecution mockClientHttpRequestExecution; @Mock private ClientHttpResponse mockClientHttpResponse; @@ -109,7 +112,7 @@ public class EnhancedRestTemplateInterceptorTest { doReturn(mockHttpHeaders).when(mockHttpRequest).getHeaders(); doReturn(mockClientHttpResponse).when(mockClientHttpRequestExecution).execute(mockHttpRequest, inputBody); - EnhancedRestTemplateInterceptor reporter = new EnhancedRestTemplateInterceptor(new DefaultEnhancedPluginRunner(new ArrayList<>(), null, sdkContext)); + EnhancedRestTemplateInterceptor reporter = new EnhancedRestTemplateInterceptor(new DefaultEnhancedPluginRunner(new ArrayList<>(), registration, null)); actualResult = reporter.intercept(mockHttpRequest, inputBody, mockClientHttpRequestExecution); assertThat(actualResult).isEqualTo(mockClientHttpResponse); diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/resttemplate/PolarisLoadBalancerRequestTransformerTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/resttemplate/PolarisLoadBalancerRequestTransformerTest.java new file mode 100644 index 000000000..f6dc32e41 --- /dev/null +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/resttemplate/PolarisLoadBalancerRequestTransformerTest.java @@ -0,0 +1,72 @@ +package com.tencent.cloud.rpc.enhancement.resttemplate; + +import com.tencent.cloud.common.metadata.MetadataContext; +import com.tencent.cloud.common.metadata.MetadataContextHolder; +import com.tencent.cloud.common.metadata.StaticMetadataManager; +import com.tencent.cloud.common.metadata.config.MetadataLocalProperties; +import com.tencent.cloud.common.util.ApplicationContextAwareUtils; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.MockedStatic; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import org.springframework.cloud.client.ServiceInstance; +import org.springframework.context.ApplicationContext; +import org.springframework.http.HttpRequest; + +import static com.tencent.cloud.rpc.enhancement.resttemplate.PolarisLoadBalancerRequestTransformer.LOAD_BALANCER_SERVICE_INSTANCE; +import static com.tencent.polaris.test.common.Consts.NAMESPACE_TEST; +import static com.tencent.polaris.test.common.Consts.SERVICE_PROVIDER; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +@ExtendWith(MockitoExtension.class) +public class PolarisLoadBalancerRequestTransformerTest { + private static MockedStatic mockedApplicationContextAwareUtils; + + private PolarisLoadBalancerRequestTransformer transformer = new PolarisLoadBalancerRequestTransformer(); + + @Mock + private HttpRequest clientRequest; + + @Mock + private ServiceInstance serviceInstance; + + @BeforeAll + static void beforeAll() { + mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class); + mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString())) + .thenReturn("unit-test"); + ApplicationContext applicationContext = mock(ApplicationContext.class); + MetadataLocalProperties metadataLocalProperties = mock(MetadataLocalProperties.class); + StaticMetadataManager staticMetadataManager = mock(StaticMetadataManager.class); + doReturn(metadataLocalProperties).when(applicationContext).getBean(MetadataLocalProperties.class); + doReturn(staticMetadataManager).when(applicationContext).getBean(StaticMetadataManager.class); + mockedApplicationContextAwareUtils.when(ApplicationContextAwareUtils::getApplicationContext).thenReturn(applicationContext); + } + + @AfterAll + static void afterAll() { + mockedApplicationContextAwareUtils.close(); + } + + @BeforeEach + void setUp() { + MetadataContext.LOCAL_NAMESPACE = NAMESPACE_TEST; + MetadataContext.LOCAL_SERVICE = SERVICE_PROVIDER; + } + + @Test + public void test() throws Throwable { + transformer.transformRequest(clientRequest, serviceInstance); + assertThat(MetadataContextHolder.get().getLoadbalancerMetadata().get(LOAD_BALANCER_SERVICE_INSTANCE)).isEqualTo(serviceInstance); + } +} + diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/scg/EnhancedGatewayGlobalFilterTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/scg/EnhancedGatewayGlobalFilterTest.java index 1474bcf26..d50adce6f 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/scg/EnhancedGatewayGlobalFilterTest.java +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/scg/EnhancedGatewayGlobalFilterTest.java @@ -41,6 +41,7 @@ import reactor.core.publisher.Mono; import org.springframework.cloud.client.ServiceInstance; import org.springframework.cloud.client.loadbalancer.Response; +import org.springframework.cloud.client.serviceregistry.Registration; import org.springframework.cloud.gateway.filter.GatewayFilterChain; import org.springframework.context.ApplicationContext; import org.springframework.http.HttpHeaders; @@ -66,6 +67,8 @@ public class EnhancedGatewayGlobalFilterTest { @Mock private SDKContext sdkContext; @Mock + Registration registration; + @Mock ServerWebExchange exchange; @Mock GatewayFilterChain chain; @@ -123,7 +126,7 @@ public class EnhancedGatewayGlobalFilterTest { doReturn(request).when(exchange).getRequest(); doReturn(response).when(exchange).getResponse(); - EnhancedGatewayGlobalFilter reporter = new EnhancedGatewayGlobalFilter(new DefaultEnhancedPluginRunner(new ArrayList<>(), null, sdkContext)); + EnhancedGatewayGlobalFilter reporter = new EnhancedGatewayGlobalFilter(new DefaultEnhancedPluginRunner(new ArrayList<>(), registration, null)); reporter.getOrder(); reporter.filter(exchange, chain).block(); diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/webclient/EnhancedWebClientExchangeFilterFunctionTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/webclient/EnhancedWebClientExchangeFilterFunctionTest.java index c216ac19c..eb00afd30 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/webclient/EnhancedWebClientExchangeFilterFunctionTest.java +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/webclient/EnhancedWebClientExchangeFilterFunctionTest.java @@ -39,9 +39,11 @@ import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension; import reactor.core.publisher.Mono; +import org.springframework.cloud.client.serviceregistry.Registration; import org.springframework.context.ApplicationContext; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; +import org.springframework.http.HttpStatusCode; import org.springframework.web.reactive.function.client.ClientRequest; import org.springframework.web.reactive.function.client.ClientResponse; import org.springframework.web.reactive.function.client.ExchangeFunction; @@ -64,6 +66,8 @@ public class EnhancedWebClientExchangeFilterFunctionTest { @Mock private SDKContext sdkContext; @Mock + private Registration registration; + @Mock private ClientRequest clientRequest; @Mock private ExchangeFunction exchangeFunction; @@ -101,9 +105,10 @@ public class EnhancedWebClientExchangeFilterFunctionTest { doReturn(HttpMethod.GET).when(clientRequest).method(); ClientResponse.Headers headers = mock(ClientResponse.Headers.class); doReturn(headers).when(clientResponse).headers(); + doReturn(HttpStatusCode.valueOf(200)).when(clientResponse).statusCode(); doReturn(Mono.just(clientResponse)).when(exchangeFunction).exchange(any()); - EnhancedWebClientExchangeFilterFunction reporter = new EnhancedWebClientExchangeFilterFunction(new DefaultEnhancedPluginRunner(new ArrayList<>(), null, sdkContext)); + EnhancedWebClientExchangeFilterFunction reporter = new EnhancedWebClientExchangeFilterFunction(new DefaultEnhancedPluginRunner(new ArrayList<>(), registration, null)); ClientResponse clientResponse1 = reporter.filter(clientRequest, exchangeFunction).block(); assertThat(clientResponse1).isEqualTo(clientResponse); diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/webclient/PolarisLoadBalancerClientRequestTransformerTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/webclient/PolarisLoadBalancerClientRequestTransformerTest.java index 811b7c5eb..7b7c4e0d5 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/webclient/PolarisLoadBalancerClientRequestTransformerTest.java +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/webclient/PolarisLoadBalancerClientRequestTransformerTest.java @@ -17,7 +17,6 @@ package com.tencent.cloud.rpc.enhancement.webclient; -import com.tencent.cloud.common.constant.HeaderConstant; import com.tencent.cloud.common.metadata.MetadataContext; import com.tencent.cloud.common.metadata.MetadataContextHolder; import com.tencent.cloud.common.metadata.StaticMetadataManager; @@ -37,6 +36,7 @@ import org.springframework.cloud.client.ServiceInstance; import org.springframework.context.ApplicationContext; import org.springframework.web.reactive.function.client.ClientRequest; +import static com.tencent.cloud.rpc.enhancement.resttemplate.PolarisLoadBalancerRequestTransformer.LOAD_BALANCER_SERVICE_INSTANCE; import static com.tencent.polaris.test.common.Consts.NAMESPACE_TEST; import static com.tencent.polaris.test.common.Consts.SERVICE_PROVIDER; import static org.assertj.core.api.Assertions.assertThat; @@ -83,8 +83,7 @@ public class PolarisLoadBalancerClientRequestTransformerTest { @Test public void test() throws Throwable { - doReturn("test").when(serviceInstance).getServiceId(); transformer.transformRequest(clientRequest, serviceInstance); - assertThat(MetadataContextHolder.get().getLoadbalancerMetadata().get(HeaderConstant.INTERNAL_CALLEE_SERVICE_ID)).isEqualTo("test"); + assertThat(MetadataContextHolder.get().getLoadbalancerMetadata().get(LOAD_BALANCER_SERVICE_INSTANCE)).isEqualTo(serviceInstance); } }