From 39ec52c5beac7a36881e2e666e7ba016e3512fc0 Mon Sep 17 00:00:00 2001 From: "Maciej J. Karpiuk" Date: Tue, 7 Oct 2014 13:02:28 +0200 Subject: [PATCH] Add DB performance analysis tests and performance improvements. Change-Id: I5e3bd05e6390392dde2d9837d067de36da82d978 --- src/manager/service/db-crypto.cpp | 18 +- tests/CMakeLists.txt | 1 + tests/DBFixture.cpp | 208 +++++++++++++++++++ tests/DBFixture.h | 46 +++++ tests/test_common.h | 3 + tests/test_db_crypto.cpp | 414 +++++++++++++++++++++----------------- 6 files changed, 491 insertions(+), 199 deletions(-) create mode 100644 tests/DBFixture.cpp create mode 100644 tests/DBFixture.h diff --git a/src/manager/service/db-crypto.cpp b/src/manager/service/db-crypto.cpp index fa33752..7155846 100644 --- a/src/manager/service/db-crypto.cpp +++ b/src/manager/service/db-crypto.cpp @@ -49,8 +49,7 @@ namespace { " data BLOB NOT NULL," " tag BLOB NOT NULL," " PRIMARY KEY(alias)" - ");"; - + "); CREATE INDEX alias_idx ON CKM_TABLE(alias);"; const char *insert_main_cmd = "INSERT INTO CKM_TABLE(" @@ -114,7 +113,7 @@ namespace { " accessFlags TEXT NOT NULL," " FOREIGN KEY(alias) REFERENCES CKM_TABLE(alias) ON DELETE CASCADE," " PRIMARY KEY(alias, label)" - ");"; + "); CREATE INDEX alias_label_idx ON PERMISSION_TABLE(alias, label);"; const char *set_permission_alias_cmd = "REPLACE INTO PERMISSION_TABLE(alias, label, accessFlags) VALUES (?, ?, ?);"; @@ -131,17 +130,12 @@ namespace { // CKM_TABLE x PERMISSION_TABLE const char *select_type_cross_cmd = - // 1 2 3 - "SELECT c.alias FROM CKM_TABLE c WHERE c.dataType=? AND (c.label=? OR c.alias IN (SELECT p.alias FROM PERMISSION_TABLE p WHERE p.label=?));"; + // 1 2 3 + "SELECT C.alias FROM CKM_TABLE AS C LEFT JOIN PERMISSION_TABLE AS P ON C.alias = P.alias WHERE C.dataType=? AND (C.label=? OR (P.label=? AND P.accessFlags IS NOT NULL)) GROUP BY C.alias;"; const char *select_key_type_cross_cmd = - "SELECT c.alias FROM CKM_TABLE c WHERE " - // 1 - " c.dataType >= ? AND " - // 2 - " c.dataType <= ? AND " - // 3 4 - " (c.label=? OR c.alias IN (SELECT p.alias FROM PERMISSION_TABLE p WHERE p.label=?));"; + // 1 2 3 4 + "SELECT C.alias FROM CKM_TABLE AS C LEFT JOIN PERMISSION_TABLE AS P ON C.alias=P.alias WHERE C.dataType>=? AND C.dataType<=? AND (C.label=? OR (P.label=? AND P.accessFlags IS NOT NULL)) GROUP BY C.alias;"; } namespace CKM { diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index f7b6eeb..21478fa 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -27,6 +27,7 @@ INCLUDE_DIRECTORIES( SET(TEST_MERGED_SOURCES ${KEY_MANAGER_TEST_MERGED_SRC}/test_common.cpp + ${KEY_MANAGER_TEST_MERGED_SRC}/DBFixture.cpp ${KEY_MANAGER_TEST_MERGED_SRC}/colour_log_formatter.cpp ${KEY_MANAGER_TEST_MERGED_SRC}/test_db_crypto.cpp ${KEY_MANAGER_TEST_MERGED_SRC}/test_sql.cpp diff --git a/tests/DBFixture.cpp b/tests/DBFixture.cpp new file mode 100644 index 0000000..f463613 --- /dev/null +++ b/tests/DBFixture.cpp @@ -0,0 +1,208 @@ +#include +#include +#include +#include + +using namespace CKM; +using namespace std::chrono; + + +DBFixture::DBFixture() +{ + high_resolution_clock::time_point srand_feed = high_resolution_clock::now(); + srand(srand_feed.time_since_epoch().count()); + + BOOST_CHECK(unlink(m_crypto_db_fname) == 0 || errno == ENOENT); + BOOST_REQUIRE_NO_THROW(m_db = DBCrypto(m_crypto_db_fname, defaultPass)); +} + +double DBFixture::performance_get_time_elapsed_ms() +{ + return duration_cast(m_end_time - m_start_time).count(); +} + +void DBFixture::performance_start(const char *operation_name) +{ + m_operation = std::string(operation_name?operation_name:"unknown"); + BOOST_TEST_MESSAGE("\t running " << m_operation << " performance test..."); + m_start_time = high_resolution_clock::now(); +} + +void DBFixture::performance_stop(long num_operations_performed) +{ + m_end_time = high_resolution_clock::now(); + double time_elapsed_ms = performance_get_time_elapsed_ms(); + BOOST_TEST_MESSAGE("\t time elapsed: " << time_elapsed_ms << "[ms], number of " << m_operation << ": " << num_operations_performed); + if(num_operations_performed>0) + BOOST_TEST_MESSAGE("\t average time per " << m_operation << ": " << time_elapsed_ms/num_operations_performed << "[ms]"); +} + +void DBFixture::generate_alias(unsigned int id, std::string & output) +{ + std::stringstream ss; + ss << "alias_no_" << id; + output = ss.str(); +} + +void DBFixture::generate_label(unsigned int id, std::string & output) +{ + std::stringstream ss; + ss << "label_no_" << id; + output = ss.str(); +} + +void DBFixture::generate_perf_DB(unsigned int num_alias, unsigned int num_label) +{ + // to speed up data creation - cache the row + DBRow rowPattern = create_default_row(DBDataType::BINARY_DATA); + rowPattern.data = RawBuffer(100, 20); + rowPattern.dataSize = rowPattern.data.size(); + rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1); + + for(unsigned int i=0; i 0, "Inserted row didn't exist in db"); + + DBCrypto::DBRowOptional row_optional; + BOOST_REQUIRE_NO_THROW(row_optional = m_db.getDBRow("alias", "label", DBDataType::BINARY_DATA)); + BOOST_REQUIRE_MESSAGE(!row_optional, "Select should not return row after deletion"); +} + +void DBFixture::insert_row() +{ + insert_row(m_default_alias, m_default_label); +} + +void DBFixture::insert_row(const std::string &alias, const std::string &accessor_label) +{ + DBRow rowPattern = create_default_row(alias, accessor_label, DBDataType::BINARY_DATA); + rowPattern.data = RawBuffer(100, 20); + rowPattern.dataSize = rowPattern.data.size(); + rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1); + BOOST_REQUIRE_NO_THROW(m_db.saveDBRow(rowPattern)); +} + +void DBFixture::delete_row(const std::string &alias, const std::string &accessor_label) +{ + bool exit_flag; + BOOST_REQUIRE_NO_THROW(exit_flag = m_db.deleteDBRow(alias, accessor_label)); + BOOST_REQUIRE_MESSAGE(true == exit_flag, "remove alias failed: no rows removed"); +} + +void DBFixture::add_permission(const std::string &alias, const std::string &owner_label, const std::string &accessor_label) +{ + int ec; + BOOST_REQUIRE_NO_THROW(ec = m_db.setAccessRights(owner_label, + alias, + accessor_label, + CKM::AccessRight::AR_READ_REMOVE)); + BOOST_REQUIRE_MESSAGE(CKM_API_SUCCESS == ec, "add permission failed: " << ec); +} + +void DBFixture::read_row_expect_fail(const std::string &alias, const std::string &accessor_label) +{ + DBCrypto::DBRowOptional row; + BOOST_REQUIRE_THROW(row = m_db.getDBRow(alias, accessor_label, DBDataType::BINARY_DATA), DBCrypto::Exception::PermissionDenied); +} + +void DBFixture::read_row_expect_success(const std::string &alias, const std::string &accessor_label) +{ + DBCrypto::DBRowOptional row; + BOOST_REQUIRE_NO_THROW(row = m_db.getDBRow(alias, accessor_label, DBDataType::BINARY_DATA)); + BOOST_REQUIRE_MESSAGE(row, "row is empty"); + BOOST_REQUIRE_MESSAGE(row->alias == alias, "alias is not valid"); +} diff --git a/tests/DBFixture.h b/tests/DBFixture.h new file mode 100644 index 0000000..883e963 --- /dev/null +++ b/tests/DBFixture.h @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include + +class DBFixture +{ + public: + DBFixture(); + + constexpr static const char* m_default_alias = "alias"; + constexpr static const char* m_default_label = "label"; + + // ::::::::::::::::::::::::: helper methods ::::::::::::::::::::::::: + static void generate_alias(unsigned int id, std::string & output); + static void generate_label(unsigned int id, std::string & output); + static CKM::DBRow create_default_row(CKM::DBDataType type = CKM::DBDataType::BINARY_DATA); + static CKM::DBRow create_default_row(const std::string &alias, + const std::string &label, + CKM::DBDataType type = CKM::DBDataType::BINARY_DATA); + static void compare_row(const CKM::DBRow &lhs, const CKM::DBRow &rhs); + + // ::::::::::::::::::::::::: time measurement ::::::::::::::::::::::::: + void performance_start(const char *operation_name); + void performance_stop(long num_operations_performed); + + // ::::::::::::::::::::::::: DB ::::::::::::::::::::::::: + void generate_perf_DB(unsigned int num_alias, unsigned int num_label); + long add_full_access_rights(unsigned int num_alias, unsigned int num_alias_per_label); + void check_DB_integrity(const CKM::DBRow &rowPattern); + void insert_row(); + void insert_row(const std::string &alias, const std::string &accessor_label); + void delete_row(const std::string &alias, const std::string &accessor_label); + void add_permission(const std::string &alias, const std::string &owner_label, const std::string &accessor_label); + void read_row_expect_fail(const std::string &alias, const std::string &accessor_label); + void read_row_expect_success(const std::string &alias, const std::string &accessor_label); + + CKM::DBCrypto m_db; + private: + double performance_get_time_elapsed_ms(); + + constexpr static const char* m_crypto_db_fname = "/tmp/testme.db"; + std::string m_operation; + std::chrono::high_resolution_clock::time_point m_start_time, m_end_time; +}; diff --git a/tests/test_common.h b/tests/test_common.h index 681bd4d..83234f1 100644 --- a/tests/test_common.h +++ b/tests/test_common.h @@ -16,6 +16,9 @@ struct TestConfig { private: }; +// mirrors the API-defined value +#define AES_GCM_TAG_SIZE 16 + CKM::RawBuffer createDefaultPass(); CKM::RawBuffer createBigBlob(std::size_t size); diff --git a/tests/test_db_crypto.cpp b/tests/test_db_crypto.cpp index e15fa44..4344541 100644 --- a/tests/test_db_crypto.cpp +++ b/tests/test_db_crypto.cpp @@ -6,8 +6,8 @@ #include #include #include - #include +#include BOOST_GLOBAL_FIXTURE(TestConfig) @@ -15,191 +15,59 @@ using namespace CKM; namespace { - -const char* default_alias = "alias"; -const char* default_label = "label"; - -const char* crypto_db = "/tmp/testme.db"; - const int restricted_local = 1; const int restricted_global = 0; -// mirrors the API-defined value -#define AES_GCM_TAG_SIZE 16 - -const char *row_A_alias = "row_A_alias"; -const char *row_A_label = "app_A"; - -const char *row_B_alias = "row_B_alias"; -const char *row_B_label = "app_B"; - -const char *row_C_alias = "row_C_alias"; -const char *row_C_label = "app_C"; - -void initDB(DBCrypto & db) -{ - BOOST_CHECK(unlink(crypto_db) == 0 || errno == ENOENT); - BOOST_REQUIRE_NO_THROW(db = DBCrypto(crypto_db, defaultPass)); -} - -DBRow createDefaultRow( DBDataType type = DBDataType::BINARY_DATA, - const char *optional_alias = NULL, - const char *optional_label = NULL) -{ - DBRow row; - row.alias = optional_alias?optional_alias:default_alias; - row.smackLabel = optional_label?optional_label:default_label; - row.exportable = 1; - row.algorithmType = DBCMAlgType::AES_GCM_256; - row.dataType = type; - row.iv = createDefaultPass(); - row.encryptionScheme = 0; - row.dataSize = 0; - - return row; -} - -void compareDBRow(const DBRow &lhs, const DBRow &rhs) { - BOOST_CHECK_MESSAGE(lhs.alias == rhs.alias, - "Aliases didn't match! Got: " << rhs.alias - << " , expected : " << lhs.alias); - - BOOST_CHECK_MESSAGE(lhs.smackLabel == rhs.smackLabel, - "smackLabel didn't match! Got: " << rhs.smackLabel - << " , expected : " << lhs.smackLabel); - - BOOST_CHECK_MESSAGE(lhs.exportable == rhs.exportable, - "exportable didn't match! Got: " << rhs.exportable - << " , expected : " << lhs.exportable); - - BOOST_CHECK_MESSAGE(lhs.iv == rhs.iv, - "iv didn't match! Got: " << rhs.iv.size() - << " , expected : " << lhs.iv.size()); - - BOOST_CHECK_MESSAGE(lhs.data == rhs.data, - "data didn't match! Got: " << rhs.data.size() - << " , expected : " << lhs.data.size()); +const unsigned int c_test_retries = 1000; +const unsigned int c_num_aliases = 500; +const unsigned int c_num_aliases_add_test = 5000; +const unsigned int c_alias_per_label = 15; } -void checkDBIntegrity(const DBRow &rowPattern, DBCrypto &db) { - - BOOST_REQUIRE_NO_THROW(db.saveDBRow(rowPattern)); - DBRow selectRow = rowPattern; - - DBCrypto::DBRowOptional optional_row; - BOOST_REQUIRE_NO_THROW(optional_row = db.getDBRow("alias", "label", DBDataType::BINARY_DATA)); - BOOST_REQUIRE_MESSAGE(optional_row, "Select didn't return any row"); - compareDBRow(selectRow, rowPattern); - DBRow alias_duplicate = rowPattern; - alias_duplicate.data = createDefaultPass(); - alias_duplicate.dataSize = alias_duplicate.data.size(); - - BOOST_REQUIRE_THROW(db.saveDBRow(alias_duplicate), DBCrypto::Exception::AliasExists); - unsigned int erased; - BOOST_REQUIRE_NO_THROW(erased = db.deleteDBRow("alias", "label")); - BOOST_REQUIRE_MESSAGE(erased > 0, "Inserted row didn't exist in db"); - - DBCrypto::DBRowOptional row_optional; - BOOST_REQUIRE_NO_THROW(row_optional = db.getDBRow("alias", "label", DBDataType::BINARY_DATA)); - BOOST_REQUIRE_MESSAGE(!row_optional, "Select should not return row after deletion"); -} - -void insertRow(DBCrypto & db, const char *alias, const char *label) -{ - DBRow rowPattern = createDefaultRow(DBDataType::BINARY_DATA, alias, label); - rowPattern.data = RawBuffer(100, 20); - rowPattern.dataSize = rowPattern.data.size(); - rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1); - BOOST_REQUIRE_NO_THROW(db.saveDBRow(rowPattern)); -} - -void deleteRow(DBCrypto & db, const char *alias, const char *label) -{ - bool exit_flag; - BOOST_REQUIRE_NO_THROW(exit_flag = db.deleteDBRow(alias, label)); - BOOST_REQUIRE_MESSAGE(true == exit_flag, "remove alias failed: no rows removed"); -} - -void addPermission(DBCrypto & db, const char *alias, const char *owner_label, const char *accessor_label) -{ - int ec; - BOOST_REQUIRE_NO_THROW(ec = db.setAccessRights(std::string(owner_label), - std::string(alias), - std::string(accessor_label), - CKM::AccessRight::AR_READ_REMOVE)); - BOOST_REQUIRE_MESSAGE(CKM_API_SUCCESS == ec, "add permission failed: " << ec); -} - -void readRowExpectFail(DBCrypto & db, const char *alias, const char *accessor_label) -{ - DBCrypto::DBRowOptional row; - BOOST_REQUIRE_THROW(row = db.getDBRow(alias, accessor_label, DBDataType::BINARY_DATA), DBCrypto::Exception::PermissionDenied); -} - -void readRowExpectSuccess(DBCrypto & db, const char *alias, const char *accessor_label) -{ - DBCrypto::DBRowOptional row; - BOOST_REQUIRE_NO_THROW(row = db.getDBRow(alias, accessor_label, DBDataType::BINARY_DATA)); - BOOST_REQUIRE_MESSAGE(row, "row is empty"); -} -} - -BOOST_AUTO_TEST_SUITE(DBCRYPTO_TEST) +BOOST_FIXTURE_TEST_SUITE(DBCRYPTO_TEST, DBFixture) BOOST_AUTO_TEST_CASE(DBtestSimple) { - DBCrypto db; - initDB(db); - - DBRow rowPattern = createDefaultRow(); + DBRow rowPattern = create_default_row(); rowPattern.data = RawBuffer(32, 1); rowPattern.dataSize = rowPattern.data.size(); rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1); - checkDBIntegrity(rowPattern, db); + check_DB_integrity(rowPattern); } BOOST_AUTO_TEST_CASE(DBtestBIG) { - DBCrypto db; - initDB(db); - - DBRow rowPattern = createDefaultRow(); + DBRow rowPattern = create_default_row(); rowPattern.data = createBigBlob(4096); rowPattern.dataSize = rowPattern.data.size(); rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1); - checkDBIntegrity(rowPattern, db); + check_DB_integrity(rowPattern); } BOOST_AUTO_TEST_CASE(DBtestGlobal) { - DBCrypto db; - initDB(db); - - DBRow rowPattern = createDefaultRow(); + DBRow rowPattern = create_default_row(); rowPattern.data = RawBuffer(1024, 2); rowPattern.dataSize = rowPattern.data.size(); rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1); - BOOST_REQUIRE_NO_THROW(db.saveDBRow(rowPattern)); + BOOST_REQUIRE_NO_THROW(m_db.saveDBRow(rowPattern)); DBRow alias_duplicate = rowPattern; rowPattern.smackLabel = rowPattern.smackLabel + "1"; - BOOST_REQUIRE_THROW(db.saveDBRow(alias_duplicate), + BOOST_REQUIRE_THROW(m_db.saveDBRow(alias_duplicate), DBCrypto::Exception::AliasExists); } BOOST_AUTO_TEST_CASE(DBtestTransaction) { - DBCrypto db; - initDB(db); - - DBRow rowPattern = createDefaultRow(); + DBRow rowPattern = create_default_row(); rowPattern.data = RawBuffer(100, 20); rowPattern.dataSize = rowPattern.data.size(); rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1); - DBCrypto::Transaction transaction(&db); + DBCrypto::Transaction transaction(&m_db); - BOOST_REQUIRE_NO_THROW(db.saveDBRow(rowPattern)); + BOOST_REQUIRE_NO_THROW(m_db.saveDBRow(rowPattern)); BOOST_REQUIRE_NO_THROW(transaction.rollback()); DBCrypto::DBRowOptional row_optional; - BOOST_REQUIRE_NO_THROW(row_optional = db.getDBRow(default_alias, default_label, + BOOST_REQUIRE_NO_THROW(row_optional = m_db.getDBRow(m_default_alias, m_default_label, DBDataType::BINARY_DATA)); BOOST_CHECK_MESSAGE(!row_optional, "Row still present after rollback"); @@ -207,84 +75,256 @@ BOOST_AUTO_TEST_CASE(DBtestTransaction) { BOOST_AUTO_TEST_CASE(DBaddDataCheckIfPermissionIsAdded) { - DBCrypto db; - initDB(db); + std::string row_A_alias, row_B_alias; + std::string row_A_label, row_B_label; + generate_alias(0, row_A_alias); generate_label(0, row_A_label); + generate_alias(1, row_B_alias); generate_label(1, row_B_label); // insert initial data set - insertRow(db, row_A_alias, row_A_label); - insertRow(db, row_B_alias, row_B_label); - readRowExpectSuccess(db, row_A_alias, row_A_label); - readRowExpectSuccess(db, row_B_alias, row_B_label); + insert_row(row_A_alias, row_A_label); + insert_row(row_B_alias, row_B_label); + read_row_expect_success(row_A_alias, row_A_label); + read_row_expect_success(row_B_alias, row_B_label); // verify that no entries present in the permission table // read row A from label B and vice versa - readRowExpectFail(db, row_A_alias, row_B_label); - readRowExpectFail(db, row_B_alias, row_A_label); + read_row_expect_fail(row_A_alias, row_B_label); + read_row_expect_fail(row_B_alias, row_A_label); // add appropriate permissions for label B - addPermission(db, row_A_alias, row_A_label, row_B_label); + add_permission(row_A_alias, row_A_label, row_B_label); // B should have access to A, while A should not to B // read row A from label B and vice versa - readRowExpectSuccess(db, row_A_alias, row_B_label); - readRowExpectFail(db, row_B_alias, row_A_label); + read_row_expect_success(row_A_alias, row_B_label); + read_row_expect_fail(row_B_alias, row_A_label); // add appropriate permissions for label A - addPermission(db, row_B_alias, row_B_label, row_A_label); + add_permission(row_B_alias, row_B_label, row_A_label); // B should have access to A, same as A have access to B // read row A from label B and vice versa - readRowExpectSuccess(db, row_A_alias, row_B_label); - readRowExpectSuccess(db, row_B_alias, row_A_label); + read_row_expect_success(row_A_alias, row_B_label); + read_row_expect_success(row_B_alias, row_A_label); } BOOST_AUTO_TEST_CASE(DBremoveDataCheckIfPermissionIsRemoved) { - DBCrypto db; - initDB(db); + std::string row_A_alias, row_B_alias, row_C_alias; + std::string row_A_label, row_B_label, row_C_label; + generate_alias(0, row_A_alias); generate_label(0, row_A_label); + generate_alias(1, row_B_alias); generate_label(1, row_B_label); + generate_alias(2, row_C_alias); generate_label(2, row_C_label); // insert initial data set - insertRow(db, row_A_alias, row_A_label); - insertRow(db, row_B_alias, row_B_label); - insertRow(db, row_C_alias, row_C_label); - addPermission(db, row_A_alias, row_A_label, row_B_label); - addPermission(db, row_B_alias, row_B_label, row_A_label); + insert_row(row_A_alias, row_A_label); + insert_row(row_B_alias, row_B_label); + insert_row(row_C_alias, row_C_label); + add_permission(row_A_alias, row_A_label, row_B_label); + add_permission(row_B_alias, row_B_label, row_A_label); // to test multiple permissions removal // put intentionally after row_B_alias permission entry - addPermission(db, row_A_alias, row_A_label, row_C_label); + add_permission(row_A_alias, row_A_label, row_C_label); // B should have access to A, same as A have access to B // read row A from label B and vice versa - readRowExpectSuccess(db, row_A_alias, row_B_label); - readRowExpectSuccess(db, row_A_alias, row_C_label); - readRowExpectSuccess(db, row_B_alias, row_A_label); - readRowExpectFail(db, row_B_alias, row_C_label); + read_row_expect_success(row_A_alias, row_B_label); + read_row_expect_success(row_A_alias, row_C_label); + read_row_expect_success(row_B_alias, row_A_label); + read_row_expect_fail(row_B_alias, row_C_label); // remove data A - expect permissions for B and C to be removed as well - deleteRow(db, row_A_alias, row_A_label); + delete_row(row_A_alias, row_A_label); // insert it again - expect permissions for label B and C not to be there anymore - insertRow(db, row_A_alias, row_A_label); + insert_row(row_A_alias, row_A_label); // read row A from label B and vice versa - readRowExpectFail(db, row_A_alias, row_B_label); - readRowExpectFail(db, row_A_alias, row_C_label); - readRowExpectSuccess(db, row_B_alias, row_A_label); + read_row_expect_fail(row_A_alias, row_B_label); + read_row_expect_fail(row_A_alias, row_C_label); + read_row_expect_success(row_B_alias, row_A_label); // remove data B - expect permission to be removed as well - deleteRow(db, row_B_alias, row_B_label); + delete_row(row_B_alias, row_B_label); // insert it again - expect permissions for label A not to be there anymore - insertRow(db, row_B_alias, row_B_label); + insert_row(row_B_alias, row_B_label); // read row A from label B and vice versa - readRowExpectFail(db, row_A_alias, row_B_label); - readRowExpectFail(db, row_A_alias, row_C_label); - readRowExpectFail(db, row_B_alias, row_A_label); + read_row_expect_fail(row_A_alias, row_B_label); + read_row_expect_fail(row_A_alias, row_C_label); + read_row_expect_fail(row_B_alias, row_A_label); // sanity check: data exists - readRowExpectSuccess(db, row_A_alias, row_A_label); - readRowExpectSuccess(db, row_B_alias, row_B_label); + read_row_expect_success(row_A_alias, row_A_label); + read_row_expect_success(row_B_alias, row_B_label); +} +BOOST_AUTO_TEST_SUITE_END() + + + +BOOST_FIXTURE_TEST_SUITE(DBCRYPTO_PERF_TEST, DBFixture) + +BOOST_AUTO_TEST_CASE(DBperfAddAliases) +{ + // actual test + performance_start("saveDBRow"); + { + generate_perf_DB(c_num_aliases_add_test, c_alias_per_label); + } + performance_stop(c_num_aliases_add_test); +} + +BOOST_AUTO_TEST_CASE(DBperfLookupAliasByOwner) +{ + // prepare data + generate_perf_DB(c_num_aliases, c_alias_per_label); + + unsigned int num_labels = c_num_aliases/c_alias_per_label; + std::string alias, label; + + // actual test - successful lookup + performance_start("getDBRow"); + for(unsigned int t=0; t