From 045b8b86c9b8b150fe32fb94caee2901f3f69662 Mon Sep 17 00:00:00 2001 From: linghengqian Date: Thu, 12 Jan 2023 22:55:27 +0800 Subject: [PATCH] Add support for `io.etcd:jetcd-core:0.7.5` --- metadata/index.json | 4 + metadata/io.etcd/jetcd-core/0.7.5/index.json | 4 + .../jetcd-core/0.7.5/reflect-config.json | 1783 ++++++++++++++ .../jetcd-core/0.7.5/resource-config.json | 13 + metadata/io.etcd/jetcd-core/index.json | 10 + tests/src/index.json | 11 + tests/src/io.etcd/jetcd-core/0.7.5/.gitignore | 4 + .../src/io.etcd/jetcd-core/0.7.5/build.gradle | 50 + .../jetcd-core/0.7.5/gradle.properties | 2 + .../io.etcd/jetcd-core/0.7.5/settings.gradle | 13 + .../io/etcd/jetcd/impl/ClientBuilderTest.java | 80 + .../io/etcd/jetcd/impl/WatchUnitTest.java | 367 +++ .../test/java/io/etcd/jetcd/op/TxnTest.java | 54 + .../jetcd_core/impl/AuthClientTest.java | 108 + .../impl/ClientConnectionManagerTest.java | 103 + .../jetcd_core/impl/ClusterClientTest.java | 100 + .../io_etcd/jetcd_core/impl/ElectionTest.java | 220 ++ .../jetcd_core/impl/KVNamespaceTest.java | 357 +++ .../java/io_etcd/jetcd_core/impl/KVTest.java | 293 +++ .../io_etcd/jetcd_core/impl/LeaseTest.java | 147 ++ .../jetcd_core/impl/LoadBalancerTest.java | 66 + .../io_etcd/jetcd_core/impl/LockTest.java | 178 ++ .../jetcd_core/impl/MaintenanceTest.java | 112 + .../jetcd_core/impl/MaintenanceUnitTest.java | 103 + .../java/io_etcd/jetcd_core/impl/SslTest.java | 55 + .../io_etcd/jetcd_core/impl/TestUtil.java | 80 + .../jetcd_core/impl/TxnResponseTest.java | 55 + .../io_etcd/jetcd_core/impl/UtilTest.java | 38 + .../jetcd_core/impl/WatchErrorTest.java | 50 + .../jetcd_core/impl/WatchResumeTest.java | 53 + .../io_etcd/jetcd_core/impl/WatchTest.java | 278 +++ .../jetcd_core/impl/WatchTokenExpireTest.java | 102 + .../jetcd_core/options/OptionsUtilTest.java | 35 + .../jetcd-test/0.7.5/reflect-config.json | 2050 +++++++++++++++++ .../jetcd-test/0.7.5/resource-config.json | 25 + .../proxy-config.json | 10 + .../reflect-config.json | 309 +++ .../resource-config.json | 13 + .../org.mockito.plugins.MockMaker | 1 + .../test/resources/ssl/cert/ca-config.json | 1 + .../src/test/resources/ssl/cert/ca-key.pem | 27 + .../0.7.5/src/test/resources/ssl/cert/ca.csr | 15 + .../0.7.5/src/test/resources/ssl/cert/ca.pem | 19 + .../test/resources/ssl/cert/client-key.pem | 27 + .../src/test/resources/ssl/cert/client.csr | 16 + .../src/test/resources/ssl/cert/client.pem | 20 + .../src/test/resources/ssl/cert/etcd0-key.pem | 27 + .../src/test/resources/ssl/cert/etcd0.csr | 16 + .../src/test/resources/ssl/cert/etcd0.pem | 20 + .../src/test/resources/ssl/cert/etcd1-key.pem | 27 + .../src/test/resources/ssl/cert/etcd1.csr | 16 + .../src/test/resources/ssl/cert/etcd1.pem | 20 + .../src/test/resources/ssl/cert/etcd2-key.pem | 27 + .../src/test/resources/ssl/cert/etcd2.csr | 16 + .../src/test/resources/ssl/cert/etcd2.pem | 20 + .../test/resources/ssl/cert/server-key.pem | 27 + .../src/test/resources/ssl/cert/server.csr | 16 + .../src/test/resources/ssl/cert/server.pem | 20 + .../jetcd-core/0.7.5/user-code-filter.json | 10 + 59 files changed, 7723 insertions(+) create mode 100644 metadata/io.etcd/jetcd-core/0.7.5/index.json create mode 100644 metadata/io.etcd/jetcd-core/0.7.5/reflect-config.json create mode 100644 metadata/io.etcd/jetcd-core/0.7.5/resource-config.json create mode 100644 metadata/io.etcd/jetcd-core/index.json create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/.gitignore create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/build.gradle create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/gradle.properties create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/settings.gradle create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io/etcd/jetcd/impl/ClientBuilderTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io/etcd/jetcd/impl/WatchUnitTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io/etcd/jetcd/op/TxnTest.java create mode 100755 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/AuthClientTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/ClientConnectionManagerTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/ClusterClientTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/ElectionTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/KVNamespaceTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/KVTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/LeaseTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/LoadBalancerTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/LockTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/MaintenanceTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/MaintenanceUnitTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/SslTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/TestUtil.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/TxnResponseTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/UtilTest.java create mode 100755 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchErrorTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchResumeTest.java create mode 100755 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchTokenExpireTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/options/OptionsUtilTest.java create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/io.etcd/jetcd-test/0.7.5/reflect-config.json create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/io.etcd/jetcd-test/0.7.5/resource-config.json create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/jetcd-core-test-metadata/proxy-config.json create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/jetcd-core-test-metadata/reflect-config.json create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/jetcd-core-test-metadata/resource-config.json create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca-config.json create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca-key.pem create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca.csr create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca.pem create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/client-key.pem create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/client.csr create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/client.pem create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd0-key.pem create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd0.csr create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd0.pem create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd1-key.pem create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd1.csr create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd1.pem create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd2-key.pem create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd2.csr create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd2.pem create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/server-key.pem create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/server.csr create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/server.pem create mode 100644 tests/src/io.etcd/jetcd-core/0.7.5/user-code-filter.json diff --git a/metadata/index.json b/metadata/index.json index 742cfa29..8443c101 100644 --- a/metadata/index.json +++ b/metadata/index.json @@ -194,6 +194,10 @@ "directory": "org.ehcache/ehcache", "module": "org.ehcache:ehcache" }, + { + "directory": "io.etcd/jetcd-core", + "module": "io.etcd:jetcd-core" + }, { "directory": "org.mockito/mockito-core", "module": "org.mockito:mockito-core" diff --git a/metadata/io.etcd/jetcd-core/0.7.5/index.json b/metadata/io.etcd/jetcd-core/0.7.5/index.json new file mode 100644 index 00000000..11ac50cc --- /dev/null +++ b/metadata/io.etcd/jetcd-core/0.7.5/index.json @@ -0,0 +1,4 @@ +[ + "reflect-config.json", + "resource-config.json" +] diff --git a/metadata/io.etcd/jetcd-core/0.7.5/reflect-config.json b/metadata/io.etcd/jetcd-core/0.7.5/reflect-config.json new file mode 100644 index 00000000..ebcebfb0 --- /dev/null +++ b/metadata/io.etcd/jetcd-core/0.7.5/reflect-config.json @@ -0,0 +1,1783 @@ +[ + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "[Lcom.github.dockerjava.api.model.VolumesFrom;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "[Lcom.github.dockerjava.api.model.VolumesFrom;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.op.TxnImpl" + }, + "name": "[Ljava.lang.Object;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "[Ljava.lang.String;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "[Ljava.lang.String;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "[Lorg.testcontainers.shaded.com.google.common.collect.ImmutableMapEntry;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.AsyncDockerCmd", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.CreateContainerResponse", + "methods": [ + { + "name": "", + "parameterTypes": [] + }, + { + "name": "setId", + "parameterTypes": [ + "java.lang.String" + ] + }, + { + "name": "setWarnings", + "parameterTypes": [ + "java.lang.String[]" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.DockerCmd", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.ExecCreateCmd", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.ExecCreateCmdResponse", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.ExecStartCmd", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.command.GraphData", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.GraphData", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.command.GraphDriver", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.GraphDriver", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.command.InspectContainerResponse", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.InspectContainerResponse", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.command.InspectContainerResponse$ContainerState", + "methods": [ + { + "name": "", + "parameterTypes": [ + "com.github.dockerjava.api.command.InspectContainerResponse" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.InspectContainerResponse$ContainerState", + "methods": [ + { + "name": "", + "parameterTypes": [ + "com.github.dockerjava.api.command.InspectContainerResponse" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.command.InspectContainerResponse$Mount", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.InspectContainerResponse$Mount", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.InspectExecResponse", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.InspectExecResponse$Container", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "queryAllPublicConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.InspectExecResponse$ProcessConfig", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "queryAllPublicConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [ + "com.github.dockerjava.api.command.InspectExecResponse" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.command.SyncDockerCmd", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.AuthConfig", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "getAuth", + "parameterTypes": [] + }, + { + "name": "getEmail", + "parameterTypes": [] + }, + { + "name": "getIdentitytoken", + "parameterTypes": [] + }, + { + "name": "getPassword", + "parameterTypes": [] + }, + { + "name": "getRegistryAddress", + "parameterTypes": [] + }, + { + "name": "getRegistrytoken", + "parameterTypes": [] + }, + { + "name": "getStackOrchestrator", + "parameterTypes": [] + }, + { + "name": "getUsername", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.model.Binds", + "methods": [ + { + "name": "fromPrimitive", + "parameterTypes": [ + "java.lang.String[]" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.Binds", + "methods": [ + { + "name": "fromPrimitive", + "parameterTypes": [ + "java.lang.String[]" + ] + }, + { + "name": "toPrimitive", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.model.ContainerConfig", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.ContainerConfig", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.model.ContainerNetwork", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.ContainerNetwork", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + }, + { + "name": "getAliases", + "parameterTypes": [] + }, + { + "name": "getEndpointId", + "parameterTypes": [] + }, + { + "name": "getGateway", + "parameterTypes": [] + }, + { + "name": "getGlobalIPv6Address", + "parameterTypes": [] + }, + { + "name": "getGlobalIPv6PrefixLen", + "parameterTypes": [] + }, + { + "name": "getIpAddress", + "parameterTypes": [] + }, + { + "name": "getIpPrefixLen", + "parameterTypes": [] + }, + { + "name": "getIpV6Gateway", + "parameterTypes": [] + }, + { + "name": "getIpamConfig", + "parameterTypes": [] + }, + { + "name": "getMacAddress", + "parameterTypes": [] + }, + { + "name": "getNetworkID", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.DockerObject", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "methods": [ + { + "name": "getRawValues", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.model.ExposedPorts", + "methods": [ + { + "name": "fromPrimitive", + "parameterTypes": [ + "java.util.Map" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.ExposedPorts", + "methods": [ + { + "name": "fromPrimitive", + "parameterTypes": [ + "java.util.Map" + ] + }, + { + "name": "toPrimitive", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.model.HostConfig", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.HostConfig", + "methods": [ + { + "name": "", + "parameterTypes": [] + }, + { + "name": "getAutoRemove", + "parameterTypes": [] + }, + { + "name": "getBlkioDeviceReadBps", + "parameterTypes": [] + }, + { + "name": "getBlkioDeviceReadIOps", + "parameterTypes": [] + }, + { + "name": "getBlkioDeviceWriteBps", + "parameterTypes": [] + }, + { + "name": "getBlkioDeviceWriteIOps", + "parameterTypes": [] + }, + { + "name": "getBlkioWeight", + "parameterTypes": [] + }, + { + "name": "getBlkioWeightDevice", + "parameterTypes": [] + }, + { + "name": "getCapAdd", + "parameterTypes": [] + }, + { + "name": "getCapDrop", + "parameterTypes": [] + }, + { + "name": "getCgroup", + "parameterTypes": [] + }, + { + "name": "getCgroupParent", + "parameterTypes": [] + }, + { + "name": "getCgroupnsMode", + "parameterTypes": [] + }, + { + "name": "getConsoleSize", + "parameterTypes": [] + }, + { + "name": "getContainerIDFile", + "parameterTypes": [] + }, + { + "name": "getCpuCount", + "parameterTypes": [] + }, + { + "name": "getCpuPercent", + "parameterTypes": [] + }, + { + "name": "getCpuPeriod", + "parameterTypes": [] + }, + { + "name": "getCpuQuota", + "parameterTypes": [] + }, + { + "name": "getCpuRealtimePeriod", + "parameterTypes": [] + }, + { + "name": "getCpuRealtimeRuntime", + "parameterTypes": [] + }, + { + "name": "getCpuShares", + "parameterTypes": [] + }, + { + "name": "getCpusetCpus", + "parameterTypes": [] + }, + { + "name": "getCpusetMems", + "parameterTypes": [] + }, + { + "name": "getDeviceCgroupRules", + "parameterTypes": [] + }, + { + "name": "getDeviceRequests", + "parameterTypes": [] + }, + { + "name": "getDevices", + "parameterTypes": [] + }, + { + "name": "getDiskQuota", + "parameterTypes": [] + }, + { + "name": "getDns", + "parameterTypes": [] + }, + { + "name": "getDnsOptions", + "parameterTypes": [] + }, + { + "name": "getDnsSearch", + "parameterTypes": [] + }, + { + "name": "getExtraHosts", + "parameterTypes": [] + }, + { + "name": "getGroupAdd", + "parameterTypes": [] + }, + { + "name": "getInit", + "parameterTypes": [] + }, + { + "name": "getIoMaximumBandwidth", + "parameterTypes": [] + }, + { + "name": "getIoMaximumIOps", + "parameterTypes": [] + }, + { + "name": "getIpcMode", + "parameterTypes": [] + }, + { + "name": "getIsolation", + "parameterTypes": [] + }, + { + "name": "getKernelMemory", + "parameterTypes": [] + }, + { + "name": "getLxcConf", + "parameterTypes": [] + }, + { + "name": "getMemory", + "parameterTypes": [] + }, + { + "name": "getMemoryReservation", + "parameterTypes": [] + }, + { + "name": "getMemorySwap", + "parameterTypes": [] + }, + { + "name": "getMemorySwappiness", + "parameterTypes": [] + }, + { + "name": "getMounts", + "parameterTypes": [] + }, + { + "name": "getNanoCPUs", + "parameterTypes": [] + }, + { + "name": "getNetworkMode", + "parameterTypes": [] + }, + { + "name": "getOomKillDisable", + "parameterTypes": [] + }, + { + "name": "getOomScoreAdj", + "parameterTypes": [] + }, + { + "name": "getPidMode", + "parameterTypes": [] + }, + { + "name": "getPidsLimit", + "parameterTypes": [] + }, + { + "name": "getPortBindings", + "parameterTypes": [] + }, + { + "name": "getPrivileged", + "parameterTypes": [] + }, + { + "name": "getPublishAllPorts", + "parameterTypes": [] + }, + { + "name": "getReadonlyRootfs", + "parameterTypes": [] + }, + { + "name": "getRestartPolicy", + "parameterTypes": [] + }, + { + "name": "getRuntime", + "parameterTypes": [] + }, + { + "name": "getSecurityOpts", + "parameterTypes": [] + }, + { + "name": "getShmSize", + "parameterTypes": [] + }, + { + "name": "getStorageOpt", + "parameterTypes": [] + }, + { + "name": "getSysctls", + "parameterTypes": [] + }, + { + "name": "getTmpFs", + "parameterTypes": [] + }, + { + "name": "getUlimits", + "parameterTypes": [] + }, + { + "name": "getUsernsMode", + "parameterTypes": [] + }, + { + "name": "getUtSMode", + "parameterTypes": [] + }, + { + "name": "getVolumeDriver", + "parameterTypes": [] + }, + { + "name": "getVolumesFrom", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.model.Isolation", + "methods": [ + { + "name": "fromValue", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.Isolation", + "methods": [ + { + "name": "fromValue", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.Links", + "methods": [ + { + "name": "toPrimitive", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.model.LogConfig", + "methods": [ + { + "name": "", + "parameterTypes": [] + }, + { + "name": "setType", + "parameterTypes": [ + "com.github.dockerjava.api.model.LogConfig$LoggingType" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.LogConfig", + "methods": [ + { + "name": "", + "parameterTypes": [] + }, + { + "name": "setType", + "parameterTypes": [ + "com.github.dockerjava.api.model.LogConfig$LoggingType" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.model.LogConfig$LoggingType", + "methods": [ + { + "name": "fromValue", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.LogConfig$LoggingType", + "methods": [ + { + "name": "fromValue", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.model.NetworkSettings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.NetworkSettings", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.model.Ports", + "methods": [ + { + "name": "fromPrimitive", + "parameterTypes": [ + "java.util.Map" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.Ports", + "methods": [ + { + "name": "fromPrimitive", + "parameterTypes": [ + "java.util.Map" + ] + }, + { + "name": "toPrimitive", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.model.RestartPolicy", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.RestartPolicy", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdClusterImpl" + }, + "name": "com.github.dockerjava.api.model.Volume", + "methods": [ + { + "name": "", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.Volume", + "methods": [ + { + "name": "", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "com.github.dockerjava.api.model.Volumes", + "methods": [ + { + "name": "toPrimitive", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.api.WatchProgressRequest" + }, + "name": "com.google.protobuf.ExtensionRegistry", + "methods": [ + { + "name": "getEmptyRegistry", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientConnectionManager" + }, + "name": "io.grpc.census.InternalCensusStatsAccessor" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientConnectionManager" + }, + "name": "io.grpc.census.InternalCensusTracingAccessor" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.resolver.AbstractNameResolver" + }, + "name": "io.grpc.netty.WriteBufferingAndExceptionHandler", + "methods": [ + { + "name": "channelInactive", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelRead", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object" + ] + }, + { + "name": "close", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "connect", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.net.SocketAddress", + "java.net.SocketAddress", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "exceptionCaught", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Throwable" + ] + }, + { + "name": "flush", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "write", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object", + "io.netty.channel.ChannelPromise" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.resolver.AbstractNameResolver" + }, + "name": "io.netty.channel.ChannelDuplexHandler", + "methods": [ + { + "name": "bind", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.net.SocketAddress", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "deregister", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "disconnect", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "read", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.resolver.AbstractNameResolver" + }, + "name": "io.netty.channel.ChannelInboundHandlerAdapter", + "methods": [ + { + "name": "channelActive", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelReadComplete", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelRegistered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelUnregistered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelWritabilityChanged", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "userEventTriggered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.resolver.AbstractNameResolver" + }, + "name": "io.netty.channel.DefaultChannelPipeline$HeadContext", + "methods": [ + { + "name": "bind", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.net.SocketAddress", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "channelActive", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelInactive", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelRead", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object" + ] + }, + { + "name": "channelReadComplete", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelRegistered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelUnregistered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelWritabilityChanged", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "close", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "connect", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.net.SocketAddress", + "java.net.SocketAddress", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "deregister", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "disconnect", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "exceptionCaught", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Throwable" + ] + }, + { + "name": "flush", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "read", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "userEventTriggered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object" + ] + }, + { + "name": "write", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object", + "io.netty.channel.ChannelPromise" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.resolver.AbstractNameResolver" + }, + "name": "io.netty.channel.DefaultChannelPipeline$TailContext", + "methods": [ + { + "name": "channelActive", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelInactive", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelRead", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object" + ] + }, + { + "name": "channelReadComplete", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelRegistered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelUnregistered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelWritabilityChanged", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "exceptionCaught", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Throwable" + ] + }, + { + "name": "userEventTriggered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.resolver.AbstractNameResolver" + }, + "name": "io.netty.channel.epoll.Epoll" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "java.io.Closeable", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "java.io.Serializable", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "java.lang.AutoCloseable", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.WatchImpl$WatcherImpl" + }, + "name": "java.lang.StackWalker", + "methods": [ + { + "name": "walk", + "parameterTypes": [ + "java.util.function.Function" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.WatchImpl$WatcherImpl" + }, + "name": "java.lang.StackWalker$StackFrame", + "methods": [ + { + "name": "getClassName", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "java.net.UnixDomainSocketAddress", + "methods": [ + { + "name": "of", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.api.AuthRoleAddRequest" + }, + "name": "java.nio.Buffer", + "fields": [ + { + "name": "address" + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "java.security.SecureRandomParameters" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientConnectionManager" + }, + "name": "java.util.concurrent.atomic.LongAdder", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.resolver.AbstractNameResolver" + }, + "name": "java.util.concurrent.atomic.LongAdder", + "methods": [ + { + "name": "", + "parameterTypes": [] + }, + { + "name": "add", + "parameterTypes": [ + "long" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.ByteSequence" + }, + "name": "libcore.io.Memory" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.WatchImpl$$Lambda$606/0x0000000800eba4a0" + }, + "name": "org.mockito.configuration.MockitoConfiguration" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.ByteSequence" + }, + "name": "org.robolectric.Robolectric" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "org.testcontainers.shaded.com.github.dockerjava.core.command.AbstrAsyncDockerCmd", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "org.testcontainers.shaded.com.github.dockerjava.core.command.AbstrDockerCmd", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "org.testcontainers.shaded.com.github.dockerjava.core.command.CreateContainerCmdImpl$NetworkingConfig", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "getEndpointsConfig", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "org.testcontainers.shaded.com.github.dockerjava.core.command.ExecCreateCmdImpl", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "getContainerId", + "parameterTypes": [] + }, + { + "name": "getEnv", + "parameterTypes": [] + }, + { + "name": "getPrivileged", + "parameterTypes": [] + }, + { + "name": "getUser", + "parameterTypes": [] + }, + { + "name": "getWorkingDir", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "org.testcontainers.shaded.com.github.dockerjava.core.command.ExecStartCmdImpl", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "org.testcontainers.shaded.org.awaitility.core.ConditionFactory$1", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.api.AuthRoleAddRequest" + }, + "name": "sun.misc.Unsafe", + "allDeclaredFields": true, + "methods": [ + { + "name": "arrayBaseOffset", + "parameterTypes": [ + "java.lang.Class" + ] + }, + { + "name": "arrayIndexScale", + "parameterTypes": [ + "java.lang.Class" + ] + }, + { + "name": "copyMemory", + "parameterTypes": [ + "long", + "long", + "long" + ] + }, + { + "name": "copyMemory", + "parameterTypes": [ + "java.lang.Object", + "long", + "java.lang.Object", + "long", + "long" + ] + }, + { + "name": "getBoolean", + "parameterTypes": [ + "java.lang.Object", + "long" + ] + }, + { + "name": "getByte", + "parameterTypes": [ + "long" + ] + }, + { + "name": "getByte", + "parameterTypes": [ + "java.lang.Object", + "long" + ] + }, + { + "name": "getDouble", + "parameterTypes": [ + "java.lang.Object", + "long" + ] + }, + { + "name": "getFloat", + "parameterTypes": [ + "java.lang.Object", + "long" + ] + }, + { + "name": "getInt", + "parameterTypes": [ + "long" + ] + }, + { + "name": "getInt", + "parameterTypes": [ + "java.lang.Object", + "long" + ] + }, + { + "name": "getLong", + "parameterTypes": [ + "long" + ] + }, + { + "name": "getLong", + "parameterTypes": [ + "java.lang.Object", + "long" + ] + }, + { + "name": "getObject", + "parameterTypes": [ + "java.lang.Object", + "long" + ] + }, + { + "name": "objectFieldOffset", + "parameterTypes": [ + "java.lang.reflect.Field" + ] + }, + { + "name": "putBoolean", + "parameterTypes": [ + "java.lang.Object", + "long", + "boolean" + ] + }, + { + "name": "putByte", + "parameterTypes": [ + "long", + "byte" + ] + }, + { + "name": "putByte", + "parameterTypes": [ + "java.lang.Object", + "long", + "byte" + ] + }, + { + "name": "putDouble", + "parameterTypes": [ + "java.lang.Object", + "long", + "double" + ] + }, + { + "name": "putFloat", + "parameterTypes": [ + "java.lang.Object", + "long", + "float" + ] + }, + { + "name": "putInt", + "parameterTypes": [ + "long", + "int" + ] + }, + { + "name": "putInt", + "parameterTypes": [ + "java.lang.Object", + "long", + "int" + ] + }, + { + "name": "putLong", + "parameterTypes": [ + "long", + "long" + ] + }, + { + "name": "putLong", + "parameterTypes": [ + "java.lang.Object", + "long", + "long" + ] + }, + { + "name": "putObject", + "parameterTypes": [ + "java.lang.Object", + "long", + "java.lang.Object" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientConnectionManager" + }, + "name": "sun.nio.ch.SelectorImpl", + "fields": [ + { + "name": "publicSelectedKeys" + }, + { + "name": "selectedKeys" + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "name": "sun.security.provider.NativePRNG", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + } +] diff --git a/metadata/io.etcd/jetcd-core/0.7.5/resource-config.json b/metadata/io.etcd/jetcd-core/0.7.5/resource-config.json new file mode 100644 index 00000000..324fe5c4 --- /dev/null +++ b/metadata/io.etcd/jetcd-core/0.7.5/resource-config.json @@ -0,0 +1,13 @@ +{ + "resources": { + "includes": [ + { + "condition": { + "typeReachable": "io.etcd.jetcd.launcher.EtcdContainer" + }, + "pattern": "\\Qorg/testcontainers/utility/ResourceReaper.class\\E" + } + ] + }, + "bundles": [] +} diff --git a/metadata/io.etcd/jetcd-core/index.json b/metadata/io.etcd/jetcd-core/index.json new file mode 100644 index 00000000..222f9aef --- /dev/null +++ b/metadata/io.etcd/jetcd-core/index.json @@ -0,0 +1,10 @@ +[ + { + "latest": true, + "metadata-version": "0.7.5", + "module": "io.etcd:jetcd-core", + "tested-versions": [ + "0.7.5" + ] + } +] diff --git a/tests/src/index.json b/tests/src/index.json index d4d2495d..2c55abf6 100644 --- a/tests/src/index.json +++ b/tests/src/index.json @@ -527,6 +527,17 @@ } ] }, + { + "test-project-path": "io.etcd/jetcd-core/0.7.5", + "libraries": [ + { + "name": "io.etcd:jetcd-core", + "versions": [ + "0.7.5" + ] + } + ] + }, { "test-project-path": "org.mockito/mockito-core/4.8.1", "libraries": [ diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/.gitignore b/tests/src/io.etcd/jetcd-core/0.7.5/.gitignore new file mode 100644 index 00000000..c98c7875 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/.gitignore @@ -0,0 +1,4 @@ +gradlew.bat +gradlew +gradle/ +build/ diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/build.gradle b/tests/src/io.etcd/jetcd-core/0.7.5/build.gradle new file mode 100644 index 00000000..851d98fb --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/build.gradle @@ -0,0 +1,50 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ + +plugins { + id "org.graalvm.internal.tck" +} + +String libraryVersion = tck.testedLibraryVersion.get() + +dependencies { + testImplementation "io.etcd:jetcd-core:$libraryVersion" + testImplementation 'org.assertj:assertj-core:3.22.0' + testImplementation "io.etcd:jetcd-test:$libraryVersion" + testImplementation 'commons-io:commons-io:2.11.0' + testImplementation 'org.awaitility:awaitility:4.2.0' + testImplementation 'org.mockito:mockito-core:4.11.0' + testImplementation 'org.mockito:mockito-junit-jupiter:4.11.0' +} + +graalvmNative { + binaries { + test { + // We have to manually add the metadata because the org.graalvm.internal.tck gradle plugin does not automatically import + configurationFileDirectories.from(tck.metadataRoot.dir('net.java.dev.jna/jna/5.8.0')) + configurationFileDirectories.from(tck.metadataRoot.dir('org.testcontainers/testcontainers/1.17.6')) + configurationFileDirectories.from(tck.metadataRoot.dir('org.mockito/mockito-core/4.8.1')) + } + } + agent { + defaultMode = "conditional" + modes { + conditional { + userCodeFilterPath = "user-code-filter.json" + } + } + metadataCopy { + mergeWithExisting = true + inputTaskNames.add("test") + outputDirectories.add("src/test/resources/META-INF/native-image/io.etcd/jetcd-core") + } + } + metadataRepository { + enabled = true + version = "0.2.5" + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/gradle.properties b/tests/src/io.etcd/jetcd-core/0.7.5/gradle.properties new file mode 100644 index 00000000..e34b4961 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/gradle.properties @@ -0,0 +1,2 @@ +library.version = 0.7.5 +metadata.dir = io.etcd/jetcd-core/0.7.5/ diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/settings.gradle b/tests/src/io.etcd/jetcd-core/0.7.5/settings.gradle new file mode 100644 index 00000000..e46dc7a8 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/settings.gradle @@ -0,0 +1,13 @@ +pluginManagement { + def tckPath = Objects.requireNonNullElse( + System.getenv("GVM_TCK_TCKDIR"), + "../../../../tck-build-logic" + ) + includeBuild(tckPath) +} + +plugins { + id "org.graalvm.internal.tck-settings" version "1.0.0-SNAPSHOT" +} + +rootProject.name = 'io.etcd.jetcd-core_tests' diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io/etcd/jetcd/impl/ClientBuilderTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io/etcd/jetcd/impl/ClientBuilderTest.java new file mode 100644 index 00000000..45b2e337 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io/etcd/jetcd/impl/ClientBuilderTest.java @@ -0,0 +1,80 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io.etcd.jetcd.impl; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.ClientBuilder; +import io.vertx.grpc.VertxChannelBuilder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.net.URI; +import java.net.URISyntaxException; +import java.util.Random; +import java.util.stream.Stream; + +import static io_etcd.jetcd_core.impl.TestUtil.bytesOf; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +@SuppressWarnings("resource") +public class ClientBuilderTest { + static Stream namespaceProvider() { + return Stream.of( + Arguments.of(ByteSequence.EMPTY, ByteSequence.EMPTY), + Arguments.of(bytesOf("/namespace1/"), bytesOf("/namespace1/")), + Arguments.of(bytesOf("namespace2/"), bytesOf("namespace2/"))); + } + + @Test + public void testEndPoints_Null() { + assertThatThrownBy(() -> Client.builder().endpoints((URI) null)).isInstanceOf(NullPointerException.class); + } + + @Test + public void testEndPoints_Verify_Empty() { + assertThatThrownBy(() -> Client.builder().endpoints(new URI(""))).isInstanceOf(IllegalArgumentException.class); + } + + @Test + public void testEndPoints_Verify_SomeEmpty() { + assertThatThrownBy(() -> Client.builder().endpoints(new URI("http://127.0.0.1:2379"), new URI(""))) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + public void testBuild_WithoutEndpoints() { + assertThatThrownBy(() -> Client.builder().build()).isInstanceOf(IllegalStateException.class); + } + + @Test + public void testMaxInboundMessageSize() throws URISyntaxException { + final int value = 1024 + new Random().nextInt(10); + final ClientBuilder builder = Client.builder().endpoints(new URI("http://127.0.0.1:2379")).maxInboundMessageSize(value); + final VertxChannelBuilder channelBuilder = (VertxChannelBuilder) new ClientConnectionManager(builder) + .defaultChannelBuilder(); + assertThat(channelBuilder.nettyBuilder()).hasFieldOrPropertyWithValue("maxInboundMessageSize", value); + } + + @Test + public void testDefaultNamespace() throws URISyntaxException { + final ClientBuilder builder = Client.builder().endpoints(new URI("http://127.0.0.1:2379")); + final ClientConnectionManager connectionManager = new ClientConnectionManager(builder); + assertThat(connectionManager.getNamespace()).isEqualTo(ByteSequence.EMPTY); + } + + @ParameterizedTest + @MethodSource("namespaceProvider") + public void testNamespace(ByteSequence namespaceSetting, ByteSequence expectedNamespace) throws URISyntaxException { + final ClientBuilder builder = Client.builder().endpoints(new URI("http://127.0.0.1:2379")).namespace(namespaceSetting); + final ClientConnectionManager connectionManager = new ClientConnectionManager(builder); + assertThat(connectionManager.getNamespace()).isEqualTo(expectedNamespace); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io/etcd/jetcd/impl/WatchUnitTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io/etcd/jetcd/impl/WatchUnitTest.java new file mode 100644 index 00000000..4b646efe --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io/etcd/jetcd/impl/WatchUnitTest.java @@ -0,0 +1,367 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io.etcd.jetcd.impl; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.KeyValue; +import io.etcd.jetcd.Watch; +import io.etcd.jetcd.api.Event; +import io.etcd.jetcd.api.Event.EventType; +import io.etcd.jetcd.api.WatchGrpc.WatchImplBase; +import io.etcd.jetcd.api.WatchRequest; +import io.etcd.jetcd.api.WatchResponse; +import io.etcd.jetcd.common.exception.ClosedClientException; +import io.etcd.jetcd.common.exception.EtcdException; +import io.etcd.jetcd.options.WatchOption; +import io.etcd.jetcd.support.Errors; +import io.etcd.jetcd.test.GrpcServerExtension; +import io.etcd.jetcd.watch.WatchEvent; +import io.grpc.Status; +import io.grpc.stub.StreamObserver; +import io_etcd.jetcd_core.impl.TestUtil; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.mockito.ArgumentMatcher; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; + +import static io_etcd.jetcd_core.impl.TestUtil.bytesOf; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatExceptionOfType; +import static org.awaitility.Awaitility.await; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.Mockito.timeout; +import static org.mockito.Mockito.verify; + +@SuppressWarnings({"SameParameterValue", "ResultOfMethodCallIgnored"}) +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +@ExtendWith(MockitoExtension.class) +public class WatchUnitTest { + private static final ByteSequence KEY = bytesOf("test_key"); + @RegisterExtension + public final GrpcServerExtension grpcServerRule = new GrpcServerExtension().directExecutor(); + private Watch watchClient; + private ExecutorService executor = Executors.newFixedThreadPool(2); + private AtomicReference> responseObserverRef; + @Mock + private StreamObserver requestStreamObserverMock; + + private static ArgumentMatcher hasCreateKey(ByteSequence key) { + return o -> Arrays.equals(o.getCreateRequest().getKey().toByteArray(), key.getBytes()); + } + + private static WatchImplBase createWatchImpBase(AtomicReference> responseObserverRef, + StreamObserver requestStreamObserver) { + return new WatchImplBase() { + @Override + public StreamObserver watch(StreamObserver responseObserver) { + responseObserverRef.set(responseObserver); + return requestStreamObserver; + } + }; + } + + private static void assertEqualOnWatchResponses(io.etcd.jetcd.watch.WatchResponse expected, + io.etcd.jetcd.watch.WatchResponse actual) { + assertThat(actual.getEvents().size()).isEqualTo(expected.getEvents().size()); + for (int idx = 0; idx < expected.getEvents().size(); idx++) { + WatchEvent act = actual.getEvents().get(idx); + WatchEvent exp = actual.getEvents().get(idx); + assertThat(act.getEventType()).isEqualTo(exp.getEventType()); + assertEqualOnKeyValues(act.getKeyValue(), exp.getKeyValue()); + assertEqualOnKeyValues(act.getPrevKV(), exp.getPrevKV()); + } + } + + private static void assertEqualOnKeyValues(KeyValue act, KeyValue exp) { + assertThat(act.getModRevision()).isEqualTo(exp.getModRevision()); + assertThat(act.getCreateRevision()).isEqualTo(exp.getCreateRevision()); + assertThat(act.getLease()).isEqualTo(exp.getLease()); + assertThat(act.getValue().getBytes()).isEqualTo(exp.getValue().getBytes()); + assertThat(act.getVersion()).isEqualTo(exp.getVersion()); + } + + private static WatchResponse createWatchResponse(int id, Event... events) { + WatchResponse.Builder builder = WatchResponse.newBuilder().setCreated(true).setWatchId(id); + Arrays.stream(events).forEach(builder::addEvents); + return builder.build(); + } + + @BeforeEach + public void setUp() { + this.executor = Executors.newSingleThreadExecutor(); + this.responseObserverRef = new AtomicReference<>(); + this.grpcServerRule.getServiceRegistry().addService(createWatchImpBase(responseObserverRef, requestStreamObserverMock)); + this.watchClient = new WatchImpl(new ClientConnectionManager(Client.builder(), this.grpcServerRule.getChannel())); + } + + @AfterEach + public void tearDown() { + watchClient.close(); + grpcServerRule.getChannel().shutdownNow(); + executor.shutdownNow(); + } + + @Test + public void testCreateWatcherAfterClientClosed() { + watchClient.close(); + assertThatExceptionOfType(ClosedClientException.class).isThrownBy(() -> watchClient.watch(KEY, Watch.listener(TestUtil::noOpWatchResponseConsumer))); + } + + @Test + @Disabled("https://github.com/mockito/mockito/issues/2862") + public void testWatchOnSendingWatchCreateRequest() { + try (Watch.Watcher ignored = watchClient.watch( + KEY, + WatchOption.DEFAULT, + Watch.listener(TestUtil::noOpWatchResponseConsumer))) { + verify(this.requestStreamObserverMock, timeout(100).times(1)).onNext(argThat(hasCreateKey(KEY))); + } + } + + @Test + public void testWatcherListenOnResponse() throws InterruptedException { + CountDownLatch latch = new CountDownLatch(1); + AtomicReference ref = new AtomicReference<>(); + Watch.Listener listener = Watch.listener(response -> { + ref.set(response); + latch.countDown(); + }); + try (Watch.Watcher ignored = watchClient.watch(KEY, WatchOption.DEFAULT, listener)) { + WatchResponse createdResponse = createWatchResponse(0); + responseObserverRef.get().onNext(createdResponse); + WatchResponse putResponse = WatchResponse.newBuilder().setWatchId(0) + .addEvents(Event.newBuilder().setType(EventType.PUT).build()).build(); + responseObserverRef.get().onNext(putResponse); + latch.await(4, TimeUnit.SECONDS); + assertThat(ref.get()).isNotNull(); + assertThat(ref.get().getEvents().size()).isEqualTo(1); + assertThat(ref.get().getEvents().get(0).getEventType()).isEqualTo(WatchEvent.EventType.PUT); + } + } + + @Test + public void testWatcherListenOnWatcherClose() { + AtomicBoolean ref = new AtomicBoolean(); + Watch.Listener listener = Watch.listener( + TestUtil::noOpWatchResponseConsumer, + () -> ref.set(true)); + Watch.Watcher watcher = watchClient.watch(KEY, listener); + executor.execute(() -> { + try { + Thread.sleep(20); + watcher.close(); + } catch (InterruptedException ignored) { + } + }); + + await().atMost(15, TimeUnit.SECONDS).untilAsserted(() -> assertThat(ref.get()).isTrue()); + } + + @SuppressWarnings("PMD.UnusedLocalVariable") + @Test + public void testWatcherListenOnWatchClientClose() { + AtomicBoolean ref = new AtomicBoolean(); + Watch.Listener listener = Watch.listener( + TestUtil::noOpWatchResponseConsumer, + () -> ref.set(true)); + try (Watch.Watcher ignored1 = watchClient.watch(KEY, listener)) { + executor.execute(() -> { + try { + Thread.sleep(20); + watchClient.close(); + } catch (InterruptedException ignored) { + } + }); + await().atMost(15, TimeUnit.SECONDS).untilAsserted(() -> assertThat(ref.get()).isTrue()); + } + } + + @Test + public void testWatcherListenForMultiplePuts() throws InterruptedException { + CountDownLatch latch = new CountDownLatch(2); + List responses = new ArrayList<>(); + Watch.Listener listener = Watch.listener(r -> { + responses.add(r); + latch.countDown(); + }); + try (Watch.Watcher ignored = watchClient.watch(KEY, listener)) { + WatchResponse createdResponse = createWatchResponse(0); + responseObserverRef.get().onNext(createdResponse); + WatchResponse resp1 = WatchResponse.newBuilder().setWatchId(0) + .addEvents(Event.newBuilder().setType(EventType.PUT) + .setKv(io.etcd.jetcd.api.KeyValue.newBuilder().setModRevision(2).build()).build()) + .build(); + WatchResponse resp2 = WatchResponse.newBuilder().setWatchId(0).addEvents(Event.newBuilder() + .setType(EventType.PUT).setKv(io.etcd.jetcd.api.KeyValue.newBuilder().setModRevision(3).build()).build()) + .build(); + responseObserverRef.get().onNext(resp1); + responseObserverRef.get().onNext(resp2); + latch.await(4, TimeUnit.SECONDS); + assertThat(responses).hasSize(2); + assertEqualOnWatchResponses(responses.get(0), new io.etcd.jetcd.watch.WatchResponse(resp1)); + assertEqualOnWatchResponses(responses.get(1), new io.etcd.jetcd.watch.WatchResponse(resp2)); + } + } + + @Test + public void testWatcherDelete() throws InterruptedException { + CountDownLatch latch = new CountDownLatch(1); + AtomicReference ref = new AtomicReference<>(); + Watch.Listener listener = Watch.listener(response -> { + ref.set(response); + latch.countDown(); + }); + try (Watch.Watcher ignored = watchClient.watch(KEY, listener)) { + WatchResponse createdResponse = createWatchResponse(0); + responseObserverRef.get().onNext(createdResponse); + WatchResponse deleteResponse = WatchResponse.newBuilder().setWatchId(0) + .addEvents(Event.newBuilder().setType(EventType.DELETE).build()).build(); + responseObserverRef.get().onNext(deleteResponse); + latch.await(4, TimeUnit.SECONDS); + assertThat(ref.get()).isNotNull(); + assertEqualOnWatchResponses(ref.get(), new io.etcd.jetcd.watch.WatchResponse(deleteResponse)); + } + } + + @Test + public void testWatchOnUnrecoverableConnectionIssue() throws InterruptedException { + CountDownLatch latch = new CountDownLatch(1); + AtomicReference ref = new AtomicReference<>(); + Watch.Listener listener = Watch.listener(r -> { + }, t -> { + ref.set(t); + latch.countDown(); + }); + try (Watch.Watcher ignored = watchClient.watch(KEY, WatchOption.DEFAULT, listener)) { + WatchResponse createdResponse = createWatchResponse(0); + responseObserverRef.get().onNext(createdResponse); + responseObserverRef.get().onError(Status.ABORTED.withDescription("connection error").asRuntimeException()); + latch.await(4, TimeUnit.SECONDS); + assertThat(ref.get()).isNotNull(); + assertThat(ref.get()).isInstanceOf(EtcdException.class).hasMessageContaining("connection error"); + } + } + + @Test + public void testWatcherCreateOnCompactionError() throws InterruptedException { + CountDownLatch latch = new CountDownLatch(1); + AtomicReference ref = new AtomicReference<>(); + Watch.Listener listener = Watch.listener(r -> { + }, t -> { + ref.set(t); + latch.countDown(); + }); + try (Watch.Watcher ignored = watchClient.watch(KEY, listener)) { + WatchResponse createdResponse = createWatchResponse(0); + responseObserverRef.get().onNext(createdResponse); + WatchResponse compactedResponse = WatchResponse.newBuilder().setCanceled(true).setCompactRevision(2).build(); + responseObserverRef.get().onNext(compactedResponse); + latch.await(4, TimeUnit.SECONDS); + assertThat(ref.get()).isNotNull(); + assertThat(ref.get()).isInstanceOf(EtcdException.class).hasFieldOrPropertyWithValue("compactedRevision", 2L); + } + } + + @Test + public void testWatcherCreateOnCancellationWithNoReason() throws InterruptedException { + CountDownLatch latch = new CountDownLatch(1); + AtomicReference ref = new AtomicReference<>(); + Watch.Listener listener = Watch.listener(r -> { + }, t -> { + ref.set(t); + latch.countDown(); + }); + try (Watch.Watcher ignored = watchClient.watch(KEY, listener)) { + WatchResponse createdResponse = createWatchResponse(0); + responseObserverRef.get().onNext(createdResponse); + WatchResponse canceledResponse = WatchResponse.newBuilder().setCanceled(true).build(); + responseObserverRef.get().onNext(canceledResponse); + latch.await(4, TimeUnit.SECONDS); + assertThat(ref.get()).isNotNull(); + assertThat(ref.get()).isInstanceOf(EtcdException.class) + .hasMessageContaining("etcdserver: mvcc: required revision is a future revision"); + } + } + + @Test + public void testWatcherCreateOnCancellationWithReason() throws InterruptedException { + CountDownLatch latch = new CountDownLatch(1); + AtomicReference ref = new AtomicReference<>(); + Watch.Listener listener = Watch.listener(r -> { + }, t -> { + ref.set(t); + latch.countDown(); + }); + try (Watch.Watcher ignored = watchClient.watch(KEY, listener)) { + WatchResponse createdResponse = createWatchResponse(0); + responseObserverRef.get().onNext(createdResponse); + WatchResponse canceledResponse = WatchResponse.newBuilder().setCanceled(true).setCancelReason("bad reason").build(); + responseObserverRef.get().onNext(canceledResponse); + latch.await(4, TimeUnit.SECONDS); + assertThat(ref.get()).isNotNull(); + assertThat(ref.get()).isInstanceOf(EtcdException.class).hasMessageContaining(canceledResponse.getCancelReason()); + } + } + + @Test + public void testWatcherCreateOnInvalidWatchID() throws InterruptedException { + CountDownLatch latch = new CountDownLatch(1); + AtomicReference ref = new AtomicReference<>(); + Watch.Listener listener = Watch.listener(r -> { + }, t -> { + ref.set(t); + latch.countDown(); + }); + try (Watch.Watcher ignored = watchClient.watch(KEY, listener)) { + WatchResponse createdResponse = createWatchResponse(-1); + responseObserverRef.get().onNext(createdResponse); + latch.await(4, TimeUnit.SECONDS); + assertThat(ref.get()).isNotNull(); + assertThat(ref.get()).isInstanceOf(EtcdException.class) + .hasMessageContaining("etcd server failed to create watch id"); + } + } + + @Test + public void testWatcherWithRequireLeaderErrsOutOnNoLeader() throws InterruptedException { + CountDownLatch latch = new CountDownLatch(1); + AtomicReference ref = new AtomicReference<>(); + Watch.Listener listener = Watch.listener(r -> { + }, t -> { + ref.set(t); + latch.countDown(); + }); + try (Watch.Watcher watcher = watchClient.watch(KEY, listener)) { + WatchResponse createdResponse = createWatchResponse(0); + responseObserverRef.get().onNext(createdResponse); + responseObserverRef.get().onError(Status.UNAVAILABLE.withDescription(Errors.NO_LEADER_ERROR_MESSAGE).asRuntimeException()); + latch.await(4, TimeUnit.SECONDS); + assertThat(ref.get()).isNotNull(); + assertThat(ref.get()).isNotNull(); + assertThat(ref.get()).isInstanceOf(EtcdException.class) + .hasMessageContaining(Errors.NO_LEADER_ERROR_MESSAGE); + final WatchImpl.WatcherImpl wimpl = (WatchImpl.WatcherImpl) watcher; + assertThat(wimpl.isClosed()).isTrue(); + } + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io/etcd/jetcd/op/TxnTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io/etcd/jetcd/op/TxnTest.java new file mode 100644 index 00000000..bf327173 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io/etcd/jetcd/op/TxnTest.java @@ -0,0 +1,54 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io.etcd.jetcd.op; + +import io.etcd.jetcd.options.PutOption; +import org.junit.jupiter.api.Test; + +import static io_etcd.jetcd_core.impl.TestUtil.bytesOf; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +public class TxnTest { + private static final Cmp CMP = new Cmp(bytesOf("key"), Cmp.Op.GREATER, CmpTarget.value(bytesOf("value"))); + private static final Op OP = Op.put(bytesOf("key2"), bytesOf("value2"), PutOption.DEFAULT); + + @Test + @SuppressWarnings("FutureReturnValueIgnored") + public void testIfs() { + TxnImpl.newTxn((t) -> null).If(CMP).If(CMP).commit(); + } + + @Test + @SuppressWarnings("FutureReturnValueIgnored") + public void testThens() { + TxnImpl.newTxn((t) -> null).Then(OP).Then(OP).commit(); + } + + @Test + @SuppressWarnings("FutureReturnValueIgnored") + public void testElses() { + TxnImpl.newTxn((t) -> null).Else(OP).Else(OP).commit(); + } + + @Test + public void testIfAfterThen() { + assertThatThrownBy(() -> TxnImpl.newTxn((t) -> null).Then(OP).If(CMP).commit().get()) + .isInstanceOf(IllegalArgumentException.class).hasMessageContaining("cannot call If after Then!"); + } + + @Test + public void testIfAfterElse() { + assertThatThrownBy(() -> TxnImpl.newTxn((t) -> null).Else(OP).If(CMP).commit().get()) + .isInstanceOf(IllegalArgumentException.class).hasMessageContaining("cannot call If after Else!"); + } + + @Test + public void testThenAfterElse() { + assertThatThrownBy(() -> TxnImpl.newTxn((t) -> null).Else(OP).Then(OP).commit().get()) + .isInstanceOf(IllegalArgumentException.class).hasMessageContaining("cannot call Then after Else!"); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/AuthClientTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/AuthClientTest.java new file mode 100755 index 00000000..f463dc61 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/AuthClientTest.java @@ -0,0 +1,108 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.Auth; +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.KV; +import io.etcd.jetcd.auth.AuthRoleGetResponse; +import io.etcd.jetcd.auth.AuthRoleListResponse; +import io.etcd.jetcd.auth.Permission; +import io.etcd.jetcd.test.EtcdClusterExtension; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; + +import java.util.List; + +import static io_etcd.jetcd_core.impl.TestUtil.bytesOf; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +@SuppressWarnings("resource") +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class AuthClientTest { + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(1) + .build(); + private static final String rootString = "root"; + private static final ByteSequence rootPass = bytesOf("123"); + private static final String rootRoleString = "root"; + private static final String userString = "user"; + private static final String userRoleString = "userRole"; + private static Auth authDisabledAuthClient; + private static KV authDisabledKVClient; + private final ByteSequence rootRoleKey = bytesOf("root"); + private final ByteSequence rootRoleValue = bytesOf("b"); + private final ByteSequence rootRoleKeyRangeBegin = bytesOf("root"); + private final ByteSequence rootRoleKeyRangeEnd = bytesOf("root1"); + private final ByteSequence userRoleKey = bytesOf("foo"); + private final ByteSequence userRoleValue = bytesOf("bar"); + private final ByteSequence userRoleKeyRangeBegin = bytesOf("foo"); + private final ByteSequence userRoleKeyRangeEnd = bytesOf("foo1"); + private final ByteSequence root = bytesOf(rootString); + private final ByteSequence rootRole = bytesOf(rootRoleString); + private final ByteSequence user = bytesOf(userString); + private final ByteSequence userPass = bytesOf("userPass"); + private final ByteSequence userNewPass = bytesOf("newUserPass"); + private final ByteSequence userRole = bytesOf(userRoleString); + + @BeforeAll + public static void setupEnv() { + Client client = TestUtil.client(cluster).build(); + authDisabledKVClient = client.getKVClient(); + authDisabledAuthClient = client.getAuthClient(); + } + + @Test + public void testAuth() throws Exception { + authDisabledAuthClient.roleAdd(rootRole).get(); + authDisabledAuthClient.roleAdd(userRole).get(); + final AuthRoleListResponse response = authDisabledAuthClient.roleList().get(); + assertThat(response.getRoles()).containsOnly(rootRoleString, userRoleString); + authDisabledAuthClient.roleGrantPermission(rootRole, rootRoleKeyRangeBegin, rootRoleKeyRangeEnd, Permission.Type.READWRITE).get(); + authDisabledAuthClient.roleGrantPermission(userRole, userRoleKeyRangeBegin, userRoleKeyRangeEnd, Permission.Type.READWRITE).get(); + authDisabledAuthClient.userAdd(root, rootPass).get(); + authDisabledAuthClient.userAdd(user, userPass).get(); + authDisabledAuthClient.userChangePassword(user, userNewPass).get(); + List users = authDisabledAuthClient.userList().get().getUsers(); + assertThat(users).containsOnly(rootString, userString); + authDisabledAuthClient.userGrantRole(root, rootRole).get(); + authDisabledAuthClient.userGrantRole(user, rootRole).get(); + authDisabledAuthClient.userGrantRole(user, userRole).get(); + assertThat(authDisabledAuthClient.userGet(root).get().getRoles()).containsOnly(rootRoleString); + assertThat(authDisabledAuthClient.userGet(user).get().getRoles()).containsOnly(rootRoleString, userRoleString); + authDisabledAuthClient.authEnable().get(); + final Client userClient = TestUtil.client(cluster).user(user).password(userNewPass).build(); + final Client rootClient = TestUtil.client(cluster).user(root).password(rootPass).build(); + userClient.getKVClient().put(rootRoleKey, rootRoleValue).get(); + userClient.getKVClient().put(userRoleKey, userRoleValue).get(); + userClient.getKVClient().get(rootRoleKey).get(); + userClient.getKVClient().get(userRoleKey).get(); + assertThatThrownBy(() -> authDisabledKVClient.put(rootRoleKey, rootRoleValue).get()).hasMessageContaining("etcdserver: user name is empty"); + assertThatThrownBy(() -> authDisabledKVClient.put(userRoleKey, rootRoleValue).get()).hasMessageContaining("etcdserver: user name is empty"); + assertThatThrownBy(() -> authDisabledKVClient.get(rootRoleKey).get()).hasMessageContaining("etcdserver: user name is empty"); + assertThatThrownBy(() -> authDisabledKVClient.get(userRoleKey).get()).hasMessageContaining("etcdserver: user name is empty"); + AuthRoleGetResponse roleGetResponse = userClient.getAuthClient().roleGet(rootRole).get(); + assertThat(roleGetResponse.getPermissions().size()).isNotEqualTo(0); + roleGetResponse = userClient.getAuthClient().roleGet(userRole).get(); + assertThat(roleGetResponse.getPermissions().size()).isNotEqualTo(0); + rootClient.getAuthClient().userRevokeRole(user, rootRole).get(); + final KV kvClient = userClient.getKVClient(); + assertThatThrownBy(() -> kvClient.get(rootRoleKey).get()).isNotNull(); + assertThat(kvClient.get(userRoleKey).get().getCount()).isNotEqualTo(0); + rootClient.getAuthClient().roleRevokePermission(userRole, userRoleKeyRangeBegin, userRoleKeyRangeEnd).get(); + assertThatThrownBy(() -> userClient.getKVClient().get(userRoleKey).get()).isNotNull(); + rootClient.getAuthClient().authDisable().get(); + authDisabledAuthClient.userDelete(root).get(); + authDisabledAuthClient.userDelete(user).get(); + authDisabledAuthClient.roleDelete(rootRole).get(); + authDisabledAuthClient.roleDelete(userRole).get(); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/ClientConnectionManagerTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/ClientConnectionManagerTest.java new file mode 100644 index 00000000..d0a5f635 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/ClientConnectionManagerTest.java @@ -0,0 +1,103 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.Auth; +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.ClientBuilder; +import io.etcd.jetcd.auth.AuthDisableResponse; +import io.etcd.jetcd.kv.PutResponse; +import io.etcd.jetcd.test.EtcdClusterExtension; +import io.grpc.CallOptions; +import io.grpc.Channel; +import io.grpc.ClientCall; +import io.grpc.ClientInterceptor; +import io.grpc.ForwardingClientCall; +import io.grpc.Metadata; +import io.grpc.MethodDescriptor; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; + +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +import static io_etcd.jetcd_core.impl.TestUtil.bytesOf; +import static org.assertj.core.api.Assertions.assertThat; + +@SuppressWarnings({"resource", "ResultOfMethodCallIgnored"}) +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class ClientConnectionManagerTest { + private final String ROOT_STRING = "root"; + private final ByteSequence ROOT = bytesOf(ROOT_STRING); + private final ByteSequence ROOT_PASS = bytesOf("123"); + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(1) + .build(); + + @Test + public void testEndpoints() throws InterruptedException, ExecutionException, TimeoutException { + try (Client client = Client.builder().endpoints(cluster.clientEndpoints()).build()) { + client.getKVClient().put(bytesOf("sample_key"), bytesOf("sample_key")).get(15, TimeUnit.SECONDS); + } + } + + @Test + public void testHeaders() throws InterruptedException, ExecutionException { + final CountDownLatch latch = new CountDownLatch(1); + final ClientBuilder builder = TestUtil.client(cluster) + .header("MyHeader1", "MyHeaderVal1") + .header("MyHeader2", "MyHeaderVal2") + .interceptor(new ClientInterceptor() { + @Override + public ClientCall interceptCall(MethodDescriptor method, + CallOptions callOptions, Channel next) { + return new ForwardingClientCall.SimpleForwardingClientCall<>( + next.newCall(method, callOptions)) { + @Override + public void start(Listener responseListener, Metadata headers) { + super.start(responseListener, headers); + assertThat(headers.get(Metadata.Key.of("MyHeader1", Metadata.ASCII_STRING_MARSHALLER))).isEqualTo("MyHeaderVal1"); + assertThat(headers.get(Metadata.Key.of("MyHeader2", Metadata.ASCII_STRING_MARSHALLER))).isEqualTo("MyHeaderVal2"); + latch.countDown(); + } + }; + } + }); + try (Client client = builder.build()) { + CompletableFuture future = client.getKVClient().put(bytesOf("sample_key"), bytesOf("sample_key")); + latch.await(1, TimeUnit.MINUTES); + future.get(); + } + } + + @Test + public void testAuthHeaders() throws InterruptedException, ExecutionException { + final CountDownLatch latch = new CountDownLatch(1); + Auth authClient = TestUtil.client(cluster).build().getAuthClient(); + authClient.userAdd(ROOT, ROOT_PASS).get(); + ByteSequence role = bytesOf("root"); + authClient.userGrantRole(ROOT, role).get(); + authClient.authEnable().get(); + final ClientBuilder builder = TestUtil.client(cluster) + .authHeader("MyAuthHeader", "MyAuthHeaderVal").header("MyHeader2", "MyHeaderVal2") + .user(ROOT).password(ROOT_PASS); + assertThat(builder.authHeaders().get(Metadata.Key.of("MyAuthHeader", Metadata.ASCII_STRING_MARSHALLER))) + .isEqualTo("MyAuthHeaderVal"); + try (Client client = builder.build()) { + CompletableFuture future = client.getAuthClient().authDisable(); + latch.await(10, TimeUnit.SECONDS); + future.get(); + } + authClient.userRevokeRole(ROOT, role).get(); + authClient.userDelete(ROOT).get(); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/ClusterClientTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/ClusterClientTest.java new file mode 100644 index 00000000..04fab5fe --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/ClusterClientTest.java @@ -0,0 +1,100 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.Client; +import io.etcd.jetcd.Cluster; +import io.etcd.jetcd.cluster.Member; +import io.etcd.jetcd.test.EtcdClusterExtension; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.testcontainers.containers.Network; + +import java.util.List; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +import static org.assertj.core.api.Assertions.assertThat; + +@SuppressWarnings("resource") +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class ClusterClientTest { + private static final Network NETWORK = Network.newNetwork(); + + @RegisterExtension + public static final EtcdClusterExtension n1 = EtcdClusterExtension.builder() + .withNodes(1) + .withPrefix("n1") + .withNetwork(NETWORK) + .build(); + @RegisterExtension + public static final EtcdClusterExtension n2 = EtcdClusterExtension.builder() + .withNodes(1) + .withPrefix("n2") + .withNetwork(NETWORK) + .build(); + @RegisterExtension + public static final EtcdClusterExtension n3 = EtcdClusterExtension.builder() + .withNodes(1) + .withPrefix("n3") + .withNetwork(NETWORK) + .build(); + + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(3) + .withPrefix("cluster") + .build(); + + @Test + public void testMemberList() throws ExecutionException, InterruptedException { + try (Client client = TestUtil.client(cluster).build()) { + assertThat(client.getClusterClient().listMember().get().getMembers()).hasSize(3); + } + } + + @Test + @Disabled("io.etcd.jetcd.common.exception.EtcdException") + public void testMemberManagement() throws ExecutionException, InterruptedException, TimeoutException { + final Client client = Client.builder().endpoints(n1.clientEndpoints()).build(); + final Cluster clusterClient = client.getClusterClient(); + Member m2 = clusterClient.addMember(n2.peerEndpoints()) + .get(5, TimeUnit.SECONDS) + .getMember(); + assertThat(m2).isNotNull(); + assertThat(clusterClient.listMember().get().getMembers()).hasSize(2); + } + + @Test + @Disabled("io.etcd.jetcd.common.exception.EtcdException") + public void testMemberManagementAddNonLearner() throws ExecutionException, InterruptedException, TimeoutException { + final Client client = Client.builder().endpoints(n1.clientEndpoints()).build(); + final Cluster clusterClient = client.getClusterClient(); + Member m2 = clusterClient.addMember(n2.peerEndpoints(), false).get(5, TimeUnit.SECONDS).getMember(); + assertThat(m2).isNotNull(); + assertThat(m2.isLearner()).isFalse(); + List members = clusterClient.listMember().get().getMembers(); + assertThat(members).hasSize(2); + assertThat(members.stream().filter(Member::isLearner).findAny()).isEmpty(); + } + + @Test + public void testMemberManagementAddLearner() throws ExecutionException, InterruptedException, TimeoutException { + final Client client = Client.builder().endpoints(n1.clientEndpoints()).build(); + final Cluster clusterClient = client.getClusterClient(); + Member m2 = clusterClient.addMember(n2.peerEndpoints(), true) + .get(5, TimeUnit.SECONDS) + .getMember(); + assertThat(m2).isNotNull(); + assertThat(m2.isLearner()).isTrue(); + List members = clusterClient.listMember().get().getMembers(); + assertThat(members).hasSize(2); + assertThat(members.stream().filter(Member::isLearner).findAny()).isPresent(); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/ElectionTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/ElectionTest.java new file mode 100644 index 00000000..cc58072c --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/ElectionTest.java @@ -0,0 +1,220 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.Election; +import io.etcd.jetcd.KV; +import io.etcd.jetcd.KeyValue; +import io.etcd.jetcd.Lease; +import io.etcd.jetcd.election.CampaignResponse; +import io.etcd.jetcd.election.LeaderKey; +import io.etcd.jetcd.election.LeaderResponse; +import io.etcd.jetcd.election.NoLeaderException; +import io.etcd.jetcd.election.NotLeaderException; +import io.etcd.jetcd.options.GetOption; +import io.etcd.jetcd.test.EtcdClusterExtension; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; + +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.IntStream; + +import static io_etcd.jetcd_core.impl.TestUtil.randomByteSequence; +import static io_etcd.jetcd_core.impl.TestUtil.randomString; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.fail; + +@SuppressWarnings({"resource", "CatchMayIgnoreException", "ResultOfMethodCallIgnored"}) +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class ElectionTest { + private static final int OPERATION_TIMEOUT = 5; + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(3) + .build(); + private static Election electionClient; + private static Lease leaseClient; + private static KV kvClient; + + @BeforeAll + public static void setUp() { + Client client = TestUtil.client(cluster).build(); + electionClient = client.getElectionClient(); + leaseClient = client.getLeaseClient(); + kvClient = client.getKVClient(); + } + + @Test + public void testIsolatedElection() throws Exception { + ByteSequence electionName = ByteSequence.from(randomString(), StandardCharsets.UTF_8); + long leaseId = leaseClient.grant(10).get().getID(); + ByteSequence firstProposal = ByteSequence.from("proposal1", StandardCharsets.UTF_8); + CampaignResponse campaignResponse = electionClient.campaign(electionName, leaseId, firstProposal) + .get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + assertThat(campaignResponse.getLeader()).isNotNull(); + assertThat(campaignResponse.getLeader().getLease()).isEqualTo(leaseId); + assertThat(campaignResponse.getLeader().getName()).isEqualTo(electionName); + GetOption getOption = GetOption.newBuilder().isPrefix(true).build(); + List keys = kvClient.get(electionName, getOption).get().getKvs(); + assertThat(keys.size()).isEqualTo(1); + assertThat(keys.get(0).getKey().toString()).isEqualTo(campaignResponse.getLeader().getKey().toString()); + assertThat(keys.get(0).getValue()).isEqualTo(firstProposal); + LeaderResponse leaderResponse = electionClient.leader(electionName) + .get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + assertThat(leaderResponse.getKv().getKey()).isEqualTo(campaignResponse.getLeader().getKey()); + assertThat(leaderResponse.getKv().getValue()).isEqualTo(firstProposal); + assertThat(leaderResponse.getKv().getLease()).isEqualTo(leaseId); + assertThat(leaderResponse.getKv().getCreateRevision()).isEqualTo(campaignResponse.getLeader().getRevision()); + ByteSequence secondProposal = ByteSequence.from("proposal2", StandardCharsets.UTF_8); + electionClient.proclaim(campaignResponse.getLeader(), secondProposal).get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + keys = kvClient.get(electionName, getOption).get().getKvs(); + assertThat(keys.size()).isEqualTo(1); + assertThat(keys.get(0).getValue()).isEqualTo(secondProposal); + electionClient.resign(campaignResponse.getLeader()).get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + keys = kvClient.get(electionName, getOption).get().getKvs(); + assertThat(keys).isEmpty(); + leaseClient.revoke(leaseId).get(); + } + + @Test + public void testEmptyElection() throws Exception { + ByteSequence electionName = ByteSequence.from(randomString(), StandardCharsets.UTF_8); + try { + electionClient.leader(electionName).get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + fail("etcd communicates missing leader with error"); + } catch (ExecutionException e) { + assertThat(e.getCause()).isInstanceOf(NoLeaderException.class); + } + } + + @Test + public void testRetryCampaignWithDifferentValue() throws Exception { + ByteSequence electionName = ByteSequence.from(randomString(), StandardCharsets.UTF_8); + long leaseId = leaseClient.grant(10).get().getID(); + ByteSequence firstProposal = ByteSequence.from("proposal1", StandardCharsets.UTF_8); + CampaignResponse campaignResponse1 = electionClient.campaign(electionName, leaseId, firstProposal) + .get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + ByteSequence secondProposal = ByteSequence.from("proposal2", StandardCharsets.UTF_8); + CampaignResponse campaignResponse2 = electionClient.campaign(electionName, leaseId, secondProposal) + .get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + LeaderResponse leaderResponse = electionClient.leader(electionName).get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + assertThat(leaderResponse.getKv().getKey()).isEqualTo(campaignResponse1.getLeader().getKey()); + assertThat(campaignResponse1.getLeader().getKey()).isEqualTo(campaignResponse2.getLeader().getKey()); + assertThat(campaignResponse1.getLeader().getRevision()).isEqualTo(campaignResponse2.getLeader().getRevision()); + GetOption getOption = GetOption.newBuilder().isPrefix(true).build(); + List keys = kvClient.get(electionName, getOption).get().getKvs(); + assertThat(keys.size()).isEqualTo(1); + assertThat(keys.get(0).getValue()).isEqualTo(secondProposal); + electionClient.resign(campaignResponse1.getLeader()).get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + leaseClient.revoke(leaseId).get(); + } + + @Test + public void testProposeValueNotBeingLeader() throws Exception { + ByteSequence electionName = ByteSequence.from(randomString(), StandardCharsets.UTF_8); + LeaderKey leaderKey = new LeaderKey(electionName, randomByteSequence(), 1, 1); + ByteSequence proposal = ByteSequence.from("proposal", StandardCharsets.UTF_8); + try { + electionClient.proclaim(leaderKey, proposal).get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + fail("Cannot proclaim proposal not being a leader"); + } catch (ExecutionException e) { + assertThat(e.getCause()).isInstanceOf(NotLeaderException.class); + } + GetOption getOption = GetOption.newBuilder().isPrefix(true).build(); + List keys = kvClient.get(electionName, getOption).get().getKvs(); + assertThat(keys).isEmpty(); + } + + @Test + public void testObserveElections() throws Exception { + int electionCount = 3; + final AtomicInteger electionsSeen = new AtomicInteger(0); + ByteSequence electionName = ByteSequence.from(randomString(), StandardCharsets.UTF_8); + electionClient.observe(electionName, new Election.Listener() { + @Override + public void onNext(LeaderResponse response) { + electionsSeen.incrementAndGet(); + } + + @Override + public void onError(Throwable error) { + } + + @Override + public void onCompleted() { + } + }); + long leaseId = leaseClient.grant(10).get().getID(); + for (int i = 0; i < electionCount; ++i) { + ByteSequence proposal = ByteSequence.from(randomString(), StandardCharsets.UTF_8); + CampaignResponse campaignResponse = electionClient.campaign(electionName, leaseId, proposal) + .get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + Thread.sleep(100); + electionClient.resign(campaignResponse.getLeader()).get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + } + TestUtil.waitForCondition( + () -> electionsSeen.get() == electionCount, OPERATION_TIMEOUT * 1000, + "Observer did not receive expected notifications, got: " + electionsSeen.get()); + leaseClient.revoke(leaseId).get(); + } + + @Test + public void testSynchronizationBarrier() throws Exception { + final int threadCount = 5; + final Random random = new Random(); + ByteSequence electionName = ByteSequence.from(randomString(), StandardCharsets.UTF_8); + final AtomicInteger sharedVariable = new AtomicInteger(0); + List clients = new ArrayList<>(threadCount); + List leases = new ArrayList<>(threadCount); + for (int i = 0; i < threadCount; ++i) { + Client client = TestUtil.client(cluster).build(); + long leaseId = client.getLeaseClient().grant(100).get().getID(); + clients.add(client); + leases.add(leaseId); + } + ExecutorService executor = Executors.newFixedThreadPool(threadCount); + List> futures = new ArrayList<>(threadCount); + IntStream.range(0, threadCount).forEach(id -> { + final ByteSequence proposal = ByteSequence.from(Integer.toString(id), StandardCharsets.UTF_8); + futures.add(executor.submit(() -> { + try { + Election electionClient = clients.get(id).getElectionClient(); + CampaignResponse campaignResponse = electionClient.campaign(electionName, leases.get(id), proposal) + .get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + int localCopy = sharedVariable.get(); + Thread.sleep(200 + random.nextInt(300)); + sharedVariable.set(localCopy + 1); + electionClient.resign(campaignResponse.getLeader()).get(OPERATION_TIMEOUT, TimeUnit.SECONDS); + } catch (Exception e) { + fail("Unexpected error in thread {}: {}", id, e); + } + })); + }); + executor.shutdown(); + executor.awaitTermination(threadCount * OPERATION_TIMEOUT, TimeUnit.SECONDS); + futures.forEach(f -> assertThat(f).isDone()); + assertThat(sharedVariable.get()).isEqualTo(threadCount); + GetOption getOption = GetOption.newBuilder().isPrefix(true).build(); + assertThat(kvClient.get(electionName, getOption).get().getCount()).isEqualTo(0L); + for (int i = 0; i < threadCount; ++i) { + clients.get(i).getLeaseClient().revoke(leases.get(i)).get(); + clients.get(i).close(); + } + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/KVNamespaceTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/KVNamespaceTest.java new file mode 100644 index 00000000..a27f316f --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/KVNamespaceTest.java @@ -0,0 +1,357 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import com.google.protobuf.ByteString; +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.KV; +import io.etcd.jetcd.KeyValue; +import io.etcd.jetcd.Txn; +import io.etcd.jetcd.kv.DeleteResponse; +import io.etcd.jetcd.kv.GetResponse; +import io.etcd.jetcd.kv.PutResponse; +import io.etcd.jetcd.kv.TxnResponse; +import io.etcd.jetcd.op.Cmp; +import io.etcd.jetcd.op.CmpTarget; +import io.etcd.jetcd.op.Op; +import io.etcd.jetcd.options.DeleteOption; +import io.etcd.jetcd.options.GetOption; +import io.etcd.jetcd.options.PutOption; +import io.etcd.jetcd.support.Util; +import io.etcd.jetcd.test.EtcdClusterExtension; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.Stream; + +import static io_etcd.jetcd_core.impl.TestUtil.byteStringOf; +import static io_etcd.jetcd_core.impl.TestUtil.bytesOf; +import static org.assertj.core.api.Assertions.assertThat; + +@SuppressWarnings("resource") +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class KVNamespaceTest { + private static final ByteSequence END_KEY = ByteSequence.from(new byte[]{0}); + + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(3) + .build(); + + private KV kvClient; + private KV kvClientWithNamespace; + private KV kvClientWithNamespace2; + + private static final AtomicInteger keyIndex = new AtomicInteger(-1); + + @AfterEach + public void cleanUpCase() { + if (kvClient != null) { + kvClient.close(); + kvClient = null; + } + if (kvClientWithNamespace != null) { + kvClientWithNamespace.close(); + kvClientWithNamespace = null; + } + if (kvClientWithNamespace2 != null) { + kvClientWithNamespace2.close(); + kvClientWithNamespace2 = null; + } + } + + static Stream namespaceProvider() { + return Stream.of( + Arguments.of(bytesOf("pfx/"), byteStringOf("a"), null, byteStringOf("pfx/a"), null), + Arguments.of(bytesOf("pfx/"), byteStringOf("abc"), byteStringOf("def"), byteStringOf("pfx/abc"), + byteStringOf("pfx/def")), + Arguments.of(bytesOf("pfx/"), byteStringOf("abc"), ByteString.copyFrom(new byte[]{0}), + byteStringOf("pfx/abc"), byteStringOf("pfx0")), + Arguments.of(ByteSequence.from(new byte[]{(byte) 0xff, (byte) 0xff}), byteStringOf("abc"), + ByteString.copyFrom(new byte[]{0}), + ByteString.copyFrom(new byte[]{(byte) 0xff, (byte) 0xff, 'a', 'b', 'c'}), + ByteString.copyFrom(new byte[]{0}))); + } + + @ParameterizedTest + @MethodSource("namespaceProvider") + public void testPrefixNamespace(ByteSequence namespace, ByteString key, ByteString end, ByteString expectedNsKey, + ByteString expectedNsEnd) { + ByteString nsKey = Util.prefixNamespace(key, namespace); + assertThat(nsKey).isEqualTo(expectedNsKey); + if (end != null) { + ByteString nsEnd = Util.prefixNamespaceToRangeEnd(end, namespace); + assertThat(nsEnd).isEqualTo(expectedNsEnd); + } + } + + @Test + public void testKV() throws Exception { + kvClient = TestUtil.client(cluster).build().getKVClient(); + ByteSequence namespace = ByteSequence + .from(TestUtil.randomByteSequence().concat(ByteSequence.NAMESPACE_DELIMITER).getBytes()); + kvClientWithNamespace = TestUtil.client(cluster).namespace(namespace).build().getKVClient(); + ByteSequence namespace2 = ByteSequence.from(TestUtil.randomByteSequence().concat(ByteSequence.NAMESPACE_DELIMITER).getBytes()); + kvClientWithNamespace2 = TestUtil.client(cluster).namespace(namespace2).build().getKVClient(); + ByteSequence key = getNonexistentKey(); + ByteSequence nsKey = ByteSequence.from(namespace.concat(key).getBytes()); + ByteSequence value; + assertNonexistentKey(kvClient, nsKey); + assertNonexistentKey(kvClientWithNamespace, key); + assertNonexistentKey(kvClientWithNamespace2, key); + value = TestUtil.randomByteSequence(); + assertThat(putKVWithAssertion(kvClient, key, value, null)).isFalse(); + assertExistentKey(kvClient, key, value); + assertNonexistentKey(kvClientWithNamespace, key); + assertNonexistentKey(kvClientWithNamespace2, key); + deleteKVWithAssertion(kvClient, key, value); + value = TestUtil.randomByteSequence(); + assertThat(putKVWithAssertion(kvClient, nsKey, value, null)).isFalse(); + assertExistentKey(kvClient, nsKey, value); + assertExistentKey(kvClientWithNamespace, key, value); + assertNonexistentKey(kvClientWithNamespace2, key); + ByteSequence prevValue = value; + value = TestUtil.randomByteSequence(); + assertThat(putKVWithAssertion(kvClientWithNamespace, key, value, prevValue)).isTrue(); + assertExistentKey(kvClient, nsKey, value); + assertExistentKey(kvClientWithNamespace, key, value); + assertNonexistentKey(kvClientWithNamespace2, key); + deleteKVWithAssertion(kvClientWithNamespace, key, value); + List kvsOfNoNamespace = Arrays.asList( + new TestKeyValue(getNonexistentKey(), TestUtil.randomByteSequence()), + new TestKeyValue(getNonexistentKey(), TestUtil.randomByteSequence()), + new TestKeyValue(getNonexistentKey(), TestUtil.randomByteSequence())); + putKVsWithAssertion(kvClient, kvsOfNoNamespace); + for (TestKeyValue keyValue : kvsOfNoNamespace) { + assertExistentKey(kvClient, keyValue.key, keyValue.value); + } + List kvsOfNamespace = Arrays.asList( + new TestKeyValue(getNonexistentKey(), TestUtil.randomByteSequence()), + new TestKeyValue(getNonexistentKey(), TestUtil.randomByteSequence()), + new TestKeyValue(getNonexistentKey(), TestUtil.randomByteSequence()), + new TestKeyValue(getNonexistentKey(), TestUtil.randomByteSequence())); + putKVsWithAssertion(kvClientWithNamespace, kvsOfNamespace); + for (TestKeyValue keyValue : kvsOfNamespace) { + assertExistentKey(kvClientWithNamespace, keyValue.key, keyValue.value); + } + List kvsOfNamespace2 = Arrays.asList( + new TestKeyValue(getNonexistentKey(), TestUtil.randomByteSequence()), + new TestKeyValue(getNonexistentKey(), TestUtil.randomByteSequence()), + new TestKeyValue(getNonexistentKey(), TestUtil.randomByteSequence()), + new TestKeyValue(getNonexistentKey(), TestUtil.randomByteSequence()), + new TestKeyValue(getNonexistentKey(), TestUtil.randomByteSequence())); + putKVsWithAssertion(kvClientWithNamespace2, kvsOfNamespace2); + for (TestKeyValue keyValue : kvsOfNamespace2) { + assertExistentKey(kvClientWithNamespace2, keyValue.key, keyValue.value); + } + assertExistentKVs(kvClient, kvsOfNoNamespace.get(0).key, END_KEY, kvsOfNoNamespace); + assertExistentKVs(kvClientWithNamespace, kvsOfNamespace.get(0).key, END_KEY, kvsOfNamespace); + assertExistentKVs(kvClientWithNamespace2, kvsOfNamespace2.get(0).key, END_KEY, kvsOfNamespace2); + assertExistentKVs(kvClient, kvsOfNoNamespace.get(0).key, kvsOfNoNamespace.get(2).key, + kvsOfNoNamespace.subList(0, 2)); + assertExistentKVs(kvClientWithNamespace, kvsOfNamespace.get(1).key, kvsOfNamespace.get(3).key, + kvsOfNamespace.subList(1, 3)); + assertExistentKVs(kvClientWithNamespace2, kvsOfNamespace2.get(1).key, kvsOfNamespace2.get(3).key, + kvsOfNamespace2.subList(1, 3)); + deleteKVsWithAssertion(kvClient, kvsOfNoNamespace.get(0).key, kvsOfNoNamespace.get(2).key, + kvsOfNoNamespace.subList(0, 2)); + deleteKVsWithAssertion(kvClientWithNamespace, kvsOfNamespace.get(1).key, kvsOfNamespace.get(3).key, + kvsOfNamespace.subList(1, 3)); + deleteKVsWithAssertion(kvClientWithNamespace2, kvsOfNamespace2.get(1).key, kvsOfNamespace2.get(3).key, + kvsOfNamespace2.subList(1, 3)); + deleteKVsWithAssertion(kvClient, kvsOfNoNamespace.get(2).key, END_KEY, kvsOfNoNamespace.subList(2, 3)); + deleteKVsWithAssertion(kvClientWithNamespace, kvsOfNamespace.get(3).key, END_KEY, kvsOfNamespace.subList(3, 4)); + deleteKVsWithAssertion(kvClientWithNamespace2, kvsOfNamespace2.get(3).key, END_KEY, kvsOfNamespace2.subList(3, 5)); + } + + @Test + public void testTxn() throws Exception { + kvClient = TestUtil.client(cluster).build().getKVClient(); + ByteSequence namespace = ByteSequence.from(TestUtil.randomByteSequence().concat(ByteSequence.NAMESPACE_DELIMITER).getBytes()); + kvClientWithNamespace = TestUtil.client(cluster).namespace(namespace).build().getKVClient(); + ByteSequence cmpKey = getNonexistentKey(); + putKVWithAssertion(kvClient, cmpKey, TestUtil.randomByteSequence(), null); + ByteSequence key1 = getNonexistentKey(); + ByteSequence value1 = TestUtil.randomByteSequence(); + putKVWithAssertion(kvClientWithNamespace, key1, value1, null); + ByteSequence key2 = getNonexistentKey(); + ByteSequence value2 = TestUtil.randomByteSequence(); + putKVWithAssertion(kvClientWithNamespace, key2, value2, null); + Txn firstTxn = kvClientWithNamespace.txn(); + CompletableFuture firstTxnFuture = firstTxn + .If(new Cmp(cmpKey, Cmp.Op.EQUAL, CmpTarget.version(0))) + .Then(Op.put(key1, TestUtil.randomByteSequence(), PutOption.newBuilder().withPrevKV().build())) + .Else(Op.put(key2, TestUtil.randomByteSequence(), PutOption.newBuilder().withPrevKV().build())).commit(); + TxnResponse firstTxnResponse = firstTxnFuture.get(); + assertThat(firstTxnResponse.getPutResponses().size()).isEqualTo(1); + assertThat(firstTxnResponse.getPutResponses().get(0).hasPrevKv()).isTrue(); + assertThat(firstTxnResponse.getPutResponses().get(0).getPrevKv().getKey()).isEqualTo(key1); + assertThat(firstTxnResponse.getPutResponses().get(0).getPrevKv().getValue()).isEqualTo(value1); + Txn secondTxn = kvClientWithNamespace.txn(); + CompletableFuture secondTxnFuture = secondTxn + .If(new Cmp(key1, Cmp.Op.EQUAL, CmpTarget.version(0))).Then(Op.get(key1, GetOption.newBuilder().build())) + .Else(Op.get(key2, GetOption.newBuilder().build())).commit(); + TxnResponse secondTxnResponse = secondTxnFuture.get(); + assertThat(secondTxnResponse.getGetResponses().size()).isEqualTo(1); + assertThat(secondTxnResponse.getGetResponses().get(0).getKvs().size()).isEqualTo(1); + assertThat(secondTxnResponse.getGetResponses().get(0).getKvs().get(0).getKey()).isEqualTo(key2); + assertThat(secondTxnResponse.getGetResponses().get(0).getKvs().get(0).getValue()).isEqualTo(value2); + Txn thirdTxn = kvClientWithNamespace.txn(); + CompletableFuture thirdTxnFuture = thirdTxn + .If(new Cmp(key1, Cmp.Op.GREATER, CmpTarget.version(0))) + .Then(Op.delete(key2, DeleteOption.newBuilder().withPrevKV(true).build())) + .Else(Op.delete(key1, DeleteOption.newBuilder().withPrevKV(true).build())).commit(); + TxnResponse thirdTxnResponse = thirdTxnFuture.get(); + assertThat(thirdTxnResponse.getDeleteResponses().size()).isEqualTo(1); + assertThat(thirdTxnResponse.getDeleteResponses().get(0).getPrevKvs().size()).isEqualTo(1); + assertThat(thirdTxnResponse.getDeleteResponses().get(0).getPrevKvs().get(0).getKey()).isEqualTo(key2); + assertThat(thirdTxnResponse.getDeleteResponses().get(0).getPrevKvs().get(0).getValue()).isEqualTo(value2); + } + + @Test + public void testNestedTxn() throws Exception { + kvClient = TestUtil.client(cluster).build().getKVClient(); + ByteSequence namespace = ByteSequence + .from(TestUtil.randomByteSequence().concat(ByteSequence.NAMESPACE_DELIMITER).getBytes()); + kvClientWithNamespace = TestUtil.client(cluster).namespace(namespace).build() + .getKVClient(); + ByteSequence cmpKey1 = getNonexistentKey(); + putKVWithAssertion(kvClient, cmpKey1, TestUtil.randomByteSequence(), null); + ByteSequence cmpKey2 = getNonexistentKey(); + putKVWithAssertion(kvClientWithNamespace, cmpKey2, TestUtil.randomByteSequence(), null); + ByteSequence key1 = getNonexistentKey(); + ByteSequence value1 = TestUtil.randomByteSequence(); + putKVWithAssertion(kvClientWithNamespace, key1, value1, null); + ByteSequence key2 = getNonexistentKey(); + ByteSequence value2 = TestUtil.randomByteSequence(); + putKVWithAssertion(kvClientWithNamespace, key2, value2, null); + Txn txn = kvClientWithNamespace.txn(); + ByteSequence nextValue1 = TestUtil.randomByteSequence(); + CompletableFuture txnFuture = txn.If(new Cmp(cmpKey1, Cmp.Op.EQUAL, CmpTarget.version(0))) + .Then(Op.txn(new Cmp[]{new Cmp(cmpKey2, Cmp.Op.GREATER, CmpTarget.version(0))}, + new Op[]{Op.put(key1, nextValue1, PutOption.newBuilder().withPrevKV().build())}, + new Op[]{ + Op.put(key2, TestUtil.randomByteSequence(), PutOption.newBuilder().withPrevKV().build())})) + .Else(Op.txn(new Cmp[]{new Cmp(cmpKey2, Cmp.Op.GREATER, CmpTarget.version(0))}, + new Op[]{ + Op.put(key2, TestUtil.randomByteSequence(), PutOption.newBuilder().withPrevKV().build())}, + new Op[]{ + Op.put(key1, TestUtil.randomByteSequence(), PutOption.newBuilder().withPrevKV().build())})) + .commit(); + TxnResponse response = txnFuture.get(); + assertThat(response.getTxnResponses().size()).isEqualTo(1); + assertThat(response.getTxnResponses().get(0).getPutResponses().size()).isEqualTo(1); + assertThat(response.getTxnResponses().get(0).getPutResponses().get(0).hasPrevKv()).isTrue(); + assertThat(response.getTxnResponses().get(0).getPutResponses().get(0).getPrevKv().getKey()).isEqualTo(key1); + assertThat(response.getTxnResponses().get(0).getPutResponses().get(0).getPrevKv().getValue()).isEqualTo(value1); + value1 = nextValue1; + assertExistentKey(kvClient, ByteSequence.from(namespace.concat(key1).getBytes()), value1); + } + + static class TestKeyValue { + ByteSequence key; + ByteSequence value; + + TestKeyValue(ByteSequence key, ByteSequence value) { + this.key = key; + this.value = value; + } + } + + private static ByteSequence getNonexistentKey() { + return bytesOf("sample_key_" + String.format("%05d", keyIndex.incrementAndGet())); + } + + private static void assertNonexistentKey(KV kvClient, ByteSequence key) throws Exception { + CompletableFuture getFeature = kvClient.get(key); + GetResponse response = getFeature.get(); + assertThat(response.getKvs().size()).isEqualTo(0); + } + + private static void assertExistentKey(KV kvClient, ByteSequence key, ByteSequence value) throws Exception { + CompletableFuture getFeature = kvClient.get(key); + GetResponse response = getFeature.get(); + assertThat(response.getKvs().size()).isEqualTo(1); + assertThat(response.getKvs().get(0).getKey()).isEqualTo(key); + assertThat(response.getKvs().get(0).getValue()).isEqualTo(value); + } + + private static boolean putKVWithAssertion(KV kvClient, ByteSequence key, ByteSequence value, ByteSequence prevValue) + throws Exception { + CompletableFuture feature = kvClient.put(key, value, PutOption.newBuilder().withPrevKV().build()); + PutResponse response = feature.get(); + if (prevValue != null) { + assertThat(response.hasPrevKv()).isTrue(); + assertThat(response.getPrevKv().getKey()).isEqualTo(key); + assertThat(response.getPrevKv().getValue()).isEqualTo(prevValue); + } + return response.hasPrevKv(); + } + + private static void deleteKVWithAssertion(KV kvClient, ByteSequence key, ByteSequence prevValue) throws Exception { + CompletableFuture deleteFuture = kvClient.delete(key, + DeleteOption.newBuilder().withPrevKV(true).build()); + DeleteResponse deleteResponse = deleteFuture.get(); + assertThat(deleteResponse.getDeleted()).isEqualTo(1); + assertThat(deleteResponse.getPrevKvs().size()).isEqualTo(1); + assertThat(deleteResponse.getPrevKvs().get(0).getKey()).isEqualTo(key); + assertThat(deleteResponse.getPrevKvs().get(0).getValue()).isEqualTo(prevValue); + assertNonexistentKey(kvClient, key); + } + + private static void putKVsWithAssertion(KV kvClient, List keyValues) throws Exception { + for (TestKeyValue keyValue : keyValues) { + putKVWithAssertion(kvClient, keyValue.key, keyValue.value, null); + } + } + + private static void assertExistentKVs(KV kvClient, ByteSequence key, ByteSequence end, List expectedKVs) + throws Exception { + CompletableFuture getFuture = kvClient.get(key, GetOption.newBuilder().withRange(end).build()); + GetResponse getResponse = getFuture.get(); + assertThat(getResponse.getKvs().size()).isEqualTo(expectedKVs.size()); + for (KeyValue keyValue : getResponse.getKvs()) { + boolean exist = false; + for (TestKeyValue expectedKV : expectedKVs) { + if (expectedKV.key.equals(keyValue.getKey())) { + exist = true; + assertThat(keyValue.getValue()).isEqualTo(expectedKV.value); + break; + } + } + assertThat(exist).isTrue(); + } + } + + private static void deleteKVsWithAssertion(KV kvClient, ByteSequence key, ByteSequence end, List previousKVs) + throws Exception { + CompletableFuture deleteFuture = kvClient.delete(key, + DeleteOption.newBuilder().withRange(end).withPrevKV(true).build()); + DeleteResponse deleteResponse = deleteFuture.get(); + assertThat(deleteResponse.getDeleted()).isEqualTo(previousKVs.size()); + assertThat(deleteResponse.getPrevKvs().size()).isEqualTo(previousKVs.size()); + for (KeyValue keyValue : deleteResponse.getPrevKvs()) { + boolean exist = false; + for (TestKeyValue previousKV : previousKVs) { + if (previousKV.key.equals(keyValue.getKey())) { + exist = true; + assertThat(keyValue.getValue()).isEqualTo(previousKV.value); + break; + } + } + assertThat(exist).isTrue(); + } + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/KVTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/KVTest.java new file mode 100644 index 00000000..1be23512 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/KVTest.java @@ -0,0 +1,293 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.KV; +import io.etcd.jetcd.Txn; +import io.etcd.jetcd.kv.DeleteResponse; +import io.etcd.jetcd.kv.GetResponse; +import io.etcd.jetcd.kv.PutResponse; +import io.etcd.jetcd.kv.TxnResponse; +import io.etcd.jetcd.op.Cmp; +import io.etcd.jetcd.op.CmpTarget; +import io.etcd.jetcd.op.Op; +import io.etcd.jetcd.options.DeleteOption; +import io.etcd.jetcd.options.GetOption; +import io.etcd.jetcd.options.GetOption.SortOrder; +import io.etcd.jetcd.options.GetOption.SortTarget; +import io.etcd.jetcd.options.PutOption; +import io.etcd.jetcd.test.EtcdClusterExtension; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; + +import java.nio.charset.StandardCharsets; +import java.time.Duration; +import java.time.temporal.ChronoUnit; +import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.stream.IntStream; + +import static com.google.common.base.Charsets.UTF_8; +import static io_etcd.jetcd_core.impl.TestUtil.bytesOf; +import static io_etcd.jetcd_core.impl.TestUtil.randomString; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType; + +@SuppressWarnings("resource") +// `@org.junit.jupiter.api.Timeout(value = 2, unit = TimeUnit.MINUTES)` can't be used in the nativeTest GraalVM CE 22.3 +public class KVTest { + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(1) + .build(); + private static KV kvClient; + private static final ByteSequence SAMPLE_KEY = bytesOf("sample_key"); + private static final ByteSequence SAMPLE_VALUE = bytesOf("sample_value"); + private static final ByteSequence SAMPLE_KEY_2 = bytesOf("sample_key2"); + private static final ByteSequence SAMPLE_VALUE_2 = bytesOf("sample_value2"); + private static final ByteSequence SAMPLE_KEY_3 = bytesOf("sample_key3"); + + @BeforeAll + public static void setUp() { + kvClient = TestUtil.client(cluster).build().getKVClient(); + } + + @Test + public void testByteSequence() { + ByteSequence prefix = bytesOf("/test-service/"); + ByteSequence subPrefix = bytesOf("uuids/"); + String keyString = randomString(); + ByteSequence key = bytesOf(keyString); + ByteSequence prefixedKey = prefix.concat(subPrefix).concat(key); + assertThat(prefixedKey.startsWith(prefix)).isTrue(); + assertThat(prefixedKey.substring(prefix.size() + subPrefix.size()).toString(UTF_8)).isEqualTo(keyString); + assertThat(prefixedKey.substring(prefix.size(), prefix.size() + subPrefix.size())).isEqualTo(subPrefix); + } + + @Test + public void testPut() throws Exception { + CompletableFuture feature = kvClient.put(SAMPLE_KEY, SAMPLE_VALUE); + PutResponse response = feature.get(); + assertThat(response.getHeader()).isNotNull(); + assertThat(!response.hasPrevKv()).isTrue(); + } + + @Test + public void testPutWithNotExistLease() { + PutOption option = PutOption.newBuilder().withLeaseId(99999).build(); + CompletableFuture future = kvClient.put(SAMPLE_KEY, SAMPLE_VALUE, option); + assertThatExceptionOfType(ExecutionException.class) + .isThrownBy(future::get).withMessageEndingWith("etcdserver: requested lease not found"); + } + + @Test + public void testGet() throws Exception { + CompletableFuture feature = kvClient.put(SAMPLE_KEY_2, SAMPLE_VALUE_2); + feature.get(); + CompletableFuture getFeature = kvClient.get(SAMPLE_KEY_2); + GetResponse response = getFeature.get(); + assertThat(response.getKvs()).hasSize(1); + assertThat(response.getKvs().get(0).getValue().toString(UTF_8)).isEqualTo(SAMPLE_VALUE_2.toString(UTF_8)); + assertThat(!response.isMore()).isTrue(); + } + + @Test + public void testGetWithRev() throws Exception { + CompletableFuture feature = kvClient.put(SAMPLE_KEY_3, SAMPLE_VALUE); + PutResponse putResp = feature.get(); + kvClient.put(SAMPLE_KEY_3, SAMPLE_VALUE_2).get(); + GetOption option = GetOption.newBuilder().withRevision(putResp.getHeader().getRevision()).build(); + CompletableFuture getFeature = kvClient.get(SAMPLE_KEY_3, option); + GetResponse response = getFeature.get(); + assertThat(response.getKvs()).hasSize(1); + assertThat(response.getKvs().get(0).getValue().toString(UTF_8)).isEqualTo(SAMPLE_VALUE.toString(UTF_8)); + } + + @Test + public void testGetSortedPrefix() throws Exception { + String prefix = randomString(); + int numPrefix = 3; + putKeysWithPrefix(prefix, numPrefix); + GetOption option = GetOption.newBuilder().withSortField(SortTarget.KEY).withSortOrder(SortOrder.DESCEND) + .isPrefix(true).build(); + CompletableFuture getFeature = kvClient.get(bytesOf(prefix), option); + GetResponse response = getFeature.get(); + assertThat(response.getKvs()).hasSize(numPrefix); + for (int i = 0; i < numPrefix; i++) { + assertThat(response.getKvs().get(i).getKey().toString(UTF_8)).isEqualTo(prefix + (numPrefix - i - 1)); + assertThat(response.getKvs().get(i).getValue().toString(UTF_8)).isEqualTo(String.valueOf(numPrefix - i - 1)); + } + } + + @Test + public void testDelete() throws Exception { + testPut(); + ByteSequence keyToDelete = SAMPLE_KEY; + CompletableFuture getFeature = kvClient.get(keyToDelete); + GetResponse resp = getFeature.get(); + CompletableFuture deleteFuture = kvClient.delete(keyToDelete); + DeleteResponse delResp = deleteFuture.get(); + assertThat(delResp.getDeleted()).isEqualTo(resp.getKvs().size()); + } + + @Test + public void testGetAndDeleteWithPrefix() throws Exception { + String prefix = randomString(); + ByteSequence key = bytesOf(prefix); + int numPrefixes = 10; + putKeysWithPrefix(prefix, numPrefixes); + CompletableFuture getFuture = kvClient.get(key, GetOption.newBuilder().isPrefix(true).build()); + GetResponse getResp = getFuture.get(); + assertThat(getResp.getCount()).isEqualTo(numPrefixes); + DeleteOption deleteOpt = DeleteOption.newBuilder().isPrefix(true).build(); + CompletableFuture delFuture = kvClient.delete(key, deleteOpt); + DeleteResponse delResp = delFuture.get(); + assertThat(delResp.getDeleted()).isEqualTo(numPrefixes); + } + + private static void putKeysWithPrefix(String prefix, int numPrefixes) throws ExecutionException, InterruptedException { + for (int i = 0; i < numPrefixes; i++) { + ByteSequence key = bytesOf(prefix + i); + ByteSequence value = bytesOf("" + i); + kvClient.put(key, value).get(); + } + } + + @Test + public void testTxn() throws Exception { + ByteSequence sampleKey = bytesOf("txn_key"); + ByteSequence sampleValue = bytesOf("xyz"); + ByteSequence cmpValue = bytesOf("abc"); + ByteSequence putValue = bytesOf("XYZ"); + ByteSequence putValueNew = bytesOf("ABC"); + kvClient.put(sampleKey, sampleValue).get(); + Txn txn = kvClient.txn(); + Cmp cmp = new Cmp(sampleKey, Cmp.Op.GREATER, CmpTarget.value(cmpValue)); + CompletableFuture txnResp = txn.If(cmp) + .Then(Op.put(sampleKey, putValue, PutOption.DEFAULT)).Else(Op.put(sampleKey, putValueNew, PutOption.DEFAULT)) + .commit(); + txnResp.get(); + GetResponse getResp = kvClient.get(sampleKey).get(); + assertThat(getResp.getKvs()).hasSize(1); + assertThat(getResp.getKvs().get(0).getValue().toString(UTF_8)).isEqualTo(putValue.toString(UTF_8)); + } + + @Test + void testTxnGetAndDeleteWithPrefix() throws ExecutionException, InterruptedException { + String prefix = randomString(); + ByteSequence sampleKey = bytesOf(prefix); + int numPrefixes = 10; + putKeysWithPrefix(prefix, numPrefixes); + Cmp cmp = new Cmp(sampleKey, Cmp.Op.EQUAL, CmpTarget.value(bytesOf("not_exists"))); + Op.PutOp putOp = Op.put(bytesOf("other_string"), bytesOf("other_value"), PutOption.DEFAULT); + Op.GetOp getByPrefix = Op.get(sampleKey, GetOption.newBuilder().isPrefix(true).build()); + Op.DeleteOp delete = Op.delete(sampleKey, DeleteOption.newBuilder().isPrefix(true).withPrevKV(true).build()); + TxnResponse txnResponse = kvClient.txn().If(cmp) + .Then(putOp).Else(getByPrefix, delete).commit().get(); + List getResponse = txnResponse.getGetResponses(); + assertThat(getResponse).hasSize(1); + assertThat(getResponse.get(0).getKvs()).hasSize(10); + assertThat(getResponse.get(0).getKvs()).anyMatch(keyValue -> keyValue.getKey().startsWith(sampleKey)); + List deleteResponses = txnResponse.getDeleteResponses(); + assertThat(deleteResponses).hasSize(1); + assertThat(deleteResponses.get(0).getDeleted()).isEqualTo(10); + assertThat(deleteResponses.get(0).getPrevKvs()).anyMatch(keyValue -> keyValue.getKey().startsWith(sampleKey)); + assertThat(txnResponse.getPutResponses()).isEmpty(); + } + + @Test + public void testTxnForCmpOpNotEqual() throws Exception { + ByteSequence sampleKey = bytesOf("txn_key"); + ByteSequence sampleValue = bytesOf("xyz"); + ByteSequence cmpValue = bytesOf("abc"); + ByteSequence putValue = bytesOf("XYZ"); + ByteSequence putValueNew = bytesOf("ABC"); + kvClient.put(sampleKey, sampleValue).get(); + Txn txn = kvClient.txn(); + Cmp cmp = new Cmp(sampleKey, Cmp.Op.NOT_EQUAL, CmpTarget.value(cmpValue)); + CompletableFuture txnResp = txn.If(cmp) + .Then(Op.put(sampleKey, putValue, PutOption.DEFAULT)).Else(Op.put(sampleKey, putValueNew, PutOption.DEFAULT)) + .commit(); + txnResp.get(); + GetResponse getResp = kvClient.get(sampleKey).get(); + assertThat(getResp.getKvs()).hasSize(1); + assertThat(getResp.getKvs().get(0).getValue().toString(UTF_8)).isEqualTo(putValue.toString(UTF_8)); + } + + @Test + public void testNestedTxn() throws Exception { + ByteSequence foo = bytesOf("txn_foo"); + ByteSequence bar = bytesOf("txn_bar"); + ByteSequence barz = bytesOf("txn_barz"); + ByteSequence abc = bytesOf("txn_abc"); + ByteSequence oneTwoThree = bytesOf("txn_123"); + Txn txn = kvClient.txn(); + Cmp cmp = new Cmp(foo, Cmp.Op.EQUAL, CmpTarget.version(0)); + CompletableFuture txnResp = txn.If(cmp) + .Then(Op.put(foo, bar, PutOption.DEFAULT), + Op.txn(null, new Op[]{Op.put(abc, oneTwoThree, PutOption.DEFAULT)}, null)) + .Else(Op.put(foo, barz, PutOption.DEFAULT)).commit(); + txnResp.get(); + GetResponse getResp = kvClient.get(foo).get(); + assertThat(getResp.getKvs()).hasSize(1); + assertThat(getResp.getKvs().get(0).getValue().toString(UTF_8)).isEqualTo(bar.toString(UTF_8)); + GetResponse getResp2 = kvClient.get(abc).get(); + assertThat(getResp2.getKvs()).hasSize(1); + assertThat(getResp2.getKvs().get(0).getValue().toString(UTF_8)).isEqualTo(oneTwoThree.toString(UTF_8)); + } + + @Test + @SuppressWarnings("FutureReturnValueIgnored") + @Disabled("https://github.com/etcd-io/jetcd/pull/1092") + public void testKVClientCanRetryPutOnEtcdRestart() throws InterruptedException { + try (Client customClient = TestUtil.client(cluster).retryMaxDuration(Duration.ofMinutes(5)).retryDelay(10).retryMaxDelay(30) + .retryChronoUnit(ChronoUnit.SECONDS).build()) { + ByteSequence key = ByteSequence.from("retry_dummy_key", StandardCharsets.UTF_8); + int putCount = 1000; + ScheduledExecutorService executor = Executors.newScheduledThreadPool(2); + executor.submit(() -> IntStream.range(0, putCount).mapToObj(i -> ByteSequence + .from(Integer.toString(i), StandardCharsets.UTF_8)).forEach(value -> customClient.getKVClient().put(key, value).join())); + executor.schedule(cluster::restart, 100, TimeUnit.MILLISECONDS); + executor.shutdown(); + assertThat(executor.awaitTermination(30, TimeUnit.SECONDS)).isTrue(); + GetResponse getResponse = kvClient.get(key).join(); + assertThat(getResponse.getKvs().size()).as("There should be exactly one KeyValue for the test key").isEqualTo(1); + ByteSequence lastPutValue = ByteSequence.from(Integer.toString(putCount - 1), StandardCharsets.UTF_8); + assertThat(getResponse.getKvs().get(0).getValue()).as("The sequence of put operations should finish successfully. " + + "Last seen value should match the expected value.").isEqualTo(lastPutValue); + } + } + + @Test() + public void waitForReadySemantics() throws ExecutionException, InterruptedException, TimeoutException { + String nonExistingServer = "http://127.0.0.1:9999"; + try (Client customClient = Client.builder().endpoints(nonExistingServer) + .waitForReady(false) + .retryMaxDuration(Duration.ofSeconds(3)) + .retryDelay(1) + .retryMaxDelay(2) + .retryChronoUnit(ChronoUnit.SECONDS) + .connectTimeout(Duration.ofSeconds(1)) + .build()) { + KV kvClient = customClient.getKVClient(); + CompletableFuture future = kvClient.get(ByteSequence.from("/x", StandardCharsets.UTF_8)) + .thenApply(response -> "we got a response") + .exceptionally(throwable -> "completed exceptionally"); + assertThat(future.get(5, TimeUnit.SECONDS)) + .isEqualTo("completed exceptionally"); + } + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/LeaseTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/LeaseTest.java new file mode 100644 index 00000000..9ec0a338 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/LeaseTest.java @@ -0,0 +1,147 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import com.google.common.base.Charsets; +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.KV; +import io.etcd.jetcd.Lease; +import io.etcd.jetcd.lease.LeaseKeepAliveResponse; +import io.etcd.jetcd.lease.LeaseTimeToLiveResponse; +import io.etcd.jetcd.options.LeaseOption; +import io.etcd.jetcd.options.PutOption; +import io.etcd.jetcd.support.CloseableClient; +import io.etcd.jetcd.support.Observers; +import io.etcd.jetcd.test.EtcdClusterExtension; +import io.grpc.stub.StreamObserver; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.RejectedExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatExceptionOfType; + +@SuppressWarnings({"JUnitMalformedDeclaration", "ResultOfMethodCallIgnored"}) +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class LeaseTest { + @RegisterExtension + public final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(3) + .build(); + private KV kvClient; + private Client client; + private Lease leaseClient; + private static final ByteSequence KEY = ByteSequence.from("foo", Charsets.UTF_8); + private static final ByteSequence KEY_2 = ByteSequence.from("foo2", Charsets.UTF_8); + private static final ByteSequence VALUE = ByteSequence.from("bar", Charsets.UTF_8); + + @BeforeEach + public void setUp() { + client = TestUtil.client(cluster).build(); + kvClient = client.getKVClient(); + leaseClient = client.getLeaseClient(); + } + + @AfterEach + public void tearDown() { + if (client != null) { + client.close(); + } + } + + @Test + public void testGrant() throws Exception { + long leaseID = leaseClient.grant(5).get().getID(); + kvClient.put(KEY, VALUE, PutOption.newBuilder().withLeaseId(leaseID).build()).get(); + assertThat(kvClient.get(KEY).get().getCount()).isEqualTo(1); + Thread.sleep(6000); + assertThat(kvClient.get(KEY).get().getCount()).isEqualTo(0); + } + + @Test + public void testGrantWithTimeout() throws Exception { + long leaseID = leaseClient.grant(5, 10, TimeUnit.SECONDS).get().getID(); + kvClient.put(KEY, VALUE, PutOption.newBuilder().withLeaseId(leaseID).build()).get(); + assertThat(kvClient.get(KEY).get().getCount()).isEqualTo(1); + Thread.sleep(6000L); + assertThat(kvClient.get(KEY).get().getCount()).isEqualTo(0); + tearDown(); + assertThatExceptionOfType(ExecutionException.class) + .isThrownBy(() -> leaseClient.grant(5, 2, TimeUnit.SECONDS).get().getID()) + .withCauseInstanceOf(RejectedExecutionException.class); + setUp(); + } + + @Test + public void testRevoke() throws Exception { + long leaseID = leaseClient.grant(5).get().getID(); + kvClient.put(KEY, VALUE, PutOption.newBuilder().withLeaseId(leaseID).build()).get(); + assertThat(kvClient.get(KEY).get().getCount()).isEqualTo(1); + leaseClient.revoke(leaseID).get(); + assertThat(kvClient.get(KEY).get().getCount()).isEqualTo(0); + } + + @Test + public void testKeepAliveOnce() throws ExecutionException, InterruptedException { + long leaseID = leaseClient.grant(2).get().getID(); + kvClient.put(KEY, VALUE, PutOption.newBuilder().withLeaseId(leaseID).build()).get(); + assertThat(kvClient.get(KEY).get().getCount()).isEqualTo(1); + LeaseKeepAliveResponse rp = leaseClient.keepAliveOnce(leaseID).get(); + assertThat(rp.getTTL()).isGreaterThan(0); + } + + @Test + public void testKeepAlive() throws ExecutionException, InterruptedException { + long leaseID = leaseClient.grant(2).get().getID(); + kvClient.put(KEY, VALUE, PutOption.newBuilder().withLeaseId(leaseID).build()).get(); + assertThat(kvClient.get(KEY).get().getCount()).isEqualTo(1); + CountDownLatch latch = new CountDownLatch(1); + AtomicReference responseRef = new AtomicReference<>(); + StreamObserver observer = Observers.observer(response -> { + responseRef.set(response); + latch.countDown(); + }); + try (CloseableClient ignored = leaseClient.keepAlive(leaseID, observer)) { + latch.await(5, TimeUnit.SECONDS); + LeaseKeepAliveResponse response = responseRef.get(); + assertThat(response.getTTL()).isGreaterThan(0); + } + Thread.sleep(3000); + assertThat(kvClient.get(KEY).get().getCount()).isEqualTo(0); + } + + @Test + public void testTimeToLive() throws ExecutionException, InterruptedException { + long ttl = 5; + long leaseID = leaseClient.grant(ttl).get().getID(); + LeaseTimeToLiveResponse resp = leaseClient.timeToLive(leaseID, LeaseOption.DEFAULT).get(); + assertThat(resp.getTTl()).isGreaterThan(0); + assertThat(resp.getGrantedTTL()).isEqualTo(ttl); + } + + @Test + public void testTimeToLiveWithKeys() throws ExecutionException, InterruptedException { + long ttl = 5; + long leaseID = leaseClient.grant(ttl).get().getID(); + PutOption putOption = PutOption.newBuilder().withLeaseId(leaseID).build(); + kvClient.put(KEY_2, VALUE, putOption).get(); + LeaseOption leaseOption = LeaseOption.newBuilder().withAttachedKeys().build(); + LeaseTimeToLiveResponse resp = leaseClient.timeToLive(leaseID, leaseOption).get(); + assertThat(resp.getTTl()).isGreaterThan(0); + assertThat(resp.getGrantedTTL()).isEqualTo(ttl); + assertThat(resp.getKeys().size()).isEqualTo(1); + assertThat(resp.getKeys().get(0)).isEqualTo(KEY_2); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/LoadBalancerTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/LoadBalancerTest.java new file mode 100644 index 00000000..3af3e35b --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/LoadBalancerTest.java @@ -0,0 +1,66 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.Client; +import io.etcd.jetcd.ClientBuilder; +import io.etcd.jetcd.KV; +import io.etcd.jetcd.Response; +import io.etcd.jetcd.kv.PutResponse; +import io.etcd.jetcd.test.EtcdClusterExtension; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; + +import java.net.URI; +import java.util.List; +import java.util.stream.Collectors; + +import static org.assertj.core.api.Assertions.assertThat; + +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class LoadBalancerTest { + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(3) + .build(); + + @Test + public void testPickFirstBalancerFactory() throws Exception { + final List endpoints = cluster.clientEndpoints(); + final ClientBuilder builder = Client.builder().endpoints(endpoints).loadBalancerPolicy("pick_first"); + try (Client client = builder.build(); KV kv = client.getKVClient()) { + long lastMemberId = 0; + final String allEndpoints = endpoints.stream().map(URI::toString).collect(Collectors.joining(",")); + for (int i = 0; i < allEndpoints.length() * 2; i++) { + Response response = kv.put(TestUtil.randomByteSequence(), TestUtil.randomByteSequence()).get(); + if (i == 0) { + lastMemberId = response.getHeader().getMemberId(); + } + assertThat(response.getHeader().getMemberId()).isEqualTo(lastMemberId); + } + } + } + + @Test + public void testRoundRobinLoadBalancerFactory() throws Exception { + final List endpoints = cluster.clientEndpoints(); + final ClientBuilder builder = Client.builder().endpoints(endpoints).loadBalancerPolicy("round_robin"); + try (Client client = builder.build(); KV kv = client.getKVClient()) { + long lastMemberId = 0; + long differences = 0; + final String allEndpoints = endpoints.stream().map(URI::toString).collect(Collectors.joining(",")); + for (int i = 0; i < allEndpoints.length(); i++) { + PutResponse response = kv.put(TestUtil.randomByteSequence(), TestUtil.randomByteSequence()).get(); + if (i > 0 && lastMemberId != response.getHeader().getMemberId()) { + differences++; + } + lastMemberId = response.getHeader().getMemberId(); + } + assertThat(differences).isNotEqualTo(lastMemberId); + } + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/LockTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/LockTest.java new file mode 100644 index 00000000..a3605712 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/LockTest.java @@ -0,0 +1,178 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import com.google.common.base.Charsets; +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.Lease; +import io.etcd.jetcd.Lock; +import io.etcd.jetcd.lease.LeaseGrantResponse; +import io.etcd.jetcd.lock.LockResponse; +import io.etcd.jetcd.test.EtcdClusterExtension; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.stream.Stream; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; + +@SuppressWarnings("resource") +// `@org.junit.jupiter.api.Timeout(value = 2, unit = TimeUnit.MINUTES)` can't be used in the nativeTest GraalVM CE 22.3 +public class LockTest { + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(3) + .build(); + private Lock lockClient; + private static Lease leaseClient; + private Set locksToRelease; + private static final ByteSequence SAMPLE_NAME = ByteSequence.from("sample_name", Charsets.UTF_8); + private static final ByteSequence namespace = ByteSequence.from("test-ns/", Charsets.UTF_8); + private static final ByteSequence namespace2 = ByteSequence.from("test-ns2/", Charsets.UTF_8); + + @BeforeAll + public static void setUp() { + Client client = TestUtil.client(cluster).build(); + leaseClient = client.getLeaseClient(); + } + + @BeforeEach + public void setUpEach() { + locksToRelease = new HashSet<>(); + } + + @AfterEach + public void tearDownEach() throws Exception { + for (ByteSequence lockKey : locksToRelease) { + lockClient.unlock(lockKey).get(); + } + } + + private void initializeLockCLient(boolean useNamespace) { + Client client = useNamespace + ? TestUtil.client(cluster).namespace(namespace).build() + : TestUtil.client(cluster).build(); + + this.lockClient = client.getLockClient(); + } + + static Stream parameters() { + return Stream.of(Arguments.of(true), Arguments.of(false)); + } + + @ParameterizedTest + @MethodSource("parameters") + public void testLockWithoutLease(boolean useNamespace) throws Exception { + initializeLockCLient(useNamespace); + CompletableFuture feature = lockClient.lock(SAMPLE_NAME, 0); + LockResponse response = feature.get(); + locksToRelease.add(response.getKey()); + assertThat(response.getHeader()).isNotNull(); + assertThat(response.getKey()).isNotNull(); + } + + @ParameterizedTest + @MethodSource("parameters") + public void testLockWithNotExistingLease(boolean useNamespace) { + Throwable exception = assertThrows(ExecutionException.class, () -> { + initializeLockCLient(useNamespace); + CompletableFuture feature = lockClient.lock(SAMPLE_NAME, 123456); + LockResponse response = feature.get(); + locksToRelease.add(response.getKey()); + }); + assertThat(exception.getMessage().contains("etcdserver: requested lease not found")).isTrue(); + } + + @ParameterizedTest + @MethodSource("parameters") + public void testLockWithLease(boolean useNamespace) throws Exception { + initializeLockCLient(useNamespace); + long lease = grantLease(5); + CompletableFuture feature = lockClient.lock(SAMPLE_NAME, lease); + LockResponse response = feature.get(); + long startMillis = System.currentTimeMillis(); + CompletableFuture feature2 = lockClient.lock(SAMPLE_NAME, 0); + LockResponse response2 = feature2.get(); + long time = System.currentTimeMillis() - startMillis; + assertThat(response2.getKey()).isNotEqualTo(response.getKey()); + assertThat(time >= 4500 && time <= 6000).withFailMessage(String.format("Lease not runned out after 5000ms, was %dms", time)).isTrue(); + locksToRelease.add(response.getKey()); + locksToRelease.add(response2.getKey()); + } + + @ParameterizedTest + @MethodSource("parameters") + public void testLockAndUnlock(boolean useNamespace) throws Exception { + initializeLockCLient(useNamespace); + long lease = grantLease(20); + CompletableFuture feature = lockClient.lock(SAMPLE_NAME, lease); + LockResponse response = feature.get(); + lockClient.unlock(response.getKey()).get(); + long startTime = System.currentTimeMillis(); + CompletableFuture feature2 = lockClient.lock(SAMPLE_NAME, 0); + LockResponse response2 = feature2.get(); + long time = System.currentTimeMillis() - startTime; + locksToRelease.add(response2.getKey()); + assertThat(response2.getKey()).isNotEqualTo(response.getKey()); + assertThat(time <= 500).withFailMessage(String.format("Lease not unlocked, wait time was too long (%dms)", time)) + .isTrue(); + } + + @Test + public void testLockSegregationByNamespaces() throws Exception { + initializeLockCLient(false); + Client clientWithNamespace = TestUtil.client(cluster).namespace(namespace).build(); + Lock lockClientWithNamespace = clientWithNamespace.getLockClient(); + long lease = grantLease(5); + CompletableFuture feature = lockClientWithNamespace.lock(SAMPLE_NAME, lease); + LockResponse response = feature.get(); + assertThat(response.getKey().startsWith(SAMPLE_NAME)).isTrue(); + ByteSequence nsKey = ByteSequence.from(namespace.concat(response.getKey()).getBytes()); + lockClient.unlock(nsKey).get(); + lease = grantLease(30); + CompletableFuture feature2 = lockClientWithNamespace.lock(SAMPLE_NAME, lease); + LockResponse response2 = feature2.get(); + long timestamp2 = System.currentTimeMillis(); + long startTime = System.currentTimeMillis(); + assertThat(response2.getKey().startsWith(SAMPLE_NAME)).isTrue(); + assertThat(response2.getKey()).isNotEqualTo(response.getKey()); + assertThat((timestamp2 - startTime) <= 1000) + .withFailMessage(String.format("Lease not unlocked, wait time was too long (%dms)", timestamp2 - startTime)) + .isTrue(); + locksToRelease.add(ByteSequence.from(namespace.concat(response2.getKey()).getBytes())); + lease = grantLease(5); + Client clientWithNamespace2 = TestUtil.client(cluster).namespace(namespace2).build(); + Lock lockClientWithNamespace2 = clientWithNamespace2.getLockClient(); + CompletableFuture feature3 = lockClientWithNamespace2.lock(SAMPLE_NAME, lease); + LockResponse response3 = feature3.get(); + long timestamp3 = System.currentTimeMillis(); + assertThat(response3.getKey().startsWith(SAMPLE_NAME)).isTrue(); + assertThat(response3.getKey()).isNotEqualTo(response2.getKey()); + assertThat((timestamp3 - timestamp2) <= 1000) + .withFailMessage(String.format("wait time for requiring the lock was too long (%dms)", timestamp3 - timestamp2)) + .isTrue(); + locksToRelease.add(ByteSequence.from(namespace2.concat(response3.getKey()).getBytes())); + } + + private static long grantLease(long ttl) throws Exception { + CompletableFuture feature = leaseClient.grant(ttl); + LeaseGrantResponse response = feature.get(); + return response.getID(); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/MaintenanceTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/MaintenanceTest.java new file mode 100644 index 00000000..499dfe06 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/MaintenanceTest.java @@ -0,0 +1,112 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.Client; +import io.etcd.jetcd.Maintenance; +import io.etcd.jetcd.maintenance.SnapshotResponse; +import io.etcd.jetcd.maintenance.StatusResponse; +import io.etcd.jetcd.test.EtcdClusterExtension; +import io.grpc.stub.StreamObserver; +import org.apache.commons.io.output.NullOutputStream; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.api.io.TempDir; + +import java.io.IOException; +import java.io.OutputStream; +import java.net.URI; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicLong; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Fail.fail; + +@SuppressWarnings({"FieldCanBeLocal", "deprecation", "ResultOfMethodCallIgnored"}) +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class MaintenanceTest { + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(3) + .build(); + private static Client client; + private static Maintenance maintenance; + private static List endpoints; + + @TempDir + static Path tempDir; + + @BeforeEach + public void setUp() { + endpoints = cluster.clientEndpoints(); + client = TestUtil.client(cluster).build(); + maintenance = client.getMaintenanceClient(); + } + + @Test + public void testStatusMember() throws ExecutionException, InterruptedException { + StatusResponse statusResponse = maintenance.statusMember(endpoints.get(0)).get(); + assertThat(statusResponse.getDbSize()).isGreaterThan(0); + } + + @Test + public void testSnapshotToOutputStream() throws ExecutionException, InterruptedException, IOException { + final Path snapfile = tempDir.resolve("snap"); + try (OutputStream stream = Files.newOutputStream(snapfile)) { + Long bytes = maintenance.snapshot(stream).get(); + stream.flush(); + Long fsize = Files.size(snapfile); + assertThat(bytes).isEqualTo(fsize); + } + } + + @Test + public void testSnapshotChunks() throws ExecutionException, InterruptedException { + final Long bytes = maintenance.snapshot(NullOutputStream.NULL_OUTPUT_STREAM).get(); + final AtomicLong count = new AtomicLong(); + final CountDownLatch latcht = new CountDownLatch(1); + maintenance.snapshot(new StreamObserver<>() { + @Override + public void onNext(SnapshotResponse value) { + count.addAndGet(value.getBlob().size()); + } + + @Override + public void onError(Throwable t) { + fail("Should not throw exception"); + } + + @Override + public void onCompleted() { + latcht.countDown(); + } + }); + latcht.await(10, TimeUnit.SECONDS); + assertThat(bytes).isEqualTo(count.get()); + } + + @Test + public void testHashKV() throws ExecutionException, InterruptedException { + maintenance.hashKV(endpoints.get(0), 0).get(); + } + + @Test + public void testAlarmList() throws ExecutionException, InterruptedException { + maintenance.listAlarms().get(); + } + + @Test + public void testDefragment() throws ExecutionException, InterruptedException { + maintenance.defragmentMember(endpoints.get(0)).get(); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/MaintenanceUnitTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/MaintenanceUnitTest.java new file mode 100644 index 00000000..c4d0c2e8 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/MaintenanceUnitTest.java @@ -0,0 +1,103 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import com.google.protobuf.ByteString; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.Maintenance; +import io.etcd.jetcd.api.MaintenanceGrpc.MaintenanceImplBase; +import io.etcd.jetcd.api.SnapshotRequest; +import io.etcd.jetcd.api.SnapshotResponse; +import io.etcd.jetcd.common.exception.EtcdException; +import io.grpc.Server; +import io.grpc.Status; +import io.grpc.netty.NettyServerBuilder; +import io.grpc.stub.StreamObserver; +import io.grpc.util.MutableHandlerRegistry; +import org.apache.commons.io.output.NullOutputStream; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.LinkedBlockingQueue; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.Fail.fail; + +@SuppressWarnings("FieldCanBeLocal") +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class MaintenanceUnitTest { + private MutableHandlerRegistry serviceRegistry; + private BlockingQueue> observerQueue; + private Server fakeServer; + private ExecutorService executor; + private Client client; + private Maintenance maintenance; + + @BeforeEach + public void setUp() throws IOException, URISyntaxException { + observerQueue = new LinkedBlockingQueue<>(); + executor = Executors.newFixedThreadPool(2); + serviceRegistry = new MutableHandlerRegistry(); + serviceRegistry.addService(new MaintenanceImplBase() { + @Override + public void snapshot(SnapshotRequest request, StreamObserver observer) { + try { + observerQueue.put(observer); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + }); + fakeServer = NettyServerBuilder.forPort(TestUtil.findNextAvailablePort()).fallbackHandlerRegistry(serviceRegistry).directExecutor().build().start(); + client = Client.builder().endpoints(new URI("http://127.0.0.1:" + fakeServer.getPort())).build(); + maintenance = client.getMaintenanceClient(); + } + + @AfterEach + public void tearDown() { + maintenance.close(); + client.close(); + fakeServer.shutdownNow(); + } + + @Test + public void testConnectionError() { + executor.execute(() -> { + try { + Thread.sleep(50); + observerQueue.take().onError(Status.ABORTED.asRuntimeException()); + } catch (InterruptedException e) { + fail("expect no exception, but got InterruptedException", e); + } + }); + assertThatThrownBy(() -> maintenance.snapshot(NullOutputStream.NULL_OUTPUT_STREAM).get()) + .isInstanceOf(ExecutionException.class).hasCauseInstanceOf(EtcdException.class); + } + + @Test + public void testWrite() throws Exception { + final ByteArrayOutputStream out = new ByteArrayOutputStream(); + final ByteString blob = ByteString.copyFromUtf8("blob"); + final CompletableFuture answer = maintenance.snapshot(out); + StreamObserver observer = observerQueue.take(); + observer.onNext(SnapshotResponse.newBuilder().setBlob(blob).setRemainingBytes(0).build()); + observer.onCompleted(); + answer.get(); + assertThat(out.toByteArray()).isEqualTo(blob.toByteArray()); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/SslTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/SslTest.java new file mode 100644 index 00000000..81cbf0cd --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/SslTest.java @@ -0,0 +1,55 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.KV; +import io.etcd.jetcd.test.EtcdClusterExtension; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; + +import java.io.FileInputStream; +import java.io.InputStream; +import java.net.URI; +import java.util.Objects; + +import static io_etcd.jetcd_core.impl.TestUtil.bytesOf; +import static org.assertj.core.api.Assertions.assertThat; + +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +@Disabled("https://github.com/etcd-io/jetcd/pull/1092") +public class SslTest { + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(1) + .withSsl(true) + .build(); + private static final String DEFAULT_SSL_AUTHORITY = "etcd0"; + private static final String DEFAULT_SSL_CA_PATH = "/ssl/cert/ca.pem"; + + @Test + public void testSimpleSllSetup() throws Exception { + final ByteSequence key = bytesOf(TestUtil.randomString()); + final ByteSequence val = bytesOf(TestUtil.randomString()); + final String capath = System.getProperty("ssl.cert.capath"); + final String authority = System.getProperty("ssl.cert.authority", DEFAULT_SSL_AUTHORITY); + final URI endpoint = new URI(System.getProperty("ssl.cert.endpoints", cluster.clientEndpoints().get(0).toString())); + try (InputStream is = Objects.nonNull(capath) + ? new FileInputStream(capath) + : getClass().getResourceAsStream(DEFAULT_SSL_CA_PATH)) { + Client client = Client.builder().endpoints(endpoint).authority(authority).sslContext(b -> b.trustManager(is)).build(); + KV kv = client.getKVClient(); + kv.put(key, val).join(); + assertThat(kv.get(key).join().getCount()).isEqualTo(1); + assertThat(kv.get(key).join().getKvs().get(0).getValue()).isEqualTo(val); + kv.close(); + client.close(); + } + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/TestUtil.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/TestUtil.java new file mode 100644 index 00000000..f21e4eb2 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/TestUtil.java @@ -0,0 +1,80 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import com.google.common.base.Charsets; +import com.google.protobuf.ByteString; +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.ClientBuilder; +import io.etcd.jetcd.test.EtcdClusterExtension; +import io.etcd.jetcd.watch.WatchResponse; + +import java.io.Closeable; +import java.io.IOException; +import java.net.ServerSocket; + +import static java.nio.charset.StandardCharsets.UTF_8; + +@SuppressWarnings({"unused", "BusyWait"}) +public class TestUtil { + public static ByteSequence bytesOf(final String string) { + return ByteSequence.from(string, UTF_8); + } + + public static ByteString byteStringOf(final String string) { + return ByteString.copyFrom(string.getBytes(UTF_8)); + } + + public static String randomString() { + return java.util.UUID.randomUUID().toString(); + } + + public static ByteSequence randomByteSequence() { + return ByteSequence.from(randomString(), Charsets.UTF_8); + } + + public static int findNextAvailablePort() throws IOException { + try (ServerSocket socket = new ServerSocket(0)) { + return socket.getLocalPort(); + } + } + + public static void closeQuietly(final Closeable closeable) { + try { + if (closeable != null) { + closeable.close(); + } + } catch (final IOException ignored) { + } + } + + public interface TestCondition { + boolean conditionMet(); + } + + public static void waitForCondition(final TestCondition testCondition, final long maxWaitMs, + String conditionDetails) throws InterruptedException { + final long startTime = System.currentTimeMillis(); + boolean testConditionMet; + while (!(testConditionMet = testCondition.conditionMet()) && (System.currentTimeMillis() - startTime) < maxWaitMs) { + Thread.sleep(Math.min(maxWaitMs, 500L)); + } + if (!testConditionMet) { + conditionDetails = conditionDetails != null ? conditionDetails : ""; + throw new AssertionError("Condition not met within timeout " + maxWaitMs + ". " + conditionDetails); + } + } + + public static void noOpWatchResponseConsumer(WatchResponse response) { + + } + + public static ClientBuilder client(EtcdClusterExtension extension) { + return Client.builder().target("cluster://" + extension.clusterName()); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/TxnResponseTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/TxnResponseTest.java new file mode 100644 index 00000000..ab3d1cf9 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/TxnResponseTest.java @@ -0,0 +1,55 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.api.DeleteRangeResponse; +import io.etcd.jetcd.api.PutResponse; +import io.etcd.jetcd.api.RangeResponse; +import io.etcd.jetcd.api.ResponseOp; +import io.etcd.jetcd.kv.TxnResponse; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class TxnResponseTest { + private TxnResponse txnResponse; + + @BeforeEach + public void setUp() { + io.etcd.jetcd.api.TxnResponse response = io.etcd.jetcd.api.TxnResponse.newBuilder() + .addResponses(ResponseOp.newBuilder().setResponsePut(PutResponse.getDefaultInstance())) + .addResponses(ResponseOp.newBuilder().setResponseDeleteRange(DeleteRangeResponse.getDefaultInstance())) + .addResponses(ResponseOp.newBuilder().setResponseRange(RangeResponse.getDefaultInstance())) + .addResponses(ResponseOp.newBuilder().setResponseTxn(io.etcd.jetcd.api.TxnResponse.getDefaultInstance())) + .build(); + txnResponse = new TxnResponse(response, ByteSequence.EMPTY); + } + + @Test + public void getDeleteResponsesTest() { + assertThat(txnResponse.getDeleteResponses().size()).isEqualTo(1); + } + + @Test + public void getPutResponsesTest() { + assertThat(txnResponse.getPutResponses().size()).isEqualTo(1); + } + + @Test + public void getGetResponsesTest() { + assertThat(txnResponse.getGetResponses().size()).isEqualTo(1); + } + + @Test + public void getTxnResponsesTest() { + assertThat(txnResponse.getTxnResponses().size()).isEqualTo(1); + } + +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/UtilTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/UtilTest.java new file mode 100644 index 00000000..61c2d6af --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/UtilTest.java @@ -0,0 +1,38 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.support.Errors; +import io.grpc.Status; +import io.grpc.StatusException; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +class UtilTest { + + @Test + public void testAuthStoreExpired() { + Status authExpiredStatus = Status.INVALID_ARGUMENT.withDescription(Errors.ERROR_AUTH_STORE_OLD); + Status status = Status.fromThrowable(new StatusException(authExpiredStatus)); + assertThat(Errors.isAuthStoreExpired(status)).isTrue(); + } + + @Test + public void testAuthErrorIsNotRetryable() { + Status authErrorStatus = Status.UNAUTHENTICATED.withDescription("etcdserver: invalid auth token"); + Status status = Status.fromThrowable(new StatusException(authErrorStatus)); + assertThat(Errors.isRetryable(status)).isTrue(); + } + + @Test + public void testUnavailableErrorIsRetryable() { + Status status = Status.fromThrowable(new StatusException(Status.UNAVAILABLE)); + assertThat(Errors.isRetryable(status)).isTrue(); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchErrorTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchErrorTest.java new file mode 100755 index 00000000..d04c4842 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchErrorTest.java @@ -0,0 +1,50 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.Watch.Watcher; +import io.etcd.jetcd.common.exception.EtcdException; +import io.etcd.jetcd.test.EtcdClusterExtension; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.TimeUnit; + +import static io_etcd.jetcd_core.impl.TestUtil.bytesOf; +import static io_etcd.jetcd_core.impl.TestUtil.randomByteSequence; +import static org.assertj.core.api.Assertions.assertThat; +import static org.awaitility.Awaitility.await; + +@SuppressWarnings({"resource", "JUnitMalformedDeclaration"}) +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class WatchErrorTest { + @RegisterExtension + public final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(3) + .build(); + + @ParameterizedTest + @ValueSource(strings = { "test-namespace/", "" }) + public void testWatchOnError(String ns) { + final Client client = ns != null && ns.length() == 0 + ? TestUtil.client(cluster).namespace(bytesOf(ns)).build() + : TestUtil.client(cluster).build(); + final ByteSequence key = randomByteSequence(); + final List events = Collections.synchronizedList(new ArrayList<>()); + try (Watcher ignored = client.getWatchClient().watch(key, TestUtil::noOpWatchResponseConsumer, events::add)) { + cluster.cluster().stop(); + await().atMost(15, TimeUnit.SECONDS).untilAsserted(() -> assertThat(events).isNotEmpty()); + } + assertThat(events).allMatch(EtcdException.class::isInstance); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchResumeTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchResumeTest.java new file mode 100644 index 00000000..68da7682 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchResumeTest.java @@ -0,0 +1,53 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.KV; +import io.etcd.jetcd.Watch; +import io.etcd.jetcd.Watch.Watcher; +import io.etcd.jetcd.test.EtcdClusterExtension; +import io.etcd.jetcd.watch.WatchEvent.EventType; +import io.etcd.jetcd.watch.WatchResponse; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; + +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.awaitility.Awaitility.await; + +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class WatchResumeTest { + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(3) + .build(); + + @Test + @Disabled("https://github.com/etcd-io/jetcd/pull/1092") + public void testWatchOnPut() throws Exception { + try (Client client = TestUtil.client(cluster).build()) { + Watch watchClient = client.getWatchClient(); + KV kvClient = client.getKVClient(); + final ByteSequence key = TestUtil.randomByteSequence(); + final ByteSequence value = TestUtil.randomByteSequence(); + final AtomicReference ref = new AtomicReference<>(); + try (Watcher ignored = watchClient.watch(key, ref::set)) { + cluster.restart(); + kvClient.put(key, value).get(1, TimeUnit.SECONDS); + await().atMost(30, TimeUnit.SECONDS).untilAsserted(() -> assertThat(ref.get()).isNotNull()); + assertThat(ref.get().getEvents().size()).isEqualTo(1); + assertThat(ref.get().getEvents().get(0).getEventType()).isEqualTo(EventType.PUT); + assertThat(ref.get().getEvents().get(0).getKeyValue().getKey()).isEqualTo(key); + } + } + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchTest.java new file mode 100755 index 00000000..383bcad6 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchTest.java @@ -0,0 +1,278 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.KeyValue; +import io.etcd.jetcd.Watch; +import io.etcd.jetcd.Watch.Watcher; +import io.etcd.jetcd.common.exception.CompactedException; +import io.etcd.jetcd.kv.PutResponse; +import io.etcd.jetcd.options.WatchOption; +import io.etcd.jetcd.test.EtcdClusterExtension; +import io.etcd.jetcd.watch.WatchEvent; +import io.etcd.jetcd.watch.WatchEvent.EventType; +import io.etcd.jetcd.watch.WatchResponse; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; +import java.util.stream.Stream; + +import static io_etcd.jetcd_core.impl.TestUtil.bytesOf; +import static io_etcd.jetcd_core.impl.TestUtil.randomByteSequence; +import static org.assertj.core.api.Assertions.assertThat; +import static org.awaitility.Awaitility.await; +import static org.junit.jupiter.params.provider.Arguments.arguments; + +@SuppressWarnings({"resource", "ResultOfMethodCallIgnored"}) +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +public class WatchTest { + /** + * This test fails too easily and is only used to collect GraalVM reachability metadata". + */ + private static final long TIME_OUT_SECONDS = 60; + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(3) + .build(); + + public static final ByteSequence namespace = bytesOf("test-namespace/"); + + static Stream parameters() { + return Stream.of( + arguments(TestUtil.client(cluster).namespace(namespace).build()), + arguments(TestUtil.client(cluster).build())); + } + + @Test + @Disabled("https://github.com/etcd-io/jetcd/pull/1092") + public void testNamespacedAndNotNamespacedClient() throws Exception { + final ByteSequence key = randomByteSequence(); + final ByteSequence nsKey = ByteSequence.from(namespace.concat(key).getBytes()); + final Client client = TestUtil.client(cluster).build(); + final Client nsClient = TestUtil.client(cluster).namespace(namespace).build(); + final ByteSequence value = randomByteSequence(); + final AtomicReference ref = new AtomicReference<>(); + try (Watcher ignored = nsClient.getWatchClient().watch(key, ref::set)) { + client.getKVClient().put(nsKey, value).get(); + await().atMost(TIME_OUT_SECONDS, TimeUnit.SECONDS).untilAsserted(() -> assertThat(ref.get()).isNotNull()); + assertThat(ref.get()).isNotNull(); + assertThat(ref.get().getEvents().size()).isEqualTo(1); + assertThat(ref.get().getEvents().get(0).getEventType()).isEqualTo(EventType.PUT); + assertThat(ref.get().getEvents().get(0).getKeyValue().getKey()).isEqualTo(key); + } + } + + @ParameterizedTest + @MethodSource("parameters") + @Disabled("https://github.com/etcd-io/jetcd/pull/1092") + public void testWatchOnPut(final Client client) throws Exception { + final ByteSequence key = randomByteSequence(); + final ByteSequence value = randomByteSequence(); + final AtomicReference ref = new AtomicReference<>(); + try (Watcher ignored = client.getWatchClient().watch(key, ref::set)) { + client.getKVClient().put(key, value).get(); + await().atMost(TIME_OUT_SECONDS, TimeUnit.SECONDS).untilAsserted(() -> assertThat(ref.get()).isNotNull()); + assertThat(ref.get()).isNotNull(); + assertThat(ref.get().getEvents().size()).isEqualTo(1); + assertThat(ref.get().getEvents().get(0).getEventType()).isEqualTo(EventType.PUT); + assertThat(ref.get().getEvents().get(0).getKeyValue().getKey()).isEqualTo(key); + } + } + + @ParameterizedTest + @MethodSource("parameters") + @Disabled("https://github.com/etcd-io/jetcd/pull/1092") + public void testMultipleWatch(final Client client) throws Exception { + final ByteSequence key = randomByteSequence(); + final CountDownLatch latch = new CountDownLatch(2); + final ByteSequence value = randomByteSequence(); + final List res = Collections.synchronizedList(new ArrayList<>(2)); + try (Watcher ignored = client.getWatchClient().watch(key, res::add); + Watcher ignored1 = client.getWatchClient().watch(key, res::add)) { + client.getKVClient().put(key, value).get(); + latch.await(4, TimeUnit.SECONDS); + await().atMost(TIME_OUT_SECONDS, TimeUnit.SECONDS).untilAsserted(() -> assertThat(res).hasSize(2)); + assertThat(res.get(0)).usingRecursiveComparison().isEqualTo(res.get(1)); + assertThat(res.get(0).getEvents().size()).isEqualTo(1); + assertThat(res.get(0).getEvents().get(0).getEventType()).isEqualTo(EventType.PUT); + assertThat(res.get(0).getEvents().get(0).getKeyValue().getKey()).isEqualTo(key); + } + } + + @ParameterizedTest + @MethodSource("parameters") + public void testWatchOnDelete(final Client client) throws Exception { + final ByteSequence key = randomByteSequence(); + final ByteSequence value = randomByteSequence(); + final AtomicReference ref = new AtomicReference<>(); + client.getKVClient().put(key, value).get(); + try (Watcher ignored = client.getWatchClient().watch(key, ref::set)) { + client.getKVClient().delete(key).get(); + await().atMost(TIME_OUT_SECONDS, TimeUnit.SECONDS).untilAsserted(() -> assertThat(ref.get()).isNotNull()); + assertThat(ref.get().getEvents().size()).isEqualTo(1); + WatchEvent event = ref.get().getEvents().get(0); + assertThat(event.getEventType()).isEqualTo(EventType.DELETE); + assertThat(Arrays.equals(event.getKeyValue().getKey().getBytes(), key.getBytes())).isTrue(); + } + } + + @ParameterizedTest + @MethodSource("parameters") + public void testWatchCompacted(final Client client) throws Exception { + final ByteSequence key = randomByteSequence(); + final AtomicReference ref = new AtomicReference<>(); + final WatchOption options = WatchOption.newBuilder().withRevision(getCompactedRevision(client, key)).build(); + final Watch wc = client.getWatchClient(); + try (Watcher ignored = wc.watch(key, options, Watch.listener(TestUtil::noOpWatchResponseConsumer, ref::set))) { + await().atMost(TIME_OUT_SECONDS, TimeUnit.SECONDS).untilAsserted(() -> assertThat(ref.get()).isNotNull()); + assertThat(ref.get().getClass()).isEqualTo(CompactedException.class); + } + } + + @ParameterizedTest + @MethodSource("parameters") + public void testWatchClose(final Client client) throws Exception { + final ByteSequence key = randomByteSequence(); + final ByteSequence value = randomByteSequence(); + final List events = Collections.synchronizedList(new ArrayList<>()); + try (Watcher ignored = client.getWatchClient().watch(key, events::add)) { + client.getKVClient().put(key, value).get(); + await().atMost(TIME_OUT_SECONDS, TimeUnit.SECONDS).untilAsserted(() -> assertThat(events).isNotEmpty()); + } + client.getKVClient().put(key, randomByteSequence()).get(); + await().atMost(TIME_OUT_SECONDS, TimeUnit.SECONDS).untilAsserted(() -> assertThat(events).hasSize(1)); + assertThat(events.get(0).getEvents()).hasSize(1); + assertThat(events.get(0).getEvents().get(0).getEventType()).isEqualTo(EventType.PUT); + assertThat(events.get(0).getEvents().get(0).getKeyValue().getKey()).isEqualTo(key); + assertThat(events.get(0).getEvents().get(0).getKeyValue().getValue()).isEqualTo(value); + } + + @ParameterizedTest + @MethodSource("parameters") + public void testProgressRequest(final Client client) throws Exception { + final ByteSequence key = randomByteSequence(); + final ByteSequence value = randomByteSequence(); + final Watch watchClient = client.getWatchClient(); + final AtomicReference emptyWatcherEventRef = new AtomicReference<>(); + final AtomicReference activeWatcherEventRef = new AtomicReference<>(); + try (Watcher ignored = watchClient.watch(key, activeWatcherEventRef::set); + Watcher ignored1 = watchClient.watch(key.concat(randomByteSequence()), emptyWatcherEventRef::set)) { + watchClient.requestProgress(); + await().atMost(TIME_OUT_SECONDS, TimeUnit.SECONDS).untilAsserted(() -> { + assertThat(activeWatcherEventRef.get()).isNotNull(); + assertThat(emptyWatcherEventRef.get()).isNotNull(); + }); + WatchResponse activeEvent = activeWatcherEventRef.get(); + WatchResponse emptyEvent = emptyWatcherEventRef.get(); + assertThat(activeEvent).satisfies(WatchResponse::isProgressNotify); + assertThat(emptyEvent).satisfies(WatchResponse::isProgressNotify); + assertThat(activeEvent.getHeader().getRevision()).isEqualTo(emptyEvent.getHeader().getRevision()); + activeWatcherEventRef.set(null); + emptyWatcherEventRef.set(null); + client.getKVClient().put(key, value).get(); + await().atMost(TIME_OUT_SECONDS, TimeUnit.SECONDS).untilAsserted(() -> assertThat(activeWatcherEventRef.get()).isNotNull()); + activeEvent = activeWatcherEventRef.get(); + emptyEvent = emptyWatcherEventRef.get(); + assertThat(emptyEvent).isNull(); + assertThat(activeEvent).isNotNull(); + long latestRevision = activeEvent.getHeader().getRevision(); + activeWatcherEventRef.set(null); + emptyWatcherEventRef.set(null); + watchClient.requestProgress(); + await().atMost(TIME_OUT_SECONDS, TimeUnit.SECONDS).untilAsserted(() -> { + assertThat(activeWatcherEventRef.get()).isNotNull(); + assertThat(emptyWatcherEventRef.get()).isNotNull(); + }); + activeEvent = activeWatcherEventRef.get(); + emptyEvent = emptyWatcherEventRef.get(); + assertThat(activeEvent).satisfies(WatchResponse::isProgressNotify); + assertThat(emptyEvent).satisfies(WatchResponse::isProgressNotify); + assertThat(activeEvent.getHeader().getRevision()).isEqualTo(emptyEvent.getHeader().getRevision()) + .isEqualTo(latestRevision); + } + } + + @ParameterizedTest + @MethodSource("parameters") + public void testWatchFutureRevisionIsNotOverwrittenOnCreation(final Client client) throws Exception { + final ByteSequence key = randomByteSequence(); + final ByteSequence value = randomByteSequence(); + final List events = Collections.synchronizedList(new ArrayList<>()); + PutResponse putResponse = client.getKVClient().put(key, value).get(); + long lastSeenRevision = putResponse.getHeader().getRevision(); + WatchOption watchOption = WatchOption.newBuilder().withRevision(lastSeenRevision + 1).build(); + try (Watcher ignored = client.getWatchClient().watch(key, watchOption, events::add)) { + cluster.restart(); + Thread.sleep(2000); + assertThat(events.isEmpty()).as("verify that received events list is empty").isTrue(); + } + } + + @ParameterizedTest + @MethodSource("parameters") + @Disabled("https://github.com/etcd-io/jetcd/pull/1092") + public void testWatchAndGet(final Client client) throws Exception { + final ByteSequence key = randomByteSequence(); + final ByteSequence value = randomByteSequence(); + final AtomicReference ref = new AtomicReference<>(); + final Consumer consumer = response -> response.getEvents().stream() + .filter(event -> event.getEventType() == EventType.PUT) + .map(event -> event.getKeyValue().getKey()) + .forEach(key1 -> client.getKVClient().get(key1).whenComplete((r, t) -> { + if (!r.getKvs().isEmpty()) { + ref.set(r.getKvs().get(0)); + } + })); + try (Watcher ignored = client.getWatchClient().watch(key, consumer)) { + client.getKVClient().put(key, value).get(); + await().atMost(TIME_OUT_SECONDS, TimeUnit.SECONDS).untilAsserted(() -> assertThat(ref.get()).isNotNull()); + assertThat(ref.get()).isNotNull(); + assertThat(ref.get().getKey()).isEqualTo(key); + assertThat(ref.get().getValue()).isEqualTo(value); + } + } + + private static long getCompactedRevision(final Client client, final ByteSequence key) throws Exception { + final ByteSequence value = randomByteSequence(); + client.getKVClient().put(key, value).get(); + final PutResponse putResponse = client.getKVClient().put(key, value).get(); + client.getKVClient().compact(putResponse.getHeader().getRevision()).get(); + return putResponse.getHeader().getRevision() - 1; + } + + @ParameterizedTest + @MethodSource("parameters") + public void testCancelledWatchGetsClosed(final Client client) throws Exception { + final ByteSequence key = randomByteSequence(); + final Watch wc = client.getWatchClient(); + long revision = getCompactedRevision(client, key); + final WatchOption options = WatchOption.newBuilder().withRevision(revision).build(); + final AtomicReference ref = new AtomicReference<>(); + final AtomicReference completed = new AtomicReference<>(); + Watch.Listener listener = Watch.listener(TestUtil::noOpWatchResponseConsumer, ref::set, () -> completed.set(Boolean.TRUE)); + try (Watcher ignored = wc.watch(key, options, listener)) { + await().atMost(TIME_OUT_SECONDS, TimeUnit.SECONDS).untilAsserted(() -> assertThat(ref.get()).isNotNull()); + assertThat(ref.get().getClass()).isEqualTo(CompactedException.class); + assertThat(completed.get()).isNotNull(); + assertThat(completed.get()).isEqualTo(Boolean.TRUE); + } + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchTokenExpireTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchTokenExpireTest.java new file mode 100644 index 00000000..c6754fc5 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/impl/WatchTokenExpireTest.java @@ -0,0 +1,102 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.impl; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.Client; +import io.etcd.jetcd.KV; +import io.etcd.jetcd.Watch; +import io.etcd.jetcd.auth.Permission; +import io.etcd.jetcd.test.EtcdClusterExtension; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.RegisterExtension; + +import java.io.File; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Objects; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.awaitility.Awaitility.await; + +// `@org.junit.jupiter.api.Timeout(value = 30)` can't be used in the nativeTest GraalVM CE 22.3 +@Disabled("https://github.com/etcd-io/jetcd/pull/1092") +public class WatchTokenExpireTest { + @RegisterExtension + public static final EtcdClusterExtension cluster = EtcdClusterExtension.builder() + .withNodes(1) + .withSsl(true) + .withAdditionalArgs(Arrays.asList("--auth-token", + "jwt,pub-key=/etc/ssl/etcd/server.pem,priv-key=/etc/ssl/etcd/server-key.pem,sign-method=RS256,ttl=1s")) + .build(); + private static final ByteSequence key = TestUtil.randomByteSequence(); + private static final ByteSequence user = TestUtil.bytesOf("root"); + private static final ByteSequence password = TestUtil.randomByteSequence(); + + private void setUpEnvironment() throws Exception { + final File caFile = new File(Objects.requireNonNull(getClass().getResource("/ssl/cert/ca.pem")).toURI()); + Client client = TestUtil.client(cluster) + .authority("etcd0") + .sslContext(b -> b.trustManager(caFile)) + .build(); + ByteSequence role = TestUtil.bytesOf("root"); + client.getAuthClient().roleAdd(role).get(); + client.getAuthClient().userAdd(user, password).get(); + client.getAuthClient().roleGrantPermission(role, key, key, Permission.Type.READWRITE).get(); + client.getAuthClient().userGrantRole(user, role).get(); + client.getAuthClient().authEnable().get(); + client.close(); + } + + private Client createAuthClient() throws Exception { + final File caFile = new File(Objects.requireNonNull(getClass().getResource("/ssl/cert/ca.pem")).toURI()); + return TestUtil.client(cluster) + .user(user) + .password(password) + .authority("etcd0") + .sslContext(b -> b.trustManager(caFile)).build(); + } + + @Test + public void testRefreshExpiredToken() throws Exception { + setUpEnvironment(); + Client authClient = createAuthClient(); + Watch authWatchClient = authClient.getWatchClient(); + KV authKVClient = authClient.getKVClient(); + authKVClient.put(key, TestUtil.randomByteSequence()).get(1, TimeUnit.SECONDS); + Thread.sleep(3000); + AtomicInteger modifications = new AtomicInteger(); + Watch.Watcher watcher = authWatchClient.watch(key, response -> modifications.incrementAndGet()); + ExecutorService executor = Executors.newFixedThreadPool(1); + List> futures; + Client anotherClient = createAuthClient(); + futures = IntStream.range(0, 2).mapToObj(i -> executor.submit(() -> { + try { + Thread.sleep(3000); + anotherClient.getKVClient().put(key, TestUtil.randomByteSequence()).get(1, TimeUnit.SECONDS); + } catch (Exception e) { + throw new RuntimeException(e); + } + })).collect(Collectors.toCollection(() -> new ArrayList<>(2))); + await().atMost(15, TimeUnit.SECONDS).untilAsserted(() -> assertThat(modifications.get()).isEqualTo(2)); + executor.shutdownNow(); + futures.forEach(f -> assertThat(f).isDone()); + anotherClient.close(); + watcher.close(); + authWatchClient.close(); + authClient.close(); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/options/OptionsUtilTest.java b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/options/OptionsUtilTest.java new file mode 100644 index 00000000..e67a212a --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/java/io_etcd/jetcd_core/options/OptionsUtilTest.java @@ -0,0 +1,35 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see . + */ +package io_etcd.jetcd_core.options; + +import io.etcd.jetcd.ByteSequence; +import io.etcd.jetcd.options.OptionsUtil; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +public class OptionsUtilTest { + static void check(byte[] prefix, byte[] expectedPrefixEndOf) { + ByteSequence actual = OptionsUtil.prefixEndOf(ByteSequence.from(prefix)); + assertThat(actual).isEqualTo(ByteSequence.from(expectedPrefixEndOf)); + } + + @Test + void aaPlus1() { + check(new byte[]{(byte) 'a', (byte) 'a'}, new byte[]{(byte) 'a', (byte) 'b'}); + } + + @Test + void axffPlus1() { + check(new byte[]{(byte) 'a', (byte) 0xff}, new byte[]{(byte) 'b'}); + } + + @Test + void xffPlus1() { + check(new byte[]{(byte) 0xff}, new byte[]{(byte) 0x00}); + } +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/io.etcd/jetcd-test/0.7.5/reflect-config.json b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/io.etcd/jetcd-test/0.7.5/reflect-config.json new file mode 100644 index 00000000..1bd996ff --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/io.etcd/jetcd-test/0.7.5/reflect-config.json @@ -0,0 +1,2050 @@ +[ + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[B" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.Bind;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.Capability;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.Device;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.ExposedPort;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.Link;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.LxcConf;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.PortBinding;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.Ports$Binding;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.Ulimit;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.Volume;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.VolumeBind;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.VolumeRW;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lcom.github.dockerjava.api.model.VolumesFrom;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Ljava.lang.String;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "[Lorg.testcontainers.shaded.com.fasterxml.jackson.databind.deser.BeanDeserializerModifier;" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.GrpcServerExtension" + }, + "name": "android.app.Application" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.CreateContainerCmd", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.CreateContainerResponse", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + }, + { + "name": "setId", + "parameterTypes": [ + "java.lang.String" + ] + }, + { + "name": "setWarnings", + "parameterTypes": [ + "java.lang.String[]" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.CreateNetworkCmd", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.CreateNetworkResponse", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + }, + { + "name": "setId", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.DockerCmd", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.GraphData", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.GraphDriver", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.HealthState", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.HealthStateLog", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.InspectContainerResponse", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.InspectContainerResponse$ContainerState", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "queryAllPublicConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [ + "com.github.dockerjava.api.command.InspectContainerResponse" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.InspectContainerResponse$Mount", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.InspectContainerResponse$Node", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "queryAllPublicConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.command.SyncDockerCmd", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.AccessMode", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.AuthConfig", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "getAuth", + "parameterTypes": [] + }, + { + "name": "getEmail", + "parameterTypes": [] + }, + { + "name": "getIdentitytoken", + "parameterTypes": [] + }, + { + "name": "getPassword", + "parameterTypes": [] + }, + { + "name": "getRegistryAddress", + "parameterTypes": [] + }, + { + "name": "getRegistrytoken", + "parameterTypes": [] + }, + { + "name": "getStackOrchestrator", + "parameterTypes": [] + }, + { + "name": "getUsername", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Bind", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.BindOptions", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.BindPropagation", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Binds", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "fromPrimitive", + "parameterTypes": [ + "java.lang.String[]" + ] + }, + { + "name": "toPrimitive", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.BlkioRateDevice", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.BlkioWeightDevice", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Capability", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.ClusterInfo", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.ContainerConfig", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.ContainerNetwork", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.ContainerNetwork$Ipam", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Device", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.DeviceRequest", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.DockerObject", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "methods": [ + { + "name": "getRawValues", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Driver", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.ExposedPort", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.ExposedPorts", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "fromPrimitive", + "parameterTypes": [ + "java.util.Map" + ] + }, + { + "name": "toPrimitive", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.ExternalCA", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.ExternalCAProtocol", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.HealthCheck", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.HostConfig", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + }, + { + "name": "getAutoRemove", + "parameterTypes": [] + }, + { + "name": "getBlkioDeviceReadBps", + "parameterTypes": [] + }, + { + "name": "getBlkioDeviceReadIOps", + "parameterTypes": [] + }, + { + "name": "getBlkioDeviceWriteBps", + "parameterTypes": [] + }, + { + "name": "getBlkioDeviceWriteIOps", + "parameterTypes": [] + }, + { + "name": "getBlkioWeight", + "parameterTypes": [] + }, + { + "name": "getBlkioWeightDevice", + "parameterTypes": [] + }, + { + "name": "getCapAdd", + "parameterTypes": [] + }, + { + "name": "getCapDrop", + "parameterTypes": [] + }, + { + "name": "getCgroup", + "parameterTypes": [] + }, + { + "name": "getCgroupParent", + "parameterTypes": [] + }, + { + "name": "getCgroupnsMode", + "parameterTypes": [] + }, + { + "name": "getConsoleSize", + "parameterTypes": [] + }, + { + "name": "getContainerIDFile", + "parameterTypes": [] + }, + { + "name": "getCpuCount", + "parameterTypes": [] + }, + { + "name": "getCpuPercent", + "parameterTypes": [] + }, + { + "name": "getCpuPeriod", + "parameterTypes": [] + }, + { + "name": "getCpuQuota", + "parameterTypes": [] + }, + { + "name": "getCpuRealtimePeriod", + "parameterTypes": [] + }, + { + "name": "getCpuRealtimeRuntime", + "parameterTypes": [] + }, + { + "name": "getCpuShares", + "parameterTypes": [] + }, + { + "name": "getCpusetCpus", + "parameterTypes": [] + }, + { + "name": "getCpusetMems", + "parameterTypes": [] + }, + { + "name": "getDeviceCgroupRules", + "parameterTypes": [] + }, + { + "name": "getDeviceRequests", + "parameterTypes": [] + }, + { + "name": "getDevices", + "parameterTypes": [] + }, + { + "name": "getDiskQuota", + "parameterTypes": [] + }, + { + "name": "getDns", + "parameterTypes": [] + }, + { + "name": "getDnsOptions", + "parameterTypes": [] + }, + { + "name": "getDnsSearch", + "parameterTypes": [] + }, + { + "name": "getExtraHosts", + "parameterTypes": [] + }, + { + "name": "getGroupAdd", + "parameterTypes": [] + }, + { + "name": "getInit", + "parameterTypes": [] + }, + { + "name": "getIoMaximumBandwidth", + "parameterTypes": [] + }, + { + "name": "getIoMaximumIOps", + "parameterTypes": [] + }, + { + "name": "getIpcMode", + "parameterTypes": [] + }, + { + "name": "getIsolation", + "parameterTypes": [] + }, + { + "name": "getKernelMemory", + "parameterTypes": [] + }, + { + "name": "getLxcConf", + "parameterTypes": [] + }, + { + "name": "getMemory", + "parameterTypes": [] + }, + { + "name": "getMemoryReservation", + "parameterTypes": [] + }, + { + "name": "getMemorySwap", + "parameterTypes": [] + }, + { + "name": "getMemorySwappiness", + "parameterTypes": [] + }, + { + "name": "getMounts", + "parameterTypes": [] + }, + { + "name": "getNanoCPUs", + "parameterTypes": [] + }, + { + "name": "getNetworkMode", + "parameterTypes": [] + }, + { + "name": "getOomKillDisable", + "parameterTypes": [] + }, + { + "name": "getOomScoreAdj", + "parameterTypes": [] + }, + { + "name": "getPidMode", + "parameterTypes": [] + }, + { + "name": "getPidsLimit", + "parameterTypes": [] + }, + { + "name": "getPortBindings", + "parameterTypes": [] + }, + { + "name": "getPrivileged", + "parameterTypes": [] + }, + { + "name": "getPublishAllPorts", + "parameterTypes": [] + }, + { + "name": "getReadonlyRootfs", + "parameterTypes": [] + }, + { + "name": "getRestartPolicy", + "parameterTypes": [] + }, + { + "name": "getRuntime", + "parameterTypes": [] + }, + { + "name": "getSecurityOpts", + "parameterTypes": [] + }, + { + "name": "getShmSize", + "parameterTypes": [] + }, + { + "name": "getStorageOpt", + "parameterTypes": [] + }, + { + "name": "getSysctls", + "parameterTypes": [] + }, + { + "name": "getTmpFs", + "parameterTypes": [] + }, + { + "name": "getUlimits", + "parameterTypes": [] + }, + { + "name": "getUsernsMode", + "parameterTypes": [] + }, + { + "name": "getUtSMode", + "parameterTypes": [] + }, + { + "name": "getVolumeDriver", + "parameterTypes": [] + }, + { + "name": "getVolumesFrom", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Image", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Info", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.InfoRegistryConfig", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.InfoRegistryConfig$IndexConfig", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.InternetProtocol", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Isolation", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "methods": [ + { + "name": "fromValue", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Link", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Links", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "toPrimitive", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.LocalNodeState", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "methods": [ + { + "name": "forValue", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.LogConfig", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + }, + { + "name": "setType", + "parameterTypes": [ + "com.github.dockerjava.api.model.LogConfig$LoggingType" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.LogConfig$LoggingType", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "methods": [ + { + "name": "fromValue", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.LxcConf", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Mount", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.MountType", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.NetworkSettings", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.PeerNode", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Ports", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "fromPrimitive", + "parameterTypes": [ + "java.util.Map" + ] + }, + { + "name": "toPrimitive", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Ports$Binding", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.PropagationMode", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.ResourceVersion", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.RestartPolicy", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.SELContext", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.SwarmCAConfig", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.SwarmDispatcherConfig", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.SwarmInfo", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.SwarmOrchestration", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.SwarmRaftConfig", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.SwarmSpec", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.TaskDefaults", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.TmpfsOptions", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Ulimit", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Version", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.VersionComponent", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.VersionPlatform", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Volume", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.VolumeBind", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.VolumeBinds", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.VolumeOptions", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.VolumeRW", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.Volumes", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "toPrimitive", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.VolumesFrom", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "com.github.dockerjava.api.model.VolumesRW", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.GrpcServerExtension" + }, + "name": "io.grpc.census.InternalCensusStatsAccessor" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.GrpcServerExtension" + }, + "name": "io.grpc.census.InternalCensusTracingAccessor" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.GrpcServerExtension" + }, + "name": "io.grpc.internal.PickFirstLoadBalancerProvider" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterNameResolver" + }, + "name": "io.grpc.netty.WriteBufferingAndExceptionHandler", + "methods": [ + { + "name": "channelInactive", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelRead", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object" + ] + }, + { + "name": "close", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "connect", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.net.SocketAddress", + "java.net.SocketAddress", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "exceptionCaught", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Throwable" + ] + }, + { + "name": "flush", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "write", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object", + "io.netty.channel.ChannelPromise" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.GrpcServerExtension" + }, + "name": "io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterNameResolver" + }, + "name": "io.netty.buffer.AbstractByteBufAllocator", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterNameResolver" + }, + "name": "io.netty.buffer.AbstractReferenceCountedByteBuf", + "fields": [ + { + "name": "refCnt" + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterNameResolver" + }, + "name": "io.netty.channel.ChannelDuplexHandler", + "methods": [ + { + "name": "bind", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.net.SocketAddress", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "deregister", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "disconnect", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "read", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterNameResolver" + }, + "name": "io.netty.channel.ChannelInboundHandlerAdapter", + "methods": [ + { + "name": "channelActive", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelReadComplete", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelRegistered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelUnregistered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelWritabilityChanged", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "userEventTriggered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterNameResolver" + }, + "name": "io.netty.channel.DefaultChannelPipeline$HeadContext", + "methods": [ + { + "name": "bind", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.net.SocketAddress", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "channelActive", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelInactive", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelRead", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object" + ] + }, + { + "name": "channelReadComplete", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelRegistered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelUnregistered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelWritabilityChanged", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "close", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "connect", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.net.SocketAddress", + "java.net.SocketAddress", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "deregister", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "disconnect", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "io.netty.channel.ChannelPromise" + ] + }, + { + "name": "exceptionCaught", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Throwable" + ] + }, + { + "name": "flush", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "read", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "userEventTriggered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object" + ] + }, + { + "name": "write", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object", + "io.netty.channel.ChannelPromise" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterNameResolver" + }, + "name": "io.netty.channel.DefaultChannelPipeline$TailContext", + "methods": [ + { + "name": "channelActive", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelInactive", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelRead", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object" + ] + }, + { + "name": "channelReadComplete", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelRegistered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelUnregistered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "channelWritabilityChanged", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext" + ] + }, + { + "name": "exceptionCaught", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Throwable" + ] + }, + { + "name": "userEventTriggered", + "parameterTypes": [ + "io.netty.channel.ChannelHandlerContext", + "java.lang.Object" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterNameResolver" + }, + "name": "io.netty.channel.epoll.Epoll" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.io.Closeable", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.io.Serializable", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.lang.AutoCloseable", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.lang.Boolean", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.lang.Comparable", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.lang.Enum", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.lang.Integer", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.lang.Long", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.lang.Number", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.lang.Object", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterNameResolver" + }, + "name": "java.lang.ProcessHandle", + "methods": [ + { + "name": "current", + "parameterTypes": [] + }, + { + "name": "pid", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.lang.constant.Constable", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.lang.constant.ConstantDesc", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.net.UnixDomainSocketAddress", + "methods": [ + { + "name": "of", + "parameterTypes": [ + "java.lang.String" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterNameResolver" + }, + "name": "java.nio.channels.spi.SelectorProvider", + "methods": [ + { + "name": "openSocketChannel", + "parameterTypes": [ + "java.net.ProtocolFamily" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.security.SecureRandomParameters" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.util.ArrayList", + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.util.HashMap", + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "java.util.LinkedHashMap", + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.GrpcServerExtension" + }, + "name": "java.util.concurrent.ScheduledThreadPoolExecutor", + "methods": [ + { + "name": "setRemoveOnCancelPolicy", + "parameterTypes": [ + "boolean" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterNameResolver" + }, + "name": "java.util.concurrent.atomic.LongAdder", + "methods": [ + { + "name": "", + "parameterTypes": [] + }, + { + "name": "add", + "parameterTypes": [ + "long" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.GrpcServerExtension" + }, + "name": "java.util.concurrent.atomic.LongAdder", + "queryAllPublicConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + }, + { + "name": "add", + "parameterTypes": [ + "long" + ] + }, + { + "name": "sum", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "org.testcontainers.dockerclient.UnixSocketClientProviderStrategy", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "org.testcontainers.shaded.com.fasterxml.jackson.databind.ext.Java7SupportImpl", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "org.testcontainers.shaded.com.github.dockerjava.core.DockerConfigFile", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "org.testcontainers.shaded.com.github.dockerjava.core.command.AbstrDockerCmd", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "org.testcontainers.shaded.com.github.dockerjava.core.command.CreateContainerCmdImpl", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "org.testcontainers.shaded.com.github.dockerjava.core.command.CreateNetworkCmdImpl", + "allDeclaredFields": true, + "queryAllDeclaredMethods": true, + "queryAllDeclaredConstructors": true, + "methods": [ + { + "name": "getAttachable", + "parameterTypes": [] + }, + { + "name": "getCheckDuplicate", + "parameterTypes": [] + }, + { + "name": "getDriver", + "parameterTypes": [] + }, + { + "name": "getEnableIPv6", + "parameterTypes": [] + }, + { + "name": "getInternal", + "parameterTypes": [] + }, + { + "name": "getIpam", + "parameterTypes": [] + }, + { + "name": "getLabels", + "parameterTypes": [] + }, + { + "name": "getName", + "parameterTypes": [] + }, + { + "name": "getOptions", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "org.testcontainers.shaded.org.awaitility.core.ConditionFactory$1", + "queryAllDeclaredMethods": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "name": "sun.security.provider.NativePRNG$NonBlocking", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + } +] diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/io.etcd/jetcd-test/0.7.5/resource-config.json b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/io.etcd/jetcd-test/0.7.5/resource-config.json new file mode 100644 index 00000000..00c19d8a --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/io.etcd/jetcd-test/0.7.5/resource-config.json @@ -0,0 +1,25 @@ +{ + "resources": { + "includes": [ + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.GrpcServerExtension" + }, + "pattern": "\\QMETA-INF/services/io.grpc.LoadBalancerProvider\\E" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "pattern": "\\QMETA-INF/services/org.testcontainers.dockerclient.DockerClientProviderStrategy\\E" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.test.EtcdClusterExtension" + }, + "pattern": "\\Qcom/github/dockerjava/zerodep/shaded/org/apache/hc/client5/version.properties\\E" + } + ] + }, + "bundles": [] +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/jetcd-core-test-metadata/proxy-config.json b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/jetcd-core-test-metadata/proxy-config.json new file mode 100644 index 00000000..67ffe295 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/jetcd-core-test-metadata/proxy-config.json @@ -0,0 +1,10 @@ +[ + { + "condition": { + "typeReachable": "org.mockito.internal.creation.proxy.ProxyMockMaker" + }, + "interfaces": [ + "io.grpc.stub.StreamObserver" + ] + } +] diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/jetcd-core-test-metadata/reflect-config.json b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/jetcd-core-test-metadata/reflect-config.json new file mode 100644 index 00000000..a4cb1a09 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/jetcd-core-test-metadata/reflect-config.json @@ -0,0 +1,309 @@ +[ + { + "condition": { + "typeReachable": "org.mockito.internal.configuration.IndependentAnnotationEngine" + }, + "name": "io.etcd.jetcd.impl.WatchUnitTest", + "allDeclaredFields": true + }, + { + "condition": { + "typeReachable": "org.mockito.internal.configuration.SpyAnnotationEngine" + }, + "name": "io.etcd.jetcd.impl.WatchUnitTest", + "allDeclaredFields": true + }, + { + "condition": { + "typeReachable": "org.mockito.internal.configuration.injection.scanner.InjectMocksScanner" + }, + "name": "io.etcd.jetcd.impl.WatchUnitTest", + "allDeclaredFields": true + }, + { + "condition": { + "typeReachable": "org.mockito.internal.configuration.injection.scanner.MockScanner" + }, + "name": "io.etcd.jetcd.impl.WatchUnitTest", + "allDeclaredFields": true + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "android.app.Application" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "io.grpc.internal.AbstractManagedChannelImplBuilder", + "fields": [ + { + "name": "maxInboundMessageSize" + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "io.grpc.internal.DnsNameResolverProvider" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "io.netty.channel.epoll.Epoll" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "io.netty.channel.socket.nio.NioSocketChannel", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "io.netty.util.internal.shaded.org.jctools.queues.BaseMpscLinkedArrayQueueColdProducerFields", + "fields": [ + { + "name": "producerLimit" + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "io.netty.util.internal.shaded.org.jctools.queues.BaseMpscLinkedArrayQueueConsumerFields", + "fields": [ + { + "name": "consumerIndex" + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "io.netty.util.internal.shaded.org.jctools.queues.BaseMpscLinkedArrayQueueProducerFields", + "fields": [ + { + "name": "producerIndex" + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "io.vertx.core.logging.Log4j2LogDelegateFactory", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "io.vertx.core.logging.SLF4JLogDelegateFactory", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "java.nio.Bits", + "methods": [ + { + "name": "unaligned", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "java.nio.Buffer", + "fields": [ + { + "name": "address" + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "java.nio.ByteBuffer", + "methods": [ + { + "name": "alignedSlice", + "parameterTypes": [ + "int" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "java.nio.DirectByteBuffer", + "methods": [ + { + "name": "", + "parameterTypes": [ + "long", + "int" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "java.security.SecureRandomParameters" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "jdk.internal.misc.Unsafe", + "methods": [ + { + "name": "getUnsafe", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "sun.misc.Unsafe", + "fields": [ + { + "name": "theUnsafe" + } + ], + "methods": [ + { + "name": "copyMemory", + "parameterTypes": [ + "java.lang.Object", + "long", + "java.lang.Object", + "long", + "long" + ] + }, + { + "name": "getAndAddLong", + "parameterTypes": [ + "java.lang.Object", + "long", + "long" + ] + }, + { + "name": "getAndSetObject", + "parameterTypes": [ + "java.lang.Object", + "long", + "java.lang.Object" + ] + }, + { + "name": "invokeCleaner", + "parameterTypes": [ + "java.nio.ByteBuffer" + ] + }, + { + "name": "storeFence", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "sun.misc.VM" + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "sun.security.provider.NativePRNG", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "name": "sun.security.provider.SHA", + "methods": [ + { + "name": "", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.WatchUnitTest" + }, + "name": "io.etcd.jetcd.common.exception.CompactedException", + "methods": [ + { + "name": "getCompactedRevision", + "parameterTypes": [] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.WatchUnitTest" + }, + "name": "java.util.concurrent.atomic.LongAdder", + "methods": [ + { + "name": "add", + "parameterTypes": [ + "long" + ] + } + ] + }, + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.WatchUnitTest" + }, + "name": "org.mockito.configuration.MockitoConfiguration" + } +] diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/jetcd-core-test-metadata/resource-config.json b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/jetcd-core-test-metadata/resource-config.json new file mode 100644 index 00000000..7d102aae --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/META-INF/native-image/jetcd-core-test-metadata/resource-config.json @@ -0,0 +1,13 @@ +{ + "resources": { + "includes": [ + { + "condition": { + "typeReachable": "io.etcd.jetcd.impl.ClientBuilderTest" + }, + "pattern": "\\QMETA-INF/services/io.grpc.NameResolverProvider\\E" + } + ] + }, + "bundles": [] +} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker new file mode 100644 index 00000000..5494acdc --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker @@ -0,0 +1 @@ +org.mockito.internal.creation.proxy.ProxyMockMaker diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca-config.json b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca-config.json new file mode 100644 index 00000000..40fe1245 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca-config.json @@ -0,0 +1 @@ +{"signing":{"default":{"expiry":"43800h","usages":["signing","key encipherment","server auth","client auth"]}}} diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca-key.pem b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca-key.pem new file mode 100644 index 00000000..e38c0533 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca-key.pem @@ -0,0 +1,27 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIEpAIBAAKCAQEArw9sxQraJl/2rCr2VoSECYKAKoo0NGmg/9bdRGFrS2ysQfr8 +S/vHBooyGYEnuESGhGbZN+B0sFSBRctjsyQFydXK2USyTaZCsEUYrl7qUG35DJqK +aABsfIIfeFp0EuFzjJxXm3Ag6v1VPcyywX+167APPN9RcALs46om2fP9OBe1DMaX +ABkxoMxcSPZ0DWBL/WTwpygcj4TViQ44NPcr8/DHKCa/OgLMb9Iydir4Isl9JP6S +lHHvUZCFTf24Np6l2kUWU/SMxMH51WB+0L4CYWOXO/w3CYVQqKUQqeDlRNyuvPH+ +FL3OmmlugcYNNhjqHkL1eczJpmKFa1pLqAk8BwIDAQABAoIBAAPTOnUzv4CHKESq +y6coThpHF7XWPz3F8RamAz+zQTzsqvbmHQ0r+zVRX7be85c7KBVMigKGjQYtUoXL +4+nOJ7I5Ua1dque3ck2XtOpaeJQ5Uu/LkKqlF7nAvh9LGq4u7u9rmx5yXMXFs08e +YemIeNklh6+00Xq5FaQD28V3Z1kKYlHIvAM8AyhzeD2BQ7PgaWYFpsfNOCvTqePH +ygZOTQAaHgWgaM/QV8kDfUcDWfqtiu7/WER76EhludzL74RGpe2299pHMhIdRWi3 +ruiX8ln1M5swYOBLbDZr5Ez1jT5LvesaSTkW3Vg0ZiynI9KO7V0IVn81woXU65v5 +QN7QcsECgYEA0MzsUOTSsyoJxG0EKOhBj1zo6erANAyuZcyqwb63gIBcypdF1ZqK +5SBwv0cuw526wYMxzoTXlHYwo2c7B2x4YjmHbZX3XCu6ykC0jpYmz4sJzHqWn8xn +RqKhU7ItlkhdBz4Y3GPS8xWrtJ8mulj4seAQKtC2JlFiKvxt9KkfKJUCgYEA1qH8 +/eN+jtP3YsTLdo+lqOJxKBXKmDwS6WZHQHTCp3JOPmZBA1N2i4luoIBkbhQo5yfU +DFCk8a9lMvhQ763fyra/hjIAs/BizUI94eCx2GVyilP95Fjzwi94hngVmKrNj2Oj +cS1TiipULviOE6H/Vv+uldM7gzntgONT4Eed/ysCgYEAqUMl4uHMKC9Q4anaMGsv +Ek+oBFAn5UnOannChvLbANGN5zFADEuOgvWMUJMcxrjrdwmqa5bmx9QT07LQeFEn +OcEXFu/2KQLOFjzj4Z648Y/trpRF3F6v7ePSUe3j5KretwtQzgAiNqp/mhlWJMQR +Pui7UmoE7wUURnKBlE8xEg0CgYEA1gKxY2qqL7pVKsu1YKO899fKIsEPwJnt9YIB +O9jwmswUDo4g9zMKufmwMCO1gDljy5FgE2N6BG7yRk9pTIOf6N4tvJ4xKzpfGfGa +CJbmXjJRcnJrb3vumkqBL/ue9RoiW35rYxdh/BtW03sNF7BpDRNmvofgCGoDUofZ +g4GFnf8CgYBEW9c6APl6KXB+d1MNIu5J7yyYb1jRNwDGb3hUvCNtGNQR17qAwASc +fCfEoa9VF2qdQn/BoFYa3cc/fMYr41KjzypekH8ZhpZHGYsf/d8ubhKUy6HHfyyQ +hWCVet9bZwIIAfNdhrjMymtu41StBu9BnSRb0IJjCcVZYrB7ewEHSg== +-----END RSA PRIVATE KEY----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca.csr b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca.csr new file mode 100644 index 00000000..2e8825e0 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca.csr @@ -0,0 +1,15 @@ +-----BEGIN CERTIFICATE REQUEST----- +MIICUjCCAToCAQAwDTELMAkGA1UEAxMCQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB +DwAwggEKAoIBAQCvD2zFCtomX/asKvZWhIQJgoAqijQ0aaD/1t1EYWtLbKxB+vxL ++8cGijIZgSe4RIaEZtk34HSwVIFFy2OzJAXJ1crZRLJNpkKwRRiuXupQbfkMmopo +AGx8gh94WnQS4XOMnFebcCDq/VU9zLLBf7XrsA8831FwAuzjqibZ8/04F7UMxpcA +GTGgzFxI9nQNYEv9ZPCnKByPhNWJDjg09yvz8McoJr86Asxv0jJ2KvgiyX0k/pKU +ce9RkIVN/bg2nqXaRRZT9IzEwfnVYH7QvgJhY5c7/DcJhVCopRCp4OVE3K688f4U +vc6aaW6Bxg02GOoeQvV5zMmmYoVrWkuoCTwHAgMBAAGgADANBgkqhkiG9w0BAQsF +AAOCAQEAR2Etwsjad/VH/K22tvXqlT39u0NadwIEIV+aPC//3taSuIk4fSl4PxiK +hAJmbG+r+Kwd2MCboZQgDAdAruNJm9e47CRwCXcvW5XlpZYe9s0MzN4yiWbZFV7u +4w/x8+Q+zhAxWdjhuAcN9tdXO/7ETFdVB1CrscRBDflyiJD9Z9mO0pMVw6YCNmQp +YVkx83Ta5gDTYvqG6Dc7HvAs/W3xF3GSLn9acL/OhI84F1hIr2O4mzUKAVTPBbFH +xRNjjRbm5I1zorQ93kXpQ/VmD4Ak9sIGAyFnJjAAQxGtLpEEzojlAol7ar1HLO9b +6SPUpDypt8FhzF/5aC0be+7c74vnmg== +-----END CERTIFICATE REQUEST----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca.pem b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca.pem new file mode 100644 index 00000000..5f8ec05b --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/ca.pem @@ -0,0 +1,19 @@ +-----BEGIN CERTIFICATE----- +MIIDDjCCAfagAwIBAgIURiFLEQLm/O4UCwAG8NV7kS1O9fUwDQYJKoZIhvcNAQEL +BQAwDTELMAkGA1UEAxMCQ0EwHhcNMTgwNTIzMDk0NTAwWhcNMjMwNTIyMDk0NTAw +WjANMQswCQYDVQQDEwJDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +AK8PbMUK2iZf9qwq9laEhAmCgCqKNDRpoP/W3URha0tsrEH6/Ev7xwaKMhmBJ7hE +hoRm2TfgdLBUgUXLY7MkBcnVytlEsk2mQrBFGK5e6lBt+QyaimgAbHyCH3hadBLh +c4ycV5twIOr9VT3MssF/teuwDzzfUXAC7OOqJtnz/TgXtQzGlwAZMaDMXEj2dA1g +S/1k8KcoHI+E1YkOODT3K/PwxygmvzoCzG/SMnYq+CLJfST+kpRx71GQhU39uDae +pdpFFlP0jMTB+dVgftC+AmFjlzv8NwmFUKilEKng5UTcrrzx/hS9zpppboHGDTYY +6h5C9XnMyaZihWtaS6gJPAcCAwEAAaNmMGQwDgYDVR0PAQH/BAQDAgEGMBIGA1Ud +EwEB/wQIMAYBAf8CAQIwHQYDVR0OBBYEFJ27c/q0uNbURXqb0VI0bqSuKWJRMB8G +A1UdIwQYMBaAFJ27c/q0uNbURXqb0VI0bqSuKWJRMA0GCSqGSIb3DQEBCwUAA4IB +AQCR8mNWCkJhCy4O3GKRwwudNTOgHfZEhjPfMNFG/xtxoyg87aSGgsNm4XO4SRLV +EFjF1iama1dYR4vWcy3wLXUH71ke7TT16lQMIOG6KFtjNV3e8asqIkJxuCiaCQRp +7/T2PEmS50OllReuA3MybgHbyRAEBcz8mJ2SDBWCxvDpQSdZiR9582srcJcSkwI9 +wHOilXX8jebjhgOS/tMH/l3HTpdi2TGeRzJ0aBJybosfriKjK4K8SaKrd7CaFRbt +YacNo2jy7RQlezYhEBp9728SgMkkYMATptM2SvUYkHiIap1ryxwkN3oAAeMjWAYG +Brfzaj2tMg70R1v/7HtJ8Y+8 +-----END CERTIFICATE----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/client-key.pem b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/client-key.pem new file mode 100644 index 00000000..8f555db7 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/client-key.pem @@ -0,0 +1,27 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIEpQIBAAKCAQEAtF68ZaHoNqobp3q6w60Q/eoBDu5WAlRVRKaX7eBroLnTwraw +LaMHWhkxpIOqFnQSG6IMOEaoqt0l64v/HXaZ39hKtQ2buPnZP+yDrGzvES04TuuP +EnU0CNJXcX5Klx+IT1LqC8wyD1kOLccfI7IIo46vTNHk1u51rHzxJzs4wEOgRmLN +k5FK7Q2j7SK4F8FCBrqTgSOTlstKiYIr/2IQ4QFlAPxrnHtcjxIZDe9usER77JMI +c7y4lWRstiM+hTz6kcArKNBCyGz+gm3PLWqMFeZdiMEMI5o/RvFO9uhgksVYAMTA +diOnZ9+iAUH6JWi8AB54HwB4R7KVaZrQsgHWhQIDAQABAoIBAQCX+n86D5tvfBQD +IXl+6TO5D1RG9XHJUq/qQYkgqYlmi02v8mkuewD13OakXUCS3MhpOjibroXuOpr6 +ByM1+zoaj9AbEFVXHkb9AtfMEJm72mNotDkAb3sht8JwYd6Nycb8N7v3pt3DauF0 +lyRY2mlHDzIMQ4tTwueqKDi2OsNN1ANj9doeNiX5V3peWDKn7j4wTI3RZXP6x2Zo +Yz31wXkN8GBTllSBWvCyUAYXGuWGwjgIeJDcF9Es8rsyMOPnghZ+Atx1RejJKV6v +dW0dy0hwQjt3R9oKVF0U+s4p5BgDY4/je5DY/0a4/khPxJAk+VqpMmH7866EhXkH +iUeQp6EdAoGBANJ6mJyXWX8kUoIwphVUw2beqglUXxo6Z2YSk0lxTueDQZLUbc12 +7rjj3rW6jza0qgyqeeKbzKvPeyhUC2TGz2FgxY7GOt+NfqnUQEmiZO1HnMRrohSB +XURMZ2x4rgYigbnpW4gTI2tRuautC+I1aCUC9CGD4TxGX85MHgDUZXTjAoGBANth +IVBUEA5bte1PO/SZVEAf0FmslBZWLSMCPBz1UcGyJ0i/QMaQZou2u0ddqbttNSU5 +WiRQs0DThc629TcWEfcA17NDQcdQj7sgLKzdJ5dc1r6Y74IImO6RFM8BTXx0ZF53 +yPWuumHLN8phVg7+CZzsy7a4iwf9PmjfH645Hkt3AoGAKvLjQ0jK9Vu3DmPY8A9c +1BfpgH/b7CEwyi5OKbVaUXmCHvED+uIi8k1lO5X29UXGUVFUD76U9BYhXmhP7t92 +n7s8dNbUWpun1gW+nIfrqlNrlNUVvLNtEau5ivPRJuVRrVsF1214U8TYa0SjYSRe +vPauVExx4HfHwvPbR3YPwdsCgYEArzyxHbdoc++yLPPD0qi/8dD33wnJ6OXBfFuG +pSMYwX6LfsK2/WXPY/79Lg6VTE/5ydg8NxH3fer40Zy3197bTtDvfBRXcNzbUwBq +b1LhEzlnmCwV9WrkrnxZgNlrieR3YDaS4h1GaGOqFxEVazhleWJ1f2l+NU2HEsJY +ThT2LBUCgYEAv+Ne0tmaZyY4EVGWo+gF7+0zfof09MW02XtFYFtvB2rM8I96vVUn +HSrlSKrBmbZhjXwJtoHFgL5pY4zTTDMW9yuDdRhLSiIeRG1agtRc3EAV/lVWIhOm ++L8/imNahc++L+cteoN9mrduDcvEuab6RW4H/fkz0j03i17CvhdxCjI= +-----END RSA PRIVATE KEY----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/client.csr b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/client.csr new file mode 100644 index 00000000..80de3123 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/client.csr @@ -0,0 +1,16 @@ +-----BEGIN CERTIFICATE REQUEST----- +MIICdDCCAVwCAQAwETEPMA0GA1UEAxMGY2xpZW50MIIBIjANBgkqhkiG9w0BAQEF +AAOCAQ8AMIIBCgKCAQEAtF68ZaHoNqobp3q6w60Q/eoBDu5WAlRVRKaX7eBroLnT +wrawLaMHWhkxpIOqFnQSG6IMOEaoqt0l64v/HXaZ39hKtQ2buPnZP+yDrGzvES04 +TuuPEnU0CNJXcX5Klx+IT1LqC8wyD1kOLccfI7IIo46vTNHk1u51rHzxJzs4wEOg +RmLNk5FK7Q2j7SK4F8FCBrqTgSOTlstKiYIr/2IQ4QFlAPxrnHtcjxIZDe9usER7 +7JMIc7y4lWRstiM+hTz6kcArKNBCyGz+gm3PLWqMFeZdiMEMI5o/RvFO9uhgksVY +AMTAdiOnZ9+iAUH6JWi8AB54HwB4R7KVaZrQsgHWhQIDAQABoB4wHAYJKoZIhvcN +AQkOMQ8wDTALBgNVHREEBDACggAwDQYJKoZIhvcNAQELBQADggEBAJllCd+q48qC +FtbThFwjAz8D1ayXanpucZB5Tr2PfghA97jLTcX6r2EnGHu3yaKaNPbCKszRxh6X +vtU+nJTs6ZE5oCT4xExq3t2Oc67thgvDXsiZugPlnROYJyYoSk6SIAKN4JtzE496 +rKhpLGX/7Q5R50w7xDtQTyLrP72o8I6ngKfJAyEZrOEYy3Q/LJzaQrygBNYwZk60 +YuQJK7frH81vudt9zfuVtXGNOyooEV3KnmytYxy9xApoTUlODdJdqmHESfFSDumg +eMr2QBaLtvLjdm1RIFkUPgVKhn1hyNkiuiro2op3/BRSvm3XLJ6JsAPQeZX2c+9Y +mN+FBAB3pXU= +-----END CERTIFICATE REQUEST----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/client.pem b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/client.pem new file mode 100644 index 00000000..40644036 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/client.pem @@ -0,0 +1,20 @@ +-----BEGIN CERTIFICATE----- +MIIDOjCCAiKgAwIBAgIUH6tALxkT2Pof7qjjcmJqnVKK8hYwDQYJKoZIhvcNAQEL +BQAwDTELMAkGA1UEAxMCQ0EwHhcNMTgwNTIzMDk0NTAwWhcNMjMwNTIyMDk0NTAw +WjARMQ8wDQYDVQQDEwZjbGllbnQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK +AoIBAQC0Xrxloeg2qhunerrDrRD96gEO7lYCVFVEppft4GugudPCtrAtowdaGTGk +g6oWdBIbogw4Rqiq3SXri/8ddpnf2Eq1DZu4+dk/7IOsbO8RLThO648SdTQI0ldx +fkqXH4hPUuoLzDIPWQ4txx8jsgijjq9M0eTW7nWsfPEnOzjAQ6BGYs2TkUrtDaPt +IrgXwUIGupOBI5OWy0qJgiv/YhDhAWUA/Guce1yPEhkN726wRHvskwhzvLiVZGy2 +Iz6FPPqRwCso0ELIbP6Cbc8taowV5l2IwQwjmj9G8U726GCSxVgAxMB2I6dn36IB +QfolaLwAHngfAHhHspVpmtCyAdaFAgMBAAGjgY0wgYowDgYDVR0PAQH/BAQDAgWg +MB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAMBgNVHRMBAf8EAjAAMB0G +A1UdDgQWBBQx56oqxCeo+lvtqTYM/mxxJCE3ajAfBgNVHSMEGDAWgBSdu3P6tLjW +1EV6m9FSNG6kriliUTALBgNVHREEBDACggAwDQYJKoZIhvcNAQELBQADggEBAGyp +IJZBoPyoKtUA6zxxX2NpEnJp9yN+wvtC7bMAgywkno+gTx72Ru12LydbTXwpU6cL +ye24hRbJLbZDNOp+jGFK+y9felxW9kZU21kepy5U+q8PEsIUpWkhJ3OfIpl6pWJJ +zeIDcbirp88GF3KPzg/JCceifHXe5zmrzFz+QIB7OpDhi/3txR2eRYXIWUgLnVe7 +H2iTiaRNijyezLgDCzpVsA+NBjT5y8EWeNCPKtTuzmW+WheLx8pLcFYMG4GNe61s +8+IZ3LeCJQfIwfTmLDvtuCA8UHfyPM6Lo/Zi6oK/LH5MK218KawvrA6JYlutmnsB +jobvbWLCyJEigL/0dxY= +-----END CERTIFICATE----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd0-key.pem b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd0-key.pem new file mode 100644 index 00000000..05df3770 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd0-key.pem @@ -0,0 +1,27 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIEpAIBAAKCAQEAvCb9389S7jWS3CbPXTXBUCqrNCKTdAXe008hEuPbiQYSjkMj +xSLyeTvC5JexZLloGHhlZ/me4azau0869CwwS8XMrjjUgPItDaAcU8uGgBdIkJX6 +UoSwMrQ8TkFC50GT8m5iHI7pGI0mX6tIXUFOa+6P8me8hoE4/04oegwCiOHLclV6 +kbFQR24ZPBMe2LaopRL04PFan27HOhU32XAFnoWhbyHOMjNgdWhwvOMQEyoJmSkl +umVJV4ZQHkTLWL88XGW/rmdm1hJKu2bPqojzKvPMJeX7xNj8GCRfDSs5cEjoIykZ +42OcfN/kbN4obZPDou2KoXyelnhnsiTNYX4/lwIDAQABAoIBACsn5mNHcoYg06ab +YETI56Yzo0E6DQg3sHxXUga7LMepFOh8jd/RvDwCcRltkcrAnBfAxcGrh73LoAAG +lEcdO5alr+TmNBe/dIYDi3vM2vTWYlaHj/sNZDy9CngIkAfrCrw4hVh3jw+KkJqw +9tAtAofPGEVJdfyD90bX7oDP8GTkwIAjIkGawbrUX6ngYqNF4IZxfSW9guHdooei +L9H/8g6gDm8cYf4nMvNx8iz7duUMzbrhGygrJhH8cC8xYyHUq/0MvdhGkFj+I+eL +cTqmzPw9aB5gQJR4mui/qXVYbi1EdNH/uY3CJifGaC4dJiuuOSb1j16N63isEVif +zkDyykECgYEA7V6TqvewI5+c3cUKZjFf04CXKMTzogIkBhKU1IK7KKayH6ZoJQKQ +tPML0uGATlmS4Ys3EsjZ551LDZcE5SqDRMjvnjR8TzG59bg61ba3mDP9WjFxwknu +KYKk0F90ol0WXQNm74qVlRoCiEYs5nq2BziEyEDLTQY9N9OGV4kLVeMCgYEAyuuA +6y2bNUepiw99IcVNxqCQ/XE71lNwjhwc8K/zDpWyCpX+t5WpMNiFHwiFtIArV1YJ +rWvIcs59KhQ76JQCyEU+5zcVluZy0OV7ZIbSuVQ/iIG7OYkz2/Yv0VoqEF7EbH7q +KQb/AnLdFpcjWyOz08LaRyTto73hXmJ7dw8Qfb0CgYEAgav7C5kH9k4JyfUMe0tZ +yBclfLYrSkPVHiQkfft09v4prLShjCZcmx1zRh6+kw7H+MKusWpb7/WzvJbVq8OP +tpH2pPyTNEg8CIo+SeXpYhJ0w0LjnHn6y159Xv/mnZQw1Vs4bn/Mu4lb/MopWTeM +HWG42BTdexR/ePHrIALT2HUCgYBjQP42CoC4duz/D/xs4E1Cspc44IIcO4P6ftXJ +BMcmgyIq+2Mz+Qhg1AeJPmnn+Ck69uKU6PuK7GVch7kl8f/KZdR21ALDZMUUWKsa +aLf53rOU2Z/ybKHpHWoWRLv+ddwuFYYDu2BQmk56FkM8+SGkmtKZqf5y8RWjTRiH +C99NIQKBgQDI9n2YDguCBuTq3rygUIuDhYLb+AWzbliRFZn1W1QNj5RDc8x4xc6g +Tb2H5WYFkexGd6deVd9fcGqalH70R9Dwt5i96g1ePG64+Dt0KBZ1aWALwBYUjA3K +Ckw2IPc9h8tJ6YhbJs4N3Y1fiuUUI3Wso7MK6odNjXrwVVAtsb6Z8g== +-----END RSA PRIVATE KEY----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd0.csr b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd0.csr new file mode 100644 index 00000000..b8c3ce06 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd0.csr @@ -0,0 +1,16 @@ +-----BEGIN CERTIFICATE REQUEST----- +MIICczCCAVsCAQAwEDEOMAwGA1UEAxMFZXRjZDAwggEiMA0GCSqGSIb3DQEBAQUA +A4IBDwAwggEKAoIBAQC8Jv3fz1LuNZLcJs9dNcFQKqs0IpN0Bd7TTyES49uJBhKO +QyPFIvJ5O8Lkl7FkuWgYeGVn+Z7hrNq7Tzr0LDBLxcyuONSA8i0NoBxTy4aAF0iQ +lfpShLAytDxOQULnQZPybmIcjukYjSZfq0hdQU5r7o/yZ7yGgTj/Tih6DAKI4cty +VXqRsVBHbhk8Ex7YtqilEvTg8Vqfbsc6FTfZcAWehaFvIc4yM2B1aHC84xATKgmZ +KSW6ZUlXhlAeRMtYvzxcZb+uZ2bWEkq7Zs+qiPMq88wl5fvE2PwYJF8NKzlwSOgj +KRnjY5x83+Rs3ihtk8Oi7YqhfJ6WeGeyJM1hfj+XAgMBAAGgHjAcBgkqhkiG9w0B +CQ4xDzANMAsGA1UdEQQEMAKCADANBgkqhkiG9w0BAQsFAAOCAQEAuJYgCDdzi8Av +VJZCPFbBV8UvmPdgf0xkJmtnjn1EmEJqiXoSNw729YEuNCTYIAb+Uv0yfde0L0Sf +q9MLBkYCWRTBo5HyyqTnwlMOzZpipwqTc651asq66znapGYKe/KOjdIaVwbV15GY +ik0NIuXaJCZTiKFUYoE7hrXh3dgMh/V172pQGvL+mE8ei9894bPqur7hoS8A6C/Z +txtudNR0usFzZf/a0Q/LxY1UkUcuAu5fWyvky+ePPIgaJ3szfmeWG5FEYlMFG13J +wSwviR1KyjTszFPFw09vFQcLaE1MFoH+JAQl/D7Rj58Oe5rM/yUw18Zh9Po1Ags3 +tfhYCsUd7w== +-----END CERTIFICATE REQUEST----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd0.pem b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd0.pem new file mode 100644 index 00000000..1ee46c22 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd0.pem @@ -0,0 +1,20 @@ +-----BEGIN CERTIFICATE----- +MIIDPjCCAiagAwIBAgIUDfNTBurkmte+phASMDqIV7VwUOkwDQYJKoZIhvcNAQEL +BQAwDTELMAkGA1UEAxMCQ0EwHhcNMTgwNTIzMDk0NTAwWhcNMjMwNTIyMDk0NTAw +WjAQMQ4wDAYDVQQDEwVldGNkMDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBALwm/d/PUu41ktwmz101wVAqqzQik3QF3tNPIRLj24kGEo5DI8Ui8nk7wuSX +sWS5aBh4ZWf5nuGs2rtPOvQsMEvFzK441IDyLQ2gHFPLhoAXSJCV+lKEsDK0PE5B +QudBk/JuYhyO6RiNJl+rSF1BTmvuj/JnvIaBOP9OKHoMAojhy3JVepGxUEduGTwT +Hti2qKUS9ODxWp9uxzoVN9lwBZ6FoW8hzjIzYHVocLzjEBMqCZkpJbplSVeGUB5E +y1i/PFxlv65nZtYSSrtmz6qI8yrzzCXl+8TY/BgkXw0rOXBI6CMpGeNjnHzf5Gze +KG2Tw6LtiqF8npZ4Z7IkzWF+P5cCAwEAAaOBkjCBjzAOBgNVHQ8BAf8EBAMCBaAw +HQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMAwGA1UdEwEB/wQCMAAwHQYD +VR0OBBYEFP8H+xKP94vaOVnqLag4Khi/DfafMB8GA1UdIwQYMBaAFJ27c/q0uNbU +RXqb0VI0bqSuKWJRMBAGA1UdEQQJMAeCBWV0Y2QwMA0GCSqGSIb3DQEBCwUAA4IB +AQCcfnxvxdzXLyz3sqeBJaSyHZG6BkPWk9duLTQjjb5EymOLvMJLJBGMNUDqWBiD +ecxMDkciBc3sYCyHiNnNXFPN1ukzBJB05beKKt/n6bfWh98cmhoz6q1BujkrDG58 +sCDmkLWC2BsjMd8NlTLl1F94t746UQuJTdxdbTnlbYgsF20CSmjZrRHfzg0OMHVn +mK7bMaqeRKLro9ZcSTMo/KqWrGQpuGibxnnaqVr7x/j3jzrhuD8h93q0DNeIOjKi +7ateW74oolgTqxsLFrYj41II9H2aJdYEBpd584JJaJWZzSoKp5UMedG4/z2xjtUw +uQKKxlsIePa0SZxtSMxkYa43 +-----END CERTIFICATE----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd1-key.pem b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd1-key.pem new file mode 100644 index 00000000..608d6b15 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd1-key.pem @@ -0,0 +1,27 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIEpAIBAAKCAQEA22he1g10QV6SqK2YDPjFJhEwt1xePzU3Fy+VmWvXCui60s4z +iUmwYWetoFGHZ+sRDiR+n0GKa5MRoer/MFNgAzsJqKO8S/fibcct87JiC7pBAS9W +o2+kCBBCFkrAZgWC/q+CWBqTQXbPWnuBjPX+DvhODbHJApN35BIxEVVK8f4IR4be +bXNWSxmWfE1aHT5tDVkebLGo3MqnXCCq3We4ztQGQUJG3nlvlyyK5Wfd4YlHBh0g +kuqwTf2vi6wbyV+xdPjfnNoAfA1rKByQQlIOkeGx0qcqbwiQBTpGfBkPfchp/hfl +KOR9i6VkBFEmTLx2iARnrS9MHkw4/nD8TFRYpQIDAQABAoIBAQCKjPD+SMa2FOuV ++vE+l8WfUVGrKHgXgBpG2PSmSnQkXmzDfBUNR+xKxjbdOz6/f7BoduFC3hdz8Q48 +anI1aSEDST/DL4pTiriAzDuXXXkOoNI11lfmozQ5J1MkUpYGlspu3BP6YOXGfCla +oQ1hH2IMv/5CJZeiuc8GxfoYUP0frDjFYqYjHVEwpA3hiNgS1jSo7XAxopSdEt4Y +Ei6ZRBCCh7KG3cLrVJKnvaZb6nofC+wtMElTkhcVsQ3c4tXBvA6pvZd/EBoIb07+ +Q45bBGLOjwTQCWKQFDoDHHsRaRCMfJopqkqSOYBYk9lJcc1E3/X2XPemPvjTSqu6 +9cgsdYlhAoGBAOXPOfPsDt8azyCNq+78mJqe84jLsR0/RhIh9awcOqCs8vJNBXSi +isLW7/c4hewOPwaxhLrYc8IhtdQQUWVYhyzUt2zcoStbbv+ggXVKzq3Y9D2sYyId +nCQIZMvjgx2OFFxk9sqGogy7v5a3vu6FQJmaBBPIXbsV6xeFGNlWAvepAoGBAPRp +qxxD/tMV23vhF2vortTnnQu3N3+l3A41tM4GscZ1E8B16k3DqJCagFLDmRG9rTEp +ghtQW1AVWu5UlWGS9jH1wrfMkLBntEDZqEb83ZMFA6Cn9NNaK+v4Vwb/BaLr54Cy +LEFvK6FKM9F8Ls6yU7F9qtPIxK5YfrrRBNTT4IadAoGBAMvMPUGiuwGB3eOpn6r9 +2Ttt8N0EfppITZSxBxRNqHRrS7wzL75ikxn80Kv2NVXEwIHoFaQ5Zlbn3D8nBXgR +zTalodDpzAgOOt55cbUZ1TX464hyAyvzBFA0HWdu6Qzhvg69/tpWEQmnyl0XsDwI +ceSF4E3G59CMvIKMJyA+Fb2ZAoGAGxJVNJVHdWP3YppE+NvV+ZkJ6RFLIWVioWRL +eYJ+UGgJXwjwgdqJIjMqwYAOxUtIEqjxU0ssQguLfdh6j0sy38fD4I3U/OUPrxss +q2g4tp8YjsPrtzlGoiVopkq6+he9FaEmi7zfjUblxG9H0/cmlANCV6DmQBVnPBQI +v/YT6XUCgYA5D0THVIkW4nzlzy5d1EIvYEWjTBxLV14KGvNAGlCDmwmAtrJmAsq+ +ECKUEXQnKuA0A1A8swfXpYAuU+yIpy0F1zyjPIZX7K5rYSMvPb0432SyRWmRcfCr +ARyEPvyl8/kvTnliXkbsJkiZV6RX9l6CR9YgnIm04IoGbxfaTXWr4Q== +-----END RSA PRIVATE KEY----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd1.csr b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd1.csr new file mode 100644 index 00000000..ef227fb4 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd1.csr @@ -0,0 +1,16 @@ +-----BEGIN CERTIFICATE REQUEST----- +MIICczCCAVsCAQAwEDEOMAwGA1UEAxMFZXRjZDEwggEiMA0GCSqGSIb3DQEBAQUA +A4IBDwAwggEKAoIBAQDbaF7WDXRBXpKorZgM+MUmETC3XF4/NTcXL5WZa9cK6LrS +zjOJSbBhZ62gUYdn6xEOJH6fQYprkxGh6v8wU2ADOwmoo7xL9+Jtxy3zsmILukEB +L1ajb6QIEEIWSsBmBYL+r4JYGpNBds9ae4GM9f4O+E4NsckCk3fkEjERVUrx/ghH +ht5tc1ZLGZZ8TVodPm0NWR5ssajcyqdcIKrdZ7jO1AZBQkbeeW+XLIrlZ93hiUcG +HSCS6rBN/a+LrBvJX7F0+N+c2gB8DWsoHJBCUg6R4bHSpypvCJAFOkZ8GQ99yGn+ +F+Uo5H2LpWQEUSZMvHaIBGetL0weTDj+cPxMVFilAgMBAAGgHjAcBgkqhkiG9w0B +CQ4xDzANMAsGA1UdEQQEMAKCADANBgkqhkiG9w0BAQsFAAOCAQEAPAhHrxe1C66J +2X55KF7C3cdjwYuJBIndpJE74ugJUPyhflIuqcAQVn8QPMxyHP3jGak3axHWmOHx +PTesg809Qi/g0QX17A+iE9lGASD0cZ2aD2QwoRkssednPmQX1aYLY40K3XTaJ1YH +AIigFKTfdw6Li9oSYfzo+dPKSDh+r7WvjeJqgPxbI+5zKchWkJuqHDxlXOnTsg7d +aOfNtRXJ8U9AOKW2Biub/DBQmGEpz69owrr7ywSLg1DFNIz95UTzR4F3PEakEmGA +Nwmy7e7ITKCes0+2rCpDXhcH6G95DHgVE94lrFMUBzfzaHI2UMzQB/MxLiCvZnG3 +AlApV7TvHA== +-----END CERTIFICATE REQUEST----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd1.pem b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd1.pem new file mode 100644 index 00000000..c4fe48ac --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd1.pem @@ -0,0 +1,20 @@ +-----BEGIN CERTIFICATE----- +MIIDPjCCAiagAwIBAgIUI8vFB6F8zPWY3YXZDNMMTz+5iZcwDQYJKoZIhvcNAQEL +BQAwDTELMAkGA1UEAxMCQ0EwHhcNMTgwNTIzMDk0NTAwWhcNMjMwNTIyMDk0NTAw +WjAQMQ4wDAYDVQQDEwVldGNkMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBANtoXtYNdEFekqitmAz4xSYRMLdcXj81NxcvlZlr1wroutLOM4lJsGFnraBR +h2frEQ4kfp9BimuTEaHq/zBTYAM7CaijvEv34m3HLfOyYgu6QQEvVqNvpAgQQhZK +wGYFgv6vglgak0F2z1p7gYz1/g74Tg2xyQKTd+QSMRFVSvH+CEeG3m1zVksZlnxN +Wh0+bQ1ZHmyxqNzKp1wgqt1nuM7UBkFCRt55b5csiuVn3eGJRwYdIJLqsE39r4us +G8lfsXT435zaAHwNaygckEJSDpHhsdKnKm8IkAU6RnwZD33Iaf4X5SjkfYulZARR +Jky8dogEZ60vTB5MOP5w/ExUWKUCAwEAAaOBkjCBjzAOBgNVHQ8BAf8EBAMCBaAw +HQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMAwGA1UdEwEB/wQCMAAwHQYD +VR0OBBYEFLSdtu7v5ynf8L2YnqoB3V2IgoJOMB8GA1UdIwQYMBaAFJ27c/q0uNbU +RXqb0VI0bqSuKWJRMBAGA1UdEQQJMAeCBWV0Y2QxMA0GCSqGSIb3DQEBCwUAA4IB +AQAH2n1/0DsNQ0etCyD1Z51QMBFEA2AaWl5VBIESud5Y3MNXrNMmb2xpVoUIVxKF +qzN4TfHXDF7sUU0WhQyFcZNHqwlmsiP52xm//VomrLbW36lX30L+Igj79EkVKJGm +lx2MATCwr0NAyJ5NR1z1I3+QqMAMgumoHw6j1hkdpFBRN++5WlSBEZNQbspnb54V +l5gXjbogBTibrNkJRnbiP2QohTw/wocH0qhqEb1Arb5mo/E/d/9MzMOwkwoo64wN +kpmqXKIi4NfWl6fBmJ+hyZDSJY9BVN0UzZOinxdJdbShQ3BnkNdI/OeDh/es+3bx +tI/dl0VDyoJfHdvvS04lTxqk +-----END CERTIFICATE----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd2-key.pem b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd2-key.pem new file mode 100644 index 00000000..98c32a81 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd2-key.pem @@ -0,0 +1,27 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIEowIBAAKCAQEAu/SQK3tZWwf4hGCGpW7jd33jQ1381GvaQcgg2OnLlaM8X291 +xt1iJpNPXxGFdR+iLX1oioj4g9qdAyqaUtXefOfyt3ErmSZ4IHa7c+CsWQS7Zqm5 +QMx7x1atEddj/REi5kcbHqjv1CjwCJ6hk3o+WPa8IYQG0rZiBW0JV+tvP9JvJJzi +5DDlPpChu/HZ9Iuxk6NfMGP9V7DsRI6Idinjkfw3NjTk1Gdsg/Vwd+5RpYdrXg/N +U0AfVLL5zuruWmQV+yEwRMXBaRHOeF4/m9kVYLfb76/phYYjBRiReDNZHUj+8Cy4 +/J0FhyTTSkJIuLFwx2qp7UJzjHwitF8SMdgQgwIDAQABAoIBAF3PVN2+9PxQYCOC +IfIUBIgxVura0EQdiJPolSxulGQdUxa3BOu6tzBVufnTPu8UWNenjjQG5TK6PD/G +VbwebqudATG51G7eGnrph+nwK1VK3VYCRCopZWY6xqru/ELk+KxCtTB6VSlpPVSw +CCkZjGDO1VtNEDK/QPFAWLd/FMmfHTdjMhDEBAK0vE9xUS0yMK1XuD8FPsfKlpDl +c4wcoq9cYsTVqkwuqWvGTTWkhBa4D29DRUGHbXiYGNSSm5haZkKI/83wLCcpV5Pa +TMMENKYLLn2C8mxNO1sdHOiXMgVFV3pNHzV2+H+JLyrmND4WJA43NsRHivkTX5Hl +9VEPPhECgYEA1SNTV8pmZ5NjzCC2xpc+o5M7Qs+WIsbtqf2PTbaim9e1rzpOH0fI +AoET46mMR/k4mcniD1/UOSIlfTbS4KYPUIhhFBddYtS0nlpXHU2MLuVe3JItvCgD +KX0vwztP7nwWC14Qw+c/uZAy8ocUgt97Ji2BsamkjMH7cTtzRkA3M2UCgYEA4cDL +fxRr5UCrFMd/4U2XM9p+Iy5oCNOm1K5eCNHHLxcedZEdhBdEUYbp7qLS2VPueZ2s +omlX9yoykIvLmrpPfdRt2jml9k5yhE3JBO5bfcNl/C6uFWQmrGRDt2MgiRoS/5hF +jOj81FO4jWE6pWXtSTyUI9xigV9Pbdu9hIs9WccCgYBXgnWJqhR5mk5zVUs2JosV +ZjICsHCYPsz96pmX8tC448w48dt5hGNeg9jCtK5gLrdKjVU/srzT6G00B/p1Ojk3 +e4dAVIeHOIYgLj9uTJSt/IcCURJuGo+RzVB6/DNJW7FBYZHInX3QlqAUa9nEEjXh +6vVBGMHy+QJf72TZByyi8QKBgEp7Byh4HljWixsh7sjwhnAvJ+qHhv9ShPoqRQ/3 +1hVtNTlolSpdWsbjEg8PXS0iic1J/gjfZIxBOcmCtbvouA01psCWwHCQ1StdVnLw +CPNnIiCfbgPUtQWvVsAMTlGtbpMxM9EXlUKgFIVgjK7BABZnjCCAt2cjgNsn4lD2 +d1lFAoGBAMomILBsdrtXhxImZmXJQLBHIKzlg3EfAHjPKp+xmgq26T+G9CA9wH7d +/U8elU36LCkbSkwSizz4Yy3hKWonkWrflxHQBIYrWFbWDosIqIFcwI/dMsDTqxfs +XFvT5Dp/7/yLnW0h00gwuMp0fTL62en0jI7z9Zog130+b2k+pNTa +-----END RSA PRIVATE KEY----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd2.csr b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd2.csr new file mode 100644 index 00000000..1ef080a1 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd2.csr @@ -0,0 +1,16 @@ +-----BEGIN CERTIFICATE REQUEST----- +MIICczCCAVsCAQAwEDEOMAwGA1UEAxMFZXRjZDIwggEiMA0GCSqGSIb3DQEBAQUA +A4IBDwAwggEKAoIBAQC79JAre1lbB/iEYIalbuN3feNDXfzUa9pByCDY6cuVozxf +b3XG3WImk09fEYV1H6ItfWiKiPiD2p0DKppS1d585/K3cSuZJnggdrtz4KxZBLtm +qblAzHvHVq0R12P9ESLmRxseqO/UKPAInqGTej5Y9rwhhAbStmIFbQlX628/0m8k +nOLkMOU+kKG78dn0i7GTo18wY/1XsOxEjoh2KeOR/Dc2NOTUZ2yD9XB37lGlh2te +D81TQB9UsvnO6u5aZBX7ITBExcFpEc54Xj+b2RVgt9vvr+mFhiMFGJF4M1kdSP7w +LLj8nQWHJNNKQki4sXDHaqntQnOMfCK0XxIx2BCDAgMBAAGgHjAcBgkqhkiG9w0B +CQ4xDzANMAsGA1UdEQQEMAKCADANBgkqhkiG9w0BAQsFAAOCAQEAfVc222H4Lb76 +bNACjuNh9z/VLGnhZlTLPmCd0947PUiLMDKxG4spAeJ1O0dlfiV2s7S3GhIqi996 +/Z7adTspkxIXZPLk06G2/cg28/wuZgvHBbdnmQXy7TptWGzY3U2B0cMCsvvqgHpf +mD+OyUpFkVHIW8rbjqyOgZuG1IvvDg4Kjk2NPn+WaCNcBCRXC8vllF1/KuM4FN+S +/wfX6rw1hMgP/Bv54SE2Vu2UPwbvNuUJTNz+gkKWNMqIRUNfYbvvBCS7v3/DXkF/ +nPO7Mz45uWvrFHaIqo2dwTEiO2HC2lp3nJvR7QnVzMzg4Ts3nGY7qvX9UGfKBJ4s +ryw6gZ9CQQ== +-----END CERTIFICATE REQUEST----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd2.pem b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd2.pem new file mode 100644 index 00000000..d96dd7d1 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/etcd2.pem @@ -0,0 +1,20 @@ +-----BEGIN CERTIFICATE----- +MIIDPjCCAiagAwIBAgIUGqyFxedLsh2gxP8OtkkFAoUzL6IwDQYJKoZIhvcNAQEL +BQAwDTELMAkGA1UEAxMCQ0EwHhcNMTgwNTIzMDk0NTAwWhcNMjMwNTIyMDk0NTAw +WjAQMQ4wDAYDVQQDEwVldGNkMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBALv0kCt7WVsH+IRghqVu43d940Nd/NRr2kHIINjpy5WjPF9vdcbdYiaTT18R +hXUfoi19aIqI+IPanQMqmlLV3nzn8rdxK5kmeCB2u3PgrFkEu2apuUDMe8dWrRHX +Y/0RIuZHGx6o79Qo8AieoZN6Plj2vCGEBtK2YgVtCVfrbz/SbySc4uQw5T6Qobvx +2fSLsZOjXzBj/Vew7ESOiHYp45H8NzY05NRnbIP1cHfuUaWHa14PzVNAH1Sy+c7q +7lpkFfshMETFwWkRznheP5vZFWC32++v6YWGIwUYkXgzWR1I/vAsuPydBYck00pC +SLixcMdqqe1Cc4x8IrRfEjHYEIMCAwEAAaOBkjCBjzAOBgNVHQ8BAf8EBAMCBaAw +HQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMAwGA1UdEwEB/wQCMAAwHQYD +VR0OBBYEFHm1I5+y6V0S1geFiOkrhBn7edj3MB8GA1UdIwQYMBaAFJ27c/q0uNbU +RXqb0VI0bqSuKWJRMBAGA1UdEQQJMAeCBWV0Y2QyMA0GCSqGSIb3DQEBCwUAA4IB +AQBWBT60/qR13TM/ZNqYbxzpk8lgTXiY/JSs+BLhLLer9/qMqYijBQNH2r6qY+GP ++zvde11JmwMMJrAVBnBgUZYpzefh3oLUz7YZijz60cIDpm/9q6FFn26rlDeN1x3h +KnfHMqZPS0OHfW3u6ctl8GBpEYL8dQdDvj5NbQbr1CSKnQObfOPSpVbCwUE321NC +Ox/MTWRQ/RY87FtVd8Tcb5mxKfCTM62lmWDJaZtxL+2smuAn/cLHcu7wuuIsqb2D +wpBjR6IGqLKR7gjB5gW9W5Br8lL7s0lU0qF3Ai1vthUIFM3uVxQNjHxzD5lxadlL +oEdEBhgGI/DZbA1JE3LzV4BM +-----END CERTIFICATE----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/server-key.pem b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/server-key.pem new file mode 100644 index 00000000..334fe488 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/server-key.pem @@ -0,0 +1,27 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIEowIBAAKCAQEA7tS/dTAP6akVV9vukVq4sI5DwqAUd2HbdrK0UTZFQjujpX+l +J7TNWvsrRbcXQ9VcON7VXRaJu7/4JJZlp8dXmH+gyNRYzbtS8UeKXC2Sdcj5Kf/0 +egP84o6lkQ9z79eMs3pFhNbM3c9X0kJcq4I3H28hJ8qB0Z4ezDGAKJvFxbWOOHiQ +Ebo3w6YETPS+A49vxFwsLwd2BWCPW7xUyPnAtlVWba12UUz/eXzGsdukowFxtxD9 +DCJO0bDDedxJduriocdQWj6YvEoxTTsvgnUB2upVb7L1gxYNQYjmPkrCdB96obV1 +kCQwLTNJjxJystN8j/vDXZrYSavrIxcwNqUEYwIDAQABAoIBAFV0B8ENXlQzbHCQ +P68Ab960OGh10HzapaS10jDQoz1Mi4QWxOgNGAD6p4P9O7TIrYOnr13sR4HG8Sle +Kqc6ewwUdloFKHUMFmRAPbA3mhTMwOIXM8lIjf4eHf1mMwxY6n35PNCH7qtamcig +d/nh0IlNwOY03fg7hDd5aqqc+cmAOJzdKlaP50bMeuGH5AgTZG06BfS0K2YbxyfH ++cwL7WCpDqMO6ccxmHMOXFI7uRXypTtvEAbVaWNq4WVZzkFzChWP/YbxOrIjZOWw +fxkzgpqhvYP7s9lEo9+ggudWkd/PfcM5cLr1FJlh+w/FEhpqEpHhpYg0MEo3Z/uJ +RGR1/WkCgYEA+NezGA0WCZ3iHXEiqx3Dkg+DHOe8qp5/+7GenIjA0OaOlMPJfkQ5 +nnzl39KXbKh0uBTaUuy4E2MKCkUcCrq3Klo/hqfHQwTUj4kdmzsy0/75YAWaVMZw +RYgWUJng+fC3jJtHqgUTmWtuC6es5/rayg0BxH0xUSDKbNAHxhsfsM0CgYEA9bNU +mnyveHQ4PXn7bvEc6+zIhJlQAwtbAvXb5JjDyhX95YaWvd8e47x2l+li51uj6Voz +Ihrmvdz6iaXRv/Mc5ZcxdrckNBZaDexGqdJOPrEspFhzkibVvQXELLqBMtU0lFTj +rkI3NVCbMcQ90K6wmX1aDXEil8Kv7TvprJM2ye8CgYEAkn3A8/a4M38bnwN8Skoi +WLkDEaAmxDa81zowSqyC/jfMVi2QT+HwHaofVY1PEWt2EuxLvqeWkesq/PLEWFik +/azVWvsoZf7Q95LbuAe4m26t9eY2fZO4gmZj5J1CAUHBfGfpX2DPsfC5fuj99C8M +YAgaM0cUIlNwd3BcMzbCiD0CgYAnstL/pxe+8aBIppXuhfyzTe3UJuVbqJEK+GiQ +FfLEiysb09Q1V4CpMUFEKEx3r0HbqVxLrWcM1FCSvv0V85T+r6ApW0v5ModYao28 +UKOd04iwAS6jNa0hPnZE99l6OiKluNWUyVQcRCrfLqMCPceA9VUAiQAa3zUHsr99 +x8d5dwKBgErAfgguKxIpbV59s3flrpBM/gkISY20QjJw2jYZuo173jxw/daVvPIS +l9slbP7UTcYoCpl3LiycldGdDzzShbE/LI/RN1i7XpbBEvklWlOaIlYTV8qZ+0s5 +qxbo144UDq7ogYrsXKGZTTalc5BeEW9DNSE2EgniCz04XxNT0UGc +-----END RSA PRIVATE KEY----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/server.csr b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/server.csr new file mode 100644 index 00000000..544e9563 --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/server.csr @@ -0,0 +1,16 @@ +-----BEGIN CERTIFICATE REQUEST----- +MIICdDCCAVwCAQAwETEPMA0GA1UEAxMGc2VydmVyMIIBIjANBgkqhkiG9w0BAQEF +AAOCAQ8AMIIBCgKCAQEA7tS/dTAP6akVV9vukVq4sI5DwqAUd2HbdrK0UTZFQjuj +pX+lJ7TNWvsrRbcXQ9VcON7VXRaJu7/4JJZlp8dXmH+gyNRYzbtS8UeKXC2Sdcj5 +Kf/0egP84o6lkQ9z79eMs3pFhNbM3c9X0kJcq4I3H28hJ8qB0Z4ezDGAKJvFxbWO +OHiQEbo3w6YETPS+A49vxFwsLwd2BWCPW7xUyPnAtlVWba12UUz/eXzGsdukowFx +txD9DCJO0bDDedxJduriocdQWj6YvEoxTTsvgnUB2upVb7L1gxYNQYjmPkrCdB96 +obV1kCQwLTNJjxJystN8j/vDXZrYSavrIxcwNqUEYwIDAQABoB4wHAYJKoZIhvcN +AQkOMQ8wDTALBgNVHREEBDACggAwDQYJKoZIhvcNAQELBQADggEBAHDh4yJYbwkK +a65aoBeWKuItKQ/2oMoi8YNdRUSnj79afVmbULB3mCzzeteqSYUS+wtzh2fGtXCW +Om8bI7VN7NUi9uPCwcZvDdLo+7H4/YOB9yfV3mEPOe+mwclh9Ndp25m/+KW6KPsO +abhxutoUdK+RSVcZ4mxx/UVQw53yqUk3415ycGwuNA06eiNwlgsDUnTSzK+B9Ql8 +gh4m934UQjY54u+FFh7HXo38vEHCi4POj51/fLrpwTm2vri5kdp6Jmpn9UVfMGPS +UlMrOIf5ddTmmIH02TM0Ams3Sl5PEBnL3l9Ah1qGAmBqHLrKEBXqDD7qkC2cURHD +6+o88gQaPZs= +-----END CERTIFICATE REQUEST----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/server.pem b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/server.pem new file mode 100644 index 00000000..67d7bcbf --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/src/test/resources/ssl/cert/server.pem @@ -0,0 +1,20 @@ +-----BEGIN CERTIFICATE----- +MIIDQjCCAiqgAwIBAgIUFcJ1ItMfRmH8GQXbJQYvCTyL5lwwDQYJKoZIhvcNAQEL +BQAwDTELMAkGA1UEAxMCQ0EwHhcNMTgwNTIzMDk0NTAwWhcNMjMwNTIyMDk0NTAw +WjARMQ8wDQYDVQQDEwZzZXJ2ZXIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK +AoIBAQDu1L91MA/pqRVX2+6RWriwjkPCoBR3Ydt2srRRNkVCO6Olf6UntM1a+ytF +txdD1Vw43tVdFom7v/gklmWnx1eYf6DI1FjNu1LxR4pcLZJ1yPkp//R6A/zijqWR +D3Pv14yzekWE1szdz1fSQlyrgjcfbyEnyoHRnh7MMYAom8XFtY44eJARujfDpgRM +9L4Dj2/EXCwvB3YFYI9bvFTI+cC2VVZtrXZRTP95fMax26SjAXG3EP0MIk7RsMN5 +3El26uKhx1BaPpi8SjFNOy+CdQHa6lVvsvWDFg1BiOY+SsJ0H3qhtXWQJDAtM0mP +EnKy03yP+8NdmthJq+sjFzA2pQRjAgMBAAGjgZUwgZIwDgYDVR0PAQH/BAQDAgWg +MB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAMBgNVHRMBAf8EAjAAMB0G +A1UdDgQWBBS+JGM3iZ2NR1vEm86vXSFyUWQ99TAfBgNVHSMEGDAWgBSdu3P6tLjW +1EV6m9FSNG6kriliUTATBgNVHREEDDAKgghldGNkLXNzbDANBgkqhkiG9w0BAQsF +AAOCAQEAq/fAGEXFywM9GUzV5O0mT2zaMTwAjXTRS830qaglPs113g4iwcb+fBo+ +JRSglsnGVmfdUOhT7bd7yGKm7de3Yp6reXLi6eX69va1gOt606FfpZLKndQCGNW9 +m/fbyhxNGeyhmKmGR8FrsnYFVkuK8Tb5jQl4dXzlP6PXspwwiaISdsTIK94q1EPW +Gh8UFyKBmr2555p//MfMmtx1h1BPmzx3NCB7QTYTRZHhylVqr8Gv6HMK/6Lt+0ny +1ntvAXmzcG6KyrW5vrJBRvX6dK5VLzD4a/9otH4NFK5jHs+jfNIQXAFVJkJ/rUH6 +VluFTqvZxuDqqWHqqZra+zhHvyl/8g== +-----END CERTIFICATE----- diff --git a/tests/src/io.etcd/jetcd-core/0.7.5/user-code-filter.json b/tests/src/io.etcd/jetcd-core/0.7.5/user-code-filter.json new file mode 100644 index 00000000..0181969d --- /dev/null +++ b/tests/src/io.etcd/jetcd-core/0.7.5/user-code-filter.json @@ -0,0 +1,10 @@ +{ + "rules": [ + { + "excludeClasses": "**" + }, + { + "includeClasses": "io.etcd.jetcd.**" + } + ] +}