Changed WriteMode to be an enum class (c2292daf) · Commits · kinetic-archive / kinetic-cpp-client

include/kinetic/kinetic_connection.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -23,7 +23,7 @@

		namespace kinetic {

		typedef enum {
		enum class WriteMode {
		/// If specified, PUTs will succeed even if the key already exists and has a different
		/// version
		IGNORE_VERSION,
		@@ -31,7 +31,7 @@ typedef enum {
		/// Requires the existing version match the given expected value. This can be used to
		/// implement compare-and-swap type operations
		REQUIRE_SAME_VERSION
		} WriteMode;
		};

		} // namespace kinetic

src/integration_test/blocking_smoketest.cc

+4 −4

Original line number	Diff line number	Diff line
		@@ -37,18 +37,18 @@ TEST_F(IntegrationTest, BlockingSmoketest) {

		auto record1 = make_shared<KineticRecord>(make_shared<string>("value1"),
		make_shared<string>("v1"), make_shared<string>("t1"), Message_Algorithm_CRC32);
		KineticStatus kineticStatus = blocking_connection_->Put("key1", "", IGNORE_VERSION, *record1);
		KineticStatus kineticStatus = blocking_connection_->Put("key1", "",WriteMode::IGNORE_VERSION, *record1);
		ASSERT_TRUE(kineticStatus.ok());

		auto record2 = make_shared<KineticRecord>(make_shared<string>("value2"),
		make_shared<string>("v2"), make_shared<string>("t2"), Message_Algorithm_SHA1);
		ASSERT_TRUE(blocking_connection_->Put(make_shared<string>("key2"), make_shared<string>(""),
		IGNORE_VERSION, record2).ok());
		WriteMode::IGNORE_VERSION, record2).ok());

		auto record3 = make_shared<KineticRecord>(make_shared<string>("value3"),
		make_shared<string>("v3"), make_shared<string>("t3"), Message_Algorithm_CRC32);
		ASSERT_TRUE(blocking_connection_->Put(make_shared<string>("key3"), make_shared<string>(""),
		IGNORE_VERSION, record3).ok());
		WriteMode::IGNORE_VERSION, record3).ok());

		KeyRangeIterator it = blocking_connection_->IterateKeyRange("key1", true, "key3", false, 1);
		ASSERT_EQ("key1", *it);
		@@ -91,7 +91,7 @@ TEST_F(IntegrationTest, BlockingSmoketest) {
		ASSERT_TRUE(status.ok());
		EXPECT_EQ(expected_keys, *actual_keys);

		ASSERT_TRUE(blocking_connection_->Delete("key1", "", IGNORE_VERSION).ok());
		ASSERT_TRUE(blocking_connection_->Delete("key1", "",WriteMode::IGNORE_VERSION).ok());

		ASSERT_EQ(blocking_connection_->Get("key1", result_record).statusCode(), StatusCode::REMOTE_NOT_FOUND);

src/integration_test/delete_test.cc

+10 −10

Original line number	Diff line number	Diff line
		@@ -33,7 +33,7 @@ using std::shared_ptr;

		TEST_F(IntegrationTest, DeleteNonexistent) {
		auto delete_callback = make_shared<StrictMock<MockSimpleCallback>>();
		nonblocking_connection_->Delete("nonexistent key", "", REQUIRE_SAME_VERSION, delete_callback);
		nonblocking_connection_->Delete("nonexistent key", "", WriteMode::REQUIRE_SAME_VERSION, delete_callback);
		EXPECT_CALL(*delete_callback,
		Failure(KineticStatusEq(StatusCode::REMOTE_NOT_FOUND, "Key not found")))
		.WillOnce(Assign(&done_, true));
		@@ -46,12 +46,12 @@ TEST_F(IntegrationTest, DeleteWithWrongVersion) {
		auto record = make_shared<KineticRecord>(make_shared<string>("value"),
		make_shared<string>("v1"), make_shared<string>("tag"), Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		// Attempt to delete version "v2"
		auto delete_callback = make_shared<StrictMock<MockSimpleCallback>>();
		nonblocking_connection_->Delete("key", "v2", REQUIRE_SAME_VERSION, delete_callback);
		nonblocking_connection_->Delete("key", "v2", WriteMode::REQUIRE_SAME_VERSION, delete_callback);
		EXPECT_CALL(*delete_callback,
		Failure(KineticStatusEq(StatusCode::REMOTE_VERSION_MISMATCH, "Version mismatch")))
		.WillOnce(Assign(&done_, true));
		@@ -65,12 +65,12 @@ TEST_F(IntegrationTest, DeleteWithMissingVersion) {
		auto record = make_shared<KineticRecord>(make_shared<string>("value"),
		make_shared<string>("v1"), make_shared<string>("tag"), Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		// Attempt to delete version "" (empty)
		auto delete_callback = make_shared<StrictMock<MockSimpleCallback>>();
		nonblocking_connection_->Delete("key", "", REQUIRE_SAME_VERSION, delete_callback);
		nonblocking_connection_->Delete("key", "", WriteMode::REQUIRE_SAME_VERSION, delete_callback);
		EXPECT_CALL(*delete_callback,
		Failure(KineticStatusEq(StatusCode::REMOTE_VERSION_MISMATCH, "Version mismatch")))
		.WillOnce(Assign(&done_, true));
		@@ -84,12 +84,12 @@ TEST_F(IntegrationTest, SuccessfulDelete) {
		auto record = make_shared<KineticRecord>(make_shared<string>("value"),
		make_shared<string>("v1"), make_shared<string>("tag"), Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		// Delete it
		auto delete_callback = make_shared<StrictMock<MockSimpleCallback>>();
		nonblocking_connection_->Delete("key", "v1", REQUIRE_SAME_VERSION, delete_callback);
		nonblocking_connection_->Delete("key", "v1", WriteMode::REQUIRE_SAME_VERSION, delete_callback);
		EXPECT_CALL(*delete_callback, Success()).WillOnce(Assign(&done_, true));

		RunSelectLoop();
		@@ -101,12 +101,12 @@ TEST_F(IntegrationTest, ForcedDelete) {
		auto record = make_shared<KineticRecord>(make_shared<string>("value"),
		make_shared<string>("v1"), make_shared<string>("tag"), Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		// Delete with wrong version should succeed if we set the force flag
		auto delete_callback = make_shared<StrictMock<MockSimpleCallback>>();
		nonblocking_connection_->Delete("key", "", IGNORE_VERSION, delete_callback);
		nonblocking_connection_->Delete("key", "", WriteMode::IGNORE_VERSION, delete_callback);
		EXPECT_CALL(*delete_callback, Success()).WillOnce(Assign(&done_, true));

		RunSelectLoop();
		@@ -115,7 +115,7 @@ TEST_F(IntegrationTest, ForcedDelete) {
		TEST_F(IntegrationTest, ForcedDeleteNonexistent) {
		// Delete of a nonexistent key should succeed if we set the force flag
		auto delete_callback = make_shared<StrictMock<MockSimpleCallback>>();
		nonblocking_connection_->Delete("key", "", IGNORE_VERSION, delete_callback);
		nonblocking_connection_->Delete("key", "", WriteMode::IGNORE_VERSION, delete_callback);
		EXPECT_CALL(*delete_callback, Success()).WillOnce(Assign(&done_, true));
		RunSelectLoop();
		}

src/integration_test/get_test.cc

+15 −15

Original line number	Diff line number	Diff line
		@@ -48,7 +48,7 @@ TEST_F(IntegrationTest, GetOk) {
		auto put_callback = make_shared<StrictMock<MockPutCallback>>();
		auto record1 = make_shared<KineticRecord>("value1", "v1", "tag1", Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key1"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record1, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record1, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		auto callback = make_shared<StrictMock<MockGetCallback>>();
		@@ -65,10 +65,10 @@ TEST_F(IntegrationTest, GetNext_KeyExistsAndHasSuccessor) {
		auto record1 = make_shared<KineticRecord>("value1", "v1", "tag1", Message_Algorithm_SHA1);
		auto record2 = make_shared<KineticRecord>("value2", "v2", "tag2", Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key1"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record1, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record1, put_callback);
		WaitForSuccessSharedPtr(put_callback);
		nonblocking_connection_->Put(make_shared<string>("key2"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record2, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record2, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		// Call GetNext on "key1" and verify that we get "key2" and its value
		@@ -85,7 +85,7 @@ TEST_F(IntegrationTest, GetManyOutstandingRequests) {
		auto put_callback = make_shared<StrictMock<MockPutCallback>>();
		auto record1 = make_shared<KineticRecord>("value1", "v1", "tag1", Message_Algorithm_CRC64);
		nonblocking_connection_->Put(make_shared<string>("key1"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record1, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record1, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		uint32_t num_reqs = 2000;
		@@ -112,7 +112,7 @@ TEST_F(IntegrationTest, GetNext_KeyExistsAndDoesNotHaveSuccessor) {
		auto put_callback = make_shared<StrictMock<MockPutCallback>>();
		auto record = make_shared<KineticRecord>("value", "version", "tag", Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key1"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		// Call GetNext on "key1" and verify that we get "not found"
		@@ -126,7 +126,7 @@ TEST_F(IntegrationTest, GetNext_KeyDoesNotExistAndHasSuccessor) {
		auto put_callback = make_shared<StrictMock<MockPutCallback>>();
		auto record = make_shared<KineticRecord>("value", "version", "tag", Message_Algorithm_CRC64);
		nonblocking_connection_->Put(make_shared<string>("key2"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		// Call GetNext on "key1" and verify that we get "key2" and its value
		@@ -155,10 +155,10 @@ TEST_F(IntegrationTest, GetPrevious_KeyExistsAndHasPredecessor) {
		auto record1 = make_shared<KineticRecord>("value1", "v1", "tag1", Message_Algorithm_SHA1);
		auto record2 = make_shared<KineticRecord>("value2", "v2", "tag2", Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key1"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record1, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record1, put_callback);
		WaitForSuccessSharedPtr(put_callback);
		nonblocking_connection_->Put(make_shared<string>("key2"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record2, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record2, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		// Call GetPrevious on "key2" and verify that we get "key1" and its value
		@@ -176,7 +176,7 @@ TEST_F(IntegrationTest, GetPrevious_KeyExistsAndDoesNotHavePredecessor) {
		auto put_callback = make_shared<StrictMock<MockPutCallback>>();
		auto record = make_shared<KineticRecord>("value", "version", "tag", Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key2"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		// Call GetPrevious on "key2" and verify that we get "not found"
		@@ -193,7 +193,7 @@ TEST_F(IntegrationTest, GetPrevious_KeyDoesNotExistAndHasPredecessor) {
		auto put_callback = make_shared<StrictMock<MockPutCallback>>();
		auto record = make_shared<KineticRecord>("value", "version", "tag", Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key1"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		// Call GetPrevious on "key2" and verify that we get "key1" and its value
		@@ -230,7 +230,7 @@ TEST_F(IntegrationTest, GetVersion) {
		auto get_version_callback = make_shared<StrictMock<MockGetVersionCallback>>();
		auto record = make_shared<KineticRecord>("value", "version", "tag", Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		nonblocking_connection_->GetVersion("key", get_version_callback);
		@@ -243,16 +243,16 @@ TEST_F(IntegrationTest, GetKeyRange) {
		// TODO(marshall) fails on java simulator with empty value
		auto record = make_shared<KineticRecord>("v", "", "", Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("k0"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);
		nonblocking_connection_->Put(make_shared<string>("k1"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);
		nonblocking_connection_->Put(make_shared<string>("k2"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);
		nonblocking_connection_->Put(make_shared<string>("k3"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);

		auto getkeyrange_callback = make_shared<StrictMock<MockGetKeyRangeCallback>>();

src/integration_test/put_test.cc

+11 −11

Original line number	Diff line number	Diff line
		@@ -36,7 +36,7 @@ TEST_F(IntegrationTest, Write) {
		auto put_callback = make_shared<StrictMock<MockPutCallback>>();
		auto get_callback = make_shared<StrictMock<MockGetCallback>>();
		auto record = make_shared<KineticRecord>("value", "version", "tag", Message_Algorithm_SHA1);
		nonblocking_connection_->Put("key", "", REQUIRE_SAME_VERSION, record, put_callback);
		nonblocking_connection_->Put("key", "", WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);
		nonblocking_connection_->Get("key", get_callback);
		EXPECT_CALL(*get_callback, Success_("key",
		@@ -50,7 +50,7 @@ TEST_F(IntegrationTest, Write_NoTag) {
		auto get_callback = make_shared<StrictMock<MockGetCallback>>();
		auto record = make_shared<KineticRecord>("value", "version", "", Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		WaitForSuccessSharedPtr(put_callback);
		nonblocking_connection_->Get("key", get_callback);
		EXPECT_CALL(*get_callback, Success_("key",
		@@ -65,7 +65,7 @@ TEST_F(IntegrationTest, WriteWithWrongVersion) {
		auto put_callback = make_shared<StrictMock<MockPutCallback>>();
		auto record = make_shared<KineticRecord>("value", "version", "tag", Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>("v2"),
		REQUIRE_SAME_VERSION, record, put_callback);
		WriteMode::REQUIRE_SAME_VERSION, record, put_callback);
		EXPECT_CALL(*put_callback,
		Failure(KineticStatusEq(StatusCode::REMOTE_VERSION_MISMATCH, "Version mismatch")))
		.WillOnce(Assign(&done_, true));
		@@ -78,7 +78,7 @@ TEST_F(IntegrationTest, Update) {
		auto initial_record = make_shared<KineticRecord>("initial value", "v1", "initial tag",
		Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, initial_record,
		WriteMode::REQUIRE_SAME_VERSION, initial_record,
		write_callback);
		WaitForSuccessSharedPtr(write_callback);

		@@ -87,7 +87,7 @@ TEST_F(IntegrationTest, Update) {
		auto new_record = make_shared<KineticRecord>("new value", "v2", "new tag",
		Message_Algorithm_CRC64);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>("v1"),
		REQUIRE_SAME_VERSION, new_record, update_callback);
		WriteMode::REQUIRE_SAME_VERSION, new_record, update_callback);
		WaitForSuccessSharedPtr(update_callback);

		// Verify that the update is now visible
		@@ -105,7 +105,7 @@ TEST_F(IntegrationTest, UpdateWithWrongVersion) {
		auto initial_record = make_shared<KineticRecord>("initial value", "v1", "initial tag",
		Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, initial_record, write_callback);
		WriteMode::REQUIRE_SAME_VERSION, initial_record, write_callback);
		WaitForSuccessSharedPtr(write_callback);

		// Attempt to update it with the wrong version
		@@ -113,7 +113,7 @@ TEST_F(IntegrationTest, UpdateWithWrongVersion) {
		auto new_record = make_shared<KineticRecord>("new value", "v2", "new tag",
		Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>("wrong version"),
		REQUIRE_SAME_VERSION, new_record, update_callback);
		WriteMode::REQUIRE_SAME_VERSION, new_record, update_callback);
		EXPECT_CALL(*update_callback,
		Failure(KineticStatusEq(StatusCode::REMOTE_VERSION_MISMATCH, "Version mismatch")))
		.WillOnce(Assign(&done_, true));
		@@ -129,7 +129,7 @@ TEST_F(IntegrationTest, InsertWithNullVersion) {
		auto initial_record = make_shared<KineticRecord>(make_shared<string>("value"),
		version, make_shared<string>("tag"), Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, initial_record, write_callback);
		WriteMode::REQUIRE_SAME_VERSION, initial_record, write_callback);
		WaitForSuccessSharedPtr(write_callback);

		auto get_callback = make_shared<StrictMock<MockGetCallback>>();
		@@ -147,7 +147,7 @@ TEST_F(IntegrationTest, ForcedWrite) {
		auto put_callback = make_shared<StrictMock<MockPutCallback>>();
		auto record = make_shared<KineticRecord>("value", "v2", "tag", Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>("v1"),
		IGNORE_VERSION, record, put_callback);
		WriteMode::IGNORE_VERSION, record, put_callback);
		EXPECT_CALL(*put_callback, Success()).WillOnce(Assign(&done_, true));
		RunSelectLoop();
		}
		@@ -158,7 +158,7 @@ TEST_F(IntegrationTest, ForcedUpdate) {
		auto initial_record = make_shared<KineticRecord>("initial value", "v1", "initial tag",
		Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>(""),
		REQUIRE_SAME_VERSION, initial_record, write_callback);
		WriteMode::REQUIRE_SAME_VERSION, initial_record, write_callback);
		WaitForSuccessSharedPtr(write_callback);

		// We can update it with an incorrect or empty version, provided that we
		@@ -167,7 +167,7 @@ TEST_F(IntegrationTest, ForcedUpdate) {
		auto new_record = make_shared<KineticRecord>("new value", "", "new tag",
		Message_Algorithm_SHA1);
		nonblocking_connection_->Put(make_shared<string>("key"), make_shared<string>("wrong version"),
		IGNORE_VERSION, new_record, update_callback);
		WriteMode::IGNORE_VERSION, new_record, update_callback);
		EXPECT_CALL(*update_callback, Success()).WillOnce(Assign(&done_, true));

		RunSelectLoop();