Redo unit tests for AdminCheckRequest in ProtocolAdmin

* squash positive test cases
* add invalid protocol test cases

Change-Id: Icfbceb6ba42d3ebf96855caf7a44482058fbb883

diff --git a/test/common/protocols/TestDataCollection.h b/test/common/protocols/TestDataCollection.h
index a1192a7678383edf9e979a3777690a6a1011ddb8..3212d0b1d10f47f6584aac67e9aca707f34f5126 100644 (file)
--- a/test/common/protocols/TestDataCollection.h
+++ b/test/common/protocols/TestDataCollection.h
@@ -175,6 +175,20 @@ typedef NumericDataCollection<Cynara::RawBuffer::value_type> Data;
 
 } /* namespace Buffer */
 
+namespace Admin {
+
+namespace Recursive {
+
+const bool recursive = true;
+const bool nonrecursive = false;
+const bool all[] = {
+    recursive, nonrecursive
+};
+
+} /* namespace Recursive */
+
+} /* namespace Admin */
+
 } /* namespace TestDataCollection */
 } /* namespace anonymous */
 

diff --git a/test/common/protocols/admin/admincheckrequest.cpp b/test/common/protocols/admin/admincheckrequest.cpp
index 709e7a32021ccbf016a7bfdb156deec84f06d9c4..36c622c2debbf2796acdccdc05eeab6034cd46a7 100644 (file)
--- a/test/common/protocols/admin/admincheckrequest.cpp
+++ b/test/common/protocols/admin/admincheckrequest.cpp
@@ -30,6 +30,7 @@
 #include <protocol/ProtocolAdmin.h>
 #include <request/AdminCheckRequest.h>
 
+#include <NegativeTestHelper.h>
 #include <RequestTestHelper.h>
 #include <TestDataCollection.h>
 
@@ -42,113 +43,93 @@ void compare(const Cynara::AdminCheckRequest &req1, const Cynara::AdminCheckRequ
     EXPECT_EQ(req1.recursive(), req2.recursive());
 }
 
-static const bool RECURSIVE = true;
-static const bool NON_RECURSIVE = false;
-
 } /* anonymous namespace */
 
 using namespace Cynara;
+using namespace NegativeTestHelper;
 using namespace RequestTestHelper;
 using namespace TestDataCollection;
 
 /* *** compare by objects test cases *** */
 
-TEST(ProtocolAdmin, AdminCheckRequest01) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_nun, Buckets::empty, RECURSIVE,
-                                                       SN::min);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, AdminCheckRequest02) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_cup, Buckets::not_empty, RECURSIVE,
-                                                       SN::min_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
+TEST(ProtocolAdmin, AdminCheckRequestPositive) {
+    for (auto &key : Keys::all) {
+        for (auto &bucket : Buckets::all) {
+            for (auto &recursive : Admin::Recursive::all) {
+                for (auto &sequenceNumber : SN::all) {
+                    auto request = std::make_shared<AdminCheckRequest>
+                        (key, bucket, recursive, sequenceNumber);
+                    auto protocol = std::make_shared<ProtocolAdmin>();
+                    testRequest(request, protocol);
+                }
+            }
+        }
+    }
 }
 
-TEST(ProtocolAdmin, AdminCheckRequest03) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_www, Buckets::empty, NON_RECURSIVE,
-                                                       SN::min_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
+TEST(ProtocolAdmin, AdminCheckRequestBinaryPositive) {
+    for (auto &key : Keys::all) {
+        for (auto &bucket : Buckets::all) {
+            for (auto &recursive : Admin::Recursive::all) {
+                for (auto &sequenceNumber : SN::all) {
+                    auto request = std::make_shared<AdminCheckRequest>
+                        (key, bucket, recursive, sequenceNumber);
+                    auto protocol = std::make_shared<ProtocolAdmin>();
+                    binaryTestRequest(request, protocol);
+                }
+            }
+        }
+    }
 }
 
-TEST(ProtocolAdmin, AdminCheckRequest04) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_wuw, Buckets::not_empty,
-                                                       NON_RECURSIVE, SN::max);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
+TEST(ProtocolAdmin, AdminCheckRequestTooLongClientNegative) {
+    PKF tooLongClient = PKF::create(std::string(CYNARA_MAX_ID_LENGTH + 1, 'c'));
+    PolicyKey key(tooLongClient, Keys::k_aaa.user(), Keys::k_cww.privilege());
+    for (auto &bucket : Buckets::all) {
+        for (auto &recursive : Admin::Recursive::all) {
+            for (auto &sequenceNumber : SN::all) {
+                testInvalidProtocol<ProtocolAdmin, AdminCheckRequest>
+                    (key, bucket, recursive, sequenceNumber);
+            }
+        }
+    }
 }
 
-TEST(ProtocolAdmin, AdminCheckRequest05) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_aaa, Buckets::empty, RECURSIVE,
-                                                       SN::max_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
+TEST(ProtocolAdmin, AdminCheckRequestTooLongUserNegative) {
+    PKF tooLongUser = PKF::create(std::string(CYNARA_MAX_ID_LENGTH + 1, 'u'));
+    PolicyKey key(Keys::k_cup.client(), tooLongUser, Keys::k_nun.privilege());
+    for (auto &bucket : Buckets::all) {
+        for (auto &recursive : Admin::Recursive::all) {
+            for (auto &sequenceNumber : SN::all) {
+                testInvalidProtocol<ProtocolAdmin, AdminCheckRequest>
+                    (key, bucket, recursive, sequenceNumber);
+            }
+        }
+    }
 }
 
-TEST(ProtocolAdmin, AdminCheckRequest06) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_wua, Buckets::not_empty, RECURSIVE,
-                                                       SN::max_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
+TEST(ProtocolAdmin, AdminCheckRequestTooLongPrivilegeNegative) {
+    PKF tooLongPrivilege = PKF::create(std::string(CYNARA_MAX_ID_LENGTH + 1, 'p'));
+    PolicyKey key(Keys::k_cup2.client(), Keys::k_cuw.user(), tooLongPrivilege);
+    for (auto &bucket : Buckets::all) {
+        for (auto &recursive : Admin::Recursive::all) {
+            for (auto &sequenceNumber : SN::all) {
+                testInvalidProtocol<ProtocolAdmin, AdminCheckRequest>
+                    (key, bucket, recursive, sequenceNumber);
+            }
+        }
+    }
 }
 
-TEST(ProtocolAdmin, AdminCheckRequest07) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_nua, Buckets::empty, NON_RECURSIVE,
-                                                       SN::mid);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
+TEST(ProtocolAdmin, AdminCheckRequestTooLongBucketNegative) {
+    PolicyBucketId bucket(CYNARA_MAX_ID_LENGTH + 1, 'b');
+    for (auto &key : Keys::all) {
+        for (auto &recursive : Admin::Recursive::all) {
+            for (auto &sequenceNumber : SN::all) {
+                testInvalidProtocol<ProtocolAdmin, AdminCheckRequest>
+                    (key, bucket, recursive, sequenceNumber);
+            }
+        }
+    }
 }
 
-/* *** compare by serialized data test cases *** */
-
-TEST(ProtocolAdmin, AdminCheckRequestBinary01) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_nun, Buckets::empty, RECURSIVE,
-                                                       SN::min);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, AdminCheckRequestBinary02) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_cup, Buckets::not_empty, RECURSIVE,
-                                                       SN::min_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, AdminCheckRequestBinary03) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_www, Buckets::empty, NON_RECURSIVE,
-                                                       SN::min_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, AdminCheckRequestBinary04) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_wuw, Buckets::not_empty,
-                                                       NON_RECURSIVE, SN::max);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, AdminCheckRequestBinary05) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_aaa, Buckets::empty, RECURSIVE,
-                                                       SN::max_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, AdminCheckRequestBinary06) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_wua, Buckets::not_empty, RECURSIVE,
-                                                       SN::max_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, AdminCheckRequestBinary07) {
-    auto request = std::make_shared<AdminCheckRequest>(Keys::k_nua, Buckets::empty, NON_RECURSIVE,
-                                                       SN::mid);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
-}