diff options
author | Nan Zhou <nanzhoumails@gmail.com> | 2022-09-10 21:11:41 +0300 |
---|---|---|
committer | Nan Zhou <nanzhoumails@gmail.com> | 2022-09-22 02:44:37 +0300 |
commit | c33a039b56fc5789ae71289adaca1e572a48d318 (patch) | |
tree | 8b936ca291537cebebf6bf505e565bff9635f511 /test/include/ibm | |
parent | 6ab9ad5492b9203c7dd8fb3e8c59d37bbc455cde (diff) | |
download | bmcweb-c33a039b56fc5789ae71289adaca1e572a48d318.tar.xz |
treewide: reorganize unit tests
Like other C++ projects, unit tests normally are in a separate repo and
respect the folder structure of the file under test.
This commit deleted all "ut" folder and move tests to a "test" folder.
The test folder also has similar structure as the main folder.
This commit also made neccessary include changes to make codes compile.
Unused tests are untouched.
Tested: unit test passed.
Reference:
[1] https://github.com/grpc/grpc/tree/master/test
[2] https://github.com/boostorg/core/tree/414dfb466878af427d33b36e6ccf84d21c0e081b/test
[3] Many other OpenBMC repos: https://github.com/openbmc/entity-manager/tree/master/test
[4] https://stackoverflow.com/questions/2360734/whats-a-good-directory-structure-for-larger-c-projects-using-makefile
Signed-off-by: Nan Zhou <nanzhoumails@gmail.com>
Change-Id: I4521c7ef5fa03c47cca5c146d322bbb51365ee96
Diffstat (limited to 'test/include/ibm')
-rw-r--r-- | test/include/ibm/configfile_test.cpp | 56 | ||||
-rw-r--r-- | test/include/ibm/lock_test.cpp | 366 |
2 files changed, 422 insertions, 0 deletions
diff --git a/test/include/ibm/configfile_test.cpp b/test/include/ibm/configfile_test.cpp new file mode 100644 index 0000000000..1d95a79066 --- /dev/null +++ b/test/include/ibm/configfile_test.cpp @@ -0,0 +1,56 @@ +#include "http_response.hpp" +#include "ibm/management_console_rest.hpp" + +#include <string> + +#include <gtest/gtest.h> // IWYU pragma: keep + +// IWYU pragma: no_include <gtest/gtest-message.h> +// IWYU pragma: no_include <gtest/gtest-test-part.h> +// IWYU pragma: no_include "gtest/gtest_pred_impl.h" + +namespace crow +{ +namespace ibm_mc +{ + +TEST(IsValidConfigFileName, FileNameValidCharReturnsTrue) +{ + crow::Response res; + + EXPECT_TRUE(isValidConfigFileName("GoodConfigFile", res)); +} +TEST(IsValidConfigFileName, FileNameInvalidCharReturnsFalse) +{ + crow::Response res; + + EXPECT_FALSE(isValidConfigFileName("Bad@file", res)); +} +TEST(IsValidConfigFileName, FileNameInvalidPathReturnsFalse) +{ + crow::Response res; + + EXPECT_FALSE(isValidConfigFileName("/../../../../../etc/badpath", res)); + EXPECT_FALSE(isValidConfigFileName("/../../etc/badpath", res)); + EXPECT_FALSE(isValidConfigFileName("/mydir/configFile", res)); +} + +TEST(IsValidConfigFileName, EmptyFileNameReturnsFalse) +{ + crow::Response res; + EXPECT_FALSE(isValidConfigFileName("", res)); +} + +TEST(IsValidConfigFileName, SlashFileNameReturnsFalse) +{ + crow::Response res; + EXPECT_FALSE(isValidConfigFileName("/", res)); +} +TEST(IsValidConfigFileName, FileNameMoreThan20CharReturnsFalse) +{ + crow::Response res; + EXPECT_FALSE(isValidConfigFileName("BadfileBadfileBadfile", res)); +} + +} // namespace ibm_mc +} // namespace crow diff --git a/test/include/ibm/lock_test.cpp b/test/include/ibm/lock_test.cpp new file mode 100644 index 0000000000..33c5354f64 --- /dev/null +++ b/test/include/ibm/lock_test.cpp @@ -0,0 +1,366 @@ +#include "ibm/locks.hpp" + +#include <cstdint> +#include <memory> +#include <string> +#include <tuple> +#include <utility> +#include <variant> +#include <vector> + +#include <gmock/gmock.h> // IWYU pragma: keep +#include <gtest/gtest.h> // IWYU pragma: keep + +// IWYU pragma: no_include <gtest/gtest-message.h> +// IWYU pragma: no_include <gtest/gtest-test-part.h> +// IWYU pragma: no_include "gtest/gtest_pred_impl.h" + +namespace crow::ibm_mc_lock +{ +namespace +{ + +using SType = std::string; +using LockRequest = std::tuple<SType, SType, SType, uint64_t, SegmentFlags>; +using LockRequests = std::vector<LockRequest>; +using Rc = + std::pair<bool, std::variant<uint32_t, std::pair<uint32_t, LockRequest>>>; +using RcRelaseLock = std::pair<bool, std::pair<uint32_t, LockRequest>>; +using RcGetLockList = + std::variant<std::string, std::vector<std::pair<uint32_t, LockRequests>>>; +using ListOfTransactionIds = std::vector<uint32_t>; +using RcAcquireLock = std::pair<bool, std::variant<Rc, std::pair<bool, int>>>; +using RcReleaseLockApi = std::pair<bool, std::variant<bool, RcRelaseLock>>; +using SessionFlags = std::pair<SType, SType>; +using ListOfSessionIds = std::vector<std::string>; +using ::testing::IsEmpty; + +class LockTest : public ::testing::Test +{ + protected: + LockRequests request; + LockRequests request1, request2; + LockRequest record; + + public: + LockTest() : + // lockrequest with multiple lockrequests + request{{"xxxxx", + "hmc-id", + "Read", + 234, + {{"DontLock", 2}, {"DontLock", 4}}}, + {"xxxxx", + "hmc-id", + "Read", + 234, + {{"DontLock", 2}, {"DontLock", 4}}}}, + request1{{"xxxxx", + "hmc-id", + "Read", + 234, + {{"DontLock", 2}, {"DontLock", 4}}}}, + request2{{"xxxxx", + "hmc-id", + "Write", + 234, + {{"LockAll", 2}, {"DontLock", 4}}}}, + record{ + "xxxxx", "hmc-id", "Read", 234, {{"DontLock", 2}, {"DontLock", 4}}} + {} + + ~LockTest() override = default; + + LockTest(const LockTest&) = delete; + LockTest(LockTest&&) = delete; + LockTest& operator=(const LockTest&) = delete; + LockTest& operator=(const LockTest&&) = delete; +}; + +class MockLock : public crow::ibm_mc_lock::Lock +{ + public: + bool isValidLockRequest(const LockRequest& record1) override + { + bool status = Lock::isValidLockRequest(record1); + return status; + } + bool isConflictRequest(const LockRequests& request) override + { + bool status = Lock::isConflictRequest(request); + return status; + } + Rc isConflictWithTable(const LockRequests& request) override + { + auto conflict = Lock::isConflictWithTable(request); + return conflict; + } + uint32_t generateTransactionId() override + { + uint32_t tid = Lock::generateTransactionId(); + return tid; + } + + bool validateRids(const ListOfTransactionIds& tids) override + { + bool status = Lock::validateRids(tids); + return status; + } + RcRelaseLock isItMyLock(const ListOfTransactionIds& tids, + const SessionFlags& ids) override + { + auto status = Lock::isItMyLock(tids, ids); + return status; + } + friend class LockTest; +}; + +TEST_F(LockTest, ValidationGoodTestCase) +{ + MockLock lockManager; + const LockRequest& t = record; + EXPECT_TRUE(lockManager.isValidLockRequest(t)); +} + +TEST_F(LockTest, ValidationBadTestWithLocktype) +{ + MockLock lockManager; + // Corrupt the lock type + std::get<2>(record) = "rwrite"; + const LockRequest& t = record; + EXPECT_FALSE(lockManager.isValidLockRequest(t)); +} + +TEST_F(LockTest, ValidationBadTestWithlockFlags) +{ + MockLock lockManager; + // Corrupt the lockflag + std::get<4>(record)[0].first = "lock"; + const LockRequest& t = record; + EXPECT_FALSE(lockManager.isValidLockRequest(t)); +} + +TEST_F(LockTest, ValidationBadTestWithSegmentlength) +{ + MockLock lockManager; + // Corrupt the Segment length + std::get<4>(record)[0].second = 7; + const LockRequest& t = record; + EXPECT_FALSE(lockManager.isValidLockRequest(t)); +} + +TEST_F(LockTest, MultiRequestWithoutConflict) +{ + MockLock lockManager; + const LockRequests& t = request; + EXPECT_FALSE(lockManager.isConflictRequest(t)); +} + +TEST_F(LockTest, MultiRequestWithConflictduetoSameSegmentLength) +{ + MockLock lockManager; + // Corrupt the locktype + std::get<2>(request[0]) = "Write"; + // Match the segment lengths to points them to lock similar kind of + // resource + std::get<4>(request[0])[0].first = "LockAll"; + const LockRequests& t = request; + EXPECT_TRUE(lockManager.isConflictRequest(t)); +} + +TEST_F(LockTest, MultiRequestWithoutConflictduetoDifferentSegmentData) +{ + MockLock lockManager; + // Corrupt the locktype + std::get<2>(request[0]) = "Write"; + // Match the segment lengths to points them to lock similar kind of + // resource + std::get<4>(request[0])[0].first = "DontLock"; + std::get<4>(request[0])[1].first = "LockAll"; + + // Change the resource id(2nd byte) of first record, so the locks are + // different so no conflict + std::get<3>(request[0]) = 216179379183550464; // HEX 03 00 06 00 00 00 00 00 + std::get<3>(request[1]) = 288236973221478400; // HEX 04 00 06 00 00 00 00 00 + const LockRequests& t = request; + EXPECT_FALSE(lockManager.isConflictRequest(t)); +} + +TEST_F(LockTest, MultiRequestWithConflictduetoSameSegmentData) +{ + MockLock lockManager; + // Corrupt the locktype + std::get<2>(request[0]) = "Write"; + // Match the segment lengths to points them to lock similar kind of + // resource + std::get<4>(request[0])[0].first = "DontLock"; + std::get<4>(request[0])[1].first = "LockAll"; + // Dont Change the resource id(1st & 2nd byte) at all, so that the + // conflict occurs from the second segment which is trying to lock all + // the resources. + std::get<3>(request[0]) = 216173882346831872; // 03 00 01 00 2B 00 00 00 + std::get<3>(request[1]) = 216173882346831872; // 03 00 01 00 2B 00 00 00 + const LockRequests& t = request; + EXPECT_TRUE(lockManager.isConflictRequest(t)); +} + +TEST_F(LockTest, MultiRequestWithoutConflictduetoDifferentSegmentLength) +{ + MockLock lockManager; + // Corrupt the locktype + std::get<2>(request[0]) = "Write"; + // Match the segment lengths to points them to lock similar kind of + // resource + std::get<4>(request[0])[0].first = "LockSame"; + // Change the segment length , so that the requests are trying to lock + // two different kind of resources + std::get<4>(request[0])[0].second = 3; + const LockRequests& t = request; + // Return No Conflict + EXPECT_FALSE(lockManager.isConflictRequest(t)); +} + +TEST_F(LockTest, MultiRequestWithoutConflictduetoReadLocktype) +{ + MockLock lockManager; + // Match the segment lengths to points them to lock similar kind of + // resource + std::get<4>(request[0])[0].first = "LockAll"; + const LockRequests& t = request; + // Return No Conflict + EXPECT_FALSE(lockManager.isConflictRequest(t)); +} + +TEST_F(LockTest, MultiRequestWithoutConflictduetoReadLocktypeAndLockall) +{ + MockLock lockManager; + // Match the segment lengths to points them to lock similar kind of + // resource + std::get<4>(request[0])[0].first = "LockAll"; + std::get<4>(request[0])[1].first = "LockAll"; + const LockRequests& t = request; + // Return No Conflict + EXPECT_FALSE(lockManager.isConflictRequest(t)); +} + +TEST_F(LockTest, RequestConflictedWithLockTableEntries) +{ + MockLock lockManager; + const LockRequests& t = request1; + auto rc1 = lockManager.isConflictWithTable(t); + // Corrupt the lock type + std::get<2>(request[0]) = "Write"; + // Corrupt the lockflag + std::get<4>(request[0])[1].first = "LockAll"; + const LockRequests& p = request; + auto rc2 = lockManager.isConflictWithTable(p); + // Return a Conflict + EXPECT_TRUE(rc2.first); +} + +TEST_F(LockTest, RequestNotConflictedWithLockTableEntries) +{ + MockLock lockManager; + const LockRequests& t = request1; + // Insert the request1 into the lock table + auto rc1 = lockManager.isConflictWithTable(t); + // Corrupt the lock type + std::get<2>(request[0]) = "Read"; + // Corrupt the lockflag + std::get<4>(request[0])[1].first = "LockAll"; + const LockRequests& p = request; + auto rc2 = lockManager.isConflictWithTable(p); + // Return No Conflict + EXPECT_FALSE(rc2.first); +} + +TEST_F(LockTest, TestGenerateTransactionIDFunction) +{ + MockLock lockManager; + uint32_t transactionId1 = lockManager.generateTransactionId(); + uint32_t transactionId2 = lockManager.generateTransactionId(); + EXPECT_EQ(transactionId2, ++transactionId1); +} + +TEST_F(LockTest, ValidateTransactionIDsGoodTestCase) +{ + MockLock lockManager; + const LockRequests& t = request1; + // Insert the request1 into the lock table + auto rc1 = lockManager.isConflictWithTable(t); + std::vector<uint32_t> tids = {1}; + const std::vector<uint32_t>& p = tids; + EXPECT_TRUE(lockManager.validateRids(p)); +} + +TEST_F(LockTest, ValidateTransactionIDsBadTestCase) +{ + MockLock lockManager; + // Insert the request1 into the lock table + const LockRequests& t = request1; + auto rc1 = lockManager.isConflictWithTable(t); + std::vector<uint32_t> tids = {10}; + const std::vector<uint32_t>& p = tids; + EXPECT_FALSE(lockManager.validateRids(p)); +} + +TEST_F(LockTest, ValidateisItMyLockGoodTestCase) +{ + MockLock lockManager; + // Insert the request1 into the lock table + const LockRequests& t = request1; + auto rc1 = lockManager.isConflictWithTable(t); + std::vector<uint32_t> tids = {1}; + const std::vector<uint32_t>& p = tids; + std::string hmcid = "hmc-id"; + std::string sessionid = "xxxxx"; + std::pair<SType, SType> ids = std::make_pair(hmcid, sessionid); + auto rc = lockManager.isItMyLock(p, ids); + EXPECT_TRUE(rc.first); +} + +TEST_F(LockTest, ValidateisItMyLockBadTestCase) +{ + MockLock lockManager; + // Corrupt the client identifier + std::get<1>(request1[0]) = "randomid"; + // Insert the request1 into the lock table + const LockRequests& t = request1; + auto rc1 = lockManager.isConflictWithTable(t); + std::vector<uint32_t> tids = {1}; + const std::vector<uint32_t>& p = tids; + std::string hmcid = "hmc-id"; + std::string sessionid = "random"; + std::pair<SType, SType> ids = std::make_pair(hmcid, sessionid); + auto rc = lockManager.isItMyLock(p, ids); + EXPECT_FALSE(rc.first); +} + +TEST_F(LockTest, ValidateSessionIDForGetlocklistBadTestCase) +{ + MockLock lockManager; + // Insert the request1 into the lock table + const LockRequests& t = request1; + auto rc1 = lockManager.isConflictWithTable(t); + std::vector<std::string> sessionid = {"random"}; + auto status = lockManager.getLockList(sessionid); + auto result = + std::get<std::vector<std::pair<uint32_t, LockRequests>>>(status); + EXPECT_THAT(result, IsEmpty()); +} + +TEST_F(LockTest, ValidateSessionIDForGetlocklistGoodTestCase) +{ + MockLock lockManager; + // Insert the request1 into the lock table + const LockRequests& t = request1; + auto rc1 = lockManager.isConflictWithTable(t); + std::vector<std::string> sessionid = {"xxxxx"}; + auto status = lockManager.getLockList(sessionid); + auto result = + std::get<std::vector<std::pair<uint32_t, LockRequests>>>(status); + EXPECT_EQ(result.size(), 1); +} + +} // namespace +} // namespace crow::ibm_mc_lock |