diff --git a/collector/src/main/java/org/apache/hertzbeat/collector/collect/push/PushCollectImpl.java b/collector/src/main/java/org/apache/hertzbeat/collector/collect/push/PushCollectImpl.java index e4412a0daf1..2be1823c30f 100644 --- a/collector/src/main/java/org/apache/hertzbeat/collector/collect/push/PushCollectImpl.java +++ b/collector/src/main/java/org/apache/hertzbeat/collector/collect/push/PushCollectImpl.java @@ -68,6 +68,9 @@ public class PushCollectImpl extends AbstractCollect { @Override public void preCheck(Metrics metrics) throws IllegalArgumentException { + if (metrics == null || metrics.getPush() == null) { + throw new IllegalArgumentException("Push collect must has Push params"); + } } @Override diff --git a/collector/src/main/java/org/apache/hertzbeat/collector/collect/script/ScriptCollectImpl.java b/collector/src/main/java/org/apache/hertzbeat/collector/collect/script/ScriptCollectImpl.java index 6ec696dd7fe..45d8fb66594 100644 --- a/collector/src/main/java/org/apache/hertzbeat/collector/collect/script/ScriptCollectImpl.java +++ b/collector/src/main/java/org/apache/hertzbeat/collector/collect/script/ScriptCollectImpl.java @@ -59,8 +59,8 @@ public class ScriptCollectImpl extends AbstractCollect { @Override public void preCheck(Metrics metrics) throws IllegalArgumentException { - ScriptProtocol scriptProtocol = metrics.getScript(); Assert.notNull(metrics, "Script collect must has Imap params"); + ScriptProtocol scriptProtocol = metrics.getScript(); Assert.notNull(scriptProtocol, "Script collect must has Imap params"); Assert.notNull(scriptProtocol.getCharset(), "Script charset is required"); Assert.notNull(scriptProtocol.getParseType(), "Script parse type is required"); diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/dns/DnsCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/dns/DnsCollectImplTest.java index e362c1890e9..51f45579adc 100644 --- a/collector/src/test/java/org/apache/hertzbeat/collector/collect/dns/DnsCollectImplTest.java +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/dns/DnsCollectImplTest.java @@ -17,16 +17,20 @@ package org.apache.hertzbeat.collector.collect.dns; - +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + import java.util.Collections; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; import org.apache.hertzbeat.common.entity.job.Metrics; import org.apache.hertzbeat.common.entity.job.protocol.DnsProtocol; import org.apache.hertzbeat.common.entity.message.CollectRep; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; - /** * Test case for {@link DnsCollectImpl} */ @@ -46,6 +50,33 @@ public void setup() { .build(); } + @Test + public void testPreCheck() { + assertThrows(IllegalArgumentException.class, () -> { + Metrics metrics = new Metrics(); + metrics.setName("question"); + metrics.setDns(dnsProtocol); + dnsCollect.preCheck(metrics); + }); + + //query class is blank + assertThrows(IllegalArgumentException.class, () -> { + DnsProtocol dns = DnsProtocol.builder().build(); + + Metrics metrics = new Metrics(); + metrics.setDns(dns); + dnsCollect.preCheck(metrics); + }); + + // no exception throws + assertDoesNotThrow(() -> { + dnsProtocol.setTcp("tcp"); + Metrics metrics = new Metrics(); + metrics.setDns(dnsProtocol); + dnsCollect.preCheck(metrics); + }); + } + @Test public void testCollect() { CollectRep.MetricsData.Builder builder = CollectRep.MetricsData.newBuilder(); @@ -57,5 +88,24 @@ public void testCollect() { metrics.setAliasFields(Collections.singletonList("section")); dnsCollect.collect(builder, monitorId, app, metrics); assertNotNull(builder.getValues(0).getColumns(0)); + + // dns is null, no exception throws + assertDoesNotThrow(() -> { + dnsCollect.collect(builder, monitorId, app, null); + }); + + // metric name is header + assertDoesNotThrow(() -> { + Metrics metrics1 = new Metrics(); + metrics1.setName("header"); + metrics1.setDns(dnsProtocol); + metrics1.setAliasFields(Collections.singletonList("section")); + dnsCollect.collect(builder, monitorId, app, metrics1); + }); + } + + @Test + public void testSupportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_DNS, dnsCollect.supportProtocol()); } } diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/jmx/JmxCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/jmx/JmxCollectImplTest.java index 5d2fc93d146..9e9dabab610 100644 --- a/collector/src/test/java/org/apache/hertzbeat/collector/collect/jmx/JmxCollectImplTest.java +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/jmx/JmxCollectImplTest.java @@ -17,7 +17,13 @@ package org.apache.hertzbeat.collector.collect.jmx; -import org.junit.jupiter.api.AfterEach; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; +import org.apache.hertzbeat.common.entity.job.Metrics; +import org.apache.hertzbeat.common.entity.job.protocol.JmxProtocol; +import org.apache.hertzbeat.common.entity.message.CollectRep; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -25,20 +31,41 @@ * Test case for {@link JmxCollectImpl} */ class JmxCollectImplTest { + private JmxCollectImpl jmxCollect; @BeforeEach - void setUp() { + void setUp() throws Exception { + jmxCollect = new JmxCollectImpl(); } - @AfterEach - void tearDown() { + @Test + void preCheck() throws IllegalArgumentException { + // metrics is null, will throw exception + assertThrows(IllegalArgumentException.class, () -> { + jmxCollect.preCheck(null); + }); + + // should not contain /stub/ + assertThrows(IllegalArgumentException.class, () -> { + JmxProtocol jmx = JmxProtocol.builder().build(); + jmx.setUrl("/stub/"); + Metrics metrics = Metrics.builder().jmx(jmx).build(); + + jmxCollect.preCheck(metrics); + }); } @Test - void getInstance() { + void collect() { + // metrics is null + assertDoesNotThrow(() -> { + CollectRep.MetricsData.Builder builder = CollectRep.MetricsData.newBuilder(); + jmxCollect.collect(builder, 1L, "app", null); + }); } @Test - void collect() { + void supportProtocol() { + assert DispatchConstants.PROTOCOL_JMX.equals(jmxCollect.supportProtocol()); } } diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/mq/RocketmqSingleCollectTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/mq/RocketmqSingleCollectTest.java new file mode 100644 index 00000000000..be10a22a93e --- /dev/null +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/mq/RocketmqSingleCollectTest.java @@ -0,0 +1,100 @@ +/* + * 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.collector.collect.mq; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; +import org.apache.hertzbeat.common.entity.job.Metrics; +import org.apache.hertzbeat.common.entity.job.protocol.RocketmqProtocol; +import org.apache.hertzbeat.common.entity.message.CollectRep; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +/** + * Test case for {@link RocketmqSingleCollectImpl} + */ +public class RocketmqSingleCollectTest { + private RocketmqSingleCollectImpl collect; + + @BeforeEach + public void setUp() throws Exception { + collect = new RocketmqSingleCollectImpl(); + } + + @Test + void preCheck() { + // metrics is null + assertThrows(IllegalArgumentException.class, () -> { + collect.preCheck(null); + }); + + // rocketmq is null + assertThrows(IllegalArgumentException.class, () -> { + collect.preCheck(Metrics.builder().build()); + }); + + // rocketmq srv host is null + assertThrows(IllegalArgumentException.class, () -> { + RocketmqProtocol mq = new RocketmqProtocol(); + collect.preCheck(Metrics.builder().rocketmq(mq).build()); + }); + + // rocketmq srv port is null + assertThrows(IllegalArgumentException.class, () -> { + RocketmqProtocol mq = RocketmqProtocol.builder().namesrvHost("127.0.0.1").build(); + collect.preCheck(Metrics.builder().rocketmq(mq).build()); + }); + + // no exception throw + assertDoesNotThrow(() -> { + RocketmqProtocol mq = RocketmqProtocol.builder().namesrvHost("127.0.0.1").namesrvPort("9876").build(); + collect.preCheck(Metrics.builder().rocketmq(mq).build()); + }); + } + + @Test + void destroy() { + assertDoesNotThrow(() -> { + collect.destroy(); + }); + } + + @Test + void collect() { + // metrics is null + assertDoesNotThrow(() -> { + CollectRep.MetricsData.Builder builder = CollectRep.MetricsData.newBuilder(); + collect.collect(builder, 1L, "app", null); + }); + + assertDoesNotThrow(() -> { + CollectRep.MetricsData.Builder builder = CollectRep.MetricsData.newBuilder(); + RocketmqProtocol mq = RocketmqProtocol.builder().namesrvHost("127.0.0.1").namesrvPort("9876").build(); + Metrics metrics = Metrics.builder().rocketmq(mq).build(); + collect.collect(builder, 1L, "app", metrics); + }); + } + + @Test + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_ROCKETMQ, collect.supportProtocol()); + } +} diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/mqtt/MqttCollectTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/mqtt/MqttCollectTest.java new file mode 100644 index 00000000000..c36b508e3f6 --- /dev/null +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/mqtt/MqttCollectTest.java @@ -0,0 +1,126 @@ +/* + * 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.collector.collect.mqtt; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.ArrayList; + +import org.apache.hertzbeat.collector.collect.mq.RocketmqSingleCollectImpl; +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; +import org.apache.hertzbeat.common.entity.job.Metrics; +import org.apache.hertzbeat.common.entity.job.protocol.MqttProtocol; +import org.apache.hertzbeat.common.entity.message.CollectRep; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import com.hivemq.client.mqtt.MqttVersion; + +/** + * Test case for {@link RocketmqSingleCollectImpl} + */ +public class MqttCollectTest { + private MqttCollectImpl mqttCollect; + private Metrics metrics; + private CollectRep.MetricsData.Builder builder; + + @BeforeEach + public void setup() { + mqttCollect = new MqttCollectImpl(); + MqttProtocol mqtt = MqttProtocol.builder().build(); + metrics = Metrics.builder() + .mqtt(mqtt) + .build(); + builder = CollectRep.MetricsData.newBuilder(); + } + + @Test + void preCheck() { + // host is empty + assertThrows(IllegalArgumentException.class, () -> { + mqttCollect.preCheck(metrics); + }); + + // port is empty + assertThrows(IllegalArgumentException.class, () -> { + MqttProtocol mqtt = MqttProtocol.builder().build(); + mqtt.setHost("example.com"); + metrics.setMqtt(mqtt); + mqttCollect.preCheck(metrics); + }); + + // protocol version is empty + assertThrows(IllegalArgumentException.class, () -> { + MqttProtocol mqtt = MqttProtocol.builder().build(); + mqtt.setHost("example.com"); + mqtt.setPort("1883"); + metrics.setMqtt(mqtt); + mqttCollect.preCheck(metrics); + }); + + // everything is ok + assertDoesNotThrow(() -> { + MqttProtocol mqtt = MqttProtocol.builder().build(); + mqtt.setHost("example.com"); + mqtt.setPort("1883"); + metrics.setMqtt(mqtt); + mqtt.setProtocolVersion("3.1.1"); + mqttCollect.preCheck(metrics); + }); + } + + @Test + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_MQTT, mqttCollect.supportProtocol()); + } + + @Test + void collect() { + // with version 3.1.1 + assertDoesNotThrow(() -> { + MqttProtocol mqtt = MqttProtocol.builder().build(); + mqtt.setHost("example.com"); + mqtt.setPort("1883"); + mqtt.setClientId("clientid"); + mqtt.setTimeout("1"); + mqtt.setProtocolVersion(MqttVersion.MQTT_3_1_1.name()); + + metrics.setMqtt(mqtt); + metrics.setAliasFields(new ArrayList<>()); + + mqttCollect.collect(builder, 1L, "app", metrics); + }); + + + assertDoesNotThrow(() -> { + MqttProtocol mqtt = MqttProtocol.builder().build(); + mqtt.setHost("example.com"); + mqtt.setPort("1883"); + mqtt.setClientId("clientid"); + mqtt.setTimeout("1"); + mqtt.setProtocolVersion(MqttVersion.MQTT_5_0.name()); + + metrics.setMqtt(mqtt); + metrics.setAliasFields(new ArrayList<>()); + + mqttCollect.collect(builder, 1L, "app", metrics); + }); + } +} diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/nebulagraph/NebulaGraphCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/nebulagraph/NebulaGraphCollectImplTest.java new file mode 100644 index 00000000000..72600503c9d --- /dev/null +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/nebulagraph/NebulaGraphCollectImplTest.java @@ -0,0 +1,103 @@ +/* + * 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.collector.collect.nebulagraph; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; +import org.apache.hertzbeat.common.entity.job.Metrics; +import org.apache.hertzbeat.common.entity.job.protocol.NebulaGraphProtocol; +import org.apache.hertzbeat.common.entity.message.CollectRep; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +/** + * Test case for {@link NebulaGraphCollectImpl} + */ +public class NebulaGraphCollectImplTest { + private NebulaGraphCollectImpl nebulaGraphCollect; + private CollectRep.MetricsData.Builder builder; + + @BeforeEach + void setUp() { + nebulaGraphCollect = new NebulaGraphCollectImpl(); + builder = CollectRep.MetricsData.newBuilder(); + } + + @Test + void preCheck() { + // metrics is null + assertThrows(IllegalArgumentException.class, () -> { + nebulaGraphCollect.preCheck(null); + }); + + // nebulaGraph is null + assertThrows(IllegalArgumentException.class, () -> { + Metrics metrics = Metrics.builder().build(); + nebulaGraphCollect.preCheck(metrics); + }); + + // everything is ok + assertDoesNotThrow(() -> { + Metrics metrics = Metrics.builder().nebulaGraph(NebulaGraphProtocol.builder().build()).build(); + nebulaGraphCollect.preCheck(metrics); + }); + } + + @Test + void collect() { + String[] validTimePeriods = new String[]{"5", "60", "600", "3600"}; + + // valid time period without host + for (String validTimePeriod : validTimePeriods) { + builder = CollectRep.MetricsData.newBuilder(); + Metrics metrics = Metrics.builder().nebulaGraph(NebulaGraphProtocol.builder().timePeriod(validTimePeriod).build()).build(); + nebulaGraphCollect.collect(builder, 0, null, metrics); + assertEquals(CollectRep.Code.FAIL, builder.getCode()); + } + + // invalid time period + assertDoesNotThrow(() -> { + builder = CollectRep.MetricsData.newBuilder(); + Metrics metrics = Metrics.builder().nebulaGraph(NebulaGraphProtocol.builder().timePeriod("invalid").build()).build(); + nebulaGraphCollect.collect(builder, 0, null, metrics); + assertEquals(CollectRep.Code.FAIL, builder.getCode()); + }); + + assertDoesNotThrow(() -> { + // valid time period and host + builder = CollectRep.MetricsData.newBuilder(); + Metrics metrics = Metrics.builder().nebulaGraph(NebulaGraphProtocol.builder() + .timePeriod("5") + .host("localhost") + .port("9090") + .url("example.com") + .timeout("1") + .build()).build(); + nebulaGraphCollect.collect(builder, 0, null, metrics); + assertEquals(CollectRep.Code.FAIL, builder.getCode()); + }); + } + + @Test + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_NEBULAGRAPH, nebulaGraphCollect.supportProtocol()); + } +} diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/nebulagraph/NgqlCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/nebulagraph/NgqlCollectImplTest.java index 98c2c978e1d..57754b80e1f 100644 --- a/collector/src/test/java/org/apache/hertzbeat/collector/collect/nebulagraph/NgqlCollectImplTest.java +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/nebulagraph/NgqlCollectImplTest.java @@ -18,6 +18,7 @@ package org.apache.hertzbeat.collector.collect.nebulagraph; import static org.junit.jupiter.api.Assertions.assertEquals; + import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; @@ -25,6 +26,8 @@ import java.util.LinkedHashMap; import java.util.List; import java.util.Map; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; import org.apache.hertzbeat.common.entity.job.Metrics; import org.apache.hertzbeat.common.entity.job.protocol.NgqlProtocol; import org.apache.hertzbeat.common.entity.message.CollectRep; @@ -197,4 +200,8 @@ void testColumnsCollect() { mocked.close(); } + @Test + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_NGQL, ngqlCollect.supportProtocol()); + } } diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/nginx/NginxCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/nginx/NginxCollectImplTest.java index fb05011231b..472af71090a 100644 --- a/collector/src/test/java/org/apache/hertzbeat/collector/collect/nginx/NginxCollectImplTest.java +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/nginx/NginxCollectImplTest.java @@ -19,6 +19,8 @@ import static org.apache.hertzbeat.common.constants.CommonConstants.TYPE_STRING; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; @@ -28,6 +30,7 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.hertzbeat.collector.collect.common.http.CommonHttpClient; +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; import org.apache.hertzbeat.common.entity.job.Metrics; import org.apache.hertzbeat.common.entity.job.protocol.NginxProtocol; import org.apache.hertzbeat.common.entity.message.CollectRep; @@ -70,6 +73,23 @@ public class NginxCollectImplTest { public void setup() { } + @Test + void preCheck() { + // metrics is null + assertThrows(IllegalArgumentException.class, () -> { + nginxCollect.preCheck(null); + }); + + // nginx protocol is null + assertThrows(IllegalArgumentException.class, () -> { + nginxCollect.preCheck(Metrics.builder().build()); + }); + + // nginx protocol is invalid + assertThrows(IllegalArgumentException.class, () -> { + nginxCollect.preCheck(Metrics.builder().nginx(NginxProtocol.builder().build()).build()); + }); + } @Test public void testNginxCollectFail() throws IOException { @@ -240,6 +260,11 @@ public void testNginxReqStatusCollect() throws IOException { } } + @Test + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_NGINX, nginxCollect.supportProtocol()); + } + static class CustomHttpEntity implements HttpEntity { private final String content; diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/pop3/Pop3CollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/pop3/Pop3CollectImplTest.java new file mode 100644 index 00000000000..6aed91c6395 --- /dev/null +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/pop3/Pop3CollectImplTest.java @@ -0,0 +1,99 @@ +/* + * 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.collector.collect.pop3; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; +import org.apache.hertzbeat.common.entity.job.Metrics; +import org.apache.hertzbeat.common.entity.job.protocol.Pop3Protocol; +import org.apache.hertzbeat.common.entity.message.CollectRep; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +/** + * Test case for {@link Pop3CollectImpl} + */ +public class Pop3CollectImplTest { + private Pop3CollectImpl pop3Collect; + + @BeforeEach + void setUp() throws Exception { + pop3Collect = new Pop3CollectImpl(); + } + + @Test + void preCheck() throws Exception { + // metrics is null + assertThrows(IllegalArgumentException.class, () -> { + pop3Collect.preCheck(null); + }); + + // protocol is null + assertThrows(IllegalArgumentException.class, () -> { + Metrics metrics = Metrics.builder().build(); + pop3Collect.preCheck(metrics); + }); + + // protocol is invalid + assertThrows(IllegalArgumentException.class, () -> { + Pop3Protocol pop3 = Pop3Protocol.builder().build(); + Metrics metrics = Metrics.builder().pop3(pop3).build(); + pop3Collect.preCheck(metrics); + }); + + // everything is ok + assertDoesNotThrow(() -> { + Pop3Protocol pop3 = Pop3Protocol.builder() + .host("localhost") + .port("110") + .timeout("1") + .ssl("true") + .email("test@example.com") + .authorize("auth") + .build(); + Metrics metrics = Metrics.builder().pop3(pop3).build(); + pop3Collect.preCheck(metrics); + }); + } + + @Test + void collect() throws Exception { + Pop3Protocol pop3 = Pop3Protocol.builder() + .host("localhost") + .port("110") + .timeout("1") + .ssl("true") + .email("test@example.com") + .authorize("auth") + .build(); + Metrics metrics = Metrics.builder().pop3(pop3).build(); + + assertDoesNotThrow(() -> { + CollectRep.MetricsData.Builder builder = CollectRep.MetricsData.newBuilder(); + pop3Collect.collect(builder, 1, "app", metrics); + }); + } + + @Test + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_POP3, pop3Collect.supportProtocol()); + } +} diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/push/PushCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/push/PushCollectImplTest.java new file mode 100644 index 00000000000..e37c574e9a6 --- /dev/null +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/push/PushCollectImplTest.java @@ -0,0 +1,72 @@ +/* + * 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.collector.collect.push; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; +import org.apache.hertzbeat.common.entity.job.Metrics; +import org.apache.hertzbeat.common.entity.job.protocol.PushProtocol; +import org.apache.hertzbeat.common.entity.message.CollectRep; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +/** + * Test case for {@link PushCollectImpl} + */ +public class PushCollectImplTest { + private PushCollectImpl pushCollect; + private PushProtocol push; + private CollectRep.MetricsData.Builder builder; + + @BeforeEach + public void setup() { + pushCollect = new PushCollectImpl(); + push = PushProtocol.builder().uri("/metrics").host("example.com").port("60").build(); + builder = CollectRep.MetricsData.newBuilder(); + } + + @Test + void preCheck() throws Exception { + // metrics is null + assertThrows(IllegalArgumentException.class, () -> pushCollect.preCheck(null)); + + // protocol is null + assertThrows(IllegalArgumentException.class, () -> pushCollect.preCheck(new Metrics())); + + // everyting is ok + assertDoesNotThrow(() -> { + pushCollect.preCheck(Metrics.builder().push(push).build()); + }); + } + + @Test + void collect() throws Exception { + assertDoesNotThrow(() -> { + pushCollect.collect(builder, 1L, "app", Metrics.builder().push(push).build()); + assertEquals(CollectRep.Code.FAIL, builder.getCode()); + }); + } + + @Test + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_PUSH, pushCollect.supportProtocol()); + } +} diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/redfish/RedfishCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/redfish/RedfishCollectImplTest.java index 3fa01f78b5a..3096be85795 100644 --- a/collector/src/test/java/org/apache/hertzbeat/collector/collect/redfish/RedfishCollectImplTest.java +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/redfish/RedfishCollectImplTest.java @@ -18,8 +18,12 @@ package org.apache.hertzbeat.collector.collect.redfish; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + import java.util.ArrayList; import java.util.List; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; import org.apache.hertzbeat.common.entity.job.Metrics; import org.apache.hertzbeat.common.entity.job.protocol.RedfishProtocol; import org.apache.hertzbeat.common.entity.message.CollectRep; @@ -171,4 +175,21 @@ void mockCollect() throws Exception { assertEquals("/redfish/v1/Chassis/2U/PowerSubsystem/PowerSupplies/Bay1", builder.getValues(2).getColumns(0)); assertEquals("/redfish/v1/Chassis/2U/PowerSubsystem/PowerSupplies/Bay2", builder.getValues(3).getColumns(0)); } + + @Test + void preCheck() throws Exception { + // metrics is null + assertThrows(IllegalArgumentException.class, () -> redfishCollect.preCheck(null)); + + // protocol is null + assertThrows(IllegalArgumentException.class, () -> { + Metrics metrics = Metrics.builder().build(); + redfishCollect.preCheck(metrics); + }); + } + + @Test + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_REDFISH, redfishCollect.supportProtocol()); + } } diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/script/ScriptCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/script/ScriptCollectImplTest.java new file mode 100644 index 00000000000..46f9a4316a1 --- /dev/null +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/script/ScriptCollectImplTest.java @@ -0,0 +1,147 @@ +/* + * 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.collector.collect.script; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; +import org.apache.hertzbeat.common.entity.job.Metrics; +import org.apache.hertzbeat.common.entity.job.protocol.ScriptProtocol; +import org.apache.hertzbeat.common.entity.message.CollectRep; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +/** + * Test case for {@link ScriptCollectImpl} + */ +public class ScriptCollectImplTest { + private ScriptCollectImpl scriptCollect; + private CollectRep.MetricsData.Builder builder; + + @BeforeEach + void setUp() throws Exception { + scriptCollect = new ScriptCollectImpl(); + builder = CollectRep.MetricsData.newBuilder(); + } + + @Test + void preCheck() { + // metrics is null + assertThrows(IllegalArgumentException.class, () -> { + scriptCollect.preCheck(null); + }); + + // protocol is null + assertThrows(IllegalArgumentException.class, () -> { + Metrics metrics = new Metrics(); + scriptCollect.preCheck(metrics); + }); + + // charset is null + assertThrows(IllegalArgumentException.class, () -> { + ScriptProtocol scriptProtocol = ScriptProtocol.builder().build(); + Metrics metrics = new Metrics(); + metrics.setScript(scriptProtocol); + scriptCollect.preCheck(metrics); + }); + + // parse type is null + assertThrows(IllegalArgumentException.class, () -> { + ScriptProtocol scriptProtocol = ScriptProtocol.builder().charset("utf-8").build(); + Metrics metrics = new Metrics(); + metrics.setScript(scriptProtocol); + scriptCollect.preCheck(metrics); + }); + + // script tool is null + assertThrows(IllegalArgumentException.class, () -> { + ScriptProtocol scriptProtocol = ScriptProtocol.builder().charset("utf-8").parseType("json").build(); + Metrics metrics = new Metrics(); + metrics.setScript(scriptProtocol); + scriptCollect.preCheck(metrics); + }); + + // script command is null + assertThrows(IllegalArgumentException.class, () -> { + ScriptProtocol scriptProtocol = ScriptProtocol.builder().charset("utf-8").parseType("json").scriptTool("sh").build(); + Metrics metrics = new Metrics(); + metrics.setScript(scriptProtocol); + scriptCollect.preCheck(metrics); + }); + + // script path is null + assertDoesNotThrow(() -> { + ScriptProtocol scriptProtocol = ScriptProtocol.builder().charset("utf-8").parseType("json").scriptTool("sh").scriptCommand("ls").build(); + Metrics metrics = new Metrics(); + metrics.setScript(scriptProtocol); + scriptCollect.preCheck(metrics); + }); + + // everything is ok + assertDoesNotThrow(() -> { + ScriptProtocol scriptProtocol = ScriptProtocol.builder().charset("utf-8").parseType("json").scriptTool("sh").scriptPath("/tmp").build(); + Metrics metrics = new Metrics(); + metrics.setScript(scriptProtocol); + scriptCollect.preCheck(metrics); + }); + } + + @Test + void collect() { + // not support script tool with command + assertDoesNotThrow(() -> { + ScriptProtocol scriptProtocol = ScriptProtocol.builder().charset("utf-8").parseType("json").scriptTool("sh").scriptCommand("cmd").build(); + Metrics metrics = new Metrics(); + metrics.setScript(scriptProtocol); + + builder = CollectRep.MetricsData.newBuilder(); + scriptCollect.collect(builder, 0, "app", metrics); + assertEquals(CollectRep.Code.FAIL, builder.getCode()); + }); + + + // not support script tool with scriptpath + assertDoesNotThrow(() -> { + ScriptProtocol scriptProtocol = ScriptProtocol.builder().charset("utf-8").parseType("json").scriptTool("sh").scriptPath("cmd").build(); + Metrics metrics = new Metrics(); + metrics.setScript(scriptProtocol); + + builder = CollectRep.MetricsData.newBuilder(); + scriptCollect.collect(builder, 0, "app", metrics); + assertEquals(CollectRep.Code.FAIL, builder.getCode()); + }); + + // without script command and path + assertDoesNotThrow(() -> { + ScriptProtocol scriptProtocol = ScriptProtocol.builder().charset("utf-8").parseType("json").build(); + Metrics metrics = new Metrics(); + metrics.setScript(scriptProtocol); + + builder = CollectRep.MetricsData.newBuilder(); + scriptCollect.collect(builder, 0, "app", metrics); + assertEquals(CollectRep.Code.FAIL, builder.getCode()); + }); + } + + @Test + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_SCRIPT, scriptCollect.supportProtocol()); + } +} diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/smtp/SmtpCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/smtp/SmtpCollectImplTest.java new file mode 100644 index 00000000000..b249578cbc0 --- /dev/null +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/smtp/SmtpCollectImplTest.java @@ -0,0 +1,80 @@ +/* + * 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.collector.collect.smtp; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; +import org.apache.hertzbeat.common.entity.job.Metrics; +import org.apache.hertzbeat.common.entity.job.protocol.SmtpProtocol; +import org.apache.hertzbeat.common.entity.message.CollectRep; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +/** + * Test case for {@link SmtpCollectImpl} + */ +public class SmtpCollectImplTest { + private SmtpCollectImpl smtpCollect; + private CollectRep.MetricsData.Builder builder; + + @BeforeEach + void setup() { + smtpCollect = new SmtpCollectImpl(); + builder = CollectRep.MetricsData.newBuilder(); + } + + @Test + void preCheck() { + // metrics is null + assertThrows(IllegalArgumentException.class, () -> { + smtpCollect.preCheck(null); + }); + + // stmp protocol is null + assertThrows(IllegalArgumentException.class, () -> { + smtpCollect.preCheck(new Metrics()); + }); + + // everthing is ok + assertDoesNotThrow(() -> { + Metrics metrics = Metrics.builder() + .smtp(new SmtpProtocol()) + .build(); + smtpCollect.preCheck(metrics); + }); + } + + @Test + void collect() { + assertDoesNotThrow(() -> { + Metrics metrics = Metrics.builder() + .smtp(new SmtpProtocol()) + .build(); + smtpCollect.collect(builder, 0, null, metrics); + assertEquals(CollectRep.Code.FAIL, builder.getCode()); + }); + } + + @Test + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_SMTP, smtpCollect.supportProtocol()); + } +} diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/snmp/SnmpCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/snmp/SnmpCollectImplTest.java index faa29a64b0c..3ae3c0f1b06 100644 --- a/collector/src/test/java/org/apache/hertzbeat/collector/collect/snmp/SnmpCollectImplTest.java +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/snmp/SnmpCollectImplTest.java @@ -17,7 +17,14 @@ package org.apache.hertzbeat.collector.collect.snmp; -import org.junit.jupiter.api.AfterEach; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; +import org.apache.hertzbeat.common.entity.job.Metrics; +import org.apache.hertzbeat.common.entity.job.protocol.SnmpProtocol; +import org.apache.hertzbeat.common.entity.message.CollectRep; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -25,20 +32,77 @@ * Test case for {@link SnmpCollectImpl} */ class SnmpCollectImplTest { + private SnmpCollectImpl snmpCollect; + private Metrics metrics; + private CollectRep.MetricsData.Builder builder; @BeforeEach void setUp() { + snmpCollect = new SnmpCollectImpl(); + metrics = new Metrics(); + SnmpProtocol snmap = new SnmpProtocol(); + snmap.setHost("127.0.0.1"); + snmap.setPort("161"); + snmap.setVersion("2c"); + metrics.setSnmp(snmap); + builder = CollectRep.MetricsData.newBuilder(); } - @AfterEach - void tearDown() { + @Test + void preCheck() { + // metrics is null + assertThrows(IllegalArgumentException.class, () -> { + snmpCollect.preCheck(null); + }); + + // snmp protocol is null + assertThrows(IllegalArgumentException.class, () -> { + Metrics metrics = new Metrics(); + snmpCollect.preCheck(metrics); + }); + + // snmp host is null + assertThrows(IllegalArgumentException.class, () -> { + Metrics metrics = new Metrics(); + metrics.setSnmp(new SnmpProtocol()); + snmpCollect.preCheck(metrics); + }); + + // snmp port is null + assertThrows(IllegalArgumentException.class, () -> { + SnmpProtocol snmap = new SnmpProtocol(); + snmap.setHost("127.0.0.1"); + Metrics metrics = new Metrics(); + metrics.setSnmp(snmap); + snmpCollect.preCheck(metrics); + }); + + // snmp version is null + assertThrows(IllegalArgumentException.class, () -> { + SnmpProtocol snmap = new SnmpProtocol(); + snmap.setHost("127.0.0.1"); + snmap.setPort("161"); + Metrics metrics = new Metrics(); + metrics.setSnmp(snmap); + snmpCollect.preCheck(metrics); + }); + + // everything is ok + assertDoesNotThrow(() -> { + snmpCollect.preCheck(metrics); + }); } @Test - void getInstance() { + void collect() { + assertDoesNotThrow(() -> { + snmpCollect.collect(builder, 0, null, metrics); + assertEquals(CollectRep.Code.FAIL, builder.getCode()); + }); } @Test - void collect() { + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_SNMP, snmpCollect.supportProtocol()); } } diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/ssh/SshCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/ssh/SshCollectImplTest.java index 4d34555d443..165bcae087f 100644 --- a/collector/src/test/java/org/apache/hertzbeat/collector/collect/ssh/SshCollectImplTest.java +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/ssh/SshCollectImplTest.java @@ -17,7 +17,14 @@ package org.apache.hertzbeat.collector.collect.ssh; -import org.junit.jupiter.api.AfterEach; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; +import org.apache.hertzbeat.common.entity.job.Metrics; +import org.apache.hertzbeat.common.entity.job.protocol.SshProtocol; +import org.apache.hertzbeat.common.entity.message.CollectRep; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -25,20 +32,46 @@ * Test case for {@link SshCollectImpl} */ class SshCollectImplTest { + private SshCollectImpl sshCollect; + private CollectRep.MetricsData.Builder builder; @BeforeEach void setUp() { + sshCollect = new SshCollectImpl(); + builder = CollectRep.MetricsData.newBuilder(); } - @AfterEach - void tearDown() { + @Test + void preCheck() { + // metrics is null + assertThrows(IllegalArgumentException.class, () -> { + sshCollect.preCheck(null); + }); + + // ssh protocol is null + assertThrows(IllegalArgumentException.class, () -> { + Metrics metrics = Metrics.builder().build(); + sshCollect.preCheck(metrics); + }); + + // everything is ok + assertDoesNotThrow(() -> { + Metrics metrics = Metrics.builder().ssh(new SshProtocol()).build(); + sshCollect.preCheck(metrics); + }); } @Test - void getInstance() { + void collect() { + assertDoesNotThrow(() -> { + Metrics metrics = Metrics.builder().ssh(new SshProtocol()).build(); + sshCollect.collect(builder, 1L, "app", metrics); + assertEquals(CollectRep.Code.FAIL, builder.getCode()); + }); } @Test - void collect() { + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_SSH, sshCollect.supportProtocol()); } } diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/telnet/TelnetCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/telnet/TelnetCollectImplTest.java index 1b4f8854165..f0968179237 100644 --- a/collector/src/test/java/org/apache/hertzbeat/collector/collect/telnet/TelnetCollectImplTest.java +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/telnet/TelnetCollectImplTest.java @@ -17,8 +17,11 @@ package org.apache.hertzbeat.collector.collect.telnet; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + import java.io.ByteArrayInputStream; import java.io.InputStream; import java.io.OutputStream; @@ -26,6 +29,7 @@ import java.util.ArrayList; import java.util.List; import org.apache.commons.net.telnet.TelnetClient; +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; import org.apache.hertzbeat.common.entity.job.Metrics; import org.apache.hertzbeat.common.entity.job.protocol.TelnetProtocol; import org.apache.hertzbeat.common.entity.message.CollectRep; @@ -150,4 +154,28 @@ void testCollectWithTab() { } mocked.close(); } + + @Test + void preCheck() throws IllegalArgumentException { + // metrics is null + assertThrows(IllegalArgumentException.class, () -> telnetCollect.preCheck(null)); + + // protocol is null + assertThrows(IllegalArgumentException.class, () -> { + Metrics metrics = new Metrics(); + telnetCollect.preCheck(metrics); + }); + + // everyting is ok + assertDoesNotThrow(() -> { + Metrics metrics = new Metrics(); + metrics.setTelnet(TelnetProtocol.builder().build()); + telnetCollect.preCheck(metrics); + }); + } + + @Test + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_TELNET, telnetCollect.supportProtocol()); + } } diff --git a/collector/src/test/java/org/apache/hertzbeat/collector/collect/udp/UdpCollectImplTest.java b/collector/src/test/java/org/apache/hertzbeat/collector/collect/udp/UdpCollectImplTest.java index 652318b4e08..4fd4b64b620 100644 --- a/collector/src/test/java/org/apache/hertzbeat/collector/collect/udp/UdpCollectImplTest.java +++ b/collector/src/test/java/org/apache/hertzbeat/collector/collect/udp/UdpCollectImplTest.java @@ -17,6 +17,7 @@ package org.apache.hertzbeat.collector.collect.udp; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertThrows; @@ -26,6 +27,8 @@ import java.net.SocketTimeoutException; import java.util.ArrayList; import java.util.List; + +import org.apache.hertzbeat.collector.dispatch.DispatchConstants; import org.apache.hertzbeat.common.entity.job.Metrics; import org.apache.hertzbeat.common.entity.job.protocol.UdpProtocol; import org.apache.hertzbeat.common.entity.message.CollectRep; @@ -52,6 +55,17 @@ void testPreCheck() { Metrics metrics = new Metrics(); metrics.setAliasFields(aliasField); assertThrows(IllegalArgumentException.class, () -> udpCollect.preCheck(metrics)); + + // metrics is null + assertThrows(IllegalArgumentException.class, () -> { + udpCollect.preCheck(null); + }); + + // everything is ok + assertDoesNotThrow(() -> { + UdpProtocol udpProtocol = UdpProtocol.builder().timeout("10").port("21").host("127.0.0.1").build(); + udpCollect.preCheck(Metrics.builder().udp(udpProtocol).build()); + }); } @Test @@ -136,4 +150,9 @@ void testCollectWithPortUnreachableException() { socketMockedConstruction.close(); } + + @Test + void supportProtocol() { + assertEquals(DispatchConstants.PROTOCOL_UDP, udpCollect.supportProtocol()); + } } diff --git a/common/src/main/java/org/apache/hertzbeat/common/entity/manager/bulletin/Bulletin.java b/common/src/main/java/org/apache/hertzbeat/common/entity/manager/bulletin/Bulletin.java index a500a6320f4..60e1d87be97 100644 --- a/common/src/main/java/org/apache/hertzbeat/common/entity/manager/bulletin/Bulletin.java +++ b/common/src/main/java/org/apache/hertzbeat/common/entity/manager/bulletin/Bulletin.java @@ -70,7 +70,7 @@ public class Bulletin { @Schema(description = "Monitor Fields") - @Column(length = 4096, columnDefinition = "json") + @Column(length = 4096) private String fields; @Schema(description = "Tags(status:success,env:prod)", example = "{name: key1, value: value1}", diff --git a/home/static/img/docs/help/plugin-4.png b/home/static/img/docs/help/plugin-4.png index e69de29bb2d..fb7413c77ae 100644 Binary files a/home/static/img/docs/help/plugin-4.png and b/home/static/img/docs/help/plugin-4.png differ diff --git a/web-app/src/app/routes/monitor/monitor-form/monitor-form.component.html b/web-app/src/app/routes/monitor/monitor-form/monitor-form.component.html index e91c22d5b04..0539ec21010 100644 --- a/web-app/src/app/routes/monitor/monitor-form/monitor-form.component.html +++ b/web-app/src/app/routes/monitor/monitor-form/monitor-form.component.html @@ -169,7 +169,7 @@ - + {{ 'monitor.grafana.upload.label' | i18n }}