This is an automated email from the ASF dual-hosted git repository.
blerer pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/cassandra.git
The following commit(s) were added to refs/heads/trunk by this push:
new 5fc8112 Refactor NodeTool commands tests
5fc8112 is described below
commit 5fc811210b70889084b2be5a6a3577963fd5f3c4
Author: Aleksei Zotov <[email protected]>
AuthorDate: Sat Apr 24 14:25:56 2021 +0400
Refactor NodeTool commands tests
patch by Aleksei Zoto; reviewed by Benjamin Lerer for CASSANDRA-16629
---
.../cassandra/tools/NodeToolGossipInfoTest.java | 130 ---------------------
.../tools/{ => nodetool}/ClearSnapshotTest.java | 51 ++++----
.../tools/{ => nodetool}/GetFullQueryLogTest.java | 58 ++++-----
.../cassandra/tools/nodetool/GossipInfoTest.java | 124 ++++++++++++++++++++
.../NetStatsTest.java} | 48 +++-----
.../apache/cassandra/tools/nodetool/RingTest.java | 75 +++++-------
.../apache/cassandra/tools/nodetool/SjkTest.java | 4 +-
.../cassandra/tools/nodetool/StatusTest.java | 57 ++++-----
...toolTableStatsTest.java => TableStatsTest.java} | 103 +++++++---------
.../TpStatsTest.java} | 86 ++++++--------
10 files changed, 332 insertions(+), 404 deletions(-)
diff --git a/test/unit/org/apache/cassandra/tools/NodeToolGossipInfoTest.java
b/test/unit/org/apache/cassandra/tools/NodeToolGossipInfoTest.java
deleted file mode 100644
index caca5ae..0000000
--- a/test/unit/org/apache/cassandra/tools/NodeToolGossipInfoTest.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * 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.cassandra.tools;
-
-import java.io.IOException;
-
-import org.apache.commons.lang3.StringUtils;
-
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import org.apache.cassandra.OrderedJUnit4ClassRunner;
-import org.apache.cassandra.cql3.CQLTester;
-import org.apache.cassandra.net.Message;
-import org.apache.cassandra.net.MessagingService;
-import org.apache.cassandra.net.NoPayload;
-import org.apache.cassandra.tools.ToolRunner.ToolResult;
-import org.apache.cassandra.utils.FBUtilities;
-import org.assertj.core.api.Assertions;
-
-import static org.apache.cassandra.net.Verb.ECHO_REQ;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
-@RunWith(OrderedJUnit4ClassRunner.class)
-public class NodeToolGossipInfoTest extends CQLTester
-{
- private static NodeProbe probe;
-
- @BeforeClass
- public static void setup() throws Exception
- {
- requireNetwork();
- startJMXServer();
- probe = new NodeProbe(jmxHost, jmxPort);
- }
-
- @AfterClass
- public static void teardown() throws IOException
- {
- probe.close();
- }
-
- @Test
- public void testMaybeChangeDocs()
- {
- // If you added, modified options or help, please update docs if
necessary
- ToolResult tool = ToolRunner.invokeNodetool("help", "gossipinfo");
- String help = "NAME\n" +
- " nodetool gossipinfo - Shows the gossip
information for the cluster\n" +
- "\n" +
- "SYNOPSIS\n" +
- " nodetool [(-h <host> | --host <host>)] [(-p
<port> | --port <port>)]\n" +
- " [(-pp | --print-port)] [(-pw
<password> | --password <password>)]\n" +
- " [(-pwf <passwordFilePath> |
--password-file <passwordFilePath>)]\n" +
- " [(-u <username> | --username
<username>)] gossipinfo\n" +
- "\n" +
- "OPTIONS\n" +
- " -h <host>, --host <host>\n" +
- " Node hostname or ip address\n" +
- "\n" +
- " -p <port>, --port <port>\n" +
- " Remote jmx agent port number\n" +
- "\n" +
- " -pp, --print-port\n" +
- " Operate in 4.0 mode with hosts
disambiguated by port number\n" +
- "\n" +
- " -pw <password>, --password <password>\n" +
- " Remote jmx agent password\n" +
- "\n" +
- " -pwf <passwordFilePath>, --password-file
<passwordFilePath>\n" +
- " Path to the JMX password file\n" +
- "\n" +
- " -u <username>, --username <username>\n" +
- " Remote jmx agent username\n" +
- "\n" +
- "\n";
- Assertions.assertThat(tool.getStdout()).isEqualTo(help);
- }
-
- @Test
- public void testGossipInfo() throws Throwable
- {
- ToolResult tool = ToolRunner.invokeNodetool("gossipinfo");
- Assertions.assertThat(tool.getStdout()).contains("/127.0.0.1");
-
Assertions.assertThat(tool.getStdout()).containsPattern("heartbeat:[0-9]+");
-
Assertions.assertThat(tool.getStdout()).containsPattern("STATUS:[0-9]+:NORMAL,.+");
- Assertions.assertThat(tool.getStdout()).containsPattern("SCHEMA:.+");
-
Assertions.assertThat(tool.getStdout()).containsPattern("DC:[0-9]+:datacenter1");
-
Assertions.assertThat(tool.getStdout()).containsPattern("RACK:[0-9]+:rack1");
-
Assertions.assertThat(tool.getStdout()).containsPattern("RELEASE_VERSION:.+");
-
Assertions.assertThat(tool.getStdout()).containsPattern("RPC_ADDRESS:[0-9]+:127.0.0.1");
-
Assertions.assertThat(tool.getStdout()).containsPattern("NET_VERSION:[0-9]+:.+");
-
Assertions.assertThat(tool.getStdout()).containsPattern("HOST_ID:[0-9]+:.+");
-
Assertions.assertThat(tool.getStdout()).containsPattern("NATIVE_ADDRESS_AND_PORT:[0-9]+:127.0.0.1:[0-9]+");
-
Assertions.assertThat(tool.getStdout()).containsPattern("STATUS_WITH_PORT:[0-9]+:NORMAL,.+");
-
Assertions.assertThat(tool.getStdout()).containsPattern("TOKENS:[0-9]+:<hidden>");
- assertTrue(tool.getCleanedStderr().isEmpty());
- assertEquals(0, tool.getExitCode());
-
- // Make sure heartbeats are detected
- Message<NoPayload> echoMessageOut = Message.out(ECHO_REQ,
NoPayload.noPayload);
- MessagingService.instance().send(echoMessageOut,
FBUtilities.getBroadcastAddressAndPort());
-
- String origHeartbeatCount =
StringUtils.substringBetween(tool.getStdout(), "heartbeat:", "\n");
- tool = ToolRunner.invokeNodetool("gossipinfo");
- assertTrue(tool.getCleanedStderr().isEmpty());
- assertEquals(0, tool.getExitCode());
- String newHeartbeatCount =
StringUtils.substringBetween(tool.getStdout(), "heartbeat:", "\n");
- assertTrue(Integer.parseInt(origHeartbeatCount) <=
Integer.parseInt(newHeartbeatCount));
- }
-}
diff --git a/test/unit/org/apache/cassandra/tools/ClearSnapshotTest.java
b/test/unit/org/apache/cassandra/tools/nodetool/ClearSnapshotTest.java
similarity index 62%
rename from test/unit/org/apache/cassandra/tools/ClearSnapshotTest.java
rename to test/unit/org/apache/cassandra/tools/nodetool/ClearSnapshotTest.java
index 975e45b..07a89d7 100644
--- a/test/unit/org/apache/cassandra/tools/ClearSnapshotTest.java
+++ b/test/unit/org/apache/cassandra/tools/nodetool/ClearSnapshotTest.java
@@ -16,26 +16,25 @@
* limitations under the License.
*/
-package org.apache.cassandra.tools;
+package org.apache.cassandra.tools.nodetool;
import java.io.IOException;
import java.util.Map;
-
import javax.management.openmbean.TabularData;
import org.junit.AfterClass;
-import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.apache.cassandra.OrderedJUnit4ClassRunner;
import org.apache.cassandra.cql3.CQLTester;
-import org.apache.cassandra.tools.ToolRunner.ToolResult;
-import org.hamcrest.CoreMatchers;
+import org.apache.cassandra.tools.NodeProbe;
+import org.apache.cassandra.tools.ToolRunner;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
+@RunWith(OrderedJUnit4ClassRunner.class)
public class ClearSnapshotTest extends CQLTester
{
private static NodeProbe probe;
@@ -56,9 +55,9 @@ public class ClearSnapshotTest extends CQLTester
@Test
public void testClearSnapshot_NoArgs()
{
- ToolResult tool = ToolRunner.invokeNodetool("clearsnapshot");
- assertEquals(2, tool.getExitCode());
- assertTrue("Tool stderr: " + tool.getCleanedStderr(),
tool.getCleanedStderr().contains("Specify snapshot name or --all"));
+ ToolRunner.ToolResult tool =
ToolRunner.invokeNodetool("clearsnapshot");
+ assertThat(tool.getExitCode()).isEqualTo(2);
+ assertThat(tool.getCleanedStderr()).contains("Specify snapshot name or
--all");
tool = ToolRunner.invokeNodetool("clearsnapshot", "--all");
tool.assertOnCleanExit();
@@ -67,49 +66,49 @@ public class ClearSnapshotTest extends CQLTester
@Test
public void testClearSnapshot_AllAndName()
{
- ToolResult tool = ToolRunner.invokeNodetool("clearsnapshot", "-t",
"some-name", "--all");
- assertEquals(2, tool.getExitCode());
- assertThat(tool.getCleanedStderr(),
CoreMatchers.containsStringIgnoringCase("Specify only one of snapshot name or
--all"));
+ ToolRunner.ToolResult tool =
ToolRunner.invokeNodetool("clearsnapshot", "-t", "some-name", "--all");
+ assertThat(tool.getExitCode()).isEqualTo(2);
+ assertThat(tool.getCleanedStderr()).contains("Specify only one of
snapshot name or --all");
}
@Test
public void testClearSnapshot_RemoveByName()
{
- ToolResult tool =
ToolRunner.invokeNodetool("snapshot","-t","some-name");
+ ToolRunner.ToolResult tool =
ToolRunner.invokeNodetool("snapshot","-t","some-name");
tool.assertOnCleanExit();
- assertTrue(!tool.getStdout().isEmpty());
+ assertThat(tool.getStdout()).isNotEmpty();
Map<String, TabularData> snapshots_before = probe.getSnapshotDetails();
- Assert.assertTrue(snapshots_before.containsKey("some-name"));
-
+ assertThat(snapshots_before).containsKey("some-name");
+
tool = ToolRunner.invokeNodetool("clearsnapshot","-t","some-name");
tool.assertOnCleanExit();
- assertTrue(!tool.getStdout().isEmpty());
+ assertThat(tool.getStdout()).isNotEmpty();
Map<String, TabularData> snapshots_after = probe.getSnapshotDetails();
- Assert.assertFalse(snapshots_after.containsKey("some-name"));
+ assertThat(snapshots_after).doesNotContainKey("some-name");
}
@Test
public void testClearSnapshot_RemoveMultiple()
{
- ToolResult tool =
ToolRunner.invokeNodetool("snapshot","-t","some-name");
+ ToolRunner.ToolResult tool =
ToolRunner.invokeNodetool("snapshot","-t","some-name");
tool.assertOnCleanExit();
- assertTrue(!tool.getStdout().isEmpty());
+ assertThat(tool.getStdout()).isNotEmpty();
tool = ToolRunner.invokeNodetool("snapshot","-t","some-other-name");
tool.assertOnCleanExit();
- assertTrue(!tool.getStdout().isEmpty());
+ assertThat(tool.getStdout()).isNotEmpty();
Map<String, TabularData> snapshots_before = probe.getSnapshotDetails();
- Assert.assertTrue(snapshots_before.size() == 2);
+ assertThat(snapshots_before).hasSize(2);
tool = ToolRunner.invokeNodetool("clearsnapshot","--all");
tool.assertOnCleanExit();
- assertTrue(!tool.getStdout().isEmpty());
+ assertThat(tool.getStdout()).isNotEmpty();
Map<String, TabularData> snapshots_after = probe.getSnapshotDetails();
- Assert.assertTrue(snapshots_after.size() == 0);
+ assertThat(snapshots_after).isEmpty();
}
}
\ No newline at end of file
diff --git a/test/unit/org/apache/cassandra/tools/GetFullQueryLogTest.java
b/test/unit/org/apache/cassandra/tools/nodetool/GetFullQueryLogTest.java
similarity index 68%
rename from test/unit/org/apache/cassandra/tools/GetFullQueryLogTest.java
rename to test/unit/org/apache/cassandra/tools/nodetool/GetFullQueryLogTest.java
index 44007a5..c4eb70c 100644
--- a/test/unit/org/apache/cassandra/tools/GetFullQueryLogTest.java
+++ b/test/unit/org/apache/cassandra/tools/nodetool/GetFullQueryLogTest.java
@@ -16,28 +16,25 @@
* limitations under the License.
*/
-package org.apache.cassandra.tools;
-
-import java.io.IOException;
+package org.apache.cassandra.tools.nodetool;
import org.junit.After;
-import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.apache.cassandra.OrderedJUnit4ClassRunner;
import org.apache.cassandra.cql3.CQLTester;
import org.apache.cassandra.fql.FullQueryLoggerOptions;
-import org.apache.cassandra.tools.ToolRunner.ToolResult;
+import org.apache.cassandra.tools.ToolRunner;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
+@RunWith(OrderedJUnit4ClassRunner.class)
public class GetFullQueryLogTest extends CQLTester
{
- private static NodeProbe probe;
-
@ClassRule
public static TemporaryFolder temporaryFolder = new TemporaryFolder();
@@ -45,13 +42,6 @@ public class GetFullQueryLogTest extends CQLTester
public static void setup() throws Exception
{
startJMXServer();
- probe = new NodeProbe(jmxHost, jmxPort);
- }
-
- @AfterClass
- public static void teardown() throws IOException
- {
- probe.close();
}
@After
@@ -87,7 +77,7 @@ public class GetFullQueryLogTest extends CQLTester
private String getFullQueryLog()
{
- ToolResult tool = ToolRunner.invokeNodetool("getfullquerylog");
+ ToolRunner.ToolResult tool =
ToolRunner.invokeNodetool("getfullquerylog");
tool.assertOnCleanExit();
return tool.getStdout();
}
@@ -122,30 +112,32 @@ public class GetFullQueryLogTest extends CQLTester
.assertOnCleanExit();
}
+ @SuppressWarnings("DynamicRegexReplaceableByCompiledPattern")
private void testChangedOutput(final String getFullQueryLogOutput)
{
final String output = getFullQueryLogOutput.replaceAll("( )+", "
").trim();
- assertTrue(output.contains("enabled true"));
- assertTrue(output.contains("log_dir " +
temporaryFolder.getRoot().toString()));
- assertTrue(output.contains("archive_command /path/to/script.sh
%path"));
- assertTrue(output.contains("roll_cycle DAILY"));
- assertTrue(output.contains("max_log_size 100000"));
- assertTrue(output.contains("max_queue_weight 10000"));
- assertTrue(output.contains("max_archive_retries 5"));
- assertTrue(output.contains("block false"));
+ assertThat(output).contains("enabled true");
+ assertThat(output).contains("log_dir " +
temporaryFolder.getRoot().toString());
+ assertThat(output).contains("archive_command /path/to/script.sh
%path");
+ assertThat(output).contains("roll_cycle DAILY");
+ assertThat(output).contains("max_log_size 100000");
+ assertThat(output).contains("max_queue_weight 10000");
+ assertThat(output).contains("max_archive_retries 5");
+ assertThat(output).contains("block false");
}
+ @SuppressWarnings("DynamicRegexReplaceableByCompiledPattern")
private void testDefaultOutput(final String getFullQueryLogOutput)
{
final FullQueryLoggerOptions options = new FullQueryLoggerOptions();
final String output = getFullQueryLogOutput.replaceAll("( )+", "
").trim();
- assertTrue(output.contains("enabled false"));
- assertFalse(output.contains("log_dir " +
temporaryFolder.getRoot().toString()));
- assertFalse(output.contains("archive_command /path/to/script.sh
%path"));
- assertTrue(output.contains("roll_cycle " + options.roll_cycle));
- assertTrue(output.contains("max_log_size " + options.max_log_size));
- assertTrue(output.contains("max_queue_weight " +
options.max_queue_weight));
- assertTrue(output.contains("max_archive_retries " +
options.max_archive_retries));
- assertTrue(output.contains("block " + options.block));
+ assertThat(output).contains("enabled false");
+ assertThat(output).doesNotContain("log_dir " +
temporaryFolder.getRoot().toString());
+ assertThat(output).doesNotContain("archive_command /path/to/script.sh
%path");
+ assertThat(output).contains("roll_cycle " + options.roll_cycle);
+ assertThat(output).contains("max_log_size " + options.max_log_size);
+ assertThat(output).contains("max_queue_weight " +
options.max_queue_weight);
+ assertThat(output).contains("max_archive_retries " +
options.max_archive_retries);
+ assertThat(output).contains("block " + options.block);
}
}
diff --git a/test/unit/org/apache/cassandra/tools/nodetool/GossipInfoTest.java
b/test/unit/org/apache/cassandra/tools/nodetool/GossipInfoTest.java
new file mode 100644
index 0000000..7a48db8
--- /dev/null
+++ b/test/unit/org/apache/cassandra/tools/nodetool/GossipInfoTest.java
@@ -0,0 +1,124 @@
+/*
+ * 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.cassandra.tools.nodetool;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.apache.cassandra.OrderedJUnit4ClassRunner;
+import org.apache.cassandra.cql3.CQLTester;
+import org.apache.cassandra.net.Message;
+import org.apache.cassandra.net.MessagingService;
+import org.apache.cassandra.net.NoPayload;
+import org.apache.cassandra.service.StorageService;
+import org.apache.cassandra.tools.ToolRunner;
+import org.apache.cassandra.utils.FBUtilities;
+import org.assertj.core.api.Assertions;
+
+import static org.apache.cassandra.net.Verb.ECHO_REQ;
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(OrderedJUnit4ClassRunner.class)
+public class GossipInfoTest extends CQLTester
+{
+ private static String token;
+
+ @BeforeClass
+ public static void setup() throws Exception
+ {
+ requireNetwork();
+ startJMXServer();
+ token = StorageService.instance.getTokens().get(0);
+ }
+
+ @Test
+ @SuppressWarnings("SingleCharacterStringConcatenation")
+ public void testMaybeChangeDocs()
+ {
+ // If you added, modified options or help, please update docs if
necessary
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("help",
"gossipinfo");
+ tool.assertOnCleanExit();
+
+ String help = "NAME\n" +
+ " nodetool gossipinfo - Shows the gossip information
for the cluster\n" +
+ "\n" +
+ "SYNOPSIS\n" +
+ " nodetool [(-h <host> | --host <host>)] [(-p <port> |
--port <port>)]\n" +
+ " [(-pp | --print-port)] [(-pw <password> |
--password <password>)]\n" +
+ " [(-pwf <passwordFilePath> | --password-file
<passwordFilePath>)]\n" +
+ " [(-u <username> | --username <username>)]
gossipinfo\n" +
+ "\n" +
+ "OPTIONS\n" +
+ " -h <host>, --host <host>\n" +
+ " Node hostname or ip address\n" +
+ "\n" +
+ " -p <port>, --port <port>\n" +
+ " Remote jmx agent port number\n" +
+ "\n" +
+ " -pp, --print-port\n" +
+ " Operate in 4.0 mode with hosts disambiguated by
port number\n" +
+ "\n" +
+ " -pw <password>, --password <password>\n" +
+ " Remote jmx agent password\n" +
+ "\n" +
+ " -pwf <passwordFilePath>, --password-file
<passwordFilePath>\n" +
+ " Path to the JMX password file\n" +
+ "\n" +
+ " -u <username>, --username <username>\n" +
+ " Remote jmx agent username\n" +
+ "\n" +
+ "\n";
+ assertThat(tool.getStdout()).isEqualTo(help);
+ }
+
+ @Test
+ public void testGossipInfo()
+ {
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("gossipinfo");
+ tool.assertOnCleanExit();
+ String stdout = tool.getStdout();
+ Assertions.assertThat(stdout).contains("/127.0.0.1");
+ Assertions.assertThat(stdout).containsPattern("\\s+generation:[0-9]+");
+ Assertions.assertThat(stdout).containsPattern("heartbeat:[0-9]+");
+ Assertions.assertThat(stdout).containsPattern("STATUS:[0-9]+:NORMAL,"
+ token);
+ Assertions.assertThat(stdout).containsPattern("SCHEMA:.+");
+ Assertions.assertThat(stdout).containsPattern("DC:[0-9]+:datacenter1");
+ Assertions.assertThat(stdout).containsPattern("RACK:[0-9]+:rack1");
+ Assertions.assertThat(stdout).containsPattern("RELEASE_VERSION:.+");
+
Assertions.assertThat(stdout).containsPattern("RPC_ADDRESS:[0-9]+:127.0.0.1");
+ Assertions.assertThat(stdout).containsPattern("NET_VERSION:[0-9]+:.+");
+ Assertions.assertThat(stdout).containsPattern("HOST_ID:[0-9]+:.+");
+
Assertions.assertThat(stdout).containsPattern("NATIVE_ADDRESS_AND_PORT:[0-9]+:127.0.0.1:[0-9]+");
+
Assertions.assertThat(stdout).containsPattern("SSTABLE_VERSIONS:[0-9]+:");
+
Assertions.assertThat(stdout).containsPattern("STATUS_WITH_PORT:[0-9]+:NORMAL,.+");
+
Assertions.assertThat(stdout).containsPattern("TOKENS:[0-9]+:<hidden>");
+
+ // Make sure heartbeats are detected
+ Message<NoPayload> echoMessageOut = Message.out(ECHO_REQ,
NoPayload.noPayload);
+ MessagingService.instance().send(echoMessageOut,
FBUtilities.getBroadcastAddressAndPort());
+
+ String origHeartbeatCount = StringUtils.substringBetween(stdout,
"heartbeat:", "\n");
+ tool = ToolRunner.invokeNodetool("gossipinfo");
+ tool.assertOnCleanExit();
+ String newHeartbeatCount = StringUtils.substringBetween(stdout,
"heartbeat:", "\n");
+
assertThat(Integer.parseInt(origHeartbeatCount)).isLessThanOrEqualTo(Integer.parseInt(newHeartbeatCount));
+ }
+}
diff --git a/test/unit/org/apache/cassandra/tools/NodetoolNetStatsTest.java
b/test/unit/org/apache/cassandra/tools/nodetool/NetStatsTest.java
similarity index 82%
rename from test/unit/org/apache/cassandra/tools/NodetoolNetStatsTest.java
rename to test/unit/org/apache/cassandra/tools/nodetool/NetStatsTest.java
index 7ef2195..330a555 100644
--- a/test/unit/org/apache/cassandra/tools/NodetoolNetStatsTest.java
+++ b/test/unit/org/apache/cassandra/tools/nodetool/NetStatsTest.java
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-package org.apache.cassandra.tools;
+package org.apache.cassandra.tools.nodetool;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
@@ -25,7 +25,6 @@ import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;
-import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -37,44 +36,34 @@ import org.apache.cassandra.net.Message;
import org.apache.cassandra.net.MessagingService;
import org.apache.cassandra.net.NoPayload;
import org.apache.cassandra.schema.TableId;
-import org.apache.cassandra.service.StorageService;
import org.apache.cassandra.streaming.SessionInfo;
import org.apache.cassandra.streaming.StreamSession.State;
import org.apache.cassandra.streaming.StreamSummary;
-import org.apache.cassandra.tools.ToolRunner.ToolResult;
-import org.apache.cassandra.tools.nodetool.NetStats;
+import org.apache.cassandra.tools.ToolRunner;
import org.apache.cassandra.utils.FBUtilities;
-import org.assertj.core.api.Assertions;
-import org.hamcrest.CoreMatchers;
import static org.apache.cassandra.net.Verb.ECHO_REQ;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
@RunWith(OrderedJUnit4ClassRunner.class)
-public class NodetoolNetStatsTest extends CQLTester
+public class NetStatsTest extends CQLTester
{
- private static NodeProbe probe;
-
@BeforeClass
public static void setup() throws Exception
{
- StorageService.instance.initServer();
+ requireNetwork();
startJMXServer();
- probe = new NodeProbe(jmxHost, jmxPort);
- }
-
- @AfterClass
- public static void teardown() throws IOException
- {
- probe.close();
}
@Test
+ @SuppressWarnings("SingleCharacterStringConcatenation")
public void testMaybeChangeDocs()
{
// If you added, modified options or help, please update docs if
necessary
- ToolResult tool = ToolRunner.invokeNodetool("help", "netstats");
- String help = "NAME\n" +
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("help",
"netstats");
+ tool.assertOnCleanExit();
+
+ String help = "NAME\n" +
" nodetool netstats - Print network information
on provided host\n" +
" (connecting node by default)\n" +
"\n" +
@@ -108,8 +97,7 @@ public class NodetoolNetStatsTest extends CQLTester
" Remote jmx agent username\n" +
"\n" +
"\n";
- Assertions.assertThat(tool.getStdout()).isEqualTo(help);
- tool.assertOnCleanExit();
+ assertThat(tool.getStdout()).isEqualTo(help);
}
@Test
@@ -117,10 +105,10 @@ public class NodetoolNetStatsTest extends CQLTester
{
Message<NoPayload> echoMessageOut = Message.out(ECHO_REQ,
NoPayload.noPayload);
MessagingService.instance().send(echoMessageOut,
FBUtilities.getBroadcastAddressAndPort());
-
- ToolResult tool = ToolRunner.invokeNodetool("netstats");
- assertThat(tool.getStdout(), CoreMatchers.containsString("Gossip
messages n/a 0 2 0"));
+
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("netstats");
tool.assertOnCleanExit();
+ assertThat(tool.getStdout()).contains("Gossip messages
n/a 0 2 0");
}
@Test
@@ -140,22 +128,22 @@ public class NodetoolNetStatsTest extends CQLTester
nstats.printReceivingSummaries(out, info, false);
String stdout = getSummariesStdout(baos, out);
- Assertions.assertThat(stdout).doesNotContain("Kib");
+ assertThat(stdout).doesNotContain("Kib");
baos.reset();
nstats.printSendingSummaries(out, info, false);
stdout = getSummariesStdout(baos, out);
- Assertions.assertThat(stdout).doesNotContain("KiB");
+ assertThat(stdout).doesNotContain("Kib");
baos.reset();
nstats.printReceivingSummaries(out, info, true);
stdout = getSummariesStdout(baos, out);
- Assertions.assertThat(stdout).contains("KiB");
+ assertThat(stdout).contains("KiB");
baos.reset();
nstats.printSendingSummaries(out, info, true);
stdout = getSummariesStdout(baos, out);
- Assertions.assertThat(stdout).contains("KiB");
+ assertThat(stdout).contains("KiB");
}
}
diff --git a/test/unit/org/apache/cassandra/tools/nodetool/RingTest.java
b/test/unit/org/apache/cassandra/tools/nodetool/RingTest.java
index 83771f6..5ab492b 100644
--- a/test/unit/org/apache/cassandra/tools/nodetool/RingTest.java
+++ b/test/unit/org/apache/cassandra/tools/nodetool/RingTest.java
@@ -30,13 +30,8 @@ import org.apache.cassandra.locator.SimpleSnitch;
import org.apache.cassandra.service.StorageService;
import org.apache.cassandra.tools.ToolRunner;
import org.apache.cassandra.utils.FBUtilities;
-import org.assertj.core.api.Assertions;
-import static org.hamcrest.CoreMatchers.*;
-import static org.hamcrest.Matchers.matchesPattern;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
@RunWith(OrderedJUnit4ClassRunner.class)
public class RingTest extends CQLTester
@@ -46,9 +41,9 @@ public class RingTest extends CQLTester
@BeforeClass
public static void setup() throws Exception
{
- StorageService.instance.initServer();
- token = StorageService.instance.getTokens().get(0);
+ requireNetwork();
startJMXServer();
+ token = StorageService.instance.getTokens().get(0);
}
/**
@@ -59,27 +54,21 @@ public class RingTest extends CQLTester
{
final HostStatWithPort host = new HostStatWithPort(null,
FBUtilities.getBroadcastAddressAndPort(),
false, null);
- validateRingOutput(host.ipOrDns(false),
- "ring");
- Arrays.asList("-pp", "--print-port").forEach(arg -> {
- validateRingOutput(host.ipOrDns(true),
- "-pp", "ring");
- });
+ validateRingOutput(host.ipOrDns(false), "ring");
+ Arrays.asList("-pp", "--print-port").forEach(arg ->
validateRingOutput(host.ipOrDns(true), "-pp", "ring"));
final HostStatWithPort hostResolved = new HostStatWithPort(null,
FBUtilities.getBroadcastAddressAndPort(),
true, null);
- Arrays.asList("-r", "--resolve-ip").forEach(arg -> {
- validateRingOutput(hostResolved.ipOrDns(false),
- "ring", "-r");
- });
- validateRingOutput(hostResolved.ipOrDns(true),
- "-pp", "ring", "-r");
+ Arrays.asList("-r", "--resolve-ip").forEach(arg ->
+ validateRingOutput(hostResolved.ipOrDns(false), "ring", "-r"));
+ validateRingOutput(hostResolved.ipOrDns(true), "-pp", "ring", "-r");
}
+ @SuppressWarnings("DynamicRegexReplaceableByCompiledPattern")
private void validateRingOutput(String hostForm, String... args)
{
- ToolRunner.ToolResult nodetool = ToolRunner.invokeNodetool(args);
- nodetool.assertOnCleanExit();
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool(args);
+ tool.assertOnCleanExit();
/*
Datacenter: datacenter1
==========
@@ -88,35 +77,37 @@ public class RingTest extends CQLTester
127.0.0.1 rack1 Up Normal 45.71 KiB 100.00%
4652409154190094022
*/
- String[] lines = nodetool.getStdout().split("\\R");
- assertThat(lines[1].trim(), endsWith(SimpleSnitch.DATA_CENTER_NAME));
- assertThat(lines[3], matchesPattern("Address *Rack *Status *State
*Load *Owns *Token *"));
+ String[] lines = tool.getStdout().split("\\R");
+ assertThat(lines[1].trim()).endsWith(SimpleSnitch.DATA_CENTER_NAME);
+ assertThat(lines[3]).containsPattern("Address *Rack *Status *State
*Load *Owns *Token *");
String hostRing = lines[lines.length-4].trim(); // this command has a
couple extra newlines and an empty error message at the end. Not messing with
it.
- assertThat(hostRing, startsWith(hostForm));
- assertThat(hostRing, containsString(SimpleSnitch.RACK_NAME));
- assertThat(hostRing, containsString("Up"));
- assertThat(hostRing, containsString("Normal"));
- assertThat(hostRing, matchesPattern(".*\\d+\\.\\d+ KiB.*"));
- assertThat(hostRing, matchesPattern(".*\\d+\\.\\d+%.*"));
- assertThat(hostRing, endsWith(token));
- assertThat(hostRing, not(containsString("?")));
+ assertThat(hostRing).startsWith(hostForm);
+ assertThat(hostRing).contains(SimpleSnitch.RACK_NAME);
+ assertThat(hostRing).contains("Up");
+ assertThat(hostRing).contains("Normal");
+ assertThat(hostRing).containsPattern("\\d+\\.\\d+ KiB");
+ assertThat(hostRing).containsPattern("\\d+\\.\\d+%");
+ assertThat(hostRing).endsWith(token);
+ assertThat(hostRing).doesNotContain("?");
}
@Test
public void testWrongArgFailsAndPrintsHelp()
{
ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("--wrongarg",
"ring");
- Assertions.assertThat(tool.getStdout()).containsIgnoringCase("nodetool
help");
- assertEquals(1, tool.getExitCode());
- assertTrue(tool.getCleanedStderr().isEmpty());
+ tool.assertCleanStdErr();
+ assertThat(tool.getExitCode()).isEqualTo(1);
+ assertThat(tool.getStdout()).contains("nodetool help");
}
@Test
+ @SuppressWarnings("SingleCharacterStringConcatenation")
public void testMaybeChangeDocs()
{
// If you added, modified options or help, please update docs if
necessary
ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("help", "ring");
+ tool.assertOnCleanExit();
String help = "NAME\n" + " nodetool ring - Print information
about the token ring\n"
+ "\n"
@@ -159,7 +150,7 @@ public class RingTest extends CQLTester
+ " awareness)\n"
+ "\n"
+ "\n";
- Assertions.assertThat(tool.getStdout()).isEqualTo(help);
+ assertThat(tool.getStdout()).isEqualTo(help);
}
@Test
@@ -167,14 +158,12 @@ public class RingTest extends CQLTester
{
// Bad KS
ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("ring",
"mockks");
- Assertions.assertThat(tool.getStdout()).contains("The keyspace mockks,
does not exist");
- assertEquals(0, tool.getExitCode());
- assertTrue(tool.getCleanedStderr().isEmpty());
+ tool.assertOnCleanExit();
+ assertThat(tool.getStdout()).contains("The keyspace mockks, does not
exist");
// Good KS
tool = ToolRunner.invokeNodetool("ring", "system_schema");
- Assertions.assertThat(tool.getStdout()).contains("Datacenter:
datacenter1");
- assertEquals(0, tool.getExitCode());
- assertTrue(tool.getCleanedStderr().isEmpty());
+ tool.assertOnCleanExit();
+ assertThat(tool.getStdout()).contains("Datacenter: datacenter1");
}
}
diff --git a/test/unit/org/apache/cassandra/tools/nodetool/SjkTest.java
b/test/unit/org/apache/cassandra/tools/nodetool/SjkTest.java
index c183edf..9812ef2 100644
--- a/test/unit/org/apache/cassandra/tools/nodetool/SjkTest.java
+++ b/test/unit/org/apache/cassandra/tools/nodetool/SjkTest.java
@@ -26,7 +26,7 @@ public class SjkTest
@Test
public void sjkHelpReturnsRc0()
{
- ToolRunner.ToolResult result = ToolRunner.invokeNodetool("sjk",
"--help");
- result.assertOnExitCode();
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("sjk",
"--help");
+ tool.assertOnExitCode();
}
}
diff --git a/test/unit/org/apache/cassandra/tools/nodetool/StatusTest.java
b/test/unit/org/apache/cassandra/tools/nodetool/StatusTest.java
index f7bc937..494d365 100644
--- a/test/unit/org/apache/cassandra/tools/nodetool/StatusTest.java
+++ b/test/unit/org/apache/cassandra/tools/nodetool/StatusTest.java
@@ -30,9 +30,7 @@ import org.apache.cassandra.service.StorageService;
import org.apache.cassandra.tools.ToolRunner;
import org.apache.cassandra.utils.FBUtilities;
-import static org.hamcrest.CoreMatchers.*;
-import static org.hamcrest.Matchers.matchesPattern;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
@RunWith(OrderedJUnit4ClassRunner.class)
public class StatusTest extends CQLTester
@@ -43,10 +41,10 @@ public class StatusTest extends CQLTester
@BeforeClass
public static void setup() throws Exception
{
- StorageService.instance.initServer();
+ requireNetwork();
+ startJMXServer();
localHostId = StorageService.instance.getLocalHostId();
token = StorageService.instance.getTokens().get(0);
- startJMXServer();
}
/**
@@ -71,6 +69,7 @@ public class StatusTest extends CQLTester
* Validate output, making sure even when bootstrapping any available info
is displayed (c16412)
*/
@Test
+ @SuppressWarnings("DynamicRegexReplaceableByCompiledPattern")
public void testOutputWhileBootstrapping()
{
// Deleting these tables will simulate we're bootstrapping
@@ -78,26 +77,28 @@ public class StatusTest extends CQLTester
schemaChange("DROP KEYSPACE " + CQLTester.KEYSPACE);
schemaChange("DROP KEYSPACE " + CQLTester.KEYSPACE_PER_TEST);
- ToolRunner.ToolResult nodetool = ToolRunner.invokeNodetool("status");
- nodetool.assertOnCleanExit();
- String[] lines = nodetool.getStdout().split("\\R");
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("status");
+ tool.assertOnCleanExit();
+ String[] lines = tool.getStdout().split("\\R");
String hostStatus = lines[lines.length-3].trim();
- assertThat(hostStatus, startsWith("UN"));
- assertThat(hostStatus,
containsString(FBUtilities.getJustLocalAddress().getHostAddress()));
- assertThat(hostStatus, matchesPattern(".*\\d+\\.\\d+ KiB.*"));
- assertThat(hostStatus, containsString(localHostId));
- assertThat(hostStatus, containsString(token));
- assertThat(hostStatus, endsWith(SimpleSnitch.RACK_NAME));
+ assertThat(hostStatus).startsWith("UN");
+
assertThat(hostStatus).contains(FBUtilities.getJustLocalAddress().getHostAddress());
+ assertThat(hostStatus).containsPattern("\\d+\\.\\d+ KiB");
+ assertThat(hostStatus).contains(localHostId);
+ assertThat(hostStatus).contains(token);
+ assertThat(hostStatus).endsWith(SimpleSnitch.RACK_NAME);
- String bootstrappingWarn = lines[lines.length-1].trim();;
- assertThat(bootstrappingWarn, containsString("probably still
bootstrapping. Effective ownership information is meaningless."));
+ String bootstrappingWarn = lines[lines.length-1].trim();
+ assertThat(bootstrappingWarn)
+ .contains("probably still bootstrapping. Effective ownership
information is meaningless.");
}
+ @SuppressWarnings("DynamicRegexReplaceableByCompiledPattern")
private void validateStatusOutput(String hostForm, String... args)
{
- ToolRunner.ToolResult nodetool = ToolRunner.invokeNodetool(args);
- nodetool.assertOnCleanExit();
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool(args);
+ tool.assertOnCleanExit();
/*
Datacenter: datacenter1
=======================
@@ -106,16 +107,16 @@ public class StatusTest extends CQLTester
-- Address Load Owns (effective) Host ID
Token Rack
UN localhost 45.71 KiB 100.0%
0b1b5e91-ad3b-444e-9c24-50578486978a 1849950853373272258 rack1
*/
- String[] lines = nodetool.getStdout().split("\\R");
- assertThat(lines[0].trim(), endsWith(SimpleSnitch.DATA_CENTER_NAME));
+ String[] lines = tool.getStdout().split("\\R");
+ assertThat(lines[0].trim()).endsWith(SimpleSnitch.DATA_CENTER_NAME);
String hostStatus = lines[lines.length-1].trim();
- assertThat(hostStatus, startsWith("UN"));
- assertThat(hostStatus, containsString(hostForm));
- assertThat(hostStatus, matchesPattern(".*\\d+\\.\\d+ KiB.*"));
- assertThat(hostStatus, matchesPattern(".*\\d+\\.\\d+%.*"));
- assertThat(hostStatus, containsString(localHostId));
- assertThat(hostStatus, containsString(token));
- assertThat(hostStatus, endsWith(SimpleSnitch.RACK_NAME));
- assertThat(hostStatus, not(containsString("?")));
+ assertThat(hostStatus).startsWith("UN");
+ assertThat(hostStatus).contains(hostForm);
+ assertThat(hostStatus).containsPattern("\\d+\\.\\d+ KiB");
+ assertThat(hostStatus).containsPattern("\\d+\\.\\d+%");
+ assertThat(hostStatus).contains(localHostId);
+ assertThat(hostStatus).contains(token);
+ assertThat(hostStatus).endsWith(SimpleSnitch.RACK_NAME);
+ assertThat(hostStatus).doesNotContain("?");
}
}
diff --git
a/test/unit/org/apache/cassandra/tools/nodetool/stats/NodetoolTableStatsTest.java
b/test/unit/org/apache/cassandra/tools/nodetool/TableStatsTest.java
similarity index 67%
rename from
test/unit/org/apache/cassandra/tools/nodetool/stats/NodetoolTableStatsTest.java
rename to test/unit/org/apache/cassandra/tools/nodetool/TableStatsTest.java
index a459f0f..ccdb16a 100644
---
a/test/unit/org/apache/cassandra/tools/nodetool/stats/NodetoolTableStatsTest.java
+++ b/test/unit/org/apache/cassandra/tools/nodetool/TableStatsTest.java
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-package org.apache.cassandra.tools.nodetool.stats;
+package org.apache.cassandra.tools.nodetool;
import java.util.ArrayList;
import java.util.Arrays;
@@ -25,39 +25,34 @@ import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang3.StringUtils;
-
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.apache.cassandra.OrderedJUnit4ClassRunner;
import org.apache.cassandra.cql3.CQLTester;
-import org.apache.cassandra.service.StorageService;
import org.apache.cassandra.tools.ToolRunner;
-import org.apache.cassandra.tools.ToolRunner.ToolResult;
-import org.assertj.core.api.Assertions;
-import org.hamcrest.CoreMatchers;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
@RunWith(OrderedJUnit4ClassRunner.class)
-public class NodetoolTableStatsTest extends CQLTester
+public class TableStatsTest extends CQLTester
{
@BeforeClass
public static void setup() throws Exception
{
- StorageService.instance.initServer();
+ requireNetwork();
startJMXServer();
}
@Test
+ @SuppressWarnings("SingleCharacterStringConcatenation")
public void testMaybeChangeDocs()
{
// If you added, modified options or help, please update docs if
necessary
- ToolResult tool = ToolRunner.invokeNodetool("help", "tablestats");
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("help",
"tablestats");
+ tool.assertOnCleanExit();
+
String help = "NAME\n" +
" nodetool tablestats - Print statistics on
tables\n" +
"\n" +
@@ -134,50 +129,41 @@ public class NodetoolTableStatsTest extends CQLTester
" List of tables (or keyspace) names\n" +
"\n" +
"\n";
- Assertions.assertThat(tool.getStdout()).isEqualTo(help);
- tool.assertOnCleanExit();
+ assertThat(tool.getStdout()).isEqualTo(help);
}
@Test
public void testTableStats()
{
- ToolResult tool = ToolRunner.invokeNodetool("tablestats");
-
- assertThat(tool.getStdout(), CoreMatchers.containsString("Keyspace :
system_schema"));
- assertTrue(StringUtils.countMatches(tool.getStdout(), "Table:") > 1);
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("tablestats");
tool.assertOnCleanExit();
+ assertThat(tool.getStdout()).contains("Keyspace : system_schema");
+ assertThat(StringUtils.countMatches(tool.getStdout(),
"Table:")).isGreaterThan(1);
tool = ToolRunner.invokeNodetool("tablestats", "system_distributed");
- assertThat(tool.getStdout(), CoreMatchers.containsString("Keyspace :
system_distributed"));
- assertThat(tool.getStdout(),
CoreMatchers.not(CoreMatchers.containsString("Keyspace : system_schema")));
- assertTrue(StringUtils.countMatches(tool.getStdout(), "Table:") > 1);
tool.assertOnCleanExit();
+ assertThat(tool.getStdout()).contains("Keyspace : system_distributed");
+ assertThat(tool.getStdout()).doesNotContain("Keyspace :
system_schema");
+ assertThat(StringUtils.countMatches(tool.getStdout(),
"Table:")).isGreaterThan(1);
}
@Test
public void testTableIgnoreArg()
{
- ToolResult tool = ToolRunner.invokeNodetool("tablestats", "-i",
"system_schema.aggregates");
-
- assertThat(tool.getStdout(), CoreMatchers.containsString("Keyspace :
system_schema"));
- assertThat(tool.getStdout(),
CoreMatchers.not(CoreMatchers.containsString("Table:
system_schema.aggregates")));
- assertTrue(StringUtils.countMatches(tool.getStdout(), "Table:") > 1);
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("tablestats",
"-i", "system_schema.aggregates");
tool.assertOnCleanExit();
+ assertThat(tool.getStdout()).contains("Keyspace : system_schema");
+ assertThat(tool.getStdout()).doesNotContain("Table:
system_schema.aggregates");
+ assertThat(StringUtils.countMatches(tool.getStdout(),
"Table:")).isGreaterThan(1);
}
@Test
public void testHumanReadableArg()
{
Arrays.asList("-H", "--human-readable").forEach(arg -> {
- ToolResult tool = ToolRunner.invokeNodetool("tablestats", arg);
- assertThat(argFormat(arg), tool.getStdout(),
CoreMatchers.containsString(" KiB"));
- assertTrue(String.format("Expected empty stderr for option [%s]
but found: %s",
- arg,
- tool.getCleanedStderr()),
- tool.getCleanedStderr().isEmpty());
- assertEquals(String.format("Expected exit code 0 for option [%s]
but found: %s", arg, tool.getExitCode()),
- 0,
- tool.getExitCode());
+ ToolRunner.ToolResult tool =
ToolRunner.invokeNodetool("tablestats", arg);
+ tool.assertOnCleanExit();
+ assertThat(tool.getStdout()).contains(" KiB");
});
}
@@ -187,66 +173,57 @@ public class NodetoolTableStatsTest extends CQLTester
Pattern regExp = Pattern.compile("((?m)Table: .*$)");
Arrays.asList("-s", "--sort").forEach(arg -> {
- ToolResult tool = ToolRunner.invokeNodetool("tablestats", arg,
"table_name");
+ ToolRunner.ToolResult tool =
ToolRunner.invokeNodetool("tablestats", arg, "table_name");
Matcher m = regExp.matcher(tool.getStdout());
ArrayList<String> orig = new ArrayList<>();
while (m.find())
orig.add(m.group(1));
tool = ToolRunner.invokeNodetool("tablestats", arg,
"sstable_count");
+ tool.assertOnCleanExit();
m = regExp.matcher(tool.getStdout());
ArrayList<String> sorted = new ArrayList<>();
while (m.find())
sorted.add(m.group(1));
- assertNotEquals(argFormat(arg), orig, sorted);
+ assertThat(sorted).isNotEqualTo(orig);
Collections.sort(orig);
Collections.sort(sorted);
- assertEquals(argFormat(arg), orig, sorted);
- assertTrue(argFormat(arg), tool.getCleanedStderr().isEmpty());
- assertEquals(0, tool.getExitCode());
+ assertThat(sorted).isEqualTo(orig);
});
- ToolResult tool = ToolRunner.invokeNodetool("tablestats", "-s",
"wrongSort");
- assertThat(tool.getStdout(), CoreMatchers.containsString("argument for
sort must be one of"));
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("tablestats",
"-s", "wrongSort");
+ assertThat(tool.getStdout()).contains("argument for sort must be one
of");
tool.assertCleanStdErr();
- assertEquals(1, tool.getExitCode());
+ assertThat(tool.getExitCode()).isEqualTo(1);
}
@Test
public void testTopArg()
{
Arrays.asList("-t", "--top").forEach(arg -> {
- ToolResult tool = ToolRunner.invokeNodetool("tablestats", "-s",
"table_name", arg, "1");
- assertEquals(argFormat(arg),
StringUtils.countMatches(tool.getStdout(), "Table:"), 1);
- assertTrue(argFormat(arg), tool.getCleanedStderr().isEmpty());
- assertEquals(argFormat(arg), 0, tool.getExitCode());
+ ToolRunner.ToolResult tool =
ToolRunner.invokeNodetool("tablestats", "-s", "table_name", arg, "1");
+ tool.assertOnCleanExit();
+ assertThat(StringUtils.countMatches(tool.getStdout(),
"Table:")).isEqualTo(1);
});
- ToolResult tool = ToolRunner.invokeNodetool("tablestats", "-s",
"table_name", "-t", "-1");
- assertThat(tool.getStdout(), CoreMatchers.containsString("argument for
top must be a positive integer"));
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("tablestats",
"-s", "table_name", "-t", "-1");
tool.assertCleanStdErr();
- assertEquals(1, tool.getExitCode());
+ assertThat(tool.getExitCode()).isEqualTo(1);
+ assertThat(tool.getStdout()).contains("argument for top must be a
positive integer");
}
@Test
public void testSSTableLocationCheckArg()
{
Arrays.asList("-l", "--sstable-location-check").forEach(arg -> {
- ToolResult tool = ToolRunner.invokeNodetool("tablestats", arg,
"system.local");
- assertEquals(argFormat(arg),
StringUtils.countMatches(tool.getStdout(), "SSTables in correct location: "),
1);
- assertTrue(argFormat(arg), tool.getCleanedStderr().isEmpty());
- assertEquals(argFormat(arg), 0, tool.getExitCode());
+ ToolRunner.ToolResult tool =
ToolRunner.invokeNodetool("tablestats", arg, "system.local");
+ tool.assertOnCleanExit();
+ assertThat(StringUtils.countMatches(tool.getStdout(), "SSTables in
correct location: ")).isEqualTo(1);
});
- ToolResult tool = ToolRunner.invokeNodetool("tablestats",
"system.local");
- assertThat(tool.getStdout(),
CoreMatchers.not(CoreMatchers.containsString("SSTables in correct location:
")));
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("tablestats",
"system.local");
tool.assertCleanStdErr();
- assertEquals(0, tool.getExitCode());
- }
-
- private String argFormat(String arg)
- {
- return "Arg: [" + arg + ']';
+ assertThat(tool.getStdout()).doesNotContain("SSTables in correct
location: ");
}
}
diff --git a/test/unit/org/apache/cassandra/tools/NodeToolTPStatsTest.java
b/test/unit/org/apache/cassandra/tools/nodetool/TpStatsTest.java
similarity index 69%
rename from test/unit/org/apache/cassandra/tools/NodeToolTPStatsTest.java
rename to test/unit/org/apache/cassandra/tools/nodetool/TpStatsTest.java
index 31423a4..0cbcb49 100644
--- a/test/unit/org/apache/cassandra/tools/NodeToolTPStatsTest.java
+++ b/test/unit/org/apache/cassandra/tools/nodetool/TpStatsTest.java
@@ -16,7 +16,7 @@
* limitations under the License.
*/
-package org.apache.cassandra.tools;
+package org.apache.cassandra.tools.nodetool;
import java.io.IOException;
import java.util.ArrayList;
@@ -26,8 +26,6 @@ import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang3.tuple.Pair;
-
-import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -38,41 +36,33 @@ import org.apache.cassandra.cql3.CQLTester;
import org.apache.cassandra.net.Message;
import org.apache.cassandra.net.MessagingService;
import org.apache.cassandra.net.NoPayload;
-import org.apache.cassandra.tools.ToolRunner.ToolResult;
+import org.apache.cassandra.tools.ToolRunner;
import org.apache.cassandra.utils.FBUtilities;
-import org.assertj.core.api.Assertions;
import org.yaml.snakeyaml.Yaml;
import static org.apache.cassandra.net.Verb.ECHO_REQ;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
@RunWith(OrderedJUnit4ClassRunner.class)
-public class NodeToolTPStatsTest extends CQLTester
+public class TpStatsTest extends CQLTester
{
- private static NodeProbe probe;
@BeforeClass
public static void setup() throws Exception
{
requireNetwork();
startJMXServer();
- probe = new NodeProbe(jmxHost, jmxPort);
- }
-
- @AfterClass
- public static void teardown() throws IOException
- {
- probe.close();
}
@Test
+ @SuppressWarnings("SingleCharacterStringConcatenation")
public void testMaybeChangeDocs()
{
// If you added, modified options or help, please update docs if
necessary
- ToolResult tool = ToolRunner.invokeNodetool("help", "tpstats");
- String help = "NAME\n" +
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("help",
"tpstats");
+ tool.assertOnCleanExit();
+
+ String help = "NAME\n" +
" nodetool tpstats - Print usage statistics of
thread pools\n" +
"\n" +
"SYNOPSIS\n" +
@@ -105,66 +95,64 @@ public class NodeToolTPStatsTest extends CQLTester
" Remote jmx agent username\n" +
"\n" +
"\n";
- Assertions.assertThat(tool.getStdout()).isEqualTo(help);
+ assertThat(tool.getStdout()).isEqualTo(help);
}
@Test
- public void testTPStats() throws Throwable
+ public void testTpStats() throws Throwable
{
- ToolResult tool = ToolRunner.invokeNodetool("tpstats");
- Assertions.assertThat(tool.getStdout()).containsPattern("Pool Name
\\s* Active Pending Completed Blocked All time blocked");
-
Assertions.assertThat(tool.getStdout()).containsIgnoringCase("Latencies waiting
in queue (micros) per dropped message types");
- assertTrue(tool.getCleanedStderr().isEmpty());
- assertEquals(0, tool.getExitCode());
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("tpstats");
+ tool.assertOnCleanExit();
+ String stdout = tool.getStdout();
+ assertThat(stdout).containsPattern("Pool Name \\s+ Active Pending
Completed Blocked All time blocked");
+ assertThat(stdout).contains("Latencies waiting in queue (micros) per
dropped message types");
// Does inserting data alter tpstats?
String nonZeroedThreadsRegExp = "((?m)\\D.*[1-9].*)";
- ArrayList<String> origStats =
getAllGroupMatches(nonZeroedThreadsRegExp, tool.getStdout());
+ ArrayList<String> origStats =
getAllGroupMatches(nonZeroedThreadsRegExp, stdout);
Collections.sort(origStats);
createTable("CREATE TABLE %s (pk int, c int, PRIMARY KEY(pk))");
execute("INSERT INTO %s (pk, c) VALUES (?, ?)", 1, 1);
tool = ToolRunner.invokeNodetool("tpstats");
- assertTrue(tool.getCleanedStderr().isEmpty());
- assertEquals(0, tool.getExitCode());
- ArrayList<String> newStats =
getAllGroupMatches(nonZeroedThreadsRegExp, tool.getStdout());
+ tool.assertOnCleanExit();
+ stdout = tool.getStdout();
+ ArrayList<String> newStats =
getAllGroupMatches(nonZeroedThreadsRegExp, stdout);
Collections.sort(newStats);
- assertNotEquals(origStats, newStats);
+ assertThat(origStats).isNotEqualTo(newStats);
// Does sending a message alter Gossip & ECHO stats?
- String origGossip = getAllGroupMatches("((?m)GossipStage.*)",
tool.getStdout()).get(0);
-
Assertions.assertThat(tool.getStdout()).doesNotContainPattern("ECHO_REQ\\D.*[1-9].*");
-
Assertions.assertThat(tool.getStdout()).doesNotContainPattern("ECHO_RSP\\D.*[1-9].*");
+ String origGossip = getAllGroupMatches("((?m)GossipStage.*)",
stdout).get(0);
+ assertThat(stdout).doesNotContainPattern("ECHO_REQ\\D.*[1-9].*");
+ assertThat(stdout).doesNotContainPattern("ECHO_RSP\\D.*[1-9].*");
Message<NoPayload> echoMessageOut = Message.out(ECHO_REQ,
NoPayload.noPayload);
MessagingService.instance().send(echoMessageOut,
FBUtilities.getBroadcastAddressAndPort());
tool = ToolRunner.invokeNodetool("tpstats");
- assertTrue(tool.getCleanedStderr().isEmpty());
- assertEquals(0, tool.getExitCode());
- String newGossip = getAllGroupMatches("((?m)GossipStage.*)",
tool.getStdout()).get(0);
+ tool.assertOnCleanExit();
+ stdout = tool.getStdout();
+ String newGossip = getAllGroupMatches("((?m)GossipStage.*)",
stdout).get(0);
- assertNotEquals(origGossip, newGossip);
-
Assertions.assertThat(tool.getStdout()).containsPattern("ECHO_REQ\\D.*[1-9].*");
-
Assertions.assertThat(tool.getStdout()).containsPattern("ECHO_RSP\\D.*[1-9].*");
+ assertThat(origGossip).isNotEqualTo(newGossip);
+ assertThat(stdout).containsPattern("ECHO_REQ\\D.*[1-9].*");
+ assertThat(stdout).containsPattern("ECHO_RSP\\D.*[1-9].*");
}
@Test
- public void testFromatArg() throws Throwable
+ public void testFromatArg()
{
Arrays.asList(Pair.of("-F", "json"), Pair.of("--format",
"json")).forEach(arg -> {
- ToolResult tool = ToolRunner.invokeNodetool("tpstats",
arg.getLeft(), arg.getRight());
- assertTrue(isJSONString(tool.getStdout()));
- assertTrue(tool.getCleanedStderr().isEmpty());
- assertEquals(0, tool.getExitCode());
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("tpstats",
arg.getLeft(), arg.getRight());
+ tool.assertOnCleanExit();
+ assertThat(isJSONString(tool.getStdout())).isTrue();
});
Arrays.asList( Pair.of("-F", "yaml"), Pair.of("--format",
"yaml")).forEach(arg -> {
- ToolResult tool = ToolRunner.invokeNodetool("tpstats",
arg.getLeft(), arg.getRight());
- assertTrue(isYAMLString(tool.getStdout()));
- assertTrue(tool.getCleanedStderr().isEmpty());
- assertEquals(0, tool.getExitCode());
+ ToolRunner.ToolResult tool = ToolRunner.invokeNodetool("tpstats",
arg.getLeft(), arg.getRight());
+ tool.assertOnCleanExit();
+ assertThat(isYAMLString(tool.getStdout())).isTrue();
});
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
