Redo unit tests for EraseRequest in ProtocolAdmin

* squash positive test cases
* add invalid protocol test cases

Change-Id: I4e3d65668c3bd42ce56c8b3107b631affe7afd70

diff --git a/test/common/protocols/admin/eraserequest.cpp b/test/common/protocols/admin/eraserequest.cpp
index f727e785821c2398156e88f3838308d5a16fae86..32f35bde300c52f1c3f33bcf1b1b29e71fcd376d 100644 (file)
--- a/test/common/protocols/admin/eraserequest.cpp
+++ b/test/common/protocols/admin/eraserequest.cpp
@@ -30,6 +30,7 @@
 #include <protocol/ProtocolAdmin.h>
 #include <request/EraseRequest.h>
 
+#include <NegativeTestHelper.h>
 #include <RequestTestHelper.h>
 #include <TestDataCollection.h>
 
@@ -42,111 +43,96 @@ void compare(const Cynara::EraseRequest &req1, const Cynara::EraseRequest &req2)
     EXPECT_EQ(req1.filter(), req2.filter());
 }
 
-static const bool RECURSIVE = true;
-static const bool NON_RECURSIVE = false;
-
 } /* namespace anonymous */
 
 using namespace Cynara;
+using namespace NegativeTestHelper;
 using namespace RequestTestHelper;
 using namespace TestDataCollection;
 
 /* *** compare by objects test cases *** */
 
-TEST(ProtocolAdmin, EraseRequest01) {
-    auto request = std::make_shared<EraseRequest>(Buckets::empty, RECURSIVE, Keys::k_nun, SN::min);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, EraseRequest02) {
-    auto request = std::make_shared<EraseRequest>(Buckets::not_empty, NON_RECURSIVE, Keys::k_cup,
-                                                  SN::min_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, EraseRequest03) {
-    auto request = std::make_shared<EraseRequest>(Buckets::empty, NON_RECURSIVE, Keys::k_www,
-                                                  SN::min_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, EraseRequest04) {
-    auto request = std::make_shared<EraseRequest>(Buckets::not_empty, RECURSIVE, Keys::k_wuw,
-                                                  SN::max);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, EraseRequest05) {
-    auto request = std::make_shared<EraseRequest>(Buckets::empty, RECURSIVE, Keys::k_aaa,
-                                                  SN::max_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, EraseRequest06) {
-    auto request = std::make_shared<EraseRequest>(Buckets::not_empty, NON_RECURSIVE, Keys::k_wua,
-                                                  SN::max_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, EraseRequest07) {
-    auto request = std::make_shared<EraseRequest>(Buckets::empty, NON_RECURSIVE, Keys::k_nua,
-                                                  SN::mid);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    testRequest(request, protocol);
+TEST(ProtocolAdmin, EraseRequestPositive) {
+    for (auto &bucket : Buckets::all) {
+        for (auto &recursive : Admin::Recursive::all) {
+            for (auto &key : Keys::all) {
+                for (auto &sequenceNumber : SN::all) {
+                        auto request = std::make_shared<EraseRequest>
+                            (bucket, recursive, key, sequenceNumber);
+                        auto protocol = std::make_shared<ProtocolAdmin>();
+                        testRequest(request, protocol);
+                }
+            }
+        }
+    }
 }
 
 /* *** compare by serialized data test cases *** */
 
-TEST(ProtocolAdmin, EraseRequestBinary01) {
-    auto request = std::make_shared<EraseRequest>(Buckets::empty, RECURSIVE, Keys::k_nun, SN::min);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, EraseRequestBinary02) {
-    auto request = std::make_shared<EraseRequest>(Buckets::not_empty, NON_RECURSIVE, Keys::k_cup,
-                                                  SN::min_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
-}
-
-TEST(ProtocolAdmin, EraseRequestBinary03) {
-    auto request = std::make_shared<EraseRequest>(Buckets::empty, NON_RECURSIVE, Keys::k_www,
-                                                  SN::min_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
+TEST(ProtocolAdmin, EraseRequestBinaryPositive) {
+    for (auto &bucket : Buckets::all) {
+        for (auto &recursive : Admin::Recursive::all) {
+            for (auto &key : Keys::all) {
+                for (auto &sequenceNumber : SN::all) {
+                        auto request = std::make_shared<EraseRequest>
+                            (bucket, recursive, key, sequenceNumber);
+                        auto protocol = std::make_shared<ProtocolAdmin>();
+                        binaryTestRequest(request, protocol);
+                }
+            }
+        }
+    }
 }
 
-TEST(ProtocolAdmin, EraseRequestBinary04) {
-    auto request = std::make_shared<EraseRequest>(Buckets::not_empty, RECURSIVE, Keys::k_wuw,
-                                                  SN::max);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
+/* *** invalid protocol tests for too long strings *** */
+
+TEST(ProtocolAdmin, EraseRequestTooLongClientNegative) {
+    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, EraseRequest>
+                    (bucket, recursive, key, sequenceNumber);
+            }
+        }
+    }
 }
 
-TEST(ProtocolAdmin, EraseRequestBinary05) {
-    auto request = std::make_shared<EraseRequest>(Buckets::empty, RECURSIVE, Keys::k_aaa,
-                                                  SN::max_1);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
+TEST(ProtocolAdmin, EraseRequestTooLongUserNegative) {
+    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, EraseRequest>
+                    (bucket, recursive, key, sequenceNumber);
+            }
+        }
+    }
 }
 
-TEST(ProtocolAdmin, EraseRequestBinary06) {
-    auto request = std::make_shared<EraseRequest>(Buckets::not_empty, NON_RECURSIVE, Keys::k_wua,
-                                                  SN::max_2);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
+TEST(ProtocolAdmin, EraseRequestTooLongPrivilegeNegative) {
+    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, EraseRequest>
+                    (bucket, recursive, key, sequenceNumber);
+            }
+        }
+    }
 }
 
-TEST(ProtocolAdmin, EraseRequestBinary07) {
-    auto request = std::make_shared<EraseRequest>(Buckets::empty, NON_RECURSIVE, Keys::k_nua,
-                                                  SN::mid);
-    auto protocol = std::make_shared<ProtocolAdmin>();
-    binaryTestRequest(request, protocol);
+TEST(ProtocolAdmin, EraseRequestTooLongBucketNegative) {
+    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, EraseRequest>
+                    (bucket, recursive, key, sequenceNumber);
+            }
+        }
+    }
 }