Categorize InMemoryStorageBackend unit tests

Categorize into positive/negative test cases.

Change-Id: Ie5212cef2761849dfbee1430293b7ea2f07215b0

diff --git a/test/storage/inmemorystoragebackend/buckets.cpp b/test/storage/inmemorystoragebackend/buckets.cpp
index 83038efe027f6fbf6833adebf4c5650a9cd5bb4d..84e9461962f5f75a5cbf30513289567629eb68b1 100644 (file)
--- a/test/storage/inmemorystoragebackend/buckets.cpp
+++ b/test/storage/inmemorystoragebackend/buckets.cpp
@@ -37,7 +37,7 @@
 
 using namespace Cynara;
 
-TEST_F(InMemoryStorageBackendFixture, createBucket) {
+TEST_F(InMemoryStorageBackendFixture, createBucketPositive) {
     using ::testing::ReturnRef;
     using ::testing::IsEmpty;
 
@@ -55,7 +55,7 @@ TEST_F(InMemoryStorageBackendFixture, createBucket) {
     ASSERT_THAT(m_buckets.at(bucketId), IsEmpty());
 }
 
-TEST_F(InMemoryStorageBackendFixture, updateBucket) {
+TEST_F(InMemoryStorageBackendFixture, updateBucketPositive) {
     using ::testing::ReturnRef;
 
     FakeInMemoryStorageBackend backend(m_fakeDbPath);
@@ -71,7 +71,7 @@ TEST_F(InMemoryStorageBackendFixture, updateBucket) {
     ASSERT_EQ(PredefinedPolicyType::DENY, bucket.defaultPolicy());
 }
 
-TEST_F(InMemoryStorageBackendFixture, updateNonexistentBucket) {
+TEST_F(InMemoryStorageBackendFixture, updateNonexistentBucketNegative) {
     using ::testing::ReturnRef;
 
     FakeInMemoryStorageBackend backend(m_fakeDbPath);
@@ -82,7 +82,7 @@ TEST_F(InMemoryStorageBackendFixture, updateNonexistentBucket) {
                  BucketNotExistsException);
 }
 
-TEST_F(InMemoryStorageBackendFixture, deleteBucket) {
+TEST_F(InMemoryStorageBackendFixture, deleteBucketPositive) {
     using ::testing::ReturnRef;
     using ::testing::IsEmpty;
 
@@ -98,7 +98,7 @@ TEST_F(InMemoryStorageBackendFixture, deleteBucket) {
     ASSERT_THAT(m_buckets, IsEmpty());
 }
 
-TEST_F(InMemoryStorageBackendFixture, hasBucket) {
+TEST_F(InMemoryStorageBackendFixture, hasBucketPositive) {
     using ::testing::ReturnRef;
     using ::testing::IsEmpty;
 
@@ -113,7 +113,7 @@ TEST_F(InMemoryStorageBackendFixture, hasBucket) {
     ASSERT_FALSE(backend.hasBucket("non-existent"));
 }
 
-TEST_F(InMemoryStorageBackendFixture, deleteNonexistentBucket) {
+TEST_F(InMemoryStorageBackendFixture, deleteNonexistentBucketNegative) {
     using ::testing::ReturnRef;
 
     FakeInMemoryStorageBackend backend(m_fakeDbPath);

diff --git a/test/storage/inmemorystoragebackend/inmemorystoragebackend.cpp b/test/storage/inmemorystoragebackend/inmemorystoragebackend.cpp
index 8e47504fadf6ae64581116ce1c5aafd451da042e..574be029740a7d434c5d9a976fba0fa1802bfd83 100644 (file)
--- a/test/storage/inmemorystoragebackend/inmemorystoragebackend.cpp
+++ b/test/storage/inmemorystoragebackend/inmemorystoragebackend.cpp
@@ -54,7 +54,7 @@ const std::string InMemoryStorageBackendFixture::m_fakeDbPath("/fake/database/pa
 const std::string InMemoryStorageBackendFixture::m_backupPath(Cynara::PathConfig::testsPath
                                                               + "/db_backup/");
 
-TEST_F(InMemoryStorageBackendFixture, defaultPolicyIsDeny) {
+TEST_F(InMemoryStorageBackendFixture, defaultPolicyIsDenyPositive) {
     using ::testing::ReturnRef;
 
     FakeInMemoryStorageBackend backend(m_fakeDbPath);
@@ -71,7 +71,7 @@ TEST_F(InMemoryStorageBackendFixture, defaultPolicyIsDeny) {
 }
 
 // TODO: Refactorize this test to be shorter and clearer
-TEST_F(InMemoryStorageBackendFixture, deleteLinking) {
+TEST_F(InMemoryStorageBackendFixture, deleteLinkingPositive) {
     using ::testing::ReturnRef;
     using ::testing::IsEmpty;
     using ::testing::UnorderedElementsAre;
@@ -126,7 +126,7 @@ TEST_F(InMemoryStorageBackendFixture, deleteLinking) {
     ASSERT_THAT(m_buckets.at(testBucket3), IsEmpty());
 }
 
-TEST_F(InMemoryStorageBackendFixture, insertPolicy) {
+TEST_F(InMemoryStorageBackendFixture, insertPolicyPositive) {
     using ::testing::ReturnRef;
     using ::testing::UnorderedElementsAre;
     using PredefinedPolicyType::ALLOW;
@@ -144,7 +144,7 @@ TEST_F(InMemoryStorageBackendFixture, insertPolicy) {
     ASSERT_THAT(m_buckets.at(bucketId), UnorderedElementsAre(policyToAdd));
 }
 
-TEST_F(InMemoryStorageBackendFixture, insertPolicyToNonexistentBucket) {
+TEST_F(InMemoryStorageBackendFixture, insertPolicyToNonexistentBucketNegative) {
     using ::testing::ReturnRef;
 
     FakeInMemoryStorageBackend backend(m_fakeDbPath);
@@ -154,7 +154,7 @@ TEST_F(InMemoryStorageBackendFixture, insertPolicyToNonexistentBucket) {
     EXPECT_THROW(backend.insertPolicy("non-existent", nullptr), BucketNotExistsException);
 }
 
-TEST_F(InMemoryStorageBackendFixture, deletePolicy) {
+TEST_F(InMemoryStorageBackendFixture, deletePolicyPositive) {
     using ::testing::ReturnRef;
     using ::testing::IsEmpty;
     using ::testing::UnorderedElementsAre;
@@ -190,7 +190,7 @@ TEST_F(InMemoryStorageBackendFixture, deletePolicy) {
     EXPECT_THAT(m_buckets.at(bucketId), UnorderedElementsAreArray(otherPolicies));
 }
 
-TEST_F(InMemoryStorageBackendFixture, deletePolicyFromNonexistentBucket) {
+TEST_F(InMemoryStorageBackendFixture, deletePolicyFromNonexistentBucketNegative) {
     using ::testing::ReturnRef;
     using ::testing::IsEmpty;
     using ::testing::UnorderedElementsAre;
@@ -204,7 +204,7 @@ TEST_F(InMemoryStorageBackendFixture, deletePolicyFromNonexistentBucket) {
 }
 
 // Database dir is empty
-TEST_F(InMemoryStorageBackendFixture, load_no_db) {
+TEST_F(InMemoryStorageBackendFixture, loadNoDbNegative) {
     using ::testing::ReturnRef;
     auto testDbPath = Cynara::PathConfig::testsPath + "/empty_db/";
     // make sure that DB directory is empty
@@ -219,7 +219,7 @@ TEST_F(InMemoryStorageBackendFixture, load_no_db) {
 
 // Database dir is empty
 // Database will be replaced with emergency backup
-TEST_F(InMemoryStorageBackendFixture, load_no_db_with_backup) {
+TEST_F(InMemoryStorageBackendFixture, loadNoDbWithBackupPositive) {
     using ::testing::ReturnRef;
     using ::testing::Return;
     const std::string TEST_DB_PATH = Cynara::PathConfig::testsPath + "/empty_db/";
@@ -235,7 +235,7 @@ TEST_F(InMemoryStorageBackendFixture, load_no_db_with_backup) {
 }
 
 // Database dir contains index with default bucket, but no file for this bucket
-TEST_F(InMemoryStorageBackendFixture, load_no_default) {
+TEST_F(InMemoryStorageBackendFixture, loadNoDefaultNegative) {
     using ::testing::ReturnRef;
     auto testDbPath = Cynara::PathConfig::testsPath + "/db2_corrupted/";
 
@@ -247,7 +247,7 @@ TEST_F(InMemoryStorageBackendFixture, load_no_default) {
 
 // Database dir contains index with default bucket, but no file for this bucket
 // Database will be replaced with emergency backup
-TEST_F(InMemoryStorageBackendFixture, load_no_default_with_backup) {
+TEST_F(InMemoryStorageBackendFixture, loadNoDefaultWithBackupPositive) {
     using ::testing::ReturnRef;
     using ::testing::Return;
     const std::string TEST_DB_PATH = Cynara::PathConfig::testsPath + "/db2/";
@@ -263,7 +263,7 @@ TEST_F(InMemoryStorageBackendFixture, load_no_default_with_backup) {
 }
 
 // Database contains index with default bucket and an empty bucket file
-TEST_F(InMemoryStorageBackendFixture, load_default_only) {
+TEST_F(InMemoryStorageBackendFixture, loadDefaultOnlyPositive) {
     using ::testing::ReturnRef;
     using ::testing::Return;
     auto testDbPath = Cynara::PathConfig::testsPath + "/db11_md5/";
@@ -276,7 +276,7 @@ TEST_F(InMemoryStorageBackendFixture, load_default_only) {
 
 // Database contains index with default bucket and an additional bucket
 // There are files for both buckets present
-TEST_F(InMemoryStorageBackendFixture, load_2_buckets) {
+TEST_F(InMemoryStorageBackendFixture, loadTwoBucketsPositive) {
     using ::testing::ReturnRef;
     using ::testing::Return;
     using ::testing::IsEmpty;
@@ -291,17 +291,16 @@ TEST_F(InMemoryStorageBackendFixture, load_2_buckets) {
     std::vector<std::string> bucketIds = { "", "additional" };
 
     for(const auto &bucketId : bucketIds) {
-        SCOPED_TRACE(bucketId);
         const auto bucketIter = m_buckets.find(bucketId);
-        ASSERT_NE(m_buckets.end(), bucketIter);
+        ASSERT_NE(m_buckets.end(), bucketIter) << " for " << bucketId;
 
         const auto &bucketPolicies = bucketIter->second;
-        ASSERT_THAT(bucketPolicies, IsEmpty());
+        ASSERT_THAT(bucketPolicies, IsEmpty()) << " for " << bucketId;
     }
 }
 
 // Database contains index with 2 buckets; 1st bucket is valid, but second is corrupted
-TEST_F(InMemoryStorageBackendFixture, second_bucket_corrupted) {
+TEST_F(InMemoryStorageBackendFixture, secondBucketCorruptedNegative) {
     using ::testing::ReturnRef;
     auto testDbPath = Cynara::PathConfig::testsPath + "/db5_corrupted/";
     FakeInMemoryStorageBackend backend(testDbPath);
@@ -312,7 +311,7 @@ TEST_F(InMemoryStorageBackendFixture, second_bucket_corrupted) {
 
 // Database contains index with 2 buckets; 1st bucket is valid, but second is corrupted
 // Database will be replaced with emergency backup
-TEST_F(InMemoryStorageBackendFixture, second_bucket_corrupted_with_backup) {
+TEST_F(InMemoryStorageBackendFixture, secondBucketCorruptedWithBackupPositive) {
     using ::testing::ReturnRef;
     using ::testing::Return;
     const std::string TEST_DB_PATH = Cynara::PathConfig::testsPath + "/db5/";
@@ -334,7 +333,7 @@ TEST_F(InMemoryStorageBackendFixture, second_bucket_corrupted_with_backup) {
  * - Execution of load() should use backup files (present, with different contents than primaries)
  * - Loaded database is checked - backup files were empty, so should recently loaded policies
  */
-TEST_F(InMemoryStorageBackendFixture, load_from_backup) {
+TEST_F(InMemoryStorageBackendFixture, loadFromBackupPositive) {
     using ::testing::ReturnRef;
     using ::testing::Return;
     using ::testing::IsEmpty;
@@ -354,12 +353,11 @@ TEST_F(InMemoryStorageBackendFixture, load_from_backup) {
 
     std::vector<std::string> bucketIds = { "", "additional" };
     for(const auto &bucketId : bucketIds) {
-        SCOPED_TRACE(bucketId);
         const auto bucketIter = m_buckets.find(bucketId);
-        ASSERT_NE(m_buckets.end(), bucketIter);
+        ASSERT_NE(m_buckets.end(), bucketIter) << " for " << bucketId;
 
         const auto &bucketPolicies = bucketIter->second;
-        ASSERT_THAT(bucketPolicies, IsEmpty());
+        ASSERT_THAT(bucketPolicies, IsEmpty()) << " for " << bucketId;
     }
 }
 
@@ -370,7 +368,7 @@ TEST_F(InMemoryStorageBackendFixture, load_from_backup) {
  *     - try erase policies from "non-existing-bucket"
  *     - expect BucketNotExistsException is thrown
  */
-TEST_F(InMemoryStorageBackendFixture, erasePoliciesEmptyBase) {
+TEST_F(InMemoryStorageBackendFixture, erasePolicyEmptyBaseNegative) {
     using ::testing::ReturnRef;
 
     FakeInMemoryStorageBackend backend(m_fakeDbPath);
@@ -381,10 +379,8 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesEmptyBase) {
     const bool NON_RECURSIVE = false;
 
     for (const auto &filter : filters()) {
-        SCOPED_TRACE(filter.name());
-
         EXPECT_THROW(backend.erasePolicies(bucketId, NON_RECURSIVE, filter.key()),
-                     BucketNotExistsException);
+                     BucketNotExistsException) << " for " << filter.name();
     }
 }
 
@@ -397,7 +393,7 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesEmptyBase) {
  *     - erase policies from "test-bucket"
  *     - check if received results match expected
  */
-TEST_F(InMemoryStorageBackendFixture, erasePoliciesSingleBucket) {
+TEST_F(InMemoryStorageBackendFixture, erasePolicySingleBucketPositive) {
     using ::testing::ReturnRef;
     using ::testing::UnorderedElementsAreArray;
 
@@ -405,8 +401,6 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesSingleBucket) {
     const bool NON_RECURSIVE = false;
 
     for (const auto &filter : filters()) {
-        SCOPED_TRACE(filter.name());
-
         FakeInMemoryStorageBackend backend(m_fakeDbPath);
         EXPECT_CALL(backend, buckets()).WillRepeatedly(ReturnRef(m_buckets));
 
@@ -415,7 +409,8 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesSingleBucket) {
 
         backend.erasePolicies(bucketId, NON_RECURSIVE, filter.key());
         ASSERT_THAT(m_buckets.at(bucketId),
-                    UnorderedElementsAreArray(expectedEraseResult(filter.name())));
+                    UnorderedElementsAreArray(expectedEraseResult(filter.name())))
+            << " for " << filter.name();
     }
 }
 
@@ -431,7 +426,7 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesSingleBucket) {
  *     - check if received results match expected in case of "test-bucket"
  *     - check if policies in "test-bucket2" remain unaffected
  */
-TEST_F(InMemoryStorageBackendFixture, erasePoliciesRecursiveNotLinkedBuckets) {
+TEST_F(InMemoryStorageBackendFixture, erasePolicyRecursiveNotLinkedBucketsPositive) {
     using ::testing::ReturnRef;
     using ::testing::UnorderedElementsAreArray;
 
@@ -440,8 +435,6 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesRecursiveNotLinkedBuckets) {
     const bool RECURSIVE = true;
 
     for (const auto &filter : filters()) {
-        SCOPED_TRACE(filter.name());
-
         FakeInMemoryStorageBackend backend(m_fakeDbPath);
         EXPECT_CALL(backend, buckets()).WillRepeatedly(ReturnRef(m_buckets));
 
@@ -453,9 +446,11 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesRecursiveNotLinkedBuckets) {
 
         backend.erasePolicies(bucketId, RECURSIVE, filter.key());
         ASSERT_THAT(m_buckets.at(bucketId),
-                    UnorderedElementsAreArray(expectedEraseResult(filter.name())));
+                    UnorderedElementsAreArray(expectedEraseResult(filter.name())))
+            << " for " << filter.name();
         ASSERT_THAT(m_buckets.at(bucketId2),
-                    UnorderedElementsAreArray(fullPoliciesCollection()));
+                    UnorderedElementsAreArray(fullPoliciesCollection()))
+            << " for " << filter.name();
     }
 }
 
@@ -472,7 +467,7 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesRecursiveNotLinkedBuckets) {
  *     - check if received results match expected in case of "test-bucket"
  *     - check if received results match expected in case of "test-bucket2"
  */
-TEST_F(InMemoryStorageBackendFixture, erasePoliciesRecursiveLinkedBuckets) {
+TEST_F(InMemoryStorageBackendFixture, erasePolicyRecursiveLinkedBucketsPositive) {
     using ::testing::ReturnRef;
     using ::testing::UnorderedElementsAreArray;
 
@@ -483,8 +478,6 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesRecursiveLinkedBuckets) {
     const bool RECURSIVE = true;
 
     for (const auto &filter : filters()) {
-        SCOPED_TRACE(filter.name());
-
         FakeInMemoryStorageBackend backend(m_fakeDbPath);
         EXPECT_CALL(backend, buckets()).WillRepeatedly(ReturnRef(m_buckets));
 
@@ -503,9 +496,10 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesRecursiveLinkedBuckets) {
             expectedResult.insert(expectedResult.end(), linkPolicy.begin(), linkPolicy.end());
         }
         ASSERT_THAT(m_buckets.at(bucketId),
-                    UnorderedElementsAreArray(expectedResult));
+                    UnorderedElementsAreArray(expectedResult)) << " for " << filter.name();
         ASSERT_THAT(m_buckets.at(bucketId2),
-                    UnorderedElementsAreArray(expectedEraseResult(filter.name())));
+                    UnorderedElementsAreArray(expectedEraseResult(filter.name())))
+            << " for " << filter.name();
     }
 }
 
@@ -522,7 +516,9 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesRecursiveLinkedBuckets) {
  *     - check if policies in "test-bucket" remain unaffected
  *     - check if received results match expected in case of "test-bucket2"
  */
-TEST_F(InMemoryStorageBackendFixture, erasePoliciesRecursiveLinkedBucketsNoBackwardPropagation) {
+TEST_F(InMemoryStorageBackendFixture,
+       erasePolicyRecursiveLinkedBucketsNoBackwardPropagationPositive)
+{
     using ::testing::ReturnRef;
     using ::testing::UnorderedElementsAreArray;
 
@@ -533,8 +529,6 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesRecursiveLinkedBucketsNoBackw
     const bool RECURSIVE = true;
 
     for (const auto &filter : filters()) {
-        SCOPED_TRACE(filter.name());
-
         FakeInMemoryStorageBackend backend(m_fakeDbPath);
         EXPECT_CALL(backend, buckets()).WillRepeatedly(ReturnRef(m_buckets));
 
@@ -552,9 +546,10 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesRecursiveLinkedBucketsNoBackw
         expectedResult.insert(expectedResult.end(), linkPolicy.begin(), linkPolicy.end());
 
         ASSERT_THAT(m_buckets.at(bucketId),
-                    UnorderedElementsAreArray(expectedResult));
+                    UnorderedElementsAreArray(expectedResult)) << " for " << filter.name();
         ASSERT_THAT(m_buckets.at(bucketId2),
-                    UnorderedElementsAreArray(expectedEraseResult(filter.name())));
+                    UnorderedElementsAreArray(expectedEraseResult(filter.name())))
+            << " for " << filter.name();
     }
 }
 
@@ -571,7 +566,7 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesRecursiveLinkedBucketsNoBackw
  *     - check if received results match expected in case of "test-bucket"
  *     - check if policies in "test-bucket2" remain unaffected
  */
-TEST_F(InMemoryStorageBackendFixture, erasePoliciesNonRecursiveLinkedBuckets) {
+TEST_F(InMemoryStorageBackendFixture, erasePolicyNonRecursiveLinkedBucketsPositive) {
     using ::testing::ReturnRef;
     using ::testing::UnorderedElementsAreArray;
 
@@ -582,8 +577,6 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesNonRecursiveLinkedBuckets) {
     const bool NON_RECURSIVE = false;
 
     for (const auto &filter : filters()) {
-        SCOPED_TRACE(filter.name());
-
         FakeInMemoryStorageBackend backend(m_fakeDbPath);
         EXPECT_CALL(backend, buckets()).WillRepeatedly(ReturnRef(m_buckets));
 
@@ -602,8 +595,9 @@ TEST_F(InMemoryStorageBackendFixture, erasePoliciesNonRecursiveLinkedBuckets) {
             expectedResult.insert(expectedResult.end(), linkPolicy.begin(), linkPolicy.end());
         }
         ASSERT_THAT(m_buckets.at(bucketId),
-                    UnorderedElementsAreArray(expectedResult));
+                    UnorderedElementsAreArray(expectedResult)) << " for " << filter.name();
         ASSERT_THAT(m_buckets.at(bucketId2),
-                    UnorderedElementsAreArray(fullPoliciesCollection()));
+                    UnorderedElementsAreArray(fullPoliciesCollection()))
+            << " for " << filter.name();
     }
 }

diff --git a/test/storage/inmemorystoragebackend/search.cpp b/test/storage/inmemorystoragebackend/search.cpp
index 0ec57cadb903439412f213a46f09c573b89a2780..6b8ddc6ff20ccd2d236a7c1d9e7e25f320c58f61 100644 (file)
--- a/test/storage/inmemorystoragebackend/search.cpp
+++ b/test/storage/inmemorystoragebackend/search.cpp
@@ -38,7 +38,7 @@
 
 using namespace Cynara;
 
-TEST_F(InMemoryStorageBackendFixture, searchDefault) {
+TEST_F(InMemoryStorageBackendFixture, searchDefaultPositive) {
     using ::testing::ReturnRef;
     using ::testing::UnorderedElementsAreArray;
     using ::testing::IsEmpty;