diff --git a/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/HttpProtocol.java b/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/HttpProtocol.java index 61b36f0e7a7..73cb917433a 100644 --- a/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/HttpProtocol.java +++ b/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/HttpProtocol.java @@ -17,12 +17,17 @@ package org.apache.hertzbeat.common.entity.job.protocol; +import static org.apache.hertzbeat.common.util.IpDomainUtil.validPort; +import static org.apache.hertzbeat.common.util.IpDomainUtil.validateIpDomain; + import java.util.List; import java.util.Map; import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; +import org.apache.commons.lang3.StringUtils; +import org.apache.hertzbeat.common.util.CommonUtil; /** * http protocol configuration @@ -136,8 +141,33 @@ public static class Authorization { @Override public boolean isInvalid() { + if (!validateIpDomain(host) || !validPort(port)) { + return true; + } + if (StringUtils.isNotBlank(timeout) && !CommonUtil.isNumeric(timeout)) { + return true; + } + if (StringUtils.isNotBlank(ssl) && !"true".equalsIgnoreCase(ssl) && !"false".equalsIgnoreCase(ssl)) { + return true; + } + if (StringUtils.isNotBlank(method) && !isValidHttpMethod(method)) { + return true; + } + if (StringUtils.isNotBlank(enableUrlEncoding) + && !"true".equalsIgnoreCase(enableUrlEncoding) + && !"false".equalsIgnoreCase(enableUrlEncoding)) { + return true; + } + return false; + } - // todo: add - return true; + private boolean isValidHttpMethod(String method) { + return method.equalsIgnoreCase("get") + || method.equalsIgnoreCase("post") + || method.equalsIgnoreCase("put") + || method.equalsIgnoreCase("delete") + || method.equalsIgnoreCase("patch") + || method.equalsIgnoreCase("head") + || method.equalsIgnoreCase("options"); } } diff --git a/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/JdbcProtocol.java b/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/JdbcProtocol.java index 0454ffcbfce..47fe9ce052f 100644 --- a/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/JdbcProtocol.java +++ b/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/JdbcProtocol.java @@ -17,11 +17,16 @@ package org.apache.hertzbeat.common.entity.job.protocol; +import static org.apache.hertzbeat.common.util.IpDomainUtil.validPort; +import static org.apache.hertzbeat.common.util.IpDomainUtil.validateIpDomain; + import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; +import org.apache.commons.lang3.StringUtils; import org.apache.hertzbeat.common.entity.job.SshTunnel; +import org.apache.hertzbeat.common.util.CommonUtil; /** * Database configuration information implemented by the common jdbc specification @@ -82,8 +87,19 @@ public class JdbcProtocol implements CommonRequestProtocol, Protocol { @Override public boolean isInvalid() { - - // todo: add - return true; + if (StringUtils.isBlank(url)) { + if (!validateIpDomain(host) || !validPort(port)) { + return true; + } + } + if (StringUtils.isNotBlank(timeout) && !CommonUtil.isNumeric(timeout)) { + return true; + } + if (StringUtils.isNotBlank(reuseConnection) + && !"true".equalsIgnoreCase(reuseConnection) + && !"false".equalsIgnoreCase(reuseConnection)) { + return true; + } + return false; } } diff --git a/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/MongodbProtocol.java b/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/MongodbProtocol.java index 0f58343bfb3..68aa1af8a62 100644 --- a/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/MongodbProtocol.java +++ b/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/MongodbProtocol.java @@ -17,10 +17,15 @@ package org.apache.hertzbeat.common.entity.job.protocol; +import static org.apache.hertzbeat.common.util.IpDomainUtil.validPort; +import static org.apache.hertzbeat.common.util.IpDomainUtil.validateIpDomain; + import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; +import org.apache.commons.lang3.StringUtils; +import org.apache.hertzbeat.common.util.CommonUtil; /** * Mongodb Protocol @@ -79,9 +84,13 @@ public class MongodbProtocol implements CommonRequestProtocol, Protocol { @Override public boolean isInvalid() { - - // todo: add - return true; + if (!validateIpDomain(host) || !validPort(port)) { + return true; + } + if (StringUtils.isNotBlank(timeout) && !CommonUtil.isNumeric(timeout)) { + return true; + } + return false; } } diff --git a/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/RedisProtocol.java b/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/RedisProtocol.java index b0c240fcecc..d96ef32d042 100644 --- a/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/RedisProtocol.java +++ b/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/RedisProtocol.java @@ -17,11 +17,16 @@ package org.apache.hertzbeat.common.entity.job.protocol; +import static org.apache.hertzbeat.common.util.IpDomainUtil.validPort; +import static org.apache.hertzbeat.common.util.IpDomainUtil.validateIpDomain; + import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; +import org.apache.commons.lang3.StringUtils; import org.apache.hertzbeat.common.entity.job.SshTunnel; +import org.apache.hertzbeat.common.util.CommonUtil; /** * Redis Protocol @@ -69,9 +74,20 @@ public class RedisProtocol implements CommonRequestProtocol, Protocol { @Override public boolean isInvalid() { + if (!validateIpDomain(host) || !validPort(port)) { + return true; + } + if (StringUtils.isNotBlank(timeout) && !CommonUtil.isNumeric(timeout)) { + return true; + } + if (StringUtils.isNotBlank(pattern) && !isValidPattern(pattern)) { + return true; + } + return false; + } - // todo: add - return true; + private boolean isValidPattern(String pattern) { + return "1".equals(pattern) || "2".equals(pattern) || "3".equals(pattern); } } diff --git a/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/SshProtocol.java b/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/SshProtocol.java index 88e5f8b78d5..1b79e45528e 100644 --- a/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/SshProtocol.java +++ b/hertzbeat-common-core/src/main/java/org/apache/hertzbeat/common/entity/job/protocol/SshProtocol.java @@ -17,10 +17,15 @@ package org.apache.hertzbeat.common.entity.job.protocol; +import static org.apache.hertzbeat.common.util.IpDomainUtil.validPort; +import static org.apache.hertzbeat.common.util.IpDomainUtil.validateIpDomain; + import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; +import org.apache.commons.lang3.StringUtils; +import org.apache.hertzbeat.common.util.CommonUtil; /** * ssh Protocol parameter configuration @@ -113,8 +118,27 @@ public class SshProtocol implements CommonRequestProtocol, Protocol { @Override public boolean isInvalid() { - - // todo: add - return true; + if (!validateIpDomain(host) || !validPort(port)) { + return true; + } + if (StringUtils.isNotBlank(timeout) && !CommonUtil.isNumeric(timeout)) { + return true; + } + if (StringUtils.isNotBlank(reuseConnection) + && !"true".equalsIgnoreCase(reuseConnection) + && !"false".equalsIgnoreCase(reuseConnection)) { + return true; + } + if (StringUtils.isNotBlank(useProxy) + && !"true".equalsIgnoreCase(useProxy) + && !"false".equalsIgnoreCase(useProxy)) { + return true; + } + if ("true".equalsIgnoreCase(useProxy)) { + if (!validateIpDomain(proxyHost) || !validPort(proxyPort)) { + return true; + } + } + return false; } } diff --git a/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/HttpProtocolTest.java b/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/HttpProtocolTest.java new file mode 100644 index 00000000000..a185b221d99 --- /dev/null +++ b/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/HttpProtocolTest.java @@ -0,0 +1,240 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hertzbeat.common.entity.job.protocol; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class HttpProtocolTest { + + @Test + void isInvalidValidProtocol() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithDomain() { + HttpProtocol protocol = HttpProtocol.builder() + .host("example.com") + .port("8080") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithLocalhost() { + HttpProtocol protocol = HttpProtocol.builder() + .host("localhost") + .port("8080") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithIpv6() { + HttpProtocol protocol = HttpProtocol.builder() + .host("::1") + .port("8080") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidHost() { + HttpProtocol protocol = HttpProtocol.builder() + .host("") + .port("8080") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidNullHost() { + HttpProtocol protocol = HttpProtocol.builder() + .host(null) + .port("8080") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidPort() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("99999") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidBlankPort() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidNullPort() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port(null) + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidValidTimeout() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .timeout("5000") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidBlankTimeout() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .timeout("") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidNullTimeout() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .timeout(null) + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidTimeout() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .timeout("abc") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidValidSsl() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .ssl("true") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidSslFalse() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .ssl("false") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidSsl() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .ssl("invalid") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidBlankSsl() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .ssl("") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidMethod() { + String[] validMethods = {"get", "GET", "post", "POST", "put", "PUT", "delete", "DELETE", "patch", "PATCH", "head", "HEAD", "options", "OPTIONS"}; + for (String method : validMethods) { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .method(method) + .build(); + assertFalse(protocol.isInvalid(), "Method " + method + " should be valid"); + } + } + + @Test + void isInvalidInvalidMethod() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .method("invalid") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidBlankMethod() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .method("") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidEnableUrlEncoding() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .enableUrlEncoding("true") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidEnableUrlEncoding() { + HttpProtocol protocol = HttpProtocol.builder() + .host("192.168.1.1") + .port("8080") + .enableUrlEncoding("invalid") + .build(); + assertTrue(protocol.isInvalid()); + } +} diff --git a/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/JdbcProtocolTest.java b/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/JdbcProtocolTest.java new file mode 100644 index 00000000000..9341ee8f4e9 --- /dev/null +++ b/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/JdbcProtocolTest.java @@ -0,0 +1,185 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hertzbeat.common.entity.job.protocol; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class JdbcProtocolTest { + + @Test + void isInvalidValidProtocol() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("192.168.1.1") + .port("3306") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithDomain() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("db.example.com") + .port("3306") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithLocalhost() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("localhost") + .port("3306") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithIpv6() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("::1") + .port("3306") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithUrl() { + JdbcProtocol protocol = JdbcProtocol.builder() + .url("jdbc:mysql://localhost:3306/test") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidHost() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("") + .port("3306") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidNullHost() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host(null) + .port("3306") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidPort() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("192.168.1.1") + .port("99999") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidBlankPort() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("192.168.1.1") + .port("") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidNullPort() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("192.168.1.1") + .port(null) + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidValidTimeout() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("192.168.1.1") + .port("3306") + .timeout("5000") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidBlankTimeout() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("192.168.1.1") + .port("3306") + .timeout("") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidNullTimeout() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("192.168.1.1") + .port("3306") + .timeout(null) + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidTimeout() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("192.168.1.1") + .port("3306") + .timeout("abc") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidValidReuseConnection() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("192.168.1.1") + .port("3306") + .reuseConnection("true") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidReuseConnectionFalse() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("192.168.1.1") + .port("3306") + .reuseConnection("false") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidReuseConnection() { + JdbcProtocol protocol = JdbcProtocol.builder() + .host("192.168.1.1") + .port("3306") + .reuseConnection("invalid") + .build(); + assertTrue(protocol.isInvalid()); + } +} diff --git a/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/MongodbProtocolTest.java b/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/MongodbProtocolTest.java new file mode 100644 index 00000000000..1fd0816a948 --- /dev/null +++ b/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/MongodbProtocolTest.java @@ -0,0 +1,168 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hertzbeat.common.entity.job.protocol; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class MongodbProtocolTest { + + @Test + void isInvalidValidProtocol() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("192.168.1.1") + .port("27017") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithDomain() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("mongodb.example.com") + .port("27017") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithLocalhost() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("localhost") + .port("27017") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithIpv6() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("::1") + .port("27017") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidHost() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("") + .port("27017") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidNullHost() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host(null) + .port("27017") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidPort() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("192.168.1.1") + .port("99999") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidBlankPort() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("192.168.1.1") + .port("") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidNullPort() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("192.168.1.1") + .port(null) + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidValidTimeout() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("192.168.1.1") + .port("27017") + .timeout("5000") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidBlankTimeout() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("192.168.1.1") + .port("27017") + .timeout("") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidNullTimeout() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("192.168.1.1") + .port("27017") + .timeout(null) + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidTimeout() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("192.168.1.1") + .port("27017") + .timeout("abc") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithUsername() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("192.168.1.1") + .port("27017") + .username("admin") + .password("password") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithDatabase() { + MongodbProtocol protocol = MongodbProtocol.builder() + .host("192.168.1.1") + .port("27017") + .database("testdb") + .build(); + assertFalse(protocol.isInvalid()); + } +} diff --git a/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/RedisProtocolTest.java b/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/RedisProtocolTest.java new file mode 100644 index 00000000000..33a8e61aaa0 --- /dev/null +++ b/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/RedisProtocolTest.java @@ -0,0 +1,217 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hertzbeat.common.entity.job.protocol; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class RedisProtocolTest { + + @Test + void isInvalidValidProtocol() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("6379") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithDomain() { + RedisProtocol protocol = RedisProtocol.builder() + .host("redis.example.com") + .port("6379") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithLocalhost() { + RedisProtocol protocol = RedisProtocol.builder() + .host("localhost") + .port("6379") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithIpv6() { + RedisProtocol protocol = RedisProtocol.builder() + .host("::1") + .port("6379") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidHost() { + RedisProtocol protocol = RedisProtocol.builder() + .host("") + .port("6379") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidNullHost() { + RedisProtocol protocol = RedisProtocol.builder() + .host(null) + .port("6379") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidPort() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("99999") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidBlankPort() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidNullPort() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port(null) + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidValidTimeout() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("6379") + .timeout("5000") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidBlankTimeout() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("6379") + .timeout("") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidNullTimeout() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("6379") + .timeout(null) + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidTimeout() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("6379") + .timeout("abc") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidValidPatternSingle() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("6379") + .pattern("1") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidPatternSentinel() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("6379") + .pattern("2") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidPatternCluster() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("6379") + .pattern("3") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidBlankPattern() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("6379") + .pattern("") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidNullPattern() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("6379") + .pattern(null) + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidPattern() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("6379") + .pattern("4") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidPatternNonNumeric() { + RedisProtocol protocol = RedisProtocol.builder() + .host("192.168.1.1") + .port("6379") + .pattern("invalid") + .build(); + assertTrue(protocol.isInvalid()); + } +} diff --git a/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/SshProtocolTest.java b/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/SshProtocolTest.java new file mode 100644 index 00000000000..ca0577efe9c --- /dev/null +++ b/hertzbeat-common-core/src/test/java/org/apache/hertzbeat/common/entity/job/protocol/SshProtocolTest.java @@ -0,0 +1,243 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.hertzbeat.common.entity.job.protocol; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class SshProtocolTest { + + @Test + void isInvalidValidProtocol() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithDomain() { + SshProtocol protocol = SshProtocol.builder() + .host("ssh.example.com") + .port("22") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithLocalhost() { + SshProtocol protocol = SshProtocol.builder() + .host("localhost") + .port("22") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidProtocolWithIpv6() { + SshProtocol protocol = SshProtocol.builder() + .host("::1") + .port("22") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidHost() { + SshProtocol protocol = SshProtocol.builder() + .host("") + .port("22") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidNullHost() { + SshProtocol protocol = SshProtocol.builder() + .host(null) + .port("22") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidPort() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("99999") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidBlankPort() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidNullPort() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port(null) + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidValidTimeout() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .timeout("5000") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidBlankTimeout() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .timeout("") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidNullTimeout() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .timeout(null) + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidTimeout() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .timeout("abc") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidValidReuseConnection() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .reuseConnection("true") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidReuseConnectionFalse() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .reuseConnection("false") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidReuseConnection() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .reuseConnection("invalid") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidValidUseProxyFalse() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .useProxy("false") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidValidUseProxyTrue() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .useProxy("true") + .proxyHost("proxy.example.com") + .proxyPort("1080") + .build(); + assertFalse(protocol.isInvalid()); + } + + @Test + void isInvalidInvalidUseProxyValue() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .useProxy("invalid") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidUseProxyTrueWithoutProxyHost() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .useProxy("true") + .proxyPort("1080") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidUseProxyTrueWithoutProxyPort() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .useProxy("true") + .proxyHost("proxy.example.com") + .build(); + assertTrue(protocol.isInvalid()); + } + + @Test + void isInvalidUseProxyTrueWithInvalidProxyPort() { + SshProtocol protocol = SshProtocol.builder() + .host("192.168.1.1") + .port("22") + .useProxy("true") + .proxyHost("proxy.example.com") + .proxyPort("99999") + .build(); + assertTrue(protocol.isInvalid()); + } +}