Redo unit tests for ListResponse in ProtocolAdmin

Change-Id: Ib012cc489597013c1b1af260d1c890af17e6673e

diff --git a/test/common/protocols/TestDataCollection.h b/test/common/protocols/TestDataCollection.h
index 57eae825f88db2a69509b7b2515ed6284974c6a4..7896e879596d367bb5efb1f20d6f3dab98998eee 100644 (file)
--- a/test/common/protocols/TestDataCollection.h
+++ b/test/common/protocols/TestDataCollection.h
@@ -158,6 +158,14 @@ typedef NumericDataCollection<std::vector<Cynara::PolicyDescription>::size_type,
 
 } /* namespace Descriptions */
 
+namespace Policies {
+
+typedef NumericDataCollection<std::vector<Cynara::Policy>::size_type,
+                              0,
+                              CYNARA_MAX_VECTOR_SIZE> Size;
+
+} /* namespace Policies */
+
 namespace Times {
 
 typedef NumericDataCollection<time_t, 0> Sec;

diff --git a/test/common/protocols/admin/listresponse.cpp b/test/common/protocols/admin/listresponse.cpp
index 2490dc217224093f81d93ee81cc5e7a8ed8e09de..3f0845400b1ba57d9e30f73839af882bd28ca4d7 100644 (file)
--- a/test/common/protocols/admin/listresponse.cpp
+++ b/test/common/protocols/admin/listresponse.cpp
@@ -34,6 +34,8 @@
 #include <response/ListResponse.h>
 #include <types/Policy.h>
 
+#include <CommonsTestHelper.h>
+#include <NegativeTestHelper.h>
 #include <ResponseTestHelper.h>
 #include <TestDataCollection.h>
 
@@ -46,251 +48,126 @@ void compare(const Cynara::ListResponse &resp1, const Cynara::ListResponse &resp
     EXPECT_EQ(resp1.isDbCorrupted(), resp2.isDbCorrupted());
 }
 
-static const bool VALID_BUCKET = true;
-static const bool NO_BUCKET = false;
-static const bool DB_OK = false;
-static const bool DB_CORRUPTED = true;
+std::vector<Cynara::Policy> genPolicies(std::vector<Cynara::Policy>::size_type size) {
+    auto &keys = TestDataCollection::Keys::all;
+    auto keysSize = std::size(keys);
+    auto &results = TestDataCollection::Results::all;
+    auto resultsSize = std::size(results);
+    return generate<Cynara::Policy>(size,
+        [&](int i, std::vector<Cynara::Policy>::size_type size) {
+            auto index = size - 1 + i;
+            return Cynara::Policy(keys[index % keysSize], results[index % resultsSize]);
+        });
+}
 
 } /* namespace anonymous */
 
 using namespace Cynara;
+using namespace NegativeTestHelper;
 using namespace ResponseTestHelper;
 using namespace TestDataCollection;
 
 /* *** compare by objects test cases *** */
 
-TEST(ProtocolAdmin, ListResponse01) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_nun, Results::allow),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::min);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponse02) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_cup, Results::deny),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::min_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponse03) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_www, Results::bucket_empty),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::min_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponse04) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_wuw, Results::bucket_not_empty),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::max);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponse05) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_aaa, Results::none),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::max_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponse06) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_wua, Results::plugin_1),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::max_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponse07) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_nua, Results::plugin_2),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::mid);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponseMultiplePolicies) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_nun, Results::allow),
-        Policy(Keys::k_cup, Results::deny),
-        Policy(Keys::k_www, Results::bucket_empty),
-        Policy(Keys::k_wuw, Results::bucket_not_empty),
-        Policy(Keys::k_aaa, Results::none),
-        Policy(Keys::k_wua, Results::plugin_1),
-        Policy(Keys::k_nua, Results::plugin_2),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::min);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponseEmptyPolicies) {
-    std::vector<Policy> policies;
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::min_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponseNoBucket) {
-    std::vector<Policy> policies;
-
-    auto response = std::make_shared<ListResponse>(policies, NO_BUCKET, DB_OK, SN::min_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testResponse(response, protocol);
-}
-
-/**
- * @brief   Verify if ListResponse is properly (de)serialized while database is corrupted
- * @test    Expected result:
- * - policies vector is empty
- * - bucketValid flag set to false (NO_BUCKET)
- * - dbCorrupted flag set to true (DB_CORRUPTED)
- */
-TEST(ProtocolAdmin, ListResponseDatabaseCorrupted) {
-    std::vector<Policy> policies;
-
-    auto response = std::make_shared<ListResponse>(policies, NO_BUCKET, DB_CORRUPTED, SN::max);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testResponse(response, protocol);
+TEST(ProtocolAdmin, ListResponsePositive) {
+    for (auto &size : Policies::Size::all) {
+        auto policies = genPolicies(size);
+        for (auto &bucket : Admin::BucketStatus::all) {
+            for (auto &db : Admin::DBStatus::all) {
+                for (auto &sequenceNumber : SN::all) {
+                    auto response = std::make_shared<ListResponse>
+                        (policies, bucket, db, sequenceNumber);
+                    auto protocol = std::make_shared<ProtocolAdmin>();
+                    testResponse(response, protocol);
+                }
+            }
+        }
+    }
 }
 
 /* *** compare by serialized data test cases *** */
 
-TEST(ProtocolAdmin, ListResponseBinary01) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_nun, Results::allow),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::min);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponseBinary02) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_cup, Results::deny),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::min_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponseBinary03) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_www, Results::bucket_empty),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::min_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponseBinary04) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_wuw, Results::bucket_not_empty),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::max);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponseBinary05) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_aaa, Results::none),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::max_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponseBinary06) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_wua, Results::plugin_1),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::max_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponseBinary07) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_nua, Results::plugin_2),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::mid);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponseBinaryMultiplePolicies) {
-    std::vector<Policy> policies = {
-        Policy(Keys::k_nun, Results::allow),
-        Policy(Keys::k_cup, Results::deny),
-        Policy(Keys::k_www, Results::bucket_empty),
-        Policy(Keys::k_wuw, Results::bucket_not_empty),
-        Policy(Keys::k_aaa, Results::none),
-        Policy(Keys::k_wua, Results::plugin_1),
-        Policy(Keys::k_nua, Results::plugin_2),
-    };
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::min);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponseBinaryEmptyPolicies) {
-    std::vector<Policy> policies;
-
-    auto response = std::make_shared<ListResponse>(policies, VALID_BUCKET, DB_OK, SN::min_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestResponse(response, protocol);
-}
-
-TEST(ProtocolAdmin, ListResponseBinaryNoBucket) {
-    std::vector<Policy> policies;
-
-    auto response = std::make_shared<ListResponse>(policies, NO_BUCKET, DB_OK, SN::min_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestResponse(response, protocol);
-}
-
-/**
- * @brief   Verify if ListResponse is properly (de)serialized while database is corrupted
- * @test    Expected result:
- * - policies vector is empty
- * - bucketValid flag set to false (NO_BUCKET)
- * - dbCorrupted flag set to true (DB_CORRUPTED)
- */
-TEST(ProtocolAdmin, ListResponseBinaryDatabaseCorrupted) {
-    std::vector<Policy> policies;
-
-    auto response = std::make_shared<ListResponse>(policies, NO_BUCKET, DB_CORRUPTED, SN::max);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestResponse(response, protocol);
+TEST(ProtocolAdmin, ListResponseBinaryPositive) {
+    for (auto &size : Policies::Size::all) {
+        auto policies = genPolicies(size);
+        for (auto &bucket : Admin::BucketStatus::all) {
+            for (auto &db : Admin::DBStatus::all) {
+                for (auto &sequenceNumber : SN::all) {
+                    auto response = std::make_shared<ListResponse>
+                        (policies, bucket, db, sequenceNumber);
+                    auto protocol = std::make_shared<ProtocolAdmin>();
+                    binaryTestResponse(response, protocol);
+                }
+            }
+        }
+    }
+}
+
+/* *** invalid protocol tests for too long strings *** */
+
+TEST(ProtocolAdmin, ListResponseTooLongClientNegative) {
+    PKF tooLongClient = PKF::create(std::string(CYNARA_MAX_ID_LENGTH + 1, 'c'));
+    PolicyKey key(tooLongClient, Keys::k_nun.user(), Keys::k_aaa.privilege());
+
+    auto policies = genPolicies(Policies::Size::min_2);
+    policies.emplace_back(key, Results::allow);
+
+    for (auto &bucket : Admin::BucketStatus::all) {
+        for (auto &db : Admin::DBStatus::all) {
+            for (auto &sequenceNumber : SN::all) {
+                testInvalidProtocol<ProtocolAdmin, ListResponse>
+                    (policies, bucket, db, sequenceNumber);
+            }
+        }
+    }
+}
+
+TEST(ProtocolAdmin, ListResponseTooLongUserNegative) {
+    PKF tooLongUser = PKF::create(std::string(CYNARA_MAX_ID_LENGTH + 1, 'u'));
+    PolicyKey key(Keys::k_wwp.client(), tooLongUser, Keys::k_cup2.privilege());
+
+    auto policies = genPolicies(Policies::Size::mid);
+    policies.emplace_back(key, Results::deny);
+
+    for (auto &bucket : Admin::BucketStatus::all) {
+        for (auto &db : Admin::DBStatus::all) {
+            for (auto &sequenceNumber : SN::all) {
+                testInvalidProtocol<ProtocolAdmin, ListResponse>
+                    (policies, bucket, db, sequenceNumber);
+            }
+        }
+    }
+}
+
+TEST(ProtocolAdmin, ListResponseTooLongPrivilegeNegative) {
+    PKF tooLongPrivilege = PKF::create(std::string(CYNARA_MAX_ID_LENGTH + 1, 'p'));
+    PolicyKey key(Keys::k_wua.client(), Keys::k_aup.user(), tooLongPrivilege);
+
+    auto policies = genPolicies(Policies::Size::min);
+    policies.emplace_back(key, Results::plugin_1);
+
+    for (auto &bucket : Admin::BucketStatus::all) {
+        for (auto &db : Admin::DBStatus::all) {
+            for (auto &sequenceNumber : SN::all) {
+                testInvalidProtocol<ProtocolAdmin, ListResponse>
+                    (policies, bucket, db, sequenceNumber);
+            }
+        }
+    }
+}
+
+TEST(ProtocolAdmin, ListResponseTooLongMetadataNegative) {
+    auto policies = genPolicies(Policies::Size::min);
+    policies.emplace_back(Keys::k_cup2,
+                          PolicyResult(Types::plugin_type,
+                                       std::string(CYNARA_MAX_ID_LENGTH + 1, 'm')));
+
+    for (auto &bucket : Admin::BucketStatus::all) {
+        for (auto &db : Admin::DBStatus::all) {
+            for (auto &sequenceNumber : SN::all) {
+                testInvalidProtocol<ProtocolAdmin, ListResponse>
+                    (policies, bucket, db, sequenceNumber);
+            }
+        }
+    }
 }