HDFS-16265. Refactor HDFS tool tests for better reuse

hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/tools/CMakeLists.txt

@@ -16,7 +16,20 @@
 # limitations under the License.
 #
 
-add_executable(hdfs_tool_test hdfs-allow-snapshot-mock.cc hdfs-cat-mock.cc hdfs-tool-test.cc main.cc)
-target_include_directories(hdfs_tool_test PRIVATE ../tools ../../tools ../../tools/hdfs-allow-snapshot ../../tools/hdfs-cat)
-target_link_libraries(hdfs_tool_test PRIVATE gmock_main hdfs_allowSnapshot_lib hdfs_cat_lib)
-add_test(hdfs_tool_test hdfs_tool_test)
+add_executable(hdfs_tool_tests
+                hdfs-allow-snapshot-mock.cc
+                hdfs-cat-mock.cc
+                hdfs-tool-test-fixtures.cc
+                hdfs-tool-tests.cc
+                main.cc)
+target_include_directories(hdfs_tool_tests PRIVATE
+                            ../tools
+                            ../../tools
+                            ../../tools/hdfs-allow-snapshot
+                            ../../tools/hdfs-delete-snapshot
+                            ../../tools/hdfs-cat)
+target_link_libraries(hdfs_tool_tests PRIVATE
+                       gmock_main
+                       hdfs_allowSnapshot_lib
+                       hdfs_cat_lib)
+add_test(hdfs_tool_tests hdfs_tool_tests)

hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/tools/hdfs-allow-snapshot-mock.cc

@@ -17,8 +17,40 @@
   under the License.
 */
 
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
 #include "hdfs-allow-snapshot-mock.h"
+#include "hdfs-tool-tests.h"
 
 namespace hdfs::tools::test {
-AllowSnapshotMock::~AllowSnapshotMock() {}
-} // namespace hdfs::tools::test
+AllowSnapshotMock::~AllowSnapshotMock() = default;
+
+void AllowSnapshotMock::SetExpectations(
+    std::function<std::unique_ptr<AllowSnapshotMock>()> test_case,
+    const std::vector<std::string> &args) const {
+  // Get the pointer to the function that defines the test case
+  const auto test_case_func =
+      test_case.target<std::unique_ptr<AllowSnapshotMock> (*)()>();
+  ASSERT_NE(test_case_func, nullptr);
+
+  // Set the expected method calls and their corresponding arguments for each
+  // test case
+  if (*test_case_func == &CallHelp<AllowSnapshotMock>) {
+    EXPECT_CALL(*this, HandleHelp()).Times(1).WillOnce(testing::Return(true));
+    return;
+  }
+
+  if (*test_case_func == &PassAPath<AllowSnapshotMock>) {
+    const auto arg1 = args[0];
+    EXPECT_CALL(*this, HandlePath(arg1))
+        .Times(1)
+        .WillOnce(testing::Return(true));
+  }
+}
+} // namespace hdfs::tools::test

hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/tools/hdfs-allow-snapshot-mock.h

@@ -19,7 +19,10 @@
 #ifndef LIBHDFSPP_TOOLS_HDFS_ALLOW_SNAPSHOT_MOCK
 #define LIBHDFSPP_TOOLS_HDFS_ALLOW_SNAPSHOT_MOCK
 
+#include <functional>
+#include <memory>
 #include <string>
+#include <vector>
 
 #include <gmock/gmock.h>
 
@@ -44,6 +47,18 @@ class AllowSnapshotMock : public hdfs::tools::AllowSnapshot {
   AllowSnapshotMock &operator=(AllowSnapshotMock &&) = delete;
   ~AllowSnapshotMock() override;
 
+  /**
+   * Defines the methods and the corresponding arguments that are expected
+   * to be called on this instance of {@link HdfsTool} for the given test case.
+   *
+   * @param test_case An {@link std::function} object that points to the
+   * function defining the test case
+   * @param args The arguments that are passed to this test case
+   */
+  void
+  SetExpectations(std::function<std::unique_ptr<AllowSnapshotMock>()> test_case,
+                  const std::vector<std::string> &args = {}) const;
+
   MOCK_METHOD(bool, HandleHelp, (), (const, override));
 
   MOCK_METHOD(bool, HandlePath, (const std::string &), (const, override));

hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/tools/hdfs-cat-mock.cc

@@ -16,8 +16,40 @@
  * limitations under the License.
  */
 
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
 #include "hdfs-cat-mock.h"
+#include "hdfs-tool-tests.h"
 
 namespace hdfs::tools::test {
-CatMock::~CatMock() {}
+CatMock::~CatMock() = default;
+
+void CatMock::SetExpectations(
+    std::function<std::unique_ptr<CatMock>()> test_case,
+    const std::vector<std::string> &args) const {
+  // Get the pointer to the function that defines the test case
+  const auto test_case_func =
+      test_case.target<std::unique_ptr<CatMock> (*)()>();
+  ASSERT_NE(test_case_func, nullptr);
+
+  // Set the expected method calls and their corresponding arguments for each
+  // test case
+  if (*test_case_func == &CallHelp<CatMock>) {
+    EXPECT_CALL(*this, HandleHelp()).Times(1).WillOnce(testing::Return(true));
+    return;
+  }
+
+  if (*test_case_func == &PassAPath<CatMock>) {
+    const auto arg1 = args[0];
+    EXPECT_CALL(*this, HandlePath(arg1))
+        .Times(1)
+        .WillOnce(testing::Return(true));
+  }
+}
 } // namespace hdfs::tools::test

hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/tools/hdfs-cat-mock.h

@@ -19,7 +19,10 @@
 #ifndef LIBHDFSPP_TOOLS_HDFS_CAT_MOCK
 #define LIBHDFSPP_TOOLS_HDFS_CAT_MOCK
 
+#include <functional>
+#include <memory>
 #include <string>
+#include <vector>
 
 #include <gmock/gmock.h>
 
@@ -44,6 +47,17 @@ class CatMock : public hdfs::tools::Cat {
   CatMock &operator=(CatMock &&) = delete;
   ~CatMock() override;
 
+  /**
+   * Defines the methods and the corresponding arguments that are expected
+   * to be called on this instance of {@link HdfsTool} for the given test case.
+   *
+   * @param test_case An {@link std::function} object that points to the
+   * function defining the test case
+   * @param args The arguments that are passed to this test case
+   */
+  void SetExpectations(std::function<std::unique_ptr<CatMock>()> test_case,
+                       const std::vector<std::string> &args = {}) const;
+
   MOCK_METHOD(bool, HandleHelp, (), (const, override));
 
   MOCK_METHOD(bool, HandlePath, (const std::string &), (const, override));

hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/tools/hdfs-tool-test-fixtures.cc

@@ -0,0 +1,41 @@
+/*
+  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.
+*/
+
+#include <tuple>
+
+#include <gtest/gtest.h>
+
+#include "hdfs-tool-test-fixtures.h"
+
+/**
+ * Implementing virtual destructors out-of-line to avoid bulky v-table entries.
+ */
+HdfsToolBasicTest::~HdfsToolBasicTest() = default;
+HdfsToolNegativeTestThrows::~HdfsToolNegativeTestThrows() = default;
+HdfsToolNegativeTestNoThrow::~HdfsToolNegativeTestNoThrow() = default;
+
+TEST_P(HdfsToolBasicTest, RunTool) { EXPECT_TRUE(this->hdfs_tool_->Do()); }
+
+TEST_P(HdfsToolNegativeTestNoThrow, RunTool) {
+  EXPECT_FALSE(this->hdfs_tool_->Do());
+}
+
+TEST_P(HdfsToolNegativeTestThrows, RunTool) {
+  EXPECT_ANY_THROW({ std::ignore = this->hdfs_tool_->Do(); });
+}

hadoop-hdfs-project/hadoop-hdfs-native-client/src/main/native/libhdfspp/tests/tools/hdfs-tool-test-fixtures.h

@@ -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.
+*/
+
+#ifndef LIBHDFSPP_TOOLS_HDFS_TOOL_TEST_FIXTURES
+#define LIBHDFSPP_TOOLS_HDFS_TOOL_TEST_FIXTURES
+
+#include <functional>
+#include <memory>
+
+#include <gtest/gtest.h>
+
+#include "hdfs-tool.h"
+
+/**
+ * {@class HdfsToolBasicTest} is a fixture that houses basic tests on {@link
+ * hdfs::tools::HdfsTool} interface. It contains the "Happy path" tests which
+ * covers the scenarios where {@link hdfs::tools::HdfsTool} is expected to
+ * work just fine.
+ *
+ * {@class HdfsToolBasicTest} is parameterized on a lambda returning an instance
+ * of {@link hdfs::tools::HdfsTool} wrapped in a std::unique_ptr. We then run
+ * the tests on this instance. Each test runs in isolation. So, a new instance
+ * is created for each test.
+ */
+class HdfsToolBasicTest
+    : public testing::TestWithParam<
+          std::function<std::unique_ptr<hdfs::tools::HdfsTool>()>> {
+public:
+  // Abiding to the rule of 5
+  HdfsToolBasicTest() = default;
+  HdfsToolBasicTest(const HdfsToolBasicTest &) = delete;
+  HdfsToolBasicTest(HdfsToolBasicTest &&) = delete;
+  HdfsToolBasicTest &operator=(const HdfsToolBasicTest &) = delete;
+  HdfsToolBasicTest &operator=(HdfsToolBasicTest &&) = delete;
+  ~HdfsToolBasicTest() override;
+
+protected:
+  void SetUp() override { hdfs_tool_ = GetParam()(); }
+
+  std::unique_ptr<hdfs::tools::HdfsTool> hdfs_tool_{nullptr};
+};
+
+/**
+ * {@class HdfsToolNegativeTestThrows} is a fixture that houses negative tests
+ * on {@link hdfs::tools::HdfsTool} interface. It covers the tests where
+ * unfavorable inputs are presented to the {@link hdfs::tools::HdfsTool}
+ * instance and is expected to throw exceptions. Regardless, the tool is not
+ * expected to crash and ensures that the thrown exceptions are handled
+ * gracefully.
+ */
+class HdfsToolNegativeTestThrows : public HdfsToolBasicTest {
+public:
+  // Abiding to the rule of 5
+  HdfsToolNegativeTestThrows() = default;
+  HdfsToolNegativeTestThrows(const HdfsToolNegativeTestThrows &) = delete;
+  HdfsToolNegativeTestThrows(HdfsToolNegativeTestThrows &&) = delete;
+  HdfsToolNegativeTestThrows &
+  operator=(const HdfsToolNegativeTestThrows &) = delete;
+  HdfsToolNegativeTestThrows &operator=(HdfsToolNegativeTestThrows &&) = delete;
+  ~HdfsToolNegativeTestThrows() override;
+};
+
+/**
+ * {@class HdfsToolNegativeTestNoThrow} is a fixture that houses negative
+ * tests on {@link hdfs::tools::HdfsTool} interface. It covers the tests where
+ * unfavorable inputs are presented to the {@link hdfs::tools::HdfsTool}
+ * instance and is not expected to throw exceptions and returns false instead.
+ * The tool is not expected to crash and ensures that the unfavorable inputs are
+ * handled gracefully.
+ */
+class HdfsToolNegativeTestNoThrow : public HdfsToolBasicTest {
+public:
+  // Abiding to the rule of 5
+  HdfsToolNegativeTestNoThrow() = default;
+  HdfsToolNegativeTestNoThrow(const HdfsToolNegativeTestNoThrow &) = delete;
+  HdfsToolNegativeTestNoThrow(HdfsToolNegativeTestNoThrow &&) = delete;
+  HdfsToolNegativeTestNoThrow &
+  operator=(const HdfsToolNegativeTestNoThrow &) = delete;
+  HdfsToolNegativeTestNoThrow &
+  operator=(HdfsToolNegativeTestNoThrow &&) = delete;
+  ~HdfsToolNegativeTestNoThrow() override;
+};
+
+#endif