This is an automated email from the ASF dual-hosted git repository.
xiaoyu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shenyu.git
The following commit(s) were added to refs/heads/master by this push:
new a13a935a3 [type:test] Improve the unit test coverage. (#3831)
a13a935a3 is described below
commit a13a935a3129f95f76c496a7f5dec80d3666a252
Author: yunlongn <[email protected]>
AuthorDate: Mon Aug 29 15:30:39 2022 +0800
[type:test] Improve the unit test coverage. (#3831)
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-web.
* [type:test] Improve the unit test coverage of shenyu-web.
* [type:test] Improve the unit test coverage of shenyu-web.
* [type:test] Improve the unit test coverage of shenyu-web.
* [type:test] Improve the unit test coverage of shenyu-web.
* [type:test] Improve the unit test coverage of shenyu-web.
* [type:test] Improve the unit test coverage of shenyu-web.
* [type:test] Improve the unit test coverage of shenyu-web.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-web.
* [type:test] Improve the unit test coverage of shenyu-web.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
* [type:test] Improve the unit test coverage of shenyu-loadbalancer.
---
.../tars/TarsServiceBeanPostProcessorTest.java | 11 ++
.../loadbalancer/factory/LoadBalancerFactory.java | 5 +-
.../cache/UpstreamCacheManagerTest.java | 82 ++++++++++++++
.../loadbalancer/cache/UpstreamCheckTaskTest.java | 1 +
.../cache/UpstreamWithSelectorIdTest.java | 49 +++++++++
.../shenyu/loadbalancer/entity/UpstreamTest.java | 79 +++++++++++++
.../loadbalancer/spi/HashLoadBalanceTest.java | 73 ++++++++++++
...alanceTest.java => RandomLoadBalancerTest.java} | 58 +++++-----
.../spi/RoundRobinLoadBalanceTest.java | 22 ++++
.../shenyu/web/loader/ShenyuPluginPathBuilder.java | 7 +-
.../ShenyuThreadPoolConfigurationTest.java | 7 +-
.../web/controller/LocalPluginControllerTest.java | 122 ++++++++++++++++++++-
.../apache/shenyu/web/filter/CrossFilterTest.java | 48 +++++++-
.../shenyu/web/filter/ExcludeFilterTest.java | 9 ++
.../shenyu/web/filter/FallbackFilterTest.java | 9 ++
.../shenyu/web/filter/FileSizeFilterTest.java | 43 ++++++++
.../apache/shenyu/web/filter/HealthFilterTest.java | 15 +++
.../ForwardedRemoteAddressResolverTest.java | 15 +++
.../shenyu/web/handler/GlobalErrorHandlerTest.java | 3 +
.../shenyu/web/handler/ShenyuWebHandlerTest.java | 21 +++-
.../shenyu/web/loader/ShenyuLoaderServiceTest.java | 79 ++++++++++++-
.../shenyu/web/loader/ShenyuPluginLoaderTest.java | 75 +++++++++++--
.../org/apache/shenyu/web/logo/ShenyuLogoTest.java | 1 +
23 files changed, 779 insertions(+), 55 deletions(-)
diff --git
a/shenyu-client/shenyu-client-tars/src/test/java/org/apache/shenyu/client/tars/TarsServiceBeanPostProcessorTest.java
b/shenyu-client/shenyu-client-tars/src/test/java/org/apache/shenyu/client/tars/TarsServiceBeanPostProcessorTest.java
index d4055cd7d..17bc19052 100644
---
a/shenyu-client/shenyu-client-tars/src/test/java/org/apache/shenyu/client/tars/TarsServiceBeanPostProcessorTest.java
+++
b/shenyu-client/shenyu-client-tars/src/test/java/org/apache/shenyu/client/tars/TarsServiceBeanPostProcessorTest.java
@@ -61,6 +61,8 @@ public final class TarsServiceBeanPostProcessorTest {
private final TarsDemoService2 tarsDemoService2 = new TarsDemoService2();
+ private final TarsDemoService3 tarsDemoService3 = new TarsDemoService3();
+
@Mock
private ApplicationContext applicationContext;
@@ -71,6 +73,7 @@ public final class TarsServiceBeanPostProcessorTest {
Map<String, Object> results = new LinkedHashMap();
results.put("tarsDemoService", tarsDemoService);
results.put("tarsDemoService2", tarsDemoService2);
+ results.put("tarsDemoService3", tarsDemoService3);
when(applicationContext.getBeansWithAnnotation(any())).thenReturn(results);
contextRefreshedEvent = new ContextRefreshedEvent(applicationContext);
@@ -136,4 +139,12 @@ public final class TarsServiceBeanPostProcessorTest {
return hello + "";
}
}
+
+ @ShenyuTarsService(serviceName = "testObj3")
+ @ShenyuTarsClient
+ static class TarsDemoService3 {
+ public String test(final String hello) {
+ return hello + "";
+ }
+ }
}
diff --git
a/shenyu-loadbalancer/src/main/java/org/apache/shenyu/loadbalancer/factory/LoadBalancerFactory.java
b/shenyu-loadbalancer/src/main/java/org/apache/shenyu/loadbalancer/factory/LoadBalancerFactory.java
index 2e7f21a50..bf1acd88c 100644
---
a/shenyu-loadbalancer/src/main/java/org/apache/shenyu/loadbalancer/factory/LoadBalancerFactory.java
+++
b/shenyu-loadbalancer/src/main/java/org/apache/shenyu/loadbalancer/factory/LoadBalancerFactory.java
@@ -25,7 +25,10 @@ import org.apache.shenyu.spi.ExtensionLoader;
/**
* The type Load balance Factory.
*/
-public class LoadBalancerFactory {
+public final class LoadBalancerFactory {
+
+ private LoadBalancerFactory() {
+ }
/**
* Selector upstream.
diff --git
a/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/cache/UpstreamCacheManagerTest.java
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/cache/UpstreamCacheManagerTest.java
new file mode 100644
index 000000000..051f3b773
--- /dev/null
+++
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/cache/UpstreamCacheManagerTest.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shenyu.loadbalancer.cache;
+
+import org.apache.shenyu.common.config.ShenyuConfig;
+import org.apache.shenyu.common.utils.Singleton;
+import org.apache.shenyu.loadbalancer.entity.Upstream;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Assertions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * The type UpstreamCacheManager check task test.
+ */
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+public class UpstreamCacheManagerTest {
+
+ private static final String SELECTOR_ID = "SELECTOR_ID";
+
+ @Test
+ @Order(1)
+ public void initUpstreamCacheManagerTest() throws InterruptedException {
+ final ShenyuConfig shenyuConfig = new ShenyuConfig();
+ shenyuConfig.getUpstreamCheck().setEnabled(true);
+ shenyuConfig.getUpstreamCheck().setPrintEnabled(true);
+ shenyuConfig.getUpstreamCheck().setPrintInterval(1);
+ Singleton.INST.single(ShenyuConfig.class, shenyuConfig);
+ Assertions.assertNotNull(UpstreamCacheManager.getInstance());
+ Thread.sleep(3);
+ }
+
+ @Test
+ @Order(2)
+ public void submitTest() {
+ final UpstreamCacheManager upstreamCacheManager =
UpstreamCacheManager.getInstance();
+ List<Upstream> upstreamList = new ArrayList<>(2);
+ upstreamCacheManager.submit(SELECTOR_ID, upstreamList);
+ upstreamList.add(Upstream.builder().url("url").status(true).build());
+ upstreamList.add(Upstream.builder().status(true).build());
+ upstreamCacheManager.submit(SELECTOR_ID, upstreamList);
+ // hit `existUpstream.stream().filter`
+ upstreamList.clear();
+ upstreamList.add(Upstream.builder().url("url2").status(true).build());
+ upstreamList.add(Upstream.builder().url("url").status(true).build());
+ upstreamCacheManager.submit(SELECTOR_ID, upstreamList);
+ }
+
+ @Test
+ @Order(3)
+ public void removeByKeyTest() {
+ final UpstreamCacheManager upstreamCacheManager =
UpstreamCacheManager.getInstance();
+ upstreamCacheManager.removeByKey(SELECTOR_ID);
+ }
+
+ @Test
+ @Order(4)
+ public void findUpstreamListBySelectorIdTest() {
+ final UpstreamCacheManager upstreamCacheManager =
UpstreamCacheManager.getInstance();
+
Assertions.assertNull(upstreamCacheManager.findUpstreamListBySelectorId(SELECTOR_ID));
+ }
+}
diff --git
a/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/cache/UpstreamCheckTaskTest.java
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/cache/UpstreamCheckTaskTest.java
index 51c0a21cd..0c0bf9e12 100644
---
a/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/cache/UpstreamCheckTaskTest.java
+++
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/cache/UpstreamCheckTaskTest.java
@@ -89,6 +89,7 @@ public class UpstreamCheckTaskTest {
healthCheckTask.run();
Awaitility.await().pollDelay(1, TimeUnit.SECONDS).untilAsserted(() ->
assertFalse(healthCheckTask.getCheckStarted().get()));
assertTrue(healthCheckTask.getHealthyUpstream().get(selectorId1).size() > 0);
+ healthCheckTask.print();
}
/**
diff --git
a/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/cache/UpstreamWithSelectorIdTest.java
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/cache/UpstreamWithSelectorIdTest.java
new file mode 100644
index 000000000..794026550
--- /dev/null
+++
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/cache/UpstreamWithSelectorIdTest.java
@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shenyu.loadbalancer.cache;
+
+import org.apache.shenyu.loadbalancer.entity.Upstream;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * The type UpstreamWithSelectorId check task test.
+ */
+public class UpstreamWithSelectorIdTest {
+
+ private static final String SELECTOR_ID = "selectorId";
+
+ @Test
+ public void initUpstreamCacheManagerTest() {
+ final UpstreamWithSelectorId upstream = new
UpstreamWithSelectorId(SELECTOR_ID, null);
+ Assertions.assertEquals(upstream, upstream);
+ final UpstreamWithSelectorId upstream2 = new
UpstreamWithSelectorId(SELECTOR_ID, null);
+ Assertions.assertEquals(upstream, upstream2);
+ upstream.setUpstream(null);
+ upstream.setSelectorId(null);
+ Assertions.assertTrue(upstream.hashCode() >= 0);
+ Assertions.assertNotNull(upstream.toString());
+ Assertions.assertNotEquals(upstream, upstream2);
+ Assertions.assertNotEquals(upstream, null);
+ Assertions.assertNotEquals(upstream, SELECTOR_ID);
+ final UpstreamWithSelectorId upstream3 = new
UpstreamWithSelectorId(SELECTOR_ID, Upstream.builder().build());
+ Assertions.assertNotEquals(upstream, upstream3);
+ final UpstreamWithSelectorId upstream4 = new
UpstreamWithSelectorId(null, Upstream.builder().build());
+ Assertions.assertNotEquals(upstream, upstream4);
+ }
+}
diff --git
a/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/entity/UpstreamTest.java
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/entity/UpstreamTest.java
new file mode 100644
index 000000000..f9fa0ef39
--- /dev/null
+++
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/entity/UpstreamTest.java
@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shenyu.loadbalancer.entity;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * The type Upstream check task test.
+ */
+public class UpstreamTest {
+
+ @Test
+ public void upstreamTest() {
+ Upstream upstream = Upstream.builder()
+ .group("group")
+ .url("url")
+ .timestamp(1)
+ .warmup(1)
+ .version("version")
+ .weight(1)
+ .status(true)
+ .build();
+ upstream.setGroup("group");
+ upstream.setHealthy(true);
+ upstream.setUrl("url");
+ upstream.setLastHealthTimestamp(1L);
+ upstream.setStatus(true);
+ upstream.setLastUnhealthyTimestamp(1L);
+ upstream.setVersion("version");
+ Assertions.assertEquals(upstream.buildDomain(), "http://url";);
+ Assertions.assertEquals(upstream.getGroup(), "group");
+ Assertions.assertNull(upstream.getProtocol());
+ Assertions.assertEquals(upstream.getLastHealthTimestamp(), 1L);
+ Assertions.assertEquals(upstream.getLastUnhealthyTimestamp(), 1L);
+ Assertions.assertEquals(upstream.getUrl(), "url");
+ Assertions.assertEquals(upstream.getWarmup(), 1);
+ Assertions.assertEquals(upstream.getWeight(), 1);
+ Assertions.assertEquals(upstream.getVersion(), "version");
+ Assertions.assertEquals(upstream.getTimestamp(), 1);
+ Assertions.assertTrue(upstream.isHealthy());
+ Assertions.assertTrue(upstream.isStatus());
+ Upstream upstream2 = Upstream.builder()
+ .protocol("https://";)
+ .url("url")
+ .weight(1)
+ .status(true)
+ .build();
+ Assertions.assertEquals(upstream2.buildDomain(), "https://url";);
+ Assertions.assertNotEquals(upstream, upstream2);
+ Assertions.assertNotEquals(upstream, null);
+ Assertions.assertNotEquals(upstream, "");
+ Assertions.assertEquals(upstream, upstream);
+ Upstream upstream3 = Upstream.builder()
+ .protocol("https://";)
+ .url("url")
+ .weight(1)
+ .status(true)
+ .build();
+ Assertions.assertEquals(upstream2, upstream3);
+ Assertions.assertNotNull(upstream2.toString());
+ Assertions.assertTrue(upstream2.hashCode() >= 0);
+ }
+}
diff --git
a/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/HashLoadBalanceTest.java
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/HashLoadBalanceTest.java
index 9fd1345f1..bd85b7a4a 100644
---
a/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/HashLoadBalanceTest.java
+++
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/HashLoadBalanceTest.java
@@ -18,10 +18,15 @@
package org.apache.shenyu.loadbalancer.spi;
import org.apache.shenyu.loadbalancer.entity.Upstream;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
import java.util.List;
import java.util.SortedMap;
import java.util.concurrent.ConcurrentSkipListMap;
@@ -29,6 +34,8 @@ import java.util.stream.Collectors;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.mockStatic;
/**
* The type Hash balance test.
@@ -37,6 +44,8 @@ public final class HashLoadBalanceTest {
private Method hash;
+ private List<Upstream> onlyOneList;
+
private List<Upstream> hashLoadBalancesOrdered;
private List<Upstream> hashLoadBalancesDisordered;
@@ -53,6 +62,12 @@ public final class HashLoadBalanceTest {
public void setUp() throws Exception {
this.hash = HashLoadBalancer.class.getDeclaredMethod("hash",
String.class);
this.hash.setAccessible(true);
+ this.onlyOneList = Stream.of(1)
+ .map(weight -> Upstream.builder()
+ .url("upstream-" + weight)
+ .status(false)
+ .build())
+ .collect(Collectors.toList());
this.hashLoadBalancesOrdered = Stream.of(1, 2, 3)
.map(weight -> Upstream.builder()
.url("upstream-" + weight)
@@ -94,6 +109,46 @@ public final class HashLoadBalanceTest {
}
}
+ /**
+ * Hash load balance test.
+ */
+ @Test
+ public void onlyOneListTest() {
+ final String ip = "127.0.0.1";
+ final HashLoadBalancer hashLoadBalance = new HashLoadBalancer();
+ Assertions.assertNotNull(hashLoadBalance.select(onlyOneList, ip));
+
Assertions.assertEquals(hashLoadBalance.getWeight(Upstream.builder().status(false).build()),
0);
+ Assertions.assertEquals(hashLoadBalance.getWeight(Upstream.builder()
+ .timestamp(System.currentTimeMillis() - 3L)
+ .warmup(4)
+ .weight(1)
+ .build()), 1);
+ Assertions.assertEquals(hashLoadBalance.getWeight(Upstream.builder()
+ .timestamp(System.currentTimeMillis() + 3L)
+ .warmup(4)
+ .weight(1)
+ .build()), 1);
+ Assertions.assertEquals(hashLoadBalance.getWeight(Upstream.builder()
+ .timestamp(System.currentTimeMillis() - 3L)
+ .warmup(4)
+ .weight(4)
+ .build()), 3);
+ Assertions.assertEquals(hashLoadBalance.getWeight(Upstream.builder()
+ .timestamp(System.currentTimeMillis() - 3L)
+ .warmup(1)
+ .weight(1)
+ .build()), 1);
+ Assertions.assertEquals(hashLoadBalance.getWeight(Upstream.builder()
+ .warmup(1)
+ .weight(0)
+ .build()), 0);
+ Assertions.assertEquals(hashLoadBalance.getWeight(Upstream.builder()
+ .warmup(0)
+ .weight(1)
+ .build()), 1);
+
+ }
+
/**
* Hash load balance test.
*/
@@ -101,12 +156,30 @@ public final class HashLoadBalanceTest {
public void hashLoadBalanceOrderedWeightTest() throws Exception {
final String ip = "127.0.0.1";
final HashLoadBalancer hashLoadBalance = new HashLoadBalancer();
+ Assertions.assertNull(hashLoadBalance.select(null, ip));
final Upstream upstream =
hashLoadBalance.select(hashLoadBalancesOrdered, ip);
final Long hashKey = Long.parseLong(hash.invoke(null, ip).toString());
final SortedMap<Long, Upstream> lastRing =
treeMapOrdered.tailMap(hashKey);
final Upstream assertUp = lastRing.get(lastRing.firstKey());
assertEquals(assertUp.getUrl(), upstream.getUrl());
+ }
+ @Test
+ public void selectTest() {
+ final String ip = "SHENYU-upstream-2-HASH-100";
+ final HashLoadBalancer hashLoadBalance = new HashLoadBalancer();
+ Assertions.assertNull(hashLoadBalance.select(null, ip));
+ final Upstream upstream =
hashLoadBalance.select(hashLoadBalancesOrdered, ip);
+ assertEquals(treeMapOrdered.firstEntry().getValue().getUrl(),
upstream.getUrl());
+ }
+
+ @Test
+ public void hashErrorTest() throws NoSuchAlgorithmException {
+ final String ip = "127.0.0.1";
+ MockedStatic<MessageDigest> messageDigestMockedStatic =
mockStatic(MessageDigest.class);
+ messageDigestMockedStatic.when((MockedStatic.Verification)
MessageDigest.getInstance("MD5")).thenThrow(NoSuchAlgorithmException.class);
+ assertThrows(InvocationTargetException.class, () -> hash.invoke(null,
ip));
+ messageDigestMockedStatic.close();
}
@Test
diff --git
a/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/RandomLoadBalanceTest.java
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/RandomLoadBalancerTest.java
similarity index 60%
rename from
shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/RandomLoadBalanceTest.java
rename to
shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/RandomLoadBalancerTest.java
index 8ef15e4e7..b6c8ad979 100644
---
a/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/RandomLoadBalanceTest.java
+++
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/RandomLoadBalancerTest.java
@@ -18,10 +18,8 @@
package org.apache.shenyu.loadbalancer.spi;
import org.apache.shenyu.loadbalancer.entity.Upstream;
-import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@@ -30,36 +28,28 @@ import static
org.junit.jupiter.api.Assertions.assertNotNull;
/**
* The type random balance test.
*/
-public class RandomLoadBalanceTest {
+public class RandomLoadBalancerTest {
- private List<Upstream> randomLoadBalancesWeightDisordered;
-
- private List<Upstream> randomLoadBalancesWeightOrdered;
-
- private List<Upstream> randomLoadBalancesWeightReversed;
-
- @BeforeEach
- public void setUp() {
- this.randomLoadBalancesWeightDisordered = Stream.of(10, 50, 40)
- .map(weight -> Upstream.builder()
- .url("upstream-" + weight)
- .weight(weight)
- .build())
- .collect(Collectors.toList());
-
- this.randomLoadBalancesWeightOrdered = Stream.of(10, 40, 50)
+ @Test
+ public void randomLoadBalancesWeightEqualTest() {
+ final Upstream upstreamOrdered = new
RandomLoadBalancer().select(Stream.of(10, 10, 10)
.map(weight -> Upstream.builder()
.url("upstream-" + weight)
.weight(weight)
.build())
- .collect(Collectors.toList());
+ .collect(Collectors.toList()), "");
+ assertNotNull(upstreamOrdered);
+ }
- this.randomLoadBalancesWeightReversed = Stream.of(50, 40, 10)
+ @Test
+ public void randomLoadBalancesWeightZeroTest() {
+ final Upstream upstreamOrdered = new
RandomLoadBalancer().select(Stream.of(0, 0, 0)
.map(weight -> Upstream.builder()
.url("upstream-" + weight)
.weight(weight)
.build())
- .collect(Collectors.toList());
+ .collect(Collectors.toList()), "");
+ assertNotNull(upstreamOrdered);
}
/**
@@ -67,22 +57,34 @@ public class RandomLoadBalanceTest {
*/
@Test
public void randomLoadBalanceOrderedWeightTest() {
- final RandomLoadBalancer randomLoadBalancer = new RandomLoadBalancer();
- final Upstream upstreamOrdered =
randomLoadBalancer.select(randomLoadBalancesWeightOrdered, "");
+ final Upstream upstreamOrdered = new
RandomLoadBalancer().select(Stream.of(10, 40, 50)
+ .map(weight -> Upstream.builder()
+ .url("upstream-" + weight)
+ .weight(weight)
+ .build())
+ .collect(Collectors.toList()), "");
assertNotNull(upstreamOrdered);
}
@Test
public void randomLoadBalanceDisOrderedWeightTest() {
- final RandomLoadBalancer randomLoadBalancer = new RandomLoadBalancer();
- final Upstream upstreamDisordered =
randomLoadBalancer.select(randomLoadBalancesWeightDisordered, "");
+ final Upstream upstreamDisordered = new
RandomLoadBalancer().select(Stream.of(10, 50, 40)
+ .map(weight -> Upstream.builder()
+ .url("upstream-" + weight)
+ .weight(weight)
+ .build())
+ .collect(Collectors.toList()), "");
assertNotNull(upstreamDisordered);
}
@Test
public void randomLoadBalanceReversedWeightTest() {
- final RandomLoadBalancer randomLoadBalancer = new RandomLoadBalancer();
- final Upstream upstreamReversed =
randomLoadBalancer.select(randomLoadBalancesWeightReversed, "");
+ final Upstream upstreamReversed = new
RandomLoadBalancer().select(Stream.of(50, 40, 10)
+ .map(weight -> Upstream.builder()
+ .url("upstream-" + weight)
+ .weight(weight)
+ .build())
+ .collect(Collectors.toList()), "");
assertNotNull(upstreamReversed);
}
}
diff --git
a/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/RoundRobinLoadBalanceTest.java
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/RoundRobinLoadBalanceTest.java
index 1ac8571a8..01af4dd61 100644
---
a/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/RoundRobinLoadBalanceTest.java
+++
b/shenyu-loadbalancer/src/test/java/org/apache/shenyu/loadbalancer/spi/RoundRobinLoadBalanceTest.java
@@ -96,4 +96,26 @@ public final class RoundRobinLoadBalanceTest {
});
assertEquals(60, countMap.get("upstream-50").intValue());
}
+
+ @Test
+ public void roundRobinLoadBalanceTest() {
+ List<Upstream> upstreamList =
+ Stream.of(50, 30, 20)
+ .map(weight -> Upstream.builder()
+ .url("upstream-" + weight)
+ .weight(weight)
+ .build())
+ .collect(Collectors.toList());
+ List<Upstream> upstreamList2 =
+ Stream.of(50, 40, 20)
+ .map(weight -> Upstream.builder()
+ .url("upstream-" + weight)
+ .weight(1)
+ .build())
+ .collect(Collectors.toList());
+
+ RoundRobinLoadBalancer roundRobinLoadBalancer = new
RoundRobinLoadBalancer();
+ roundRobinLoadBalancer.select(upstreamList, "");
+ roundRobinLoadBalancer.select(upstreamList2, "");
+ }
}
diff --git
a/shenyu-web/src/main/java/org/apache/shenyu/web/loader/ShenyuPluginPathBuilder.java
b/shenyu-web/src/main/java/org/apache/shenyu/web/loader/ShenyuPluginPathBuilder.java
index 5b7fa32ce..173f2b67e 100644
---
a/shenyu-web/src/main/java/org/apache/shenyu/web/loader/ShenyuPluginPathBuilder.java
+++
b/shenyu-web/src/main/java/org/apache/shenyu/web/loader/ShenyuPluginPathBuilder.java
@@ -27,11 +27,14 @@ import java.util.Optional;
* The type Shenyu plugin path builder.
*/
public final class ShenyuPluginPathBuilder {
-
+
private static final String PLUGIN_PATH = "plugin-ext";
private static final String DEFAULT_EXT_PLUGIN_PATH = "/ext-lib/";
-
+
+ private ShenyuPluginPathBuilder() {
+ }
+
/**
* Gets plugin file.
*
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/configuration/ShenyuThreadPoolConfigurationTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/configuration/ShenyuThreadPoolConfigurationTest.java
index e47b02b96..76e6d2ff4 100644
---
a/shenyu-web/src/test/java/org/apache/shenyu/web/configuration/ShenyuThreadPoolConfigurationTest.java
+++
b/shenyu-web/src/test/java/org/apache/shenyu/web/configuration/ShenyuThreadPoolConfigurationTest.java
@@ -24,6 +24,7 @@ import org.apache.shenyu.common.config.ShenyuConfig;
import org.apache.shenyu.common.constant.Constants;
import org.apache.shenyu.common.exception.ShenyuException;
import org.apache.shenyu.plugin.api.utils.SpringBeanUtils;
+import org.apache.shenyu.web.controller.TestObjectProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.ObjectProvider;
@@ -35,7 +36,6 @@ import org.springframework.context.event.ContextClosedEvent;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -87,8 +87,9 @@ public class ShenyuThreadPoolConfigurationTest {
when(sharedPool.getMaximumPoolSize()).thenReturn(1);
when(sharedPool.getKeepAliveTime()).thenReturn(60L);
when(sharedPool.getPrefix()).thenReturn("TEST-");
- when(objectProvider.getIfAvailable(any())).thenReturn(new
MemorySafeTaskQueue<>(Constants.THE_256_MB));
-
assertNotNull(shenyuThreadPoolConfiguration.shenyuThreadPoolExecutor(shenyuConfig,
objectProvider));
+ when(objectProvider.getIfAvailable()).thenReturn(null);
+
assertNotNull(shenyuThreadPoolConfiguration.shenyuThreadPoolExecutor(shenyuConfig,
new TestObjectProvider<>(null)));
+
assertNotNull(shenyuThreadPoolConfiguration.shenyuThreadPoolExecutor(shenyuConfig,
new TestObjectProvider<>(new MemorySafeTaskQueue<>(Constants.THE_256_MB))));
}
@Test
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/controller/LocalPluginControllerTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/controller/LocalPluginControllerTest.java
index 435c639f8..1c6820a4c 100644
---
a/shenyu-web/src/test/java/org/apache/shenyu/web/controller/LocalPluginControllerTest.java
+++
b/shenyu-web/src/test/java/org/apache/shenyu/web/controller/LocalPluginControllerTest.java
@@ -52,6 +52,8 @@ import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
@@ -60,6 +62,7 @@ import java.util.stream.Collectors;
import java.util.stream.Stream;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
import static
org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@@ -126,7 +129,6 @@ public final class LocalPluginControllerTest {
@Test
public void testCleanPlugin() throws Exception {
final String testCleanPluginName = "testCleanPluginName";
- final String testCleanRuleName = "testCleanRuleName";
subscribePluginForTest(testCleanPluginName);
subscribeSelectorForTest(testCleanPluginName);
final MockHttpServletResponse response =
this.mockMvc.perform(MockMvcRequestBuilders.get("/shenyu/cleanPlugin")
@@ -191,6 +193,28 @@ public final class LocalPluginControllerTest {
final List<String> ruleIds =
list.stream().map(RuleData::getId).collect(Collectors.toList());
assertThat(ruleSelectorIds).contains(testSelectorId);
assertThat(ruleIds).contains(testId);
+
+ final Object result2 = this.mockMvc
+
.perform(MockMvcRequestBuilders.get("/shenyu/plugin/rule/findList")
+ .param("selectorId", testSelectorId))
+ .andExpect(status().isOk())
+ .andReturn()
+ .getAsyncResult();
+ assertThat(result).isInstanceOf(String.class);
+ @SuppressWarnings("UnstableApiUsage")
+ final List<RuleData> list2 = GsonUtils.getGson().fromJson((String)
result2, new TypeToken<List<RuleData>>() {
+ }.getType());
+ final List<String> ruleSelectorIds2 =
list2.stream().map(RuleData::getSelectorId).collect(Collectors.toList());
+ assertThat(ruleSelectorIds2).contains(testSelectorId);
+
+ final Object resultError = this.mockMvc
+
.perform(MockMvcRequestBuilders.get("/shenyu/plugin/rule/findList")
+ .param("selectorId", "testSelectorIdError")
+ .param("id", testId))
+ .andExpect(status().isOk())
+ .andReturn()
+ .getAsyncResult();
+ assertThat(resultError).isEqualTo("Error: can not find rule data by
selector id :testSelectorIdError");
}
@Test
@@ -213,8 +237,10 @@ public final class LocalPluginControllerTest {
@Test
public void testFindListSelector() throws Exception {
final String selectorPluginName = "testFindListSelector";
+ final String testFindListSelectorId = "testFindListSelectorId";
final SelectorData selectorData = new SelectorData();
selectorData.setPluginName(selectorPluginName);
+ selectorData.setId(testFindListSelectorId);
subscriber.onSelectorSubscribe(selectorData);
final Object result = this.mockMvc
.perform(MockMvcRequestBuilders.get("/shenyu/plugin/selector/findList")
@@ -228,6 +254,26 @@ public final class LocalPluginControllerTest {
}.getType());
final List<String> idList =
list.stream().map(SelectorData::getPluginName).collect(Collectors.toList());
assertThat(idList).contains(selectorPluginName);
+
+ final Object resultError1 = this.mockMvc
+
.perform(MockMvcRequestBuilders.get("/shenyu/plugin/selector/findList")
+ .param("pluginName", "testFindListSelectorError"))
+ .andExpect(status().isOk())
+ .andReturn()
+ .getAsyncResult();
+ assertThat(resultError1).isEqualTo("Error: can not find selector data
by pluginName :testFindListSelectorError");
+
+ final Object result2 = this.mockMvc
+
.perform(MockMvcRequestBuilders.get("/shenyu/plugin/selector/findList")
+ .param("id", "testFindListSelectorId")
+ .param("pluginName", selectorPluginName))
+ .andExpect(status().isOk())
+ .andReturn()
+ .getAsyncResult();
+ final List<SelectorData> list2 = GsonUtils.getGson().fromJson((String)
result2, new TypeToken<List<SelectorData>>() {
+ }.getType());
+ final List<String> selectorDataIds =
list2.stream().map(SelectorData::getId).collect(Collectors.toList());
+ assertThat(selectorDataIds).contains(testFindListSelectorId);
}
@Test
@@ -243,6 +289,14 @@ public final class LocalPluginControllerTest {
assertThat(result).isInstanceOf(String.class);
final PluginData pluginData = GsonUtils.getGson().fromJson((String)
result, PluginData.class);
assertThat(pluginData.getName()).isEqualTo(pluginName);
+
+ final Object resultErr = this.mockMvc
+
.perform(MockMvcRequestBuilders.get("/shenyu/plugin/findByName")
+ .param("name", "testFindByNamePluginError"))
+ .andExpect(status().isOk())
+ .andReturn()
+ .getAsyncResult();
+ assertThat(resultErr).isEqualTo("can not find this plugin :
testFindByNamePluginError");
}
@Test
@@ -258,6 +312,19 @@ public final class LocalPluginControllerTest {
.andExpect(status().isOk())
.andReturn();
assertThat(baseDataCache.obtainSelectorData(selectorPluginName)).isNotNull();
+
+ final String selectorPluginNameError = "testSaveSelectorError";
+ final SelectorData selectorDataError = new SelectorData();
+ selectorData.setPluginName(selectorPluginNameError);
+ final String jsonError = GsonUtils.getGson().toJson(selectorDataError);
+ final Object resultErr = this.mockMvc
+
.perform(MockMvcRequestBuilders.post("/shenyu/plugin/selector/saveOrUpdate")
+ .content(jsonError)
+ .contentType(MediaType.APPLICATION_JSON))
+ .andExpect(status().isOk())
+ .andReturn()
+ .getAsyncResult();
+ assertThat(resultErr).isEqualTo("Error: please add pluginName!");
}
@Test
@@ -288,6 +355,35 @@ public final class LocalPluginControllerTest {
final List<RuleData> selectorId =
baseDataCache.obtainRuleData(testSelectorId);
assertThat(selectorId.get(0).getSelectorId()).isEqualTo(testSelectorId);
+
+ Object result = this.mockMvc
+
.perform(MockMvcRequestBuilders.post("/shenyu/plugin/rule/saveOrUpdate")
+ .content("{}")
+ .contentType(MediaType.APPLICATION_JSON))
+ .andExpect(status().isOk())
+ .andReturn()
+ .getAsyncResult();
+ assertThat(result).isEqualTo("Error: please add selectorId!");
+ }
+
+ @Test
+ public void testDeleteRule() throws Exception {
+ final String testSelectorId = "testSaveRuleId";
+ final String testRuleId = "ruleId";
+ final String pluginName = "pluginName";
+ final RuleData ruleData = createRuleData(testSelectorId, testRuleId);
+ subscriber.onRuleSubscribe(ruleData);
+ this.mockMvc
+
.perform(MockMvcRequestBuilders.get("/shenyu/plugin/rule/delete")
+ .param("selectorId", ruleData.getSelectorId())
+ .param("id", ruleData.getId())
+ .param("pluginName", pluginName)
+ .contentType(MediaType.APPLICATION_JSON))
+ .andExpect(status().isOk())
+ .andReturn();
+
+ final List<RuleData> selectorId =
baseDataCache.obtainRuleData(testSelectorId);
+ Assertions.assertTrue(selectorId.isEmpty());
}
@Test
@@ -311,6 +407,7 @@ public final class LocalPluginControllerTest {
.andExpect(status().isOk())
.andReturn();
Assertions.assertNotNull(baseDataCache.obtainSelectorData(selectorRulesData.getPluginName()));
+ Assertions.assertEquals(selectorRulesData.getSelectorName(),
"selectorName");
}
private void subscribeRuleForTest(final String testSelectorId, final
String testId) {
@@ -349,6 +446,7 @@ public final class LocalPluginControllerTest {
SelectorRuleData selectorRuleData = new SelectorRuleData();
selectorRuleData.setPluginName(PluginEnum.DIVIDE.getName());
selectorRuleData.setSelectorHandler(JsonUtils.toJson(collect));
+ selectorRuleData.setSelectorName("selectorName");
List<ConditionData> dataList = Stream.of(1).map(weight -> {
ConditionData data = new ConditionData();
data.setParamType(ParamTypeEnum.URI.getName());
@@ -360,5 +458,27 @@ public final class LocalPluginControllerTest {
DivideRuleHandle divideRuleHandle = new DivideRuleHandle();
divideRuleHandle.setLoadBalance(LoadBalanceEnum.RANDOM.getName());
selectorRuleData.setRuleHandler(JsonUtils.toJson(divideRuleHandle));
+ Assertions.assertEquals(selectorRuleData.getSelectorName(),
"selectorName");
+ }
+
+ @Test
+ public void testBuildDefaultSelectorData() throws NoSuchMethodException,
InvocationTargetException, IllegalAccessException {
+ Method buildDefaultSelectorData =
LocalPluginController.class.getDeclaredMethod("buildDefaultSelectorData",
SelectorData.class);
+ buildDefaultSelectorData.setAccessible(true);
+ LocalPluginController localPluginController =
mock(LocalPluginController.class);
+ SelectorData selectorData =
SelectorData.builder().id("id").name("name").sort(1)
+ .enabled(true)
+ .logged(true)
+ .build();
+ buildDefaultSelectorData.invoke(localPluginController, selectorData);
+ }
+
+ @Test
+ public void testBuildDefaultRuleData() throws NoSuchMethodException,
InvocationTargetException, IllegalAccessException {
+ Method buildDefaultRuleData =
LocalPluginController.class.getDeclaredMethod("buildDefaultRuleData",
RuleData.class);
+ buildDefaultRuleData.setAccessible(true);
+ LocalPluginController localPluginController =
mock(LocalPluginController.class);
+
+ buildDefaultRuleData.invoke(localPluginController,
RuleData.builder().sort(1).enabled(true).loged(true).build());
}
}
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/filter/CrossFilterTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/filter/CrossFilterTest.java
index 960886867..df153019b 100644
--- a/shenyu-web/src/test/java/org/apache/shenyu/web/filter/CrossFilterTest.java
+++ b/shenyu-web/src/test/java/org/apache/shenyu/web/filter/CrossFilterTest.java
@@ -20,6 +20,8 @@ package org.apache.shenyu.web.filter;
import org.apache.shenyu.common.config.ShenyuConfig.CrossFilterConfig;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.mock.http.server.reactive.MockServerHttpRequest;
import org.springframework.mock.web.server.MockServerWebExchange;
import org.springframework.web.server.ServerWebExchange;
@@ -83,7 +85,7 @@ public final class CrossFilterTest {
public void testCorsWhitelist() {
ServerWebExchange exchange =
MockServerWebExchange.from(MockServerHttpRequest
.get("http://localhost:8080";)
- .header("Origin", "a.apache.org")
+ .header("Origin", "http://a.apache.org";)
.build());
WebFilterChain chainNormal = mock(WebFilterChain.class);
when(chainNormal.filter(exchange)).thenReturn(Mono.empty());
@@ -108,11 +110,55 @@ public final class CrossFilterTest {
StepVerifier.create(filter.filter(exchange, chainNormal))
.expectSubscription()
.verifyComplete();
+ allowedOriginConfig.setOrigins(new HashSet<String>() {
+ {
+ add("a.apache.org");
+ }
+ });
+ StepVerifier.create(new CrossFilter(filterConfig).filter(exchange,
chainNormal))
+ .expectSubscription()
+ .verifyComplete();
+
+ filterConfig.setAllowedAnyOrigin(true);
+ StepVerifier.create(new CrossFilter(filterConfig).filter(exchange,
chainNormal))
+ .expectSubscription()
+ .verifyComplete();
+ filterConfig.setAllowedOrigin(null);
+ StepVerifier.create(new CrossFilter(filterConfig).filter(exchange,
chainNormal))
+ .expectSubscription()
+ .verifyComplete();
+
+ filterConfig.setAllowedAnyOrigin(false);
+ allowedOriginConfig.setOrigins(new HashSet<String>() {
+ {
+ add("*");
+ }
+ });
+ allowedOriginConfig.setPrefixes(null);
+ filterConfig.setAllowedOrigin(allowedOriginConfig);
+ StepVerifier.create(new CrossFilter(filterConfig).filter(exchange,
chainNormal))
+ .expectSubscription()
+ .verifyComplete();
}
@Test
public void testOriginRegex() {
+ ServerWebExchange exchange =
MockServerWebExchange.from(MockServerHttpRequest
+ .get("http://localhost:8080";)
+ .header("Origin", "http://abc.com";)
+ .build());
+ ServerHttpResponse exchangeResponse = exchange.getResponse();
+ exchangeResponse.getHeaders().add(HttpHeaders.ACCESS_CONTROL_MAX_AGE,
"0");
+
exchangeResponse.getHeaders().add(HttpHeaders.ACCESS_CONTROL_ALLOW_CREDENTIALS,
"*");
+ WebFilterChain chainNoHeader = mock(WebFilterChain.class);
+ when(chainNoHeader.filter(exchange)).thenReturn(Mono.empty());
+ CrossFilterConfig crossFilterConfig = new CrossFilterConfig();
final String regex = "^http(|s)://(.*\\.|)abc.com$";
+ crossFilterConfig.getAllowedOrigin().setOriginRegex(regex);
+ CrossFilter filterNoHeader = new CrossFilter(crossFilterConfig);
+ StepVerifier.create(filterNoHeader.filter(exchange, chainNoHeader))
+ .expectSubscription()
+ .verifyComplete();
Assertions.assertTrue(Pattern.matches(regex,
"http://console.ada.abc.com";));
Assertions.assertTrue(Pattern.matches(regex,
"http://console.abc.com";));
Assertions.assertTrue(Pattern.matches(regex, "http://abc.com";));
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/filter/ExcludeFilterTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/filter/ExcludeFilterTest.java
index 6587d9145..0bbdf6534 100644
---
a/shenyu-web/src/test/java/org/apache/shenyu/web/filter/ExcludeFilterTest.java
+++
b/shenyu-web/src/test/java/org/apache/shenyu/web/filter/ExcludeFilterTest.java
@@ -72,4 +72,13 @@ public final class ExcludeFilterTest {
StepVerifier.create(filter).expectNext(Boolean.FALSE).verifyComplete();
}
+ @Test
+ public void testDoFilter() {
+ ServerWebExchange webExchange =
+ MockServerWebExchange.from(MockServerHttpRequest
+ .post("http://localhost:8080/";));
+ Mono<Void> filter = excludeFilter.doFilter(webExchange);
+ StepVerifier.create(filter).verifyComplete();
+ }
+
}
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/filter/FallbackFilterTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/filter/FallbackFilterTest.java
index f165632dc..af76f2895 100644
---
a/shenyu-web/src/test/java/org/apache/shenyu/web/filter/FallbackFilterTest.java
+++
b/shenyu-web/src/test/java/org/apache/shenyu/web/filter/FallbackFilterTest.java
@@ -81,4 +81,13 @@ public final class FallbackFilterTest {
StepVerifier.create(filter).expectNext(Boolean.FALSE).verifyComplete();
}
+ @Test
+ public void testDoFilter() {
+ ServerWebExchange webExchange =
+ MockServerWebExchange.from(MockServerHttpRequest
+ .post("http://localhost:8080/";));
+ Mono<Void> filter = fallbackFilter.doFilter(webExchange);
+ StepVerifier.create(filter).verifyComplete();
+ }
+
}
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/filter/FileSizeFilterTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/filter/FileSizeFilterTest.java
index c32320de1..70a6b045f 100644
---
a/shenyu-web/src/test/java/org/apache/shenyu/web/filter/FileSizeFilterTest.java
+++
b/shenyu-web/src/test/java/org/apache/shenyu/web/filter/FileSizeFilterTest.java
@@ -19,11 +19,14 @@ package org.apache.shenyu.web.filter;
import org.apache.shenyu.plugin.api.result.ShenyuResult;
import org.apache.shenyu.plugin.api.utils.SpringBeanUtils;
+import org.apache.shenyu.plugin.base.support.CachedBodyOutputMessage;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.http.MediaType;
import org.springframework.http.server.reactive.ServerHttpRequest;
+import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.mock.http.server.reactive.MockServerHttpRequest;
import org.springframework.mock.web.server.MockServerWebExchange;
import org.springframework.web.server.ServerWebExchange;
@@ -31,6 +34,9 @@ import org.springframework.web.server.WebFilterChain;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -70,8 +76,45 @@ public final class FileSizeFilterTest {
Mono<Void> voidMono = fileSizeFilter.filter(webExchange,
webFilterChain);
StepVerifier.create(voidMono).expectSubscription().verifyComplete();
+ final ServerWebExchange webExchangeTextPlain =
+ MockServerWebExchange.from(MockServerHttpRequest
+ .post("http://localhost:8080";)
+ .contentType(MediaType.TEXT_PLAIN)
+ .contentLength(4)
+ .body("test"));
+ FileSizeFilter fileSizeFilterTextPlain = new FileSizeFilter(10);
+ Mono<Void> voidMonoTextPlain =
fileSizeFilterTextPlain.filter(webExchangeTextPlain, webFilterChain);
+
StepVerifier.create(voidMonoTextPlain).expectSubscription().verifyComplete();
+
fileSizeFilter = new FileSizeFilter(1);
voidMono = fileSizeFilter.filter(webExchange, webFilterChain);
StepVerifier.create(voidMono).expectSubscription().verifyComplete();
+
+ final ServerWebExchange webExchangeError =
+ MockServerWebExchange.from(MockServerHttpRequest
+ .post("http://localhost:8081";)
+ .contentType(MediaType.MULTIPART_FORM_DATA)
+ .body("test"));
+ // hit `size.capacity() > BYTES_PER_MB * fileMaxSize`
+ FileSizeFilter fileSizeFilterError = new FileSizeFilter(-1);
+ Mono<Void> voidMonoError =
fileSizeFilterError.filter(webExchangeError, webFilterChain);
+
StepVerifier.create(voidMonoError).expectSubscription().verifyComplete();
+ }
+
+ @Test
+ public void testDecorate() throws NoSuchMethodException,
InvocationTargetException, IllegalAccessException {
+
+ ServerWebExchange webExchangeTextPlain =
+ MockServerWebExchange.from(MockServerHttpRequest
+ .post("http://localhost:8080";)
+ .contentType(MediaType.TEXT_PLAIN)
+ .contentLength(4)
+ .body("test"));
+ FileSizeFilter fileSizeFilterError = new FileSizeFilter(1);
+ Method declaredMethod =
FileSizeFilter.class.getDeclaredMethod("decorate", ServerWebExchange.class,
CachedBodyOutputMessage.class);
+ CachedBodyOutputMessage cachedBodyOutputMessage =
mock(CachedBodyOutputMessage.class);
+ declaredMethod.setAccessible(true);
+ ServerHttpRequestDecorator decorator = (ServerHttpRequestDecorator)
declaredMethod.invoke(fileSizeFilterError, webExchangeTextPlain,
cachedBodyOutputMessage);
+ Assertions.assertEquals(decorator.getBody(),
cachedBodyOutputMessage.getBody());
}
}
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/filter/HealthFilterTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/filter/HealthFilterTest.java
index 5e6b95a14..d5fc156e2 100644
---
a/shenyu-web/src/test/java/org/apache/shenyu/web/filter/HealthFilterTest.java
+++
b/shenyu-web/src/test/java/org/apache/shenyu/web/filter/HealthFilterTest.java
@@ -66,6 +66,12 @@ public final class HealthFilterTest {
StepVerifier.create(filter).expectNext(Boolean.TRUE).verifyComplete();
}
+ @Test
+ public void testPathNull() {
+ List<String> paths = new ArrayList<>();
+ new HealthFilter(paths);
+ }
+
@Test
public void testDoNotMatcher() {
ServerWebExchange webExchange =
@@ -75,4 +81,13 @@ public final class HealthFilterTest {
StepVerifier.create(filter).expectNext(Boolean.FALSE).verifyComplete();
}
+ @Test
+ public void testDoFilter() {
+ ServerWebExchange webExchange =
+ MockServerWebExchange.from(MockServerHttpRequest
+ .post("http://localhost:8080/";));
+ Mono<Void> filter = healthFilter.doFilter(webExchange);
+ StepVerifier.create(filter).verifyComplete();
+ }
+
}
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/forward/ForwardedRemoteAddressResolverTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/forward/ForwardedRemoteAddressResolverTest.java
index 27077d82d..d790d6712 100644
---
a/shenyu-web/src/test/java/org/apache/shenyu/web/forward/ForwardedRemoteAddressResolverTest.java
+++
b/shenyu-web/src/test/java/org/apache/shenyu/web/forward/ForwardedRemoteAddressResolverTest.java
@@ -20,12 +20,19 @@ package org.apache.shenyu.web.forward;
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.server.reactive.ServerHttpRequest;
import org.springframework.mock.http.server.reactive.MockServerHttpRequest;
import org.springframework.mock.web.server.MockServerWebExchange;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.web.server.ServerWebExchange;
+import java.util.Collections;
+
+import static
org.apache.shenyu.web.forward.ForwardedRemoteAddressResolver.X_FORWARDED_FOR;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
/**
* Test cases for ForwardedRemoteAddressResolver.
@@ -74,6 +81,14 @@ public final class ForwardedRemoteAddressResolverTest {
instance.resolve(forwardExchange);
instance.resolve(multiForwardExchangeError);
instance.resolve(multiForwardExchange);
+
+ ServerWebExchange headerEmptyExchange = mock(ServerWebExchange.class);
+ ServerHttpRequest headerEmptyServerHttpRequest =
mock(ServerHttpRequest.class);
+ HttpHeaders headerEmptyHttpHeaders = mock(HttpHeaders.class);
+
when(headerEmptyExchange.getRequest()).thenReturn(headerEmptyServerHttpRequest);
+
when(headerEmptyServerHttpRequest.getHeaders()).thenReturn(headerEmptyHttpHeaders);
+
when(headerEmptyHttpHeaders.get(X_FORWARDED_FOR)).thenReturn(Collections.emptyList());
+ instance.resolve(headerEmptyExchange);
}
}
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/handler/GlobalErrorHandlerTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/handler/GlobalErrorHandlerTest.java
index 80f44c225..31d5f9a7b 100644
---
a/shenyu-web/src/test/java/org/apache/shenyu/web/handler/GlobalErrorHandlerTest.java
+++
b/shenyu-web/src/test/java/org/apache/shenyu/web/handler/GlobalErrorHandlerTest.java
@@ -30,8 +30,10 @@ import org.mockito.junit.jupiter.MockitoExtension;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.http.HttpStatus;
import org.springframework.mock.http.server.reactive.MockServerHttpRequest;
import org.springframework.mock.web.server.MockServerWebExchange;
+import org.springframework.web.server.ResponseStatusException;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
@@ -85,5 +87,6 @@ public final class GlobalErrorHandlerTest {
NullPointerException nullPointerException = new
NullPointerException("nullPointerException");
Mono<Void> response = globalErrorHandler.handle(webExchange,
nullPointerException);
assertNotNull(response);
+ assertNotNull(globalErrorHandler.handle(webExchange, new
ResponseStatusException(HttpStatus.BAD_REQUEST)));
}
}
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/handler/ShenyuWebHandlerTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/handler/ShenyuWebHandlerTest.java
index d57291961..1cfe2ba7d 100644
---
a/shenyu-web/src/test/java/org/apache/shenyu/web/handler/ShenyuWebHandlerTest.java
+++
b/shenyu-web/src/test/java/org/apache/shenyu/web/handler/ShenyuWebHandlerTest.java
@@ -36,6 +36,7 @@ import
org.springframework.mock.web.server.MockServerWebExchange;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
import java.net.InetSocketAddress;
import java.util.ArrayList;
@@ -78,7 +79,7 @@ public final class ShenyuWebHandlerTest {
exchange.getAttributes().put(Constants.CONTEXT,
mock(ShenyuContext.class));
exchange.getAttributes().put(Constants.PARAM_TRANSFORM, "{key:value}");
Mono<Void> handle = shenyuWebHandler.handle(exchange);
- assertNotNull(handle);
+ StepVerifier.create(handle).expectSubscription().verifyComplete();
}
@Test
@@ -88,6 +89,22 @@ public final class ShenyuWebHandlerTest {
shenyuWebHandler.putExtPlugins(Collections.singletonList(new
TestPlugin3()));
}
+ @Test
+ public void scheduledEnableTest() {
+ final ServerWebExchange exchange =
MockServerWebExchange.from(MockServerHttpRequest.get("localhost")
+ .remoteAddress(new InetSocketAddress(8090))
+ .build());
+ ShenyuConfig shenyuConfig = new ShenyuConfig();
+ shenyuConfig.getScheduler().setEnabled(true);
+ ShenyuWebHandler shenyuWebHandler1 = new ShenyuWebHandler(listPlugins,
shenyuConfig);
+ Mono<Void> handle = shenyuWebHandler1.handle(exchange);
+ assertNotNull(handle);
+ shenyuConfig.getScheduler().setType("elastic");
+ ShenyuWebHandler shenyuWebHandler2 = new ShenyuWebHandler(listPlugins,
shenyuConfig);
+ Mono<Void> handle2 = shenyuWebHandler2.handle(exchange);
+ assertNotNull(handle2);
+ }
+
@Test
public void testOnApplicationEvent() {
PluginData pluginData1 = PluginData.builder().id("1")
@@ -173,7 +190,7 @@ public final class ShenyuWebHandlerTest {
@Override
public boolean skip(final ServerWebExchange exchange) {
- return ShenyuPlugin.super.skip(exchange);
+ return true;
}
}
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/loader/ShenyuLoaderServiceTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/loader/ShenyuLoaderServiceTest.java
index d10057879..7e7fe87a7 100644
---
a/shenyu-web/src/test/java/org/apache/shenyu/web/loader/ShenyuLoaderServiceTest.java
+++
b/shenyu-web/src/test/java/org/apache/shenyu/web/loader/ShenyuLoaderServiceTest.java
@@ -17,12 +17,35 @@
package org.apache.shenyu.web.loader;
+import com.google.common.collect.Lists;
import org.apache.shenyu.common.config.ShenyuConfig;
-import org.junit.Test;
+import org.apache.shenyu.common.exception.ShenyuException;
+import org.apache.shenyu.plugin.api.utils.SpringBeanUtils;
+import org.apache.shenyu.plugin.base.cache.CommonPluginDataSubscriber;
+import org.apache.shenyu.web.handler.ShenyuWebHandler;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.io.TempDir;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
+import org.springframework.context.ApplicationContext;
+
+import java.io.BufferedOutputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.nio.file.Path;
+import java.util.jar.JarOutputStream;
+import java.util.zip.ZipEntry;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.doThrow;
/**
* Test for ShenyuLoaderServiceTest.
@@ -31,14 +54,58 @@ import org.mockito.quality.Strictness;
@MockitoSettings(strictness = Strictness.LENIENT)
public class ShenyuLoaderServiceTest {
+ @TempDir
+ private static Path folder;
+
+ private Path path;
+
+ @BeforeEach
+ public void setUp() throws IOException, NoSuchFieldException,
IllegalAccessException {
+ Path jar = folder.resolve("plugin.jar");
+ path = jar.getParent();
+ try (FileOutputStream fos = new FileOutputStream(jar.toFile());
+ BufferedOutputStream bos = new BufferedOutputStream(fos);
+ JarOutputStream jos = new JarOutputStream(bos)) {
+ String pluginClz = "public class DividePlugin {}";
+ jos.putNextEntry(new
ZipEntry("org.apache.shenyu.plugin.DividePlugin.class"));
+ jos.write(pluginClz.getBytes());
+ jos.closeEntry();
+ }
+
+ ApplicationContext mockApplication =
+ mock(ApplicationContext.class);
+ when(mockApplication.getBean("dividePlugin")).thenReturn(new Object());
+ when(mockApplication.containsBean("dividePlugin")).thenReturn(true);
+ SpringBeanUtils instance = SpringBeanUtils.getInstance();
+ instance.setApplicationContext(mockApplication);
+ }
+
@Test
- public void loaderExtPluginsTest() {
+ public void loaderExtPluginsTest() throws NoSuchMethodException,
InvocationTargetException, IllegalAccessException, NoSuchFieldException {
+ final ShenyuPluginLoader loader = ShenyuPluginLoader.getInstance();
+ final Field field = ShenyuPluginLoader.class.getDeclaredField("jars");
+ field.setAccessible(true);
+ field.set(loader, Lists.newArrayList());
+ final ShenyuWebHandler shenyuWebHandler = mock(ShenyuWebHandler.class);
+ final CommonPluginDataSubscriber commonPluginDataSubscriber =
mock(CommonPluginDataSubscriber.class);
final ShenyuConfig.ExtPlugin extPlugin = new ShenyuConfig.ExtPlugin();
- extPlugin.setEnabled(true);
- extPlugin.setScheduleDelay(0);
- extPlugin.setScheduleTime(2);
+ extPlugin.setEnabled(false);
final ShenyuConfig shenyuConfig = new ShenyuConfig();
shenyuConfig.setExtPlugin(extPlugin);
- new ShenyuLoaderService(null, null, shenyuConfig);
+ new ShenyuLoaderService(shenyuWebHandler, commonPluginDataSubscriber,
shenyuConfig);
+ extPlugin.setEnabled(true);
+ extPlugin.setPath(path.toString());
+ ShenyuLoaderService shenyuLoaderService = new
ShenyuLoaderService(shenyuWebHandler, commonPluginDataSubscriber, shenyuConfig);
+
+ final Method loaderExtPlugins =
ShenyuLoaderService.class.getDeclaredMethod("loaderExtPlugins");
+ loaderExtPlugins.setAccessible(true);
+ loaderExtPlugins.invoke(shenyuLoaderService);
+
+
doThrow(ShenyuException.class).when(shenyuWebHandler).putExtPlugins(any());
+ loaderExtPlugins.invoke(shenyuLoaderService);
+
+ extPlugin.setPath("test");
+ loaderExtPlugins.invoke(shenyuLoaderService);
+ ShenyuPluginLoader.getInstance().close();
}
}
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/loader/ShenyuPluginLoaderTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/loader/ShenyuPluginLoaderTest.java
index f8c1ed139..62b9ceaf3 100644
---
a/shenyu-web/src/test/java/org/apache/shenyu/web/loader/ShenyuPluginLoaderTest.java
+++
b/shenyu-web/src/test/java/org/apache/shenyu/web/loader/ShenyuPluginLoaderTest.java
@@ -17,18 +17,30 @@
package org.apache.shenyu.web.loader;
+import com.google.common.collect.Lists;
import org.apache.shenyu.plugin.api.utils.SpringBeanUtils;
-import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.io.TempDir;
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.ApplicationContext;
+import org.springframework.stereotype.Component;
+import org.springframework.stereotype.Service;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
import java.nio.file.Path;
import java.util.List;
+import java.util.jar.Attributes;
import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
import java.util.zip.ZipEntry;
import static org.hamcrest.CoreMatchers.is;
@@ -36,19 +48,19 @@ import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
/**
* Test for ShenyuPluginLoader.
*/
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public final class ShenyuPluginLoaderTest {
-
+
@TempDir
private static Path folder;
private ShenyuPluginLoader shenyuPluginLoader;
-
+
private Path path;
@BeforeEach
@@ -56,17 +68,25 @@ public final class ShenyuPluginLoaderTest {
shenyuPluginLoader = ShenyuPluginLoader.getInstance();
Path jar = folder.resolve("plugin.jar");
path = jar.getParent();
- FileOutputStream fos = new FileOutputStream(jar.toFile());
- BufferedOutputStream bos = new BufferedOutputStream(fos);
- try (JarOutputStream jos = new JarOutputStream(bos)) {
+
+ try (FileOutputStream fos = new FileOutputStream(jar.toFile());
+ BufferedOutputStream bos = new BufferedOutputStream(fos);
+ JarOutputStream jos = new JarOutputStream(bos)) {
String pluginClz = "public class DividePlugin {}";
jos.putNextEntry(new
ZipEntry("org.apache.shenyu.plugin.DividePlugin.class"));
jos.write(pluginClz.getBytes());
+ jos.putNextEntry(new
ZipEntry("org.apache.shenyu.plugin.Plugin.class"));
+ jos.write(pluginClz.getBytes());
+ jos.putNextEntry(new
ZipEntry("org.apache.shenyu.plugin.DividePlugin"));
+ jos.write(pluginClz.getBytes());
+ jos.putNextEntry(new
ZipEntry("org/apache/shenyu/plugin/DividePlugin.class"));
+ jos.write(pluginClz.getBytes());
jos.closeEntry();
}
ApplicationContext mockApplication =
mock(ApplicationContext.class);
when(mockApplication.getBean("dividePlugin")).thenReturn(new Object());
+
when(mockApplication.getAutowireCapableBeanFactory()).thenReturn(mock(DefaultListableBeanFactory.class));
when(mockApplication.containsBean("dividePlugin")).thenReturn(true);
SpringBeanUtils instance = SpringBeanUtils.getInstance();
instance.setApplicationContext(mockApplication);
@@ -86,16 +106,49 @@ public final class ShenyuPluginLoaderTest {
}
@Test
- public void testGetPluginPathWithNoJar() throws IOException,
ClassNotFoundException, InstantiationException, IllegalAccessException {
+ public void testGetPluginPathWithNoJar() throws IOException {
List<ShenyuLoaderResult> pluginList =
shenyuPluginLoader.loadExtendPlugins("test");
assertThat(pluginList.size(), is(0));
}
-
+
@Test
- public void testGetPluginPathWithJar() throws IOException,
ClassNotFoundException, InstantiationException, IllegalAccessException {
- ShenyuPluginLoader loader = spy(shenyuPluginLoader);
+ public void testGetPluginPathWithJar() throws IOException,
NoSuchFieldException, IllegalAccessException {
+ ShenyuPluginLoader loader = ShenyuPluginLoader.getInstance();
+ Field field = ShenyuPluginLoader.class.getDeclaredField("jars");
+ field.setAccessible(true);
+ field.set(loader, Lists.newArrayList());
List<ShenyuLoaderResult> pluginList =
loader.loadExtendPlugins(path.toString());
assertThat(pluginList.size(), is(1));
+ Assertions.assertTrue(loader.findResources("").hasMoreElements());
+ loader.findResources("org.apache.shenyu.plugin.DividePlugin");
+
Assertions.assertNotNull(loader.findResource("org.apache.shenyu.plugin.DividePlugin"));
+ Assertions.assertNull(loader.findResource("DividePlugin"));
+
Assertions.assertNull(loader.findResource("org.apache.shenyu.plugin.Plugin"));
loader.close();
}
+
+ @Test
+ public void testGetOrCreateSpringBean() throws NoSuchMethodException,
InvocationTargetException, IllegalAccessException {
+ Method getOrCreateSpringBean =
ShenyuPluginLoader.class.getDeclaredMethod("getOrCreateSpringBean",
String.class);
+ getOrCreateSpringBean.setAccessible(true);
+ getOrCreateSpringBean.invoke(ShenyuPluginLoader.getInstance(),
"org.apache.shenyu.web.loader.ShenyuPluginLoaderTest$TestComponent");
+ getOrCreateSpringBean.invoke(ShenyuPluginLoader.getInstance(),
"org.apache.shenyu.web.loader.ShenyuPluginLoaderTest$TestService");
+ }
+
+ @Test
+ public void testDefinePackageInternal() throws NoSuchMethodException,
InvocationTargetException, IllegalAccessException, IOException {
+ Method definePackageInternal =
ShenyuPluginLoader.class.getDeclaredMethod("definePackageInternal",
String.class, Manifest.class);
+ definePackageInternal.setAccessible(true);
+ Manifest manifest = mock(Manifest.class);
+ when(manifest.getMainAttributes()).thenReturn(mock(Attributes.class));
+ definePackageInternal.invoke(ShenyuPluginLoader.getInstance(),
"org.apache.shenyu.plugin.DividePlugin", manifest);
+ }
+
+ @Component
+ public static class TestComponent {
+ }
+
+ @Service
+ public static class TestService {
+ }
}
diff --git
a/shenyu-web/src/test/java/org/apache/shenyu/web/logo/ShenyuLogoTest.java
b/shenyu-web/src/test/java/org/apache/shenyu/web/logo/ShenyuLogoTest.java
index 6114d1e05..d72463c96 100644
--- a/shenyu-web/src/test/java/org/apache/shenyu/web/logo/ShenyuLogoTest.java
+++ b/shenyu-web/src/test/java/org/apache/shenyu/web/logo/ShenyuLogoTest.java
@@ -51,6 +51,7 @@ public final class ShenyuLogoTest {
ConfigurableEnvironment environment = new MockEnvironment();
ApplicationEnvironmentPreparedEvent event = new
ApplicationEnvironmentPreparedEvent(null, application, null, environment);
shenyuLogo.onApplicationEvent(event);
+ shenyuLogo.onApplicationEvent(event);
Field field = shenyuLogo.getClass().getDeclaredField("ALREADY_LOG");
field.setAccessible(true);
AtomicBoolean atomicBoolean = (AtomicBoolean) field.get(shenyuLogo);
