void test_KineticOperation_BuildNoop_should_build_and_execute_a_NOOP_operation(void)
{
LOG_LOCATION;
KineticConnection_IncrementSequence_Expect(&Connection);
KineticOperation_BuildNoop(&Operation);
// NOOP
// The NOOP operation can be used as a quick test of whether the Kinetic
// Device is running and available. If the Kinetic Device is running,
// this operation will always succeed.
//
// Request Message:
//
// command {
// header {
// clusterVersion: ...
// identity: ...
// connectionID: ...
// sequence: ...
// messageType: NOOP
// }
// }
// hmac: "..."
//
TEST_ASSERT_TRUE(Request.proto->command->header->has_messageType);
TEST_ASSERT_EQUAL(KINETIC_PROTO_MESSAGE_TYPE_NOOP, Request.proto->command->header->messageType);
TEST_ASSERT_ByteBuffer_NULL(Request.entry.value);
TEST_ASSERT_ByteBuffer_NULL(Response.entry.value);
}
void test_put_get_delete_one_entry_by_one_entry(void)
{
uint8_t version_data[DEFAULT_BUFFER_SIZE], tag_data[DEFAULT_BUFFER_SIZE], value_data[DEFAULT_BUFFER_SIZE];
ByteBuffer version_buffer, tag_buffer, value_buffer;
version_buffer = ByteBuffer_CreateAndAppendCString(version_data, sizeof(version_data), "v1.0");
ExpectedVersionBuffer = ByteBuffer_CreateAndAppendCString(version_data, sizeof(version_data), "v1.0");
tag_buffer = ByteBuffer_CreateAndAppendCString(tag_data, sizeof(tag_data), "SomeTagValue");
ExpectedTagBuffer = ByteBuffer_CreateAndAppendCString(tag_data, sizeof(tag_data), "SomeTagValue");
value_buffer = ByteBuffer_Create(value_data, DEFAULT_BUFFER_SIZE, 0);
unsigned int i;
for (i=0; i<KV_PAIRS_PER_GROUP; i++)
{
// put object
KineticEntry putEntry = {
.key = generate_entry_key_by_index(i),
.tag = tag_buffer,
.newVersion = version_buffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = generate_entry_value_by_index(i),
.force = true,
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
KineticStatus status = KineticClient_Put(Fixture.session, &putEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
ByteBuffer_Reset(&value_buffer);
// get object
value_buffer = ByteBuffer_Create(value_data, DEFAULT_BUFFER_SIZE, 0);
KineticEntry getEntry = {
.key = generate_entry_key_by_index(i),
.dbVersion = version_buffer,
.tag = tag_buffer,
.value = value_buffer,
};
status = KineticClient_Get(Fixture.session, &getEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedVersionBuffer, getEntry.dbVersion);
TEST_ASSERT_ByteBuffer_NULL(getEntry.newVersion);
TEST_ASSERT_EQUAL_ByteBuffer(generate_entry_key_by_index(i), getEntry.key);
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedTagBuffer, getEntry.tag);
TEST_ASSERT_EQUAL(KINETIC_ALGORITHM_SHA1, getEntry.algorithm);
TEST_ASSERT_EQUAL_ByteBuffer(generate_entry_value_by_index(i), getEntry.value);
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedVersionBuffer, version_buffer);
// delete object
KineticEntry deleteEntry = {
.key = generate_entry_key_by_index(i),
.dbVersion = version_buffer,
};
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedVersionBuffer, version_buffer);
status = KineticClient_Delete(Fixture.session, &deleteEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL(0, deleteEntry.value.bytesUsed);
// get object again
status = KineticClient_Get(Fixture.session, &getEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_NOT_FOUND, status);
}
}
void test_put_get_delete_one_group_by_one_group(void)
{
uint8_t version_data[DEFAULT_BUFFER_SIZE], tag_data[DEFAULT_BUFFER_SIZE], value_data[DEFAULT_BUFFER_SIZE];
ByteBuffer version_buffer, tag_buffer, value_buffer;
version_buffer = ByteBuffer_CreateAndAppendCString(version_data, sizeof(version_data), "v1.0");
ExpectedVersionBuffer = ByteBuffer_CreateAndAppendCString(version_data, sizeof(version_data), "v1.0");
tag_buffer = ByteBuffer_CreateAndAppendCString(tag_data, sizeof(tag_data), "SomeTagValue");
ExpectedTagBuffer = ByteBuffer_CreateAndAppendCString(tag_data, sizeof(tag_data), "SomeTagValue");
value_buffer = ByteBuffer_Create(value_data, DEFAULT_BUFFER_SIZE, 0);
unsigned int i, j;
for (i =0; i<TOTAL_GROUPS; i++)
{
KineticStatus status;
// put a group of entries
for (j=0; j<KV_PAIRS_PER_GROUP; j++)
{
KineticEntry putEntry = {
.key = generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + j),
.tag = tag_buffer,
.newVersion = version_buffer,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = generate_entry_value_by_index(i*KV_PAIRS_PER_GROUP + j),
.force = true,
.synchronization = KINETIC_SYNCHRONIZATION_WRITETHROUGH,
};
status = KineticClient_Put(Fixture.session, &putEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
}
// get key_range
KineticKeyRange range = {
.startKey = generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP),
.endKey = generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + KV_PAIRS_PER_GROUP -1),
.startKeyInclusive = true,
.endKeyInclusive = true,
.maxReturned = KV_PAIRS_PER_GROUP,
};
ByteBuffer keyBuff[KV_PAIRS_PER_GROUP];
uint8_t keysData[KV_PAIRS_PER_GROUP][DEFAULT_BUFFER_SIZE];
for (j = 0; j < KV_PAIRS_PER_GROUP; j++) {
memset(&keysData[j], 0, DEFAULT_BUFFER_SIZE);
keyBuff[j] = ByteBuffer_Create(&keysData[j], DEFAULT_BUFFER_SIZE, 0);
}
ByteBufferArray keys = {.buffers = keyBuff, .count = KV_PAIRS_PER_GROUP, .used = 0};
status = KineticClient_GetKeyRange(Fixture.session, &range, &keys, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL(KV_PAIRS_PER_GROUP, keys.used);
for (j = 0; j < KV_PAIRS_PER_GROUP; j++)
{
TEST_ASSERT_EQUAL_ByteBuffer(generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + j), keys.buffers[j]);
}
// delete a group of entries
for (j=0; j<KV_PAIRS_PER_GROUP; j++)
{
ByteBuffer_Reset(&value_buffer);
// get object
value_buffer = ByteBuffer_Create(value_data, DEFAULT_BUFFER_SIZE, 0);
KineticEntry getEntry = {
.key = generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + j),
.dbVersion = version_buffer,
.tag = tag_buffer,
.value = value_buffer,
};
status = KineticClient_Get(Fixture.session, &getEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedVersionBuffer, getEntry.dbVersion);
TEST_ASSERT_ByteBuffer_NULL(getEntry.newVersion);
TEST_ASSERT_EQUAL_ByteBuffer(generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + j), getEntry.key);
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedTagBuffer, getEntry.tag);
TEST_ASSERT_EQUAL(KINETIC_ALGORITHM_SHA1, getEntry.algorithm);
TEST_ASSERT_EQUAL_ByteBuffer(generate_entry_value_by_index(i*KV_PAIRS_PER_GROUP + j), getEntry.value);
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedVersionBuffer, version_buffer);
}
// delete a group of entries
for (j=0; j<KV_PAIRS_PER_GROUP; j++)
{
// delete object
KineticEntry deleteEntry = {
.key = generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + j),
.dbVersion = version_buffer,
};
TEST_ASSERT_EQUAL_ByteBuffer(ExpectedVersionBuffer, version_buffer);
status = KineticClient_Delete(Fixture.session, &deleteEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL(0, deleteEntry.value.bytesUsed);
// get object again
ByteBuffer_Reset(&value_buffer);
// get object
value_buffer = ByteBuffer_Create(value_data, DEFAULT_BUFFER_SIZE, 0);
KineticEntry getEntry = {
.key = generate_entry_key_by_index(i*KV_PAIRS_PER_GROUP + j),
.dbVersion = version_buffer,
.tag = tag_buffer,
.value = value_buffer,
};
status = KineticClient_Get(Fixture.session, &getEntry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_NOT_FOUND, status);
}
}
}
void test_KineticOperation_BuildGet_should_build_a_GET_operation(void)
{
LOG_LOCATION;
const ByteArray key = ByteArray_CreateWithCString("foobar");
ByteArray value = {.data = ValueData, .len = sizeof(ValueData)};
KineticEntry entry = {
.key = ByteBuffer_CreateWithArray(key),
.value = ByteBuffer_CreateWithArray(value),
};
KineticConnection_IncrementSequence_Expect(&Connection);
KineticMessage_ConfigureKeyValue_Expect(&Request.protoData.message, &entry);
KineticOperation_BuildGet(&Operation, &entry);
// GET
// The GET operation is used to retrieve the value and metadata for a given key.
//
// Request Message:
// command {
// header {
// // See above for descriptions of these fields
// clusterVersion: ...
// identity: ...
// connectionID: ...
// sequence: ...
//
// // The mesageType should be GET
// messageType: GET
TEST_ASSERT_TRUE(Request.proto->command->header->has_messageType);
TEST_ASSERT_EQUAL(KINETIC_PROTO_MESSAGE_TYPE_GET, Request.proto->command->header->messageType);
// }
// body {
// keyValue {
// // See above
// key: "..."
// }
// }
// }
// // See above
// hmac: "..."
TEST_ASSERT_ByteBuffer_NULL(Request.entry.value);
TEST_ASSERT_EQUAL_ByteArray(value, Operation.response->entry.value.array);
TEST_ASSERT_EQUAL(0, Operation.response->entry.value.bytesUsed);
}
void test_KineticOperation_BuildGet_should_build_a_GET_operation_requesting_metadata_only(void)
{
LOG_LOCATION;
const ByteArray key = ByteArray_CreateWithCString("foobar");
ByteArray value = ByteArray_Create(ValueData, sizeof(ValueData));
KineticEntry entry = {
.key = ByteBuffer_CreateWithArray(key),
.metadataOnly = true,
.value = ByteBuffer_CreateWithArray(value),
};
KineticConnection_IncrementSequence_Expect(&Connection);
KineticMessage_ConfigureKeyValue_Expect(&Request.protoData.message, &entry);
KineticOperation_BuildGet(&Operation, &entry);
// GET
// The GET operation is used to retrieve the value and metadata for a given key.
//
// Request Message:
// command {
// header {
// // See above for descriptions of these fields
// clusterVersion: ...
// identity: ...
// connectionID: ...
// sequence: ...
//
// // The mesageType should be GET
// messageType: GET
TEST_ASSERT_TRUE(Request.proto->command->header->has_messageType);
TEST_ASSERT_EQUAL(KINETIC_PROTO_MESSAGE_TYPE_GET, Request.proto->command->header->messageType);
// }
// body {
// keyValue {
// // See above
// key: "..."
// }
// }
// }
// // See above
// hmac: "..."
TEST_ASSERT_ByteBuffer_NULL(Request.entry.value);
TEST_ASSERT_ByteBuffer_NULL(Response.entry.value);
}
void test_KineticOperation_BuildDelete_should_build_a_DELETE_operation(void)
{
LOG_LOCATION;
const ByteArray key = ByteArray_CreateWithCString("foobar");
KineticEntry entry = {.key = ByteBuffer_CreateWithArray(key)};
KineticConnection_IncrementSequence_Expect(&Connection);
KineticMessage_ConfigureKeyValue_Expect(&Request.protoData.message, &entry);
KineticOperation_BuildDelete(&Operation, &entry);
// The `DELETE` operation removes the entry for a given key. It respects the
// same locking behavior around `dbVersion` and `force` as described in the previous sections.
// The following request will remove a key value pair to the store.
//
// ```
// command {
// // See top level cross cutting concerns for header details
// header {
// clusterVersion: ...
// identity: ...
// connectionID: ...
// sequence: ...
// // messageType should be DELETE
// messageType: DELETE
TEST_ASSERT_TRUE(Request.proto->command->header->has_messageType);
TEST_ASSERT_EQUAL(KINETIC_PROTO_MESSAGE_TYPE_DELETE, Request.proto->command->header->messageType);
// }
// body {
// keyValue {
// key: "..."
// // See write operation cross cutting concerns
// synchronization: ...
// }
// }
// }
// hmac: "..."
TEST_ASSERT_ByteBuffer_NULL(Request.entry.value);
TEST_ASSERT_ByteBuffer_NULL(Response.entry.value);
}
void test_KineticOperation_BuildPut_should_build_and_execute_a_PUT_operation_to_create_a_new_object(void)
{
LOG_LOCATION;
ByteArray value = ByteArray_CreateWithCString("Luke, I am your father");
ByteArray key = ByteArray_CreateWithCString("foobar");
ByteArray newVersion = ByteArray_CreateWithCString("v1.0");
ByteArray tag = ByteArray_CreateWithCString("some_tag");
KineticConnection_IncrementSequence_Expect(&Connection);
// PUT
// The PUT operation sets the value and metadata for a given key. If a value
// already exists in the store for the given key, the client must pass a
// value for dbVersion which matches the stored version for this key to
// overwrite the value metadata. This behavior can be overridden (so that
// the version is ignored and the value and metadata are always written) by
// setting forced to true in the KeyValue option.
//
// Request Message:
//
// command {
// // See top level cross cutting concerns for header details
// header {
// clusterVersion: ...
// identity: ...
// connectionID: ...
// sequence: ...
// messageType: PUT
// }
// body: {
// keyValue {
// // Required bytes
// // The key for the value being set
// key: "..."
//
// // Required bytes
// // Versions are set on objects to support optimistic locking.
// // For operations that modify data, if the dbVersion sent in the
// // request message does not match the version stored in the db, the
// // request will fail.
// dbVersion: "..."
//
// // Required bytes
// // Specifies what the next version of the data will be if this
// // operation is successful.
// newVersion: "..."
//
// // Optional bool, default false
// // Setting force to true ignores potential version mismatches
// // and carries out the operation.
// force: true
//
// // Optional bytes
// // The integrity value for the data. This value should be computed
// // by the client application by applying the hash algorithm
// // specified below to the value (and only to the value).
// // The algorithm used should be specified in the algorithm field.
// // The Kinetic Device will not do any processing on this value.
// tag: "..."
//
// // Optional enum
// // The algorithm used by the client to compute the tag.
// // The allowed values are: SHA1, SHA2, SHA3, CRC32, CRC64
// algorithm: ...
//
// // Optional Synchronization enum value, defaults to WRITETHROUGH
// // Allows client to specify if the data must be written to disk
// // immediately, or can be written in the future.
// //
// // WRITETHROUGH: This request is made persistent before returning.
// // This does not effect any other pending operations.
// // WRITEBACK: They can be made persistent when the drive chooses,
// // or when a subsequent FLUSH is give to the drive.
// // FLUSH: All pending information that has not been written is
// // pushed to the disk and the command that specifies
// // FLUSH is written last and then returned. All WRITEBACK writes
// // that have received ending status will be guaranteed to be
// // written before the FLUSH operation is returned completed.
// synchronization: ...
// }
KineticEntry entry = {
.key = ByteBuffer_CreateWithArray(key),
.newVersion = ByteBuffer_CreateWithArray(newVersion),
// .dbVersion = ByteBuffer_CreateWithArray(BYTE_ARRAY_NONE),
.tag = ByteBuffer_CreateWithArray(tag),
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = ByteBuffer_CreateWithArray(value),
};
KineticMessage_ConfigureKeyValue_Expect(&Operation.request->protoData.message, &entry);
// }
// }
// hmac: "..."
//
// Build the operation
KineticOperation_BuildPut(&Operation, &entry);
// Ensure proper message type
TEST_ASSERT_TRUE(Request.proto->command->header->has_messageType);
TEST_ASSERT_EQUAL(KINETIC_PROTO_MESSAGE_TYPE_PUT, Request.proto->command->header->messageType);
TEST_ASSERT_EQUAL_ByteArray(value, Operation.request->entry.value.array);
TEST_ASSERT_EQUAL(0, Operation.request->entry.value.bytesUsed);
TEST_ASSERT_ByteBuffer_NULL(Response.entry.value);
}
