Added unit-tests for RocksDB (161fe157) · Commits · David Auer / gekkofs

tests/unit/CMakeLists.txt

+1 −2

Original line number	Diff line number	Diff line
		@@ -29,8 +29,7 @@ target_link_libraries(catch2_main
		Catch2::Catch2
		)

		# needed for filesystem header
		set(CMAKE_CXX_STANDARD 17)


		# define executables for tests and make them depend on the convenience
		# library (and Catch2 transitively) and fmt

tests/unit/db_test.cpp

+207 −161

Original line number	Diff line number	Diff line
		@@ -14,13 +14,46 @@
		#include <set>
		#include <filesystem>
		#include <string>
		#include <boost/filesystem.hpp>

		// nach auflistugn/beschreibungsmöglichkeiten schauen
		// -l -t für auflistung
		// --list-test-names-only

		std::string gen_random(const int len, bool key) {
		std::string s;
		s.resize(len);
		static const char alphanum[] =
		"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
		"abcdefghijklmnopqrstuvwxyz";

		static const char numbers[] = "123456789";
		if (key) {
		s[0] = '/';
		for (int i = 1; i < len; ++i) {
		s[i] = alphanum[std::rand() % (sizeof(alphanum) - 1)];
		}
		s[len] = '\0';
		}else{
		if(len < 6) return s;
		for (int i = 0; i < len-5; ++i) {
		s[i] = numbers[std::rand() % (sizeof(numbers) - 1)];
		}
		s[len-5] = '\|';
		for (int i = len-4; i < len; ++i) {
		s[i] = numbers[std::rand() % (sizeof(numbers) - 1)];
		}

		s[len-1] = '\|';
		}
		return s;
		}
		// BDD STYLE
		SCENARIO("Test Db functionality"){

		GIVEN("Open a db") {
		int i = 0;
		SCENARIO( "RDB - Input single Key", "[RocksDB]") {
		GIVEN("Open a db") {

		// when open db
		std::string metadata_path = "/tmp/db_test" + std::to_string(i);
		MetadataDB db = MetadataDB(metadata_path);
		@@ -30,15 +63,28 @@ SCENARIO("Test Db functionality"){
		std::string val = "453\|123\|";

		db.put(key, val);

		THEN("Key and value in DB") {
		auto res = db.get(key);
		REQUIRE(res == val);
		}
		}
		system( (std::string("rm -rf ") + metadata_path).data());
		boost::filesystem::remove_all(metadata_path);
		//system( (std::string("rm -rf ") + metadata_path).data()); // boost verwenden
		metadata_path = "/tmp/db_test" + std::to_string(i);
		db = MetadataDB(metadata_path);
		i++;
		}
		}

		SCENARIO( "RDB - Insert 1 key with two values", "[RocksDB]") {
		GIVEN("Open a db") {

		// when open db
		std::string metadata_path = "/tmp/db_test" + std::to_string(i);
		MetadataDB db = MetadataDB(metadata_path);
		i++;

		WHEN("RocksDB 1 key two values - returns first value") {
		std::string key = "/a";
		std::string val = "453\|123\|";
		@@ -54,139 +100,122 @@ SCENARIO("Test Db functionality"){
		}
		}

		system( (std::string("rm -rf ") + metadata_path).data());

		boost::filesystem::remove_all(metadata_path);
		metadata_path = "/tmp/db_test" + std::to_string(i);
		db = MetadataDB(metadata_path);
		i++;
		}

		}

		// Regular test case style
		TEST_CASE("RocksDB single input"){
		std::string metadata_path = "/home/tunahan/rocksdb";
		std::string key = "/a";
		std::string val = "453\|123\|";
		try {
		MetadataDB db = MetadataDB(metadata_path);
		db.put(key, val);

		auto res = db.get(key);
		REQUIRE(res == val);

		} catch (const std::exception & e) {
		throw;
		}
		}
		TEST_CASE("RocksDB 1 key two values - returns first value"){
		std::string metadata_path = "/home/tunahan/rocksdb";

		std::string key = "/a";
		std::string val = "453\|123\|";
		std::string val2 = "453\|124\|";
		SCENARIO( "RDB - delete existing Key", "[RocksDB]") {
		GIVEN("Open a db") {

		try {
		// when open db
		std::string metadata_path = "/tmp/db_test" + std::to_string(i);
		MetadataDB db = MetadataDB(metadata_path);
		db.put(key, val);
		db.put(key, val2);
		auto res = db.get(key);
		REQUIRE(res == val);

		} catch (const std::exception & e) {
		throw;
		}
		}
		i++;

		TEST_CASE("RocksDB delete inserted key"){
		WHEN("RocksDB delete inserted key") {
		std::string metadata_path = "/home/tunahan/rocksdb";

		std::string key = "/";
		std::string val = "453\|123\|";

		try {
		MetadataDB db = MetadataDB(metadata_path);
		THEN("Key not in DB anymore") {
		db.put(key, val);
		db.remove(key);
		}
		}


		} catch (const std::exception & e) {
		throw;
		boost::filesystem::remove_all(metadata_path);
		metadata_path = "/tmp/db_test" + std::to_string(i);
		db = MetadataDB(metadata_path);
		i++;
		}
		}


		TEST_CASE("RocksDB get deleted key"){
		SCENARIO( "RDB - Get deleted Key", "[RocksDB]") {
		GIVEN("Open a db") {

		// when open db
		std::string metadata_path = "/tmp/db_test" + std::to_string(i);
		MetadataDB db = MetadataDB(metadata_path);
		i++;

		WHEN("RocksDB get deleted key") {
		std::string metadata_path = "/home/tunahan/rocksdb";

		std::string key = "/";
		std::string val = "453\|123\|";

		try {
		MetadataDB db = MetadataDB(metadata_path);
		THEN(" requie return = Nor Found: ") {
		db.put(key, val);
		db.remove(key);
		REQUIRE_THROWS(db.get(key), "Not Found: ");
		}
		}

		boost::filesystem::remove_all(metadata_path);
		metadata_path = "/tmp/db_test" + std::to_string(i);
		db = MetadataDB(metadata_path);
		i++;

		} catch (const std::exception & e) {
		throw;
		}
		}


		TEST_CASE("RocksDB update key"){
		SCENARIO( "RDB - update existing Key", "[RocksDB]") {
		GIVEN("Open a db") {

		// when open db
		std::string metadata_path = "/tmp/db_test" + std::to_string(i);
		MetadataDB db = MetadataDB(metadata_path);
		i++;



		WHEN("RocksDB update key") {
		std::string metadata_path = "/home/tunahan/rocksdb";

		std::string key = "/";
		std::string key2 = "/a";
		std::string val = "453\|123\|";
		std::string val2 = "453\|151\|";

		try {
		MetadataDB db = MetadataDB(metadata_path);
		THEN("require old key deleted and new key inserted") {
		db.put(key, val);
		db.update(key, key2, val2);
		auto res2 = db.get(key2);
		REQUIRE_THROWS(db.get(key), "Not Found: ");
		REQUIRE(res2 == val2);
		} catch (const std::exception & e) {
		throw;
		}
		}

		std::string gen_random(const int len, bool key) {
		std::string s;
		s.resize(len);
		static const char alphanum[] =
		"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
		"abcdefghijklmnopqrstuvwxyz";
		boost::filesystem::remove_all(metadata_path);
		metadata_path = "/tmp/db_test" + std::to_string(i);
		db = MetadataDB(metadata_path);
		i++;

		static const char numbers[] = "123456789";
		if (key) {
		s[0] = '/';
		for (int i = 1; i < len; ++i) {
		s[i] = alphanum[std::rand() % (sizeof(alphanum) - 1)];
		}
		s[len] = '\0';
		}else{
		if(len < 6) return s;
		for (int i = 0; i < len-5; ++i) {
		s[i] = numbers[std::rand() % (sizeof(numbers) - 1)];
		}
		s[len-5] = '\|';
		for (int i = len-4; i < len; ++i) {
		s[i] = numbers[std::rand() % (sizeof(numbers) - 1)];
		}

		s[len-1] = '\|';
		}
		return s;
		}

		TEST_CASE("Bulk Insert/Get - single core"){
		std::string metadata_path = "/home/tunahan/rocksdb";
		SCENARIO( "RDB - Bulk Put/Get - single core", "[RocksDB]") {
		GIVEN("Open a db") {

		// when open db
		std::string metadata_path = "/tmp/db_test" + std::to_string(i);
		MetadataDB db = MetadataDB(metadata_path);
		i++;

		WHEN("Bulk Insert/Get - single core") {


		const int number_Entries = 100;
		const int len_strings = 10;
		std::set<std::string> keyList;
		std::vector<std::string> valList;
		for(int i = 0; i < number_Entries; i++){
		for (int j = 0; j < number_Entries; j++) {
		std::string temp;
		temp = gen_random(len_strings, false);
		valList.push_back(temp);
		@@ -196,32 +225,39 @@ TEST_CASE("Bulk Insert/Get - single core"){
		//std::cout << temp << "\n";
		}

		try {
		MetadataDB db = MetadataDB(metadata_path);
		THEN("require all successfull") {

		auto keys = keyList.begin();
		for(int i = 0; i<number_Entries; i++) {
		for (int j = 0; j < number_Entries; j++) {
		auto key = *(keys++);
		db.put( key, valList[i]);
		db.put(key, valList[j]);
		auto res = db.get(key);
		REQUIRE(res == valList[i]);
		REQUIRE(res == valList[j]);
		}
		} catch (const std::exception & e) {
		throw;
		}
		}
		#define NUM_THREADS 5


		boost::filesystem::remove_all(metadata_path);
		metadata_path = "/tmp/db_test" + std::to_string(i);
		db = MetadataDB(metadata_path);
		i++;

		}
		}

		TEST_CASE("Multithreaded Bulk Insert and Get"){

		const int number_Entries = 1000;

		SCENARIO( "RDB - Multithreaded Bulk Insert and Get", "[RocksDB]") {
		GIVEN("Open a db") {

		std::string metadata_path = "/home/tunahan/rocksdb2";
		// when open db
		std::string metadata_path = "/tmp/db_test" + std::to_string(i);
		MetadataDB db = MetadataDB(metadata_path);
		i++;

		WHEN("Multithreaded Bulk Insert and Get") {

		const int number_Entries = 1000;


		std::vector<std::thread> threads;
		@@ -251,20 +287,30 @@ TEST_CASE("Multithreaded Bulk Insert and Get"){
		for (auto &t : threads) { t.join(); }

		}
		boost::filesystem::remove_all(metadata_path);
		metadata_path = "/tmp/db_test" + std::to_string(i);
		db = MetadataDB(metadata_path);
		i++;

		}
		}
		SCENARIO( "RDB - Merge Operator", "[RocksDB]") {
		GIVEN("Open a db") {

		// when open db
		std::string metadata_path = "/tmp/db_test" + std::to_string(i);
		MetadataDB db = MetadataDB(metadata_path);
		i++;
		WHEN("Merge Operation") {

		TEST_CASE("Merge Operation"){
		std::string metadata_path = "/home/tunahan/rocksdb3";
		std::string key = "/a";
		std::string val = "4523\|123\|";

		try {
		MetadataDB db = MetadataDB(metadata_path);
		THEN("increase size of key") {
		db.put(key, val);
		db.increase_size(key, 10, true);



		} catch (const std::exception & e) {
		throw;
		}
		}
		}

		}