CKM: Run async api tests in single process

[Problem] Timeouts during key generation. Test dependency.
[Solution] Single process test cases used. Test env fixed.

[Verification] Run tests.

Change-Id: I471c1003403f6638aa836d47b42f3c1e06952e7e

diff --git a/src/ckm/async-api.cpp b/src/ckm/async-api.cpp
index 62b125a..756f842 100644 (file)
--- a/src/ckm/async-api.cpp
+++ b/src/ckm/async-api.cpp
@@ -49,13 +49,17 @@ using namespace TestData;
 
 namespace {
 
-const char* TEST_LABEL      = "test_label";
+const char* TEST_LABEL  = "test_label";
 const char* TEST_LABEL_2    = "test_label-2";
 
 const char* TEST_DATA = "dsflsdkghkslhglrtghierhgilrehgidsafasdffsgfdgdgfdgfdgfdgfdggf";
 
+const char* TEST_PASS = "test-pass";
+
 const CertificateShPtrVector EMPTY_CERT_VECTOR;
 const AliasVector EMPTY_ALIAS_VECTOR;
+const Alias alias_PKCS_exportable = "async-test-PKCS-export";
+const Alias alias_PKCS_not_exportable = "async-test-PKCS-no-export";
 
 class MyObserver: public ManagerAsync::Observer
 {
@@ -130,8 +134,6 @@ protected:
 
 typedef shared_ptr<MyObserver> MyObserverPtr;
 
-const char* TEST_PASS = "test-pass";
-
 enum Type {
     RSA,
     DSA,
@@ -384,24 +386,22 @@ typedef void (ManagerAsync::*certChainFn2)(const ManagerAsync::ObserverPtr&,
                                            const AliasVector&,
                                            bool);
 
-class CKMAsyncAPIEnv
+class UserEnv : public RemoveDataEnv<APP_UID>
 {
 public:
-    void init(const std::string &) {
-        remove_user_data(0);
-        remove_user_data(APP_UID);
-        ScopedAccessProvider ap(TEST_LABEL, APP_UID, APP_GID);
+    void init(const std::string & str) {
+        RemoveDataEnv<APP_UID>::init(str);
         unlock_user_data(APP_UID, TEST_PASS);
+        m_ap.reset(new ScopedAccessProvider(TEST_LABEL, APP_UID, APP_GID));
     }
     void finish() {
-        remove_user_data(APP_UID);
-        remove_user_data(0);
+        m_ap.reset();
+        // lock is performed by remove_user_data() in RemoveDataEnv
+        RemoveDataEnv<APP_UID>::finish();
     }
+    std::unique_ptr<ScopedAccessProvider> m_ap;
 };
 
-CKM::Alias alias_PKCS_exportable = "async-test-PKCS-export";
-CKM::Alias alias_PKCS_not_exportable = "async-test-PKCS-no-export";
-
 CKM::PKCS12ShPtr loadPkcs()
 {
     std::ifstream is("/usr/share/ckm-test/pkcs.p12");
@@ -436,352 +436,267 @@ CKM::PKCS12ShPtr loadPkcs()
 
 } // namespace anonymous
 
-
 RUNNER_TEST_GROUP_INIT(CKM_ASYNC_API);
 
 // saveKey
-RUNNER_CHILD_TEST(TA0010_save_key_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0010_save_key_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::saveKey, "alias", keys[RSA][0].prv, Policy());
     test_invalid_param(&ManagerAsync::saveKey, "", keys[RSA][0].prv, Policy());
     test_invalid_param(&ManagerAsync::saveKey, "alias", KeyShPtr(), Policy());
 }
 
-RUNNER_CHILD_TEST(TA0020_save_key_already_exists, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0020_save_key_already_exists, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy());
+    test_positive(&ManagerAsync::saveKey, "alias", keys[RSA][0].prv, Policy());
     test_negative(&ManagerAsync::saveKey,
                   CKM_API_ERROR_DB_ALIAS_EXISTS,
-                  dbc.alias("alias"),
+                  "alias",
                   keys[RSA][0].prv,
                   Policy());
 }
 
-RUNNER_CHILD_TEST(TA0050_save_key_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0050_save_key_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy());
+    test_positive(&ManagerAsync::saveKey, "alias", keys[RSA][0].prv, Policy());
 }
 
 
 // saveCertificate
-RUNNER_CHILD_TEST(TA0110_save_cert_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0110_save_cert_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     CertificateShPtr cert = Certificate::create(test_buffer, DataFormat::FORM_PEM);
     test_no_observer(&ManagerAsync::saveCertificate, "", cert, Policy());
     test_invalid_param(&ManagerAsync::saveCertificate, "", cert, Policy());
     test_invalid_param(&ManagerAsync::saveCertificate, "alias", CertificateShPtr(), Policy());
 }
 
-RUNNER_CHILD_TEST(TA0120_save_cert_already_exists, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0120_save_cert_already_exists, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias"), getTestCertificate(MBANK), Policy());
+    test_positive(&ManagerAsync::saveCertificate, "alias", getTestCertificate(MBANK), Policy());
     test_negative(&ManagerAsync::saveCertificate,
                   CKM_API_ERROR_DB_ALIAS_EXISTS,
-                  dbc.alias("alias"),
+                  "alias",
                   getTestCertificate(MBANK),
                   Policy());
 }
 
-RUNNER_CHILD_TEST(TA0150_save_cert_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0150_save_cert_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias"), getTestCertificate(MBANK), Policy());
+    test_positive(&ManagerAsync::saveCertificate, "alias", getTestCertificate(MBANK), Policy());
 }
 
 
 // saveData
-RUNNER_CHILD_TEST(TA0210_save_data_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0210_save_data_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::saveData, "", test_buffer, Policy());
     test_invalid_param(&ManagerAsync::saveData, "", test_buffer, Policy());
     test_invalid_param(&ManagerAsync::saveData, "alias", RawBuffer(), Policy());
 }
 
-RUNNER_CHILD_TEST(TA0220_save_data_already_exists, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0220_save_data_already_exists, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
+    test_positive(&ManagerAsync::saveData, "alias", test_buffer, Policy());
     test_negative(&ManagerAsync::saveData,
                   CKM_API_ERROR_DB_ALIAS_EXISTS,
-                  dbc.alias("alias"),
+                  "alias",
                   test_buffer,
                   Policy());
 }
 
-RUNNER_CHILD_TEST(TA0250_save_data_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0250_save_data_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
+    test_positive(&ManagerAsync::saveData, "alias", test_buffer, Policy());
 }
 
 
 // removeKey
-RUNNER_CHILD_TEST(TA0310_remove_alias_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0310_remove_alias_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::removeAlias, "alias");
     test_invalid_param(&ManagerAsync::removeAlias, "");
 }
 
-RUNNER_CHILD_TEST(TA0330_remove_alias_unknown_alias, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0330_remove_alias_unknown_alias, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_negative(&ManagerAsync::removeAlias, CKM_API_ERROR_DB_ALIAS_UNKNOWN, "non-existing-alias");
 }
 
-RUNNER_CHILD_TEST(TA0350_remove_key_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0350_remove_key_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy());
-    test_positive(&ManagerAsync::removeAlias, dbc.alias("alias"));
+    test_positive(&ManagerAsync::saveKey, "alias", keys[RSA][0].prv, Policy());
+    test_positive(&ManagerAsync::removeAlias, "alias");
 }
 
 
-RUNNER_CHILD_TEST(TA0450_remove_cert_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0450_remove_cert_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias"), getTestCertificate(MBANK), Policy());
-    test_positive(&ManagerAsync::removeAlias, dbc.alias("alias"));
+    test_positive(&ManagerAsync::saveCertificate, "alias", getTestCertificate(MBANK), Policy());
+    test_positive(&ManagerAsync::removeAlias, "alias");
 }
 
 
-RUNNER_CHILD_TEST(TA0550_remove_data_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0550_remove_data_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy());
-    test_positive(&ManagerAsync::removeAlias, dbc.alias("alias"));
+    test_positive(&ManagerAsync::saveData, "alias", test_buffer, Policy());
+    test_positive(&ManagerAsync::removeAlias, "alias");
 }
 
 
 // getKey
-RUNNER_CHILD_TEST(TA0610_get_key_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0610_get_key_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::getKey, "alias", "");
     test_invalid_param(&ManagerAsync::getKey, "", "");
 }
 
-RUNNER_CHILD_TEST(TA0630_get_key_unknown_alias, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0630_get_key_unknown_alias, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_negative(&ManagerAsync::getKey, CKM_API_ERROR_DB_ALIAS_UNKNOWN, "non-existing-alias", "");
 }
 
-RUNNER_CHILD_TEST(TA0640_get_key_wrong_password, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0640_get_key_wrong_password, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy("password"));
+    test_positive(&ManagerAsync::saveKey, "alias", keys[RSA][0].prv, Policy("password"));
     test_negative(&ManagerAsync::getKey,
                   CKM_API_ERROR_AUTHENTICATION_FAILED,
-                  dbc.alias("alias"),
+                  "alias",
                   "wrong-password");
 }
 
-RUNNER_CHILD_TEST(TA0650_get_key_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0650_get_key_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy("password"));
-    test_positive(&ManagerAsync::getKey, dbc.alias("alias"), "password");
+    test_positive(&ManagerAsync::saveKey, "alias", keys[RSA][0].prv, Policy("password"));
+    test_positive(&ManagerAsync::getKey, "alias", "password");
 }
 
 
 // getCertificate
-RUNNER_CHILD_TEST(TA0710_get_cert_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0710_get_cert_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::getCertificate, "alias", "");
     test_invalid_param(&ManagerAsync::getCertificate, "", "");
 }
 
-RUNNER_CHILD_TEST(TA0730_get_cert_unknown_alias, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0730_get_cert_unknown_alias, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_negative(&ManagerAsync::getCertificate,
                   CKM_API_ERROR_DB_ALIAS_UNKNOWN,
                   "non-existing-alias",
                   "");
 }
 
-RUNNER_CHILD_TEST(TA0740_get_cert_wrong_password, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0740_get_cert_wrong_password, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
     test_positive(&ManagerAsync::saveCertificate,
-                  dbc.alias("alias"),
+                  "alias",
                   getTestCertificate(MBANK),
                   Policy("password"));
     test_negative(&ManagerAsync::getCertificate,
                   CKM_API_ERROR_AUTHENTICATION_FAILED,
-                  dbc.alias("alias"),
+                  "alias",
                   "wrong-password");
 }
 
-RUNNER_CHILD_TEST(TA0750_get_cert_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0750_get_cert_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias"), getTestCertificate(MBANK), Policy("password"));
-    test_positive(&ManagerAsync::getCertificate, dbc.alias("alias"), "password");
+    test_positive(&ManagerAsync::saveCertificate, "alias", getTestCertificate(MBANK), Policy("password"));
+    test_positive(&ManagerAsync::getCertificate, "alias", "password");
 }
 
 
 // getData
-RUNNER_CHILD_TEST(TA0810_get_data_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0810_get_data_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::getData, "alias", "");
     test_invalid_param(&ManagerAsync::getData, "", "");
 }
 
-RUNNER_CHILD_TEST(TA0830_get_data_unknown_alias, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0830_get_data_unknown_alias, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_negative(&ManagerAsync::getData, CKM_API_ERROR_DB_ALIAS_UNKNOWN, "non-existing-alias", "");
 }
 
-RUNNER_CHILD_TEST(TA0840_get_data_wrong_password, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0840_get_data_wrong_password, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy("password"));
+    test_positive(&ManagerAsync::saveData, "alias", test_buffer, Policy("password"));
     test_negative(&ManagerAsync::getData,
                   CKM_API_ERROR_AUTHENTICATION_FAILED,
-                  dbc.alias("alias"),
+                  "alias",
                   "wrong-password");
 }
 
-RUNNER_CHILD_TEST(TA0850_get_data_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0850_get_data_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveData, dbc.alias("alias"), test_buffer, Policy("password"));
-    test_positive(&ManagerAsync::getData, dbc.alias("alias"), "password");
+    test_positive(&ManagerAsync::saveData, "alias", test_buffer, Policy("password"));
+    test_positive(&ManagerAsync::getData, "alias", "password");
 }
 
 
 // getKeyAliasVector
-RUNNER_CHILD_TEST(TA0910_get_key_alias_vector_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0910_get_key_alias_vector_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::getKeyAliasVector);
 }
 
-RUNNER_CHILD_TEST(TA0950_get_key_alias_vector_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA0950_get_key_alias_vector_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias1"), keys[RSA][0].prv, Policy());
-    test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")) });
+    test_positive(&ManagerAsync::saveKey, "alias1", keys[RSA][0].prv, Policy());
+    test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, "alias1") });
 
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias2"), keys[DSA][0].prv, Policy());
-    test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")),
-                                                           aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
+    test_positive(&ManagerAsync::saveKey, "alias2", keys[DSA][0].prv, Policy());
+    test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, "alias1"),
+                                                           aliasWithLabel(TEST_LABEL, "alias2") });
 
-    test_positive(&ManagerAsync::removeAlias, dbc.alias("alias1"));
-    test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
+    test_positive(&ManagerAsync::removeAlias, "alias1");
+    test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, "alias2") });
 }
 
 
 // getCertificateAliasVector
-RUNNER_CHILD_TEST(TA1010_get_cert_alias_vector_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1010_get_cert_alias_vector_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::getCertificateAliasVector);
 }
 
-RUNNER_CHILD_TEST(TA1050_get_cert_alias_vector_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1050_get_cert_alias_vector_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias1"), getTestCertificate(MBANK), Policy());
-    test_check_aliases(&ManagerAsync::getCertificateAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")) });
+    test_positive(&ManagerAsync::saveCertificate, "alias1", getTestCertificate(MBANK), Policy());
+    test_check_aliases(&ManagerAsync::getCertificateAliasVector, { aliasWithLabel(TEST_LABEL, "alias1") });
 
-    test_positive(&ManagerAsync::saveCertificate, dbc.alias("alias2"), getTestCertificate(SYMANTEC), Policy());
-    test_check_aliases(&ManagerAsync::getCertificateAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")),
-                                                                   aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
+    test_positive(&ManagerAsync::saveCertificate, "alias2", getTestCertificate(SYMANTEC), Policy());
+    test_check_aliases(&ManagerAsync::getCertificateAliasVector, { aliasWithLabel(TEST_LABEL, "alias1"),
+                                                                   aliasWithLabel(TEST_LABEL, "alias2") });
 
-    test_positive(&ManagerAsync::removeAlias, dbc.alias("alias1"));
-    test_check_aliases(&ManagerAsync::getCertificateAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
+    test_positive(&ManagerAsync::removeAlias, "alias1");
+    test_check_aliases(&ManagerAsync::getCertificateAliasVector, { aliasWithLabel(TEST_LABEL, "alias2") });
 }
 
 
 // getDataAliasVector
-RUNNER_CHILD_TEST(TA1110_get_data_alias_vector_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1110_get_data_alias_vector_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::getDataAliasVector);
 }
 
-RUNNER_CHILD_TEST(TA1150_get_data_alias_vector_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1150_get_data_alias_vector_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
+    test_positive(&ManagerAsync::saveData, "alias1", test_buffer, Policy());
+    test_check_aliases(&ManagerAsync::getDataAliasVector, { aliasWithLabel(TEST_LABEL, "alias1") });
 
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveData, dbc.alias("alias1"), test_buffer, Policy());
-    test_check_aliases(&ManagerAsync::getDataAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")) });
+    test_positive(&ManagerAsync::saveData, "alias2", test_buffer, Policy());
+    test_check_aliases(&ManagerAsync::getDataAliasVector, { aliasWithLabel(TEST_LABEL, "alias1"),
+                                                            aliasWithLabel(TEST_LABEL, "alias2") });
 
-    test_positive(&ManagerAsync::saveData, dbc.alias("alias2"), test_buffer, Policy());
-    test_check_aliases(&ManagerAsync::getDataAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias1")),
-                                                            aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
-
-    test_positive(&ManagerAsync::removeAlias, dbc.alias("alias1"));
-    test_check_aliases(&ManagerAsync::getDataAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias2")) });
+    test_positive(&ManagerAsync::removeAlias, "alias1");
+    test_check_aliases(&ManagerAsync::getDataAliasVector, { aliasWithLabel(TEST_LABEL, "alias2") });
 }
 
 
 // createKeyPairRSA
-RUNNER_CHILD_TEST(TA1210_create_key_pair_rsa_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1210_create_key_pair_rsa_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::createKeyPairRSA,
                      1024,
                      "alias_prv",
@@ -790,42 +705,34 @@ RUNNER_CHILD_TEST(TA1210_create_key_pair_rsa_invalid_param, CKMAsyncAPIEnv)
                      Policy());
 }
 
-RUNNER_CHILD_TEST(TA1220_create_key_pair_rsa_already_exists, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1220_create_key_pair_rsa_already_exists, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy());
+    test_positive(&ManagerAsync::saveKey, "alias_prv", keys[RSA][0].prv, Policy());
     test_negative(&ManagerAsync::createKeyPairRSA,
                   CKM_API_ERROR_DB_ALIAS_EXISTS,
                   1024,
-                  dbc.alias("alias_prv"),
-                  dbc.alias("alias_pub"),
+                  "alias_prv",
+                  "alias_pub",
                   Policy(),
                   Policy());
 }
 
-RUNNER_CHILD_TEST(TA1250_create_key_pair_rsa_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1250_create_key_pair_rsa_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
     test_positive(&ManagerAsync::createKeyPairRSA,
                   1024,
-                  dbc.alias("alias_prv"),
-                  dbc.alias("alias_pub"),
+                  "alias_prv",
+                  "alias_pub",
                   Policy(),
                   Policy());
 
-    test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias_prv")),
-                                                           aliasWithLabel(TEST_LABEL, dbc.alias("alias_pub")) });
+    test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, "alias_prv"),
+                                                           aliasWithLabel(TEST_LABEL, "alias_pub") });
 }
 
 // createKeyPairDSA
-RUNNER_CHILD_TEST(TA1270_create_key_pair_dsa_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1270_create_key_pair_dsa_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::createKeyPairDSA,
                      1024,
                      "alias_prv",
@@ -834,42 +741,34 @@ RUNNER_CHILD_TEST(TA1270_create_key_pair_dsa_invalid_param, CKMAsyncAPIEnv)
                      Policy());
 }
 
-RUNNER_CHILD_TEST(TA1280_create_key_pair_dsa_already_exists, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1280_create_key_pair_dsa_already_exists, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[DSA][0].prv, Policy());
+    test_positive(&ManagerAsync::saveKey, "alias_prv", keys[DSA][0].prv, Policy());
     test_negative(&ManagerAsync::createKeyPairDSA,
                   CKM_API_ERROR_DB_ALIAS_EXISTS,
                   1024,
-                  dbc.alias("alias_prv"),
-                  dbc.alias("alias_pub"),
+                  "alias_prv",
+                  "alias_pub",
                   Policy(),
                   Policy());
 }
 
-RUNNER_CHILD_TEST(TA1290_create_key_pair_dsa_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1290_create_key_pair_dsa_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
     test_positive(&ManagerAsync::createKeyPairDSA,
                   1024,
-                  dbc.alias("alias_prv"),
-                  dbc.alias("alias_pub"),
+                  "alias_prv",
+                  "alias_pub",
                   Policy(),
                   Policy());
 
-    test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias_prv")),
-                                                           aliasWithLabel(TEST_LABEL, dbc.alias("alias_pub")) });
+    test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, "alias_prv"),
+                                                           aliasWithLabel(TEST_LABEL, "alias_pub") });
 }
 
 // createKeyPairECDSA
-RUNNER_CHILD_TEST(TA1310_create_key_pair_ecdsa_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1310_create_key_pair_ecdsa_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::createKeyPairECDSA,
                      ElipticCurve::prime192v1,
                      "alias_prv",
@@ -878,43 +777,35 @@ RUNNER_CHILD_TEST(TA1310_create_key_pair_ecdsa_invalid_param, CKMAsyncAPIEnv)
                      Policy());
 }
 
-RUNNER_CHILD_TEST(TA1320_create_key_pair_ecdsa_already_exists, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1320_create_key_pair_ecdsa_already_exists, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[ECDSA][0].prv, Policy());
+    test_positive(&ManagerAsync::saveKey, "alias_prv", keys[ECDSA][0].prv, Policy());
     test_negative(&ManagerAsync::createKeyPairECDSA,
                   CKM_API_ERROR_DB_ALIAS_EXISTS,
                   ElipticCurve::prime192v1,
-                  dbc.alias("alias_prv"),
-                  dbc.alias("alias_pub"),
+                  "alias_prv",
+                  "alias_pub",
                   Policy(),
                   Policy());
 }
 
-RUNNER_CHILD_TEST(TA1350_create_key_pair_ecdsa_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1350_create_key_pair_ecdsa_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
     test_positive(&ManagerAsync::createKeyPairECDSA,
                   ElipticCurve::prime192v1,
-                  dbc.alias("alias_prv"),
-                  dbc.alias("alias_pub"),
+                  "alias_prv",
+                  "alias_pub",
                   Policy(),
                   Policy());
 
-    test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, dbc.alias("alias_prv")),
-                                                           aliasWithLabel(TEST_LABEL, dbc.alias("alias_pub")) });
+    test_check_aliases(&ManagerAsync::getKeyAliasVector, { aliasWithLabel(TEST_LABEL, "alias_prv"),
+                                                           aliasWithLabel(TEST_LABEL, "alias_pub") });
 }
 
 
 // getCertificateChain
-RUNNER_CHILD_TEST(TA1410_get_certificate_chain_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1410_get_certificate_chain_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     CertificateShPtr cert = getTestCertificate(MBANK);
     CertificateShPtrVector certv = { getTestCertificate(SYMANTEC) };
     test_no_observer<certChainFn1>(&ManagerAsync::getCertificateChain,
@@ -942,11 +833,8 @@ RUNNER_CHILD_TEST(TA1410_get_certificate_chain_invalid_param, CKMAsyncAPIEnv)
                                      true);
 }
 
-RUNNER_CHILD_TEST(TA1420_get_certificate_chain_negative, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1420_get_certificate_chain_negative, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
     CertificateShPtr cert = getTestCertificate(MBANK);
     CertificateShPtrVector certv = { getTestCertificate(MBANK) };
     test_negative<certChainFn1>(&ManagerAsync::getCertificateChain,
@@ -961,7 +849,7 @@ RUNNER_CHILD_TEST(TA1420_get_certificate_chain_negative, CKMAsyncAPIEnv)
                                 certv,
                                 EMPTY_CERT_VECTOR,
                                 true);
-    AliasVector aliasv = { dbc.alias("alias") };
+    AliasVector aliasv = { "alias" };
     test_positive(&ManagerAsync::saveCertificate, aliasv[0], getTestCertificate(MBANK), Policy());
     test_negative<certChainFn2>(&ManagerAsync::getCertificateChain,
                                 CKM_API_ERROR_VERIFICATION_FAILED,
@@ -977,11 +865,8 @@ RUNNER_CHILD_TEST(TA1420_get_certificate_chain_negative, CKMAsyncAPIEnv)
                                 true);
 }
 
-RUNNER_CHILD_TEST(TA1450_get_certificate_chain_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1450_get_certificate_chain_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
     CertificateShPtr cert = getTestCertificate(MBANK);
     CertificateShPtrVector certv = { getTestCertificate(SYMANTEC) };
     test_check_cert_chain<certChainFn1>(&ManagerAsync::getCertificateChain,
@@ -991,7 +876,7 @@ RUNNER_CHILD_TEST(TA1450_get_certificate_chain_positive, CKMAsyncAPIEnv)
                                         EMPTY_CERT_VECTOR,
                                         true);
 
-    AliasVector aliasv = { dbc.alias("alias") };
+    AliasVector aliasv = { "alias" };
     test_positive(&ManagerAsync::saveCertificate, aliasv[0], getTestCertificate(SYMANTEC), Policy());
     test_check_cert_chain<certChainFn2>(&ManagerAsync::getCertificateChain,
                                         3,
@@ -1003,10 +888,8 @@ RUNNER_CHILD_TEST(TA1450_get_certificate_chain_positive, CKMAsyncAPIEnv)
 
 
 // createSignature
-RUNNER_CHILD_TEST(TA1510_create_signature_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1510_create_signature_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::createSignature,
                      "alias",
                      "",
@@ -1027,29 +910,23 @@ RUNNER_CHILD_TEST(TA1510_create_signature_invalid_param, CKMAsyncAPIEnv)
                        RSAPaddingAlgorithm::PKCS1);
 }
 
-RUNNER_CHILD_TEST(TA1520_create_signature_invalid_password, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1520_create_signature_invalid_password, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy("password"));
+    test_positive(&ManagerAsync::saveKey, "alias", keys[RSA][0].prv, Policy("password"));
     test_negative(&ManagerAsync::createSignature,
                   CKM_API_ERROR_INPUT_PARAM,
-                  dbc.alias("alias"),
+                  "alias",
                   "wrong-password",
                   RawBuffer(),
                   HashAlgorithm::SHA1,
                   RSAPaddingAlgorithm::PKCS1);
 }
 
-RUNNER_CHILD_TEST(TA1550_create_signature_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1550_create_signature_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias"), keys[RSA][0].prv, Policy("password"));
+    test_positive(&ManagerAsync::saveKey, "alias", keys[RSA][0].prv, Policy("password"));
     test_positive(&ManagerAsync::createSignature,
-                  dbc.alias("alias"),
+                  "alias",
                   "password",
                   test_buffer,
                   HashAlgorithm::SHA1,
@@ -1058,10 +935,8 @@ RUNNER_CHILD_TEST(TA1550_create_signature_positive, CKMAsyncAPIEnv)
 
 
 // verifySignature
-RUNNER_CHILD_TEST(TA1610_verify_signature_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1610_verify_signature_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::verifySignature,
                      "",
                      "",
@@ -1078,15 +953,12 @@ RUNNER_CHILD_TEST(TA1610_verify_signature_invalid_param, CKMAsyncAPIEnv)
                        RSAPaddingAlgorithm::PKCS1);
 }
 
-RUNNER_CHILD_TEST(TA1620_verify_signature_invalid_password, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1620_verify_signature_invalid_password, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy("pass1"));
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy("pass2"));
+    test_positive(&ManagerAsync::saveKey, "alias_prv", keys[RSA][0].prv, Policy("pass1"));
+    test_positive(&ManagerAsync::saveKey, "alias_pub", keys[RSA][0].pub, Policy("pass2"));
     auto obs = test_positive(&ManagerAsync::createSignature,
-                             dbc.alias("alias_prv"),
+                             "alias_prv",
                              "pass1",
                              test_buffer,
                              HashAlgorithm::SHA1,
@@ -1094,7 +966,7 @@ RUNNER_CHILD_TEST(TA1620_verify_signature_invalid_password, CKMAsyncAPIEnv)
 
     test_negative(&ManagerAsync::verifySignature,
                   CKM_API_ERROR_AUTHENTICATION_FAILED,
-                  dbc.alias("alias_pub"),
+                  "alias_pub",
                   "wrong-password",
                   test_buffer,
                   obs->m_signed,
@@ -1102,16 +974,13 @@ RUNNER_CHILD_TEST(TA1620_verify_signature_invalid_password, CKMAsyncAPIEnv)
                   RSAPaddingAlgorithm::PKCS1);
 }
 
-RUNNER_CHILD_TEST(TA1630_verify_signature_invalid_message, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1630_verify_signature_invalid_message, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy(""));
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy(""));
+    test_positive(&ManagerAsync::saveKey, "alias_prv", keys[RSA][0].prv, Policy(""));
+    test_positive(&ManagerAsync::saveKey, "alias_pub", keys[RSA][0].pub, Policy(""));
 
     auto obs = test_positive(&ManagerAsync::createSignature,
-                             dbc.alias("alias_prv"),
+                             "alias_prv",
                              "",
                              test_buffer,
                              HashAlgorithm::SHA1,
@@ -1119,7 +988,7 @@ RUNNER_CHILD_TEST(TA1630_verify_signature_invalid_message, CKMAsyncAPIEnv)
 
     test_negative(&ManagerAsync::verifySignature,
                   CKM_API_ERROR_VERIFICATION_FAILED,
-                  dbc.alias("alias_pub"),
+                  "alias_pub",
                   "",
                   raw_buffer("invalid-unsigned-mesage"),
                   obs->m_signed,
@@ -1127,16 +996,13 @@ RUNNER_CHILD_TEST(TA1630_verify_signature_invalid_message, CKMAsyncAPIEnv)
                   RSAPaddingAlgorithm::PKCS1);
 }
 
-RUNNER_CHILD_TEST(TA1640_verify_signature_invalid_signature, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1640_verify_signature_invalid_signature, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy(""));
+    test_positive(&ManagerAsync::saveKey, "alias_pub", keys[RSA][0].pub, Policy(""));
 
     test_negative(&ManagerAsync::verifySignature,
                   CKM_API_ERROR_VERIFICATION_FAILED,
-                  dbc.alias("alias_pub"),
+                  "alias_pub",
                   "",
                   test_buffer,
                   raw_buffer("invalid-signature"),
@@ -1144,24 +1010,21 @@ RUNNER_CHILD_TEST(TA1640_verify_signature_invalid_signature, CKMAsyncAPIEnv)
                   RSAPaddingAlgorithm::PKCS1);
 }
 
-RUNNER_CHILD_TEST(TA1650_verify_signature_wrong_key, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1650_verify_signature_wrong_key, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy(""));
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy(""));
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub2"), keys[RSA][1].pub, Policy(""));
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub3"), keys[DSA][0].prv, Policy(""));
+    test_positive(&ManagerAsync::saveKey, "alias_prv", keys[RSA][0].prv, Policy(""));
+    test_positive(&ManagerAsync::saveKey, "alias_pub", keys[RSA][0].pub, Policy(""));
+    test_positive(&ManagerAsync::saveKey, "alias_pub2", keys[RSA][1].pub, Policy(""));
+    test_positive(&ManagerAsync::saveKey, "alias_pub3", keys[DSA][0].prv, Policy(""));
     auto obs = test_positive(&ManagerAsync::createSignature,
-                             dbc.alias("alias_prv"),
+                             "alias_prv",
                              "",
                              test_buffer,
                              HashAlgorithm::SHA1,
                              RSAPaddingAlgorithm::PKCS1);
 
     test_positive(&ManagerAsync::verifySignature,
-                  dbc.alias("alias_prv"),
+                  "alias_prv",
                   "",
                   test_buffer,
                   obs->m_signed,
@@ -1169,7 +1032,7 @@ RUNNER_CHILD_TEST(TA1650_verify_signature_wrong_key, CKMAsyncAPIEnv)
                   RSAPaddingAlgorithm::PKCS1);
 
     test_positive(&ManagerAsync::verifySignature,
-                  dbc.alias("alias_pub"),
+                  "alias_pub",
                   "",
                   test_buffer,
                   obs->m_signed,
@@ -1178,7 +1041,7 @@ RUNNER_CHILD_TEST(TA1650_verify_signature_wrong_key, CKMAsyncAPIEnv)
 
     test_negative(&ManagerAsync::verifySignature,
                   CKM_API_ERROR_VERIFICATION_FAILED,
-                  dbc.alias("alias_pub2"),
+                  "alias_pub2",
                   "",
                   test_buffer,
                   obs->m_signed,
@@ -1187,7 +1050,7 @@ RUNNER_CHILD_TEST(TA1650_verify_signature_wrong_key, CKMAsyncAPIEnv)
 
     test_negative(&ManagerAsync::verifySignature,
                   CKM_API_ERROR_VERIFICATION_FAILED,
-                  dbc.alias("alias_pub3"),
+                  "alias_pub3",
                   "",
                   test_buffer,
                   obs->m_signed,
@@ -1195,22 +1058,19 @@ RUNNER_CHILD_TEST(TA1650_verify_signature_wrong_key, CKMAsyncAPIEnv)
                   RSAPaddingAlgorithm::PKCS1);
 }
 
-RUNNER_CHILD_TEST(TA1660_verify_signature_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1660_verify_signature_positive, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
-    DBCleanup dbc;
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_prv"), keys[RSA][0].prv, Policy("pass1"));
-    test_positive(&ManagerAsync::saveKey, dbc.alias("alias_pub"), keys[RSA][0].pub, Policy("pass2"));
+    test_positive(&ManagerAsync::saveKey, "alias_prv", keys[RSA][0].prv, Policy("pass1"));
+    test_positive(&ManagerAsync::saveKey, "alias_pub", keys[RSA][0].pub, Policy("pass2"));
     auto obs = test_positive(&ManagerAsync::createSignature,
-                             dbc.alias("alias_prv"),
+                             "alias_prv",
                              "pass1",
                              test_buffer,
                              HashAlgorithm::SHA1,
                              RSAPaddingAlgorithm::PKCS1);
 
     test_positive(&ManagerAsync::verifySignature,
-                  dbc.alias("alias_pub"),
+                  "alias_pub",
                   "pass2",
                   test_buffer,
                   obs->m_signed,
@@ -1220,17 +1080,14 @@ RUNNER_CHILD_TEST(TA1660_verify_signature_positive, CKMAsyncAPIEnv)
 
 
 // ocspCheck
-RUNNER_CHILD_TEST(TA1710_ocsp_check_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1710_ocsp_check_invalid_param, UserEnv)
 {
     test_no_observer(&ManagerAsync::ocspCheck, EMPTY_CERT_VECTOR);
     test_invalid_param(&ManagerAsync::ocspCheck, EMPTY_CERT_VECTOR);
 }
 
-RUNNER_CHILD_TEST(TA1720_ocsp_check_negative, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1720_ocsp_check_negative, UserEnv)
 {
-    switch_to_storage_ocsp_user(TEST_LABEL);
-
-    DBCleanup dbc;
     CertificateShPtrVector certv = { getTestCertificate(MBANK), getTestCertificate(MBANK) };
 
     auto obs = test_positive(&ManagerAsync::ocspCheck, certv);
@@ -1238,11 +1095,8 @@ RUNNER_CHILD_TEST(TA1720_ocsp_check_negative, CKMAsyncAPIEnv)
                          "Verification should fail. Got: " << obs->m_ocspStatus);
 }
 
-RUNNER_CHILD_TEST(TA1750_ocsp_check_positive, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1750_ocsp_check_positive, UserEnv)
 {
-    switch_to_storage_ocsp_user(TEST_LABEL);
-
-    DBCleanup dbc;
     CertificateShPtr cert = getTestCertificate(MBANK);
     CertificateShPtrVector certv = { getTestCertificate(SYMANTEC) };
     auto obs = test_positive<certChainFn1>(&ManagerAsync::getCertificateChain,
@@ -1257,27 +1111,26 @@ RUNNER_CHILD_TEST(TA1750_ocsp_check_positive, CKMAsyncAPIEnv)
 }
 
 // setPermission
-RUNNER_CHILD_TEST(TA1810_allow_access_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1810_allow_access_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::setPermission, "alias", "accessor", CKM::Permission::READ | CKM::Permission::REMOVE);
     test_invalid_param(&ManagerAsync::setPermission, "", "accessor", CKM::Permission::READ | CKM::Permission::REMOVE);
     test_invalid_param(&ManagerAsync::setPermission, "alias", "", CKM::Permission::READ | CKM::Permission::REMOVE);
 }
 
-RUNNER_TEST(TA1820_allow_access, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1820_allow_access, RemoveDataEnv<APP_UID>)
 {
+    ScopedDBUnlock dbu(APP_UID, TEST_PASS);
+
     // prepare: add data
     std::string alias1 = aliasWithLabel(TEST_LABEL, "alias-1");
     std::string alias2 = aliasWithLabel(TEST_LABEL, "alias-2");
     std::string alias3 = aliasWithLabel(TEST_LABEL, "alias-3");
-    GarbageCollector gc;
     {
         ScopedAccessProvider ap(TEST_LABEL, APP_UID, APP_GID);
-        gc.save(alias1.c_str(), TEST_DATA);
-        gc.save(alias2.c_str(), TEST_DATA);
-        gc.save(alias3.c_str(), TEST_DATA);
+        save_data(alias1.c_str(), TEST_DATA);
+        save_data(alias2.c_str(), TEST_DATA);
+        save_data(alias3.c_str(), TEST_DATA);
 
         test_positive(&ManagerAsync::setPermission,
                       alias2,
@@ -1308,23 +1161,22 @@ RUNNER_TEST(TA1820_allow_access, CKMAsyncAPIEnv)
 }
 
 // denyAccess
-RUNNER_CHILD_TEST(TA1910_deny_access_invalid_param, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1910_deny_access_invalid_param, UserEnv)
 {
-    switch_to_storage_user(TEST_LABEL);
-
     test_no_observer(&ManagerAsync::setPermission, "alias", "accessor", CKM::Permission::NONE);
     test_invalid_param(&ManagerAsync::setPermission, "", "accessor", CKM::Permission::NONE);
     test_invalid_param(&ManagerAsync::setPermission, "alias", "", CKM::Permission::NONE);
 }
 
-RUNNER_TEST(TA1920_deny_access, CKMAsyncAPIEnv)
+RUNNER_TEST(TA1920_deny_access, RemoveDataEnv<APP_UID>)
 {
+    ScopedDBUnlock dbu(APP_UID, TEST_PASS);
+
     // prepare: add data
     std::string alias1 = aliasWithLabel(TEST_LABEL, "alias-1");
-    GarbageCollector gc;
     {
         ScopedAccessProvider ap(TEST_LABEL, APP_UID, APP_GID);
-        gc.save(alias1.c_str(), TEST_DATA);
+        save_data(alias1.c_str(), TEST_DATA);
 
         test_positive(&ManagerAsync::setPermission,
                       alias1,
@@ -1344,9 +1196,8 @@ RUNNER_TEST(TA1920_deny_access, CKMAsyncAPIEnv)
     }
 }
 
-RUNNER_TEST(TA2000_PKCS_add_bundle_with_chain_certs, CKMAsyncAPIEnv)
+RUNNER_TEST(TA2000_PKCS_add_bundle_with_chain_certs, RemoveDataEnv<0>)
 {
-    DBCleanup dbc;
     auto pkcs = loadPkcs();
 
     // save to the CKM
@@ -1354,34 +1205,32 @@ RUNNER_TEST(TA2000_PKCS_add_bundle_with_chain_certs, CKMAsyncAPIEnv)
     CKM::Policy notExportable(CKM::Password(), false);
 
     test_positive(&ManagerAsync::savePKCS12,
-                  dbc.alias(sharedDatabase(alias_PKCS_exportable).c_str()),
+                  sharedDatabase(alias_PKCS_exportable),
                   pkcs,
                   exportable,
                   exportable);
     test_negative(&ManagerAsync::savePKCS12,
                   CKM_API_ERROR_DB_ALIAS_EXISTS,
-                  dbc.alias(sharedDatabase(alias_PKCS_exportable).c_str()),
+                  sharedDatabase(alias_PKCS_exportable),
                   pkcs,
                   exportable,
                   exportable);
 
     test_positive(&ManagerAsync::savePKCS12,
-                  dbc.alias(sharedDatabase(alias_PKCS_not_exportable).c_str()),
+                  sharedDatabase(alias_PKCS_not_exportable),
                   pkcs,
                   notExportable,
                   notExportable);
     test_negative(&ManagerAsync::savePKCS12,
                   CKM_API_ERROR_DB_ALIAS_EXISTS,
-                  dbc.alias(sharedDatabase(alias_PKCS_not_exportable).c_str()),
+                  sharedDatabase(alias_PKCS_not_exportable),
                   pkcs,
                   notExportable,
                   notExportable);
 }
 
-RUNNER_TEST(TA2010_PKCS_get, CKMAsyncAPIEnv)
+RUNNER_TEST(TA2010_PKCS_get, RemoveDataEnv<0>)
 {
-    DBCleanup dbc;
-
     auto pkcs = loadPkcs();
 
     // save to the CKM
@@ -1389,12 +1238,12 @@ RUNNER_TEST(TA2010_PKCS_get, CKMAsyncAPIEnv)
     CKM::Policy notExportable(CKM::Password(), false);
 
     test_positive(&ManagerAsync::savePKCS12,
-                  dbc.alias(sharedDatabase(alias_PKCS_exportable).c_str()),
+                  sharedDatabase(alias_PKCS_exportable),
                   pkcs,
                   exportable,
                   exportable);
     test_positive(&ManagerAsync::savePKCS12,
-                  dbc.alias(sharedDatabase(alias_PKCS_not_exportable).c_str()),
+                  sharedDatabase(alias_PKCS_not_exportable),
                   pkcs,
                   notExportable,
                   notExportable);
@@ -1410,13 +1259,13 @@ RUNNER_TEST(TA2010_PKCS_get, CKMAsyncAPIEnv)
     // fail - not exportable
     test_negative(&ManagerAsync::getPKCS12,
                   CKM_API_ERROR_NOT_EXPORTABLE,
-                  dbc.alias(sharedDatabase(alias_PKCS_not_exportable).c_str()),
+                  sharedDatabase(alias_PKCS_not_exportable),
                   CKM::Password(),
                   CKM::Password());
 
     // success - exportable
     auto obs = test_positive(&ManagerAsync::getPKCS12,
-                             dbc.alias(sharedDatabase(alias_PKCS_exportable).c_str()),
+                             sharedDatabase(alias_PKCS_exportable),
                              CKM::Password(),
                              CKM::Password());
 
@@ -1435,9 +1284,3 @@ RUNNER_TEST(TA2010_PKCS_get, CKMAsyncAPIEnv)
         2 == caVector.size(),
         "Wrong size of vector");
 }
-
-RUNNER_TEST(TA9999_deinit)
-{
-    remove_user_data(0);
-    remove_user_data(APP_UID);
-}

diff --git a/src/ckm/ckm-common.cpp b/src/ckm/ckm-common.cpp
index 3bbbd4f..e999373 100644 (file)
--- a/src/ckm/ckm-common.cpp
+++ b/src/ckm/ckm-common.cpp
@@ -48,31 +48,6 @@ void stop_service(ServiceIdx idx)
     sm.stopService();
 }
 
-
-void switch_to_storage_user(const char* label)
-{
-    AccessProvider ap(label);
-    ap.allowAPI("key-manager::api-storage", "rw");
-    ap.applyAndSwithToUser(APP_UID, APP_GID);
-}
-
-void switch_to_storage_ocsp_user(const char* label)
-{
-    AccessProvider ap(label);
-    ap.allowAPI("key-manager::api-storage", "rw");
-    ap.allowAPI("key-manager::api-ocsp", "rw");
-    ap.applyAndSwithToUser(APP_UID, APP_GID);
-}
-
-DBCleanup::~DBCleanup()
-{
-    // Let it throw. If db can't be cleared further tests are unreliable
-    CKM::ManagerShPtr mgr = CKM::Manager::create();
-    for(const auto& it:m_aliases)
-        mgr->removeAlias(it);
-    m_aliases.clear();
-}
-
 // returns process label
 CharPtr get_label()
 {

diff --git a/src/ckm/ckm-common.h b/src/ckm/ckm-common.h
index 51f60ce..7a5ccd7 100644 (file)
--- a/src/ckm/ckm-common.h
+++ b/src/ckm/ckm-common.h
@@ -22,17 +22,13 @@
 #pragma once
 
 #include <string>
-#include <unordered_set>
 #include <memory>
 #include <ckm/ckm-type.h>
 #include <ckmc/ckmc-type.h>
 #include <ckmc/ckmc-error.h>
 #include <tests_common.h>
 #include <sys/types.h>
-
-void switch_to_storage_user(const char* label);
-void switch_to_storage_ocsp_user(const char* label);
-
+#include <access_provider2.h>
 
 // RUNNER_ASSERT wrappers
 template <typename F, typename... Args>
@@ -80,23 +76,6 @@ void stop_service(ServiceIdx idx);
 const char * CKMCErrorToString(int error);
 std::string CKMCReadableError(int error);
 
-// Class responsible for db cleanup after positive tests. Will remove all used aliases in destructor
-class DBCleanup
-{
-public:
-    DBCleanup() {}
-
-    const char* alias(const char* alias)
-    {
-        return m_aliases.insert(CKM::Alias(alias)).first->c_str();
-    }
-
-    ~DBCleanup();
-
-private:
-    std::unordered_set<CKM::Alias> m_aliases;
-};
-
 // scoped free
 typedef std::unique_ptr<char, void (*)(void *)> CharPtr;
 
@@ -199,3 +178,31 @@ typedef enum {
 } alias_type_;
 size_t count_aliases(alias_type_ type, size_t minimum_initial_element_count = 0);
 std::string sharedDatabase(const CKM::Alias & alias);
+
+// Test env class for database cleanup. Pass database uids to cleanup before and after test
+template <uid_t ...Args>
+class RemoveDataEnv;
+
+template <>
+class RemoveDataEnv<>
+{
+public:
+    void init(const std::string&)
+    {}
+    void finish()
+    {}
+};
+
+template <uid_t UID, uid_t ...Args>
+class RemoveDataEnv<UID, Args...> : public RemoveDataEnv<Args...>
+{
+public:
+    void init(const std::string & str) {
+        remove_user_data(UID);
+        RemoveDataEnv<Args...>::init(str);
+    }
+    void finish() {
+        RemoveDataEnv<Args...>::finish();
+        remove_user_data(UID);
+    }
+};