From 1deae436d5c6fef77d52a062584b98323e4935fe Mon Sep 17 00:00:00 2001 From: 13009 Date: Wed, 21 Feb 2024 13:03:49 +0800 Subject: [PATCH] =?UTF-8?q?=E5=8D=95=E5=85=83=E6=B5=8B=E8=AF=95=E8=A6=86?= =?UTF-8?q?=E7=9B=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../cipher/AbstractPrivacyDecryptorTest.java | 67 +++++++++++++ .../cipher/AbstractPrivacyEncryptorTest.java | 49 +++++++++ .../api/core/cipher/AbstractSignerTest.java | 52 ++++++++++ .../api/core/cipher/AbstractVerifierTest.java | 24 +++++ .../scfs/api/core/cipher/TestProvider.java | 13 +++ .../scfs/api/core/util/StopWatchTest.java | 66 +++++++++++++ .../starter/ScfsApiGatewayPropertiesTest.java | 99 +++++++++++++++++++ .../boot/starter/SmConfigurationTest.java | 85 ++++++++++++++++ 8 files changed, 455 insertions(+) create mode 100644 scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractPrivacyDecryptorTest.java create mode 100644 scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractPrivacyEncryptorTest.java create mode 100644 scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractSignerTest.java create mode 100644 scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractVerifierTest.java create mode 100644 scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/TestProvider.java create mode 100644 scfs-api-core/src/test/java/com/czcb/scfs/api/core/util/StopWatchTest.java create mode 100644 scfs-api-spring-boot-starter/src/test/java/com/czcb/scfs/spring/boot/starter/ScfsApiGatewayPropertiesTest.java create mode 100644 scfs-api-spring-boot-starter/src/test/java/com/czcb/scfs/spring/boot/starter/SmConfigurationTest.java diff --git a/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractPrivacyDecryptorTest.java b/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractPrivacyDecryptorTest.java new file mode 100644 index 0000000..d25204a --- /dev/null +++ b/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractPrivacyDecryptorTest.java @@ -0,0 +1,67 @@ +package com.czcb.scfs.api.core.cipher; + +import com.czcb.scfs.api.core.KeyText; +import com.czcb.scfs.api.core.http.client.TestPrivacyDecryptor; +import com.czcb.scfs.api.core.http.client.TestPrivacyEncryptor; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.security.PrivateKey; +import java.security.Provider; +import java.security.cert.X509Certificate; + +class AbstractPrivacyDecryptorTest { + + @Test + void decrypt() { + PrivateKey privateKey = KeyText.loadTestPrivateKeyRSA(); + PrivacyDecryptor decryptor = new TestPrivacyDecryptor(privateKey); + + X509Certificate certificate = KeyText.loadTestRSA(); + PrivacyEncryptor encryptor = new TestPrivacyEncryptor(certificate.getPublicKey()); + + String text = "123456"; + String ecn = encryptor.encrypt(text); + Assertions.assertEquals(text, decryptor.decrypt(ecn)); + + TestPrivacyDecryptorV2 testPrivacyDecryptorV2 = new TestPrivacyDecryptorV2(privateKey, null); + Assertions.assertEquals(text, testPrivacyDecryptorV2.decrypt(ecn)); + } + + @Test + void decryptError() { + PrivateKey privateKey = KeyText.loadTestPrivateKeyRSA2(); + PrivacyDecryptor decryptor = new TestPrivacyDecryptor(privateKey); + + X509Certificate certificate = KeyText.loadTestRSA(); + PrivacyEncryptor encryptor = new TestPrivacyEncryptor(certificate.getPublicKey()); + + String text = "123456"; + String ecn = encryptor.encrypt(text); + Assertions.assertThrows(IllegalArgumentException.class, () -> decryptor.decrypt(ecn)); + + PrivacyDecryptor decryptorv1 = new TestPrivacyDecryptorV2(privateKey); + Assertions.assertThrows(IllegalArgumentException.class, () -> decryptorv1.decrypt(ecn)); + + PrivacyDecryptor decryptorv2 = new TestPrivacyDecryptorV2(privateKey, new TestProvider()); + Assertions.assertThrows(IllegalArgumentException.class, () -> decryptorv2.decrypt(ecn)); + } + + @Test + void getPrivateKey() { + PrivateKey privateKey = KeyText.loadTestPrivateKeyRSA(); + PrivacyDecryptor decryptor = new TestPrivacyDecryptor(privateKey); + Assertions.assertNotNull(decryptor.getPrivateKey()); + } + + private static class TestPrivacyDecryptorV2 extends AbstractPrivacyDecryptor { + public TestPrivacyDecryptorV2(PrivateKey privateKey) { + super("RSA/ECB/", privateKey, null); + } + + public TestPrivacyDecryptorV2(PrivateKey privateKey, Provider provider) { + super("RSA/ECB/OAEPWithSHA-1AndMGF1Padding", privateKey, provider); + } + } + +} \ No newline at end of file diff --git a/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractPrivacyEncryptorTest.java b/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractPrivacyEncryptorTest.java new file mode 100644 index 0000000..ca966d2 --- /dev/null +++ b/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractPrivacyEncryptorTest.java @@ -0,0 +1,49 @@ +package com.czcb.scfs.api.core.cipher; + +import com.czcb.scfs.api.core.KeyText; +import com.czcb.scfs.api.core.http.client.TestPrivacyDecryptor; +import com.czcb.scfs.api.core.http.client.TestPrivacyEncryptor; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.security.PrivateKey; +import java.security.Provider; +import java.security.PublicKey; +import java.security.cert.X509Certificate; + +import static org.junit.jupiter.api.Assertions.assertThrows; + +class AbstractPrivacyEncryptorTest { + + @Test + void encrypt() { + PrivateKey privateKey = KeyText.loadTestPrivateKeyRSA(); + PrivacyDecryptor decryptor = new TestPrivacyDecryptor(privateKey); + + X509Certificate certificate = KeyText.loadTestRSA(); + PrivacyEncryptor encryptor = new TestPrivacyEncryptor(certificate.getPublicKey()); + String text = "123456"; + String ecn = encryptor.encrypt(text); + Assertions.assertEquals(text, decryptor.decrypt(ecn)); + } + + @Test + void encryptError() { + X509Certificate certificate = KeyText.loadTestRSA(); + PrivacyEncryptor encryptor = new TestPrivacyEncryptorv2(certificate.getPublicKey(), new TestProvider()); + assertThrows(IllegalArgumentException.class, () -> encryptor.encrypt("123456")); + } + + @Test + void getPublicKey() { + X509Certificate certificate = KeyText.loadTestRSA(); + PrivacyEncryptor encryptor = new TestPrivacyEncryptor(certificate.getPublicKey()); + Assertions.assertNotNull(encryptor.getPublicKey()); + } + + private static class TestPrivacyEncryptorv2 extends AbstractPrivacyEncryptor { + public TestPrivacyEncryptorv2(PublicKey publicKey, Provider provider) { + super("RSA/ECB/OAEPWithSHA-1AndMGF1Padding", publicKey, provider); + } + } +} \ No newline at end of file diff --git a/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractSignerTest.java b/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractSignerTest.java new file mode 100644 index 0000000..10c8436 --- /dev/null +++ b/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractSignerTest.java @@ -0,0 +1,52 @@ +package com.czcb.scfs.api.core.cipher; + +import com.czcb.scfs.api.core.KeyText; +import com.czcb.scfs.api.core.http.client.TestVerifier; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.security.PrivateKey; +import java.security.Provider; +import java.security.cert.X509Certificate; +import java.util.ArrayList; +import java.util.List; + +class AbstractSignerTest { + + @Test + void sign() { + TestSigner signer = new TestSigner(KeyText.loadTestPrivateKeyRSA(), null); + String message = "1234567890"; + String sg = signer.sign(message).getResult(); + Assertions.assertNotNull(sg); + Assertions.assertEquals("SHA256withRSA", signer.getAlgorithm()); + + List list = new ArrayList<>(); + list.add(KeyText.loadTestRSA()); + CertificateProvider certificateProvider = new LocalCertificateProvider(list); + TestVerifier verifier = new TestVerifier(certificateProvider); + Assertions.assertTrue(verifier.verify("", message, sg)); + } + + @Test + void signError() { + TestSigner signer = new TestSigner(KeyText.loadTestPrivateKeyRSA()); + String message = "1234567890"; + Assertions.assertThrows(UnsupportedOperationException.class, () -> signer.sign(message)); + } + + private static class TestSigner extends AbstractSigner { + + /** + * @param privateKey API私钥 + */ + public TestSigner(PrivateKey privateKey, Provider provider) { + super("SHA256withRSA", "SHA256withRSA", privateKey, provider); + } + + public TestSigner(PrivateKey privateKey) { + // 错误的签名算法 + super("SHA256withRSA1", "SHA256withRSA1", privateKey, null); + } + } +} \ No newline at end of file diff --git a/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractVerifierTest.java b/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractVerifierTest.java new file mode 100644 index 0000000..3e1aa82 --- /dev/null +++ b/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/AbstractVerifierTest.java @@ -0,0 +1,24 @@ +package com.czcb.scfs.api.core.cipher; + +import com.czcb.scfs.api.core.KeyText; +import com.czcb.scfs.api.core.http.client.TestVerifier; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.security.cert.X509Certificate; +import java.util.ArrayList; +import java.util.List; + +class AbstractVerifierTest { + + @Test + void verify() { + List list = new ArrayList<>(); + list.add(KeyText.loadTestRSA()); + CertificateProvider certificateProvider = new LocalCertificateProvider(list); + TestVerifier verifier = new TestVerifier(certificateProvider); + + Assertions.assertFalse(verifier.verify("", "", "")); + Assertions.assertFalse(verifier.verify(KeyText.loadTestRSA(), "", "")); + } +} \ No newline at end of file diff --git a/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/TestProvider.java b/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/TestProvider.java new file mode 100644 index 0000000..908c0ed --- /dev/null +++ b/scfs-api-core/src/test/java/com/czcb/scfs/api/core/cipher/TestProvider.java @@ -0,0 +1,13 @@ +package com.czcb.scfs.api.core.cipher; + +import java.security.Provider; + +/** + * @author wangwei + * @date 2024/2/20 + */ +public class TestProvider extends Provider { + public TestProvider() { + super("TestProvider", 1.0, "TestProvider"); + } +} diff --git a/scfs-api-core/src/test/java/com/czcb/scfs/api/core/util/StopWatchTest.java b/scfs-api-core/src/test/java/com/czcb/scfs/api/core/util/StopWatchTest.java new file mode 100644 index 0000000..fdfcf18 --- /dev/null +++ b/scfs-api-core/src/test/java/com/czcb/scfs/api/core/util/StopWatchTest.java @@ -0,0 +1,66 @@ +package com.czcb.scfs.api.core.util; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.concurrent.TimeUnit; + +class StopWatchTest { + + @Test + void create() { + StopWatch stopWatch = new StopWatch(); + Assertions.assertEquals("", stopWatch.getId()); + Assertions.assertEquals("1234567", StopWatch.create("1234567").getId()); + } + + @Test + void start() throws InterruptedException { + StopWatch stopWatch = new StopWatch().start("test"); + stopWatch.setKeepTaskList(true); + Assertions.assertEquals("test", stopWatch.currentTaskName()); + Assertions.assertTrue(stopWatch.isRunning()); + Thread.sleep(10); + stopWatch.stop(); + + Assertions.assertTrue(stopWatch.getLastTaskTimeMillis() > 0); + Assertions.assertTrue(stopWatch.getLastTaskTimeNanos() > 0); + Assertions.assertTrue(stopWatch.getTotalTimeSeconds() > 0); + Assertions.assertTrue(stopWatch.getTotalTimeMillis() > 0); + Assertions.assertNotEquals(0, stopWatch.getTotalTimeNanos()); + Assertions.assertTrue(stopWatch.getTotal(TimeUnit.MILLISECONDS) > 0); + + Assertions.assertTrue(stopWatch.getTaskCount() > 0); + + System.out.println(); + System.out.println(); + Assertions.assertEquals("test", stopWatch.getLastTaskName()); + Assertions.assertNotNull(stopWatch.getLastTaskInfo()); + } + + @Test + void start2() { + StopWatch stopWatch = new StopWatch().start(); + stopWatch.setKeepTaskList(false); + Assertions.assertEquals("", stopWatch.currentTaskName()); + stopWatch.stop(); + } + + @Test + void start3() { + StopWatch stopWatch = new StopWatch("11", false).start(); + stopWatch.setKeepTaskList(true); + Assertions.assertEquals("", stopWatch.currentTaskName()); + Assertions.assertEquals("11", stopWatch.getId()); + try { + Thread.sleep(10); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + stopWatch.stop(); + + Assertions.assertNotNull(stopWatch.getTaskInfo()); + Assertions.assertEquals(1, stopWatch.getTaskInfo().length); + Assertions.assertNotEquals(0, stopWatch.getTaskInfo()[0].getTimeSeconds()); + } +} \ No newline at end of file diff --git a/scfs-api-spring-boot-starter/src/test/java/com/czcb/scfs/spring/boot/starter/ScfsApiGatewayPropertiesTest.java b/scfs-api-spring-boot-starter/src/test/java/com/czcb/scfs/spring/boot/starter/ScfsApiGatewayPropertiesTest.java new file mode 100644 index 0000000..21fbd65 --- /dev/null +++ b/scfs-api-spring-boot-starter/src/test/java/com/czcb/scfs/spring/boot/starter/ScfsApiGatewayPropertiesTest.java @@ -0,0 +1,99 @@ +package com.czcb.scfs.spring.boot.starter; + +import com.czcb.scfs.api.core.cipher.StoreType; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.HashMap; +import java.util.Map; + +import static net.javacrumbs.jsonunit.assertj.JsonAssertions.assertThatJson; + +class ScfsApiGatewayPropertiesTest { + + @Test + void getOnline() { + ScfsApiGatewayProperties properties = new ScfsApiGatewayProperties(); + properties.setOnline(false); + Assertions.assertFalse(properties.getOnline()); + } + + @Test + void getHost() { + ScfsApiGatewayProperties properties = new ScfsApiGatewayProperties(); + properties.setOnline(true); + Assertions.assertTrue(properties.getOnline()); + + properties.setHost("http://10.129.135.192:7100/"); + Assertions.assertEquals("http://10.129.135.192:7100/", properties.getHost()); + } + + @Test + void setChannel() { + ScfsApiGatewayProperties.Channel channel = new ScfsApiGatewayProperties.Channel(); + channel.setChannelNo("000000"); + channel.setAppNo("111111"); + ScfsApiGatewayProperties properties = new ScfsApiGatewayProperties(); + properties.setChannel(channel); + + Assertions.assertNotNull(properties.getChannel()); + assertThatJson("{\"channelNo\":\"000000\",\"appNo\":\"111111\"}").isEqualTo(properties.getChannel()); + } + + @Test + void getHttpclient() { + ScfsApiGatewayProperties.Httpclient httpclient = new ScfsApiGatewayProperties.Httpclient(); + Map headers = new HashMap<>(); + headers.put("aa", "123456"); + httpclient.setHeaders(headers); + + ScfsApiGatewayProperties.Httpclient.Proxy proxy = new ScfsApiGatewayProperties.Httpclient.Proxy(); + proxy.setEnabled(true); + proxy.setHost("128.0.0.1"); + proxy.setPort("1000"); + proxy.setUsername("name"); + proxy.setPassword("123456"); + proxy.setScheme("https"); + httpclient.setProxy(proxy); + + ScfsApiGatewayProperties.Httpclient.ConnPool connPool = new ScfsApiGatewayProperties.Httpclient.ConnPool(); + connPool.setMaxRequests(100); + connPool.setMaxRequestPerHost(100); + connPool.setConnectTimeout(100); + connPool.setSocketTimeout(100); + httpclient.setConnPool(connPool); + + httpclient.setCompressionEnabled(false); + httpclient.setLogEnabled(false); + ScfsApiGatewayProperties properties = new ScfsApiGatewayProperties(); + properties.setHttpclient(httpclient); + + Assertions.assertNotNull(properties.getHttpclient()); + Assertions.assertFalse(properties.getHttpclient().getCompressionEnabled()); + Assertions.assertFalse(properties.getHttpclient().getLogEnabled()); + + assertThatJson("{\"logEnabled\":false,\"compressionEnabled\":false," + + "\"connPool\":{\"maxRequests\":100,\"maxRequestPerHost\":100,\"connectTimeout\":100,\"socketTimeout\":100}," + + "\"proxy\":{\"enabled\":true,\"host\":\"128.0.0.1\",\"port\":\"1000\",\"username\":\"name\",\"password\":\"123456\",\"scheme\":\"https\"}," + + "\"headers\":{\"aa\":\"123456\"}}") + .isEqualTo(properties.getHttpclient()); + } + + @Test + void getCipher() { + ScfsApiGatewayProperties.Cipher cipher = new ScfsApiGatewayProperties.Cipher(); + cipher.setStoreType(StoreType.RESOURCES); + cipher.setChannelPrivateKey("/home/key.pem"); + cipher.setChannelCertificate("/home/c1.pem"); + cipher.setCertificate("/home/c2.pem"); + + ScfsApiGatewayProperties properties = new ScfsApiGatewayProperties(); + properties.setCipher(cipher); + + Assertions.assertNotNull(properties.getCipher()); + + assertThatJson("{\"storeType\":\"RESOURCES\",\"channelPrivateKey\":\"/home/key.pem\",\"channelCertificate\":\"/home/c1.pem\",\"certificate\":\"/home/c2.pem\"}") + .isEqualTo(properties.getCipher()); + + } +} \ No newline at end of file diff --git a/scfs-api-spring-boot-starter/src/test/java/com/czcb/scfs/spring/boot/starter/SmConfigurationTest.java b/scfs-api-spring-boot-starter/src/test/java/com/czcb/scfs/spring/boot/starter/SmConfigurationTest.java new file mode 100644 index 0000000..a6f32aa --- /dev/null +++ b/scfs-api-spring-boot-starter/src/test/java/com/czcb/scfs/spring/boot/starter/SmConfigurationTest.java @@ -0,0 +1,85 @@ +package com.czcb.scfs.spring.boot.starter; + +import com.czcb.scfs.api.core.cipher.StoreType; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.HashMap; +import java.util.Map; + +@ExtendWith(MockitoExtension.class) +class SmConfigurationTest { + + @Mock + private SmConfiguration smConfiguration; + + private ScfsApiGatewayProperties properties() { + ScfsApiGatewayProperties properties = new ScfsApiGatewayProperties(); + + ScfsApiGatewayProperties.Httpclient httpclient = new ScfsApiGatewayProperties.Httpclient(); + Map headers = new HashMap<>(); + headers.put("aa", "123456"); + httpclient.setHeaders(headers); + + ScfsApiGatewayProperties.Httpclient.Proxy proxy = new ScfsApiGatewayProperties.Httpclient.Proxy(); + proxy.setEnabled(true); + proxy.setHost("128.0.0.1"); + proxy.setPort("1000"); + proxy.setUsername("name"); + proxy.setPassword("123456"); + proxy.setScheme("https"); + httpclient.setProxy(proxy); + + ScfsApiGatewayProperties.Httpclient.ConnPool connPool = new ScfsApiGatewayProperties.Httpclient.ConnPool(); + connPool.setMaxRequests(100); + connPool.setMaxRequestPerHost(100); + connPool.setConnectTimeout(100); + connPool.setSocketTimeout(100); + httpclient.setConnPool(connPool); + httpclient.setCompressionEnabled(false); + httpclient.setLogEnabled(false); + properties.setHttpclient(httpclient); + + ScfsApiGatewayProperties.Channel channel = new ScfsApiGatewayProperties.Channel(); + channel.setChannelNo("000000"); + channel.setAppNo("111111"); + properties.setChannel(channel); + + ScfsApiGatewayProperties.Cipher cipher = new ScfsApiGatewayProperties.Cipher(); + cipher.setStoreType(StoreType.RESOURCES); + cipher.setChannelPrivateKey("/home/key.pem"); + cipher.setChannelCertificate("/home/c1.pem"); + cipher.setCertificate("/home/c2.pem"); + properties.setCipher(cipher); + + properties.setOnline(true); + properties.setHost("http://127.0.0.1"); + return properties; + } + + @Test + void getProperties() { + Mockito.when(smConfiguration.getProperties()).thenReturn(properties()); + ScfsApiGatewayProperties properties = smConfiguration.getProperties(); + Assertions.assertNotNull(properties); + } + +// @Test +// void smProfile() { +// Mockito.when(smConfiguration.getProperties()).thenReturn(properties()); +// Mockito.when(smConfiguration.smProfile()).thenReturn(new SmConfiguration().smProfile()); +// Mockito.when(smConfiguration.getChannel()).thenReturn(new SmConfiguration().getChannel()); +// SmProfile smProfile = smConfiguration.smProfile(); +// Assertions.assertNotNull(smProfile); +// assertThatJson("{\"channelNo\":\"000000\",\"appNo\":\"111111\"}").isEqualTo(smProfile.getChannel()); +// assertThatJson("{\"logEnabled\":false,\"compressionEnabled\":false," + +// "\"connPool\":{\"maxRequests\":100,\"maxRequestPerHost\":100,\"connectTimeout\":100,\"socketTimeout\":100}," + +// "\"proxy\":{\"enabled\":true,\"host\":\"128.0.0.1\",\"port\":\"1000\",\"username\":\"name\",\"password\":\"123456\",\"scheme\":\"https\"}," + +// "\"headers\":{\"aa\":\"123456\"}}") +// .isEqualTo(smProfile.getHttpProfile()); +// } +} \ No newline at end of file