void test_KineticClient_Get_should_execute_GET_operation(void)
{
uint8_t KeyData[64];
ByteArray Key = ByteArray_Create(KeyData, sizeof(KeyData));
ByteBuffer KeyBuffer = ByteBuffer_CreateWithArray(Key);
uint8_t ValueData[64];
ByteArray Value = ByteArray_Create(ValueData, sizeof(ValueData));
ByteBuffer ValueBuffer = ByteBuffer_CreateWithArray(Value);
ByteBuffer_AppendDummyData(&KeyBuffer, Key.len);
KineticEntry entry = {
.key = KeyBuffer,
.value = ValueBuffer,
};
KineticOperation operation;
KineticAllocator_NewOperation_ExpectAndReturn(&Session, &operation);
KineticBuilder_BuildGet_ExpectAndReturn(&operation, &entry, KINETIC_STATUS_SUCCESS);
KineticController_ExecuteOperation_ExpectAndReturn(&operation, NULL, KINETIC_STATUS_CLUSTER_MISMATCH);
KineticStatus status = KineticClient_Get(&Session, &entry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_CLUSTER_MISMATCH, status);
}
void test_KineticPDU_Init_should_set_the_exchange_fields_in_the_embedded_protobuf_header(void)
{
LOG_LOCATION;
KINETIC_CONNECTION_INIT(&Connection);
Connection.sequence = 24;
Connection.connectionID = 8765432;
Session = (KineticSession) {
.clusterVersion = 1122334455667788,
.identity = 37,
};
Connection.session = Session;
KINETIC_PDU_INIT(&PDU, &Connection);
TEST_ASSERT_TRUE(PDU.protoData.message.header.has_clusterVersion);
TEST_ASSERT_EQUAL_INT64(1122334455667788,
PDU.protoData.message.header.clusterVersion);
TEST_ASSERT_TRUE(PDU.protoData.message.header.has_identity);
TEST_ASSERT_EQUAL_INT64(37, PDU.protoData.message.header.identity);
TEST_ASSERT_TRUE(PDU.protoData.message.header.has_connectionID);
TEST_ASSERT_EQUAL_INT64(8765432, PDU.protoData.message.header.connectionID);
TEST_ASSERT_TRUE(PDU.protoData.message.header.has_sequence);
TEST_ASSERT_EQUAL_INT64(24, PDU.protoData.message.header.sequence);
}
void test_KineticPDU_AttachEntry_should_attach_specified_KineticEntry(void)
{
LOG_LOCATION;
KineticPDU_Init(&PDU, &Connection);
uint8_t data[5];
ByteArray value = {.data = data, .len = sizeof(data)};
ByteBuffer valueBuffer = ByteBuffer_CreateWithArray(value);
KineticEntry entry = {.value = valueBuffer};
entry.value.bytesUsed = 3;
KineticPDU_AttachEntry(&PDU, &entry);
TEST_ASSERT_EQUAL_PTR(entry.value.array.data, PDU.entry.value.array.data);
TEST_ASSERT_EQUAL(3, PDU.entry.value.bytesUsed);
TEST_ASSERT_EQUAL(3, entry.value.bytesUsed);
TEST_ASSERT_EQUAL(sizeof(data), entry.value.array.len);
}
void test_KINETIC_PDU_INIT_WITH_MESSAGE_should_initialize_PDU_and_protobuf_message(void)
{
LOG_LOCATION;
memset(&PDU, 0, sizeof(KineticPDU));
KINETIC_PDU_INIT_WITH_MESSAGE(&PDU, &Connection);
PDU.protoData.message.status.code = KINETIC_PROTO_STATUS_STATUS_CODE_SERVICE_BUSY;
PDU.protoData.message.command.status = &PDU.protoData.message.status;
TEST_ASSERT_EQUAL(
KINETIC_PROTO_STATUS_STATUS_CODE_SERVICE_BUSY,
PDU.proto->command->status->code);
}
void test_KineticClient_Get_should_get_error_MISSING_VALUE_BUFFER_if_called_without_value_buffer(void)
{
uint8_t KeyData[64];
ByteArray Key = ByteArray_Create(KeyData, sizeof(KeyData));
ByteBuffer KeyBuffer = ByteBuffer_CreateWithArray(Key);
KineticEntry entry = { .key = KeyBuffer };
memset(&entry, 0, sizeof(entry));
KineticStatus status = KineticClient_Get(&Session, &entry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_MISSING_KEY, status);
}
void test_KineticClient_Get_should_get_error_MISSING_KEY_if_called_without_key(void)
{
uint8_t ValueData[64];
ByteArray Value = ByteArray_Create(ValueData, sizeof(ValueData));
ByteBuffer ValueBuffer = ByteBuffer_CreateWithArray(Value);
KineticEntry entry = {.value = ValueBuffer};
memset(&entry, 0, sizeof(entry));
KineticStatus status = KineticClient_Get(&Session, &entry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_MISSING_KEY, status);
}
void test_ByteBuffer_CreateWithArray_should_create_an_empty_ByteBuffer_with_specified_ByteArray(void)
{
uint8_t data[] = {0x1u, 0x2u, 0x3u, 0x4u};
size_t len = sizeof(data);
ByteArray array = {.data = data, .len = len};
ByteBuffer buffer = ByteBuffer_CreateWithArray(array);
TEST_ASSERT_EQUAL_PTR(data, buffer.array.data);
TEST_ASSERT_EQUAL(len, buffer.array.len);
TEST_ASSERT_EQUAL_PTR(array.data, buffer.array.data);
TEST_ASSERT_EQUAL(array.len, buffer.array.len);
TEST_ASSERT_EQUAL_HEX8_ARRAY(data, buffer.array.data, len);
TEST_ASSERT_EQUAL(0, buffer.bytesUsed);
}
void test_ByteBuffer_BytesRemaining_should_return_lenth_of_unconsumed_bytes(void)
{
uint8_t data[] = {0x1u, 0x2u, 0x3u, 0x4u};
size_t len = sizeof(data);
ByteArray array = {.data = data, .len = len};
ByteBuffer buffer = ByteBuffer_CreateWithArray(array);
TEST_ASSERT_EQUAL(len, ByteBuffer_BytesRemaining(buffer));
buffer.bytesUsed = 3;
TEST_ASSERT_EQUAL(1, ByteBuffer_BytesRemaining(buffer));
buffer.bytesUsed = len;
TEST_ASSERT_EQUAL(0, ByteBuffer_BytesRemaining(buffer));
}
void test_KineticClient_Get_should_execute_GET_operation_and_retrieve_only_metadata(void)
{
uint8_t KeyData[64];
ByteArray Key = ByteArray_Create(KeyData, sizeof(KeyData));
ByteBuffer KeyBuffer = ByteBuffer_CreateWithArray(Key);
ByteBuffer_AppendDummyData(&KeyBuffer, Key.len);
KineticEntry entry = {
.key = KeyBuffer,
.metadataOnly = true,
};
KineticOperation operation;
KineticAllocator_NewOperation_ExpectAndReturn(&Session, &operation);
KineticBuilder_BuildGet_ExpectAndReturn(&operation, &entry, KINETIC_STATUS_SUCCESS);
KineticController_ExecuteOperation_ExpectAndReturn(&operation, NULL, KINETIC_STATUS_SUCCESS);
KineticStatus status = KineticClient_Get(&Session, &entry, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
}
void test_KineticBuilder_BuildPut_should_build_and_execute_a_PUT_operation_to_create_a_new_object_with_calculated_tag(void)
{
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");
KineticEntry entry = {
.key = ByteBuffer_CreateWithArray(key),
.newVersion = ByteBuffer_CreateWithArray(newVersion),
.tag = ByteBuffer_CreateWithArray(tag),
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = ByteBuffer_CreateWithArray(value),
.computeTag = true,
};
KineticOperation_ValidateOperation_Expect(&Operation);
KineticMessage_ConfigureKeyValue_Expect(&Operation.request->message, &entry);
// Build the operation
KineticBuilder_BuildPut(&Operation, &entry);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL_PTR(entry.value.array.data, Operation.value.data);
TEST_ASSERT_EQUAL(entry.value.bytesUsed, Operation.value.len);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__PUT,
Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_ByteArray(value, Operation.entry->value.array);
TEST_ASSERT_EQUAL(0, Operation.entry->value.bytesUsed);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
}
uint8_t ValueData[KINETIC_OBJ_SIZE];
void test_KineticBuilder_BuildGet_should_build_a_GET_operation(void)
{
const ByteArray key = ByteArray_CreateWithCString("foobar");
ByteArray value = {.data = ValueData, .len = sizeof(ValueData)};
KineticEntry entry = {
.key = ByteBuffer_CreateWithArray(key),
.value = ByteBuffer_CreateWithArray(value),
};
entry.value.bytesUsed = 123; // Set to non-empty state, since it should be reset to 0
KineticOperation_ValidateOperation_Expect(&Operation);
KineticMessage_ConfigureKeyValue_Expect(&Request.message, &entry);
KineticBuilder_BuildGet(&Operation, &entry);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__GET, Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_PTR(KineticCallbacks_Get, Operation.opCallback);
TEST_ASSERT_EQUAL_PTR(value.data, Operation.entry->value.array.data);
TEST_ASSERT_EQUAL(value.len, Operation.entry->value.array.len);
TEST_ASSERT_EQUAL(0, Operation.entry->value.bytesUsed);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
TEST_ASSERT_FALSE(Operation.entry->metadataOnly);
}
void test_KineticBuilder_BuildGet_should_build_a_GET_operation_requesting_metadata_only(void)
{
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),
};
entry.value.bytesUsed = 123; // Set to non-empty state, since it should be reset to 0 for a metadata-only request
KineticOperation_ValidateOperation_Expect(&Operation);
KineticMessage_ConfigureKeyValue_Expect(&Request.message, &entry);
KineticBuilder_BuildGet(&Operation, &entry);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__GET, Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_PTR(KineticCallbacks_Get, Operation.opCallback);
TEST_ASSERT_EQUAL_PTR(value.data, Operation.entry->value.array.data);
TEST_ASSERT_EQUAL_PTR(value.len, Operation.entry->value.array.len);
TEST_ASSERT_EQUAL(0, Operation.entry->value.bytesUsed);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
TEST_ASSERT_TRUE(Operation.entry->metadataOnly);
}
void test_KineticBuilder_BuildGetNext_should_build_a_GETNEXT_operation(void)
{
const ByteArray key = ByteArray_CreateWithCString("foobar");
ByteArray value = {.data = ValueData, .len = sizeof(ValueData)};
KineticEntry entry = {
.key = ByteBuffer_CreateWithArray(key),
.value = ByteBuffer_CreateWithArray(value),
};
entry.value.bytesUsed = 123; // Set to non-empty state, since it should be reset to 0
KineticOperation_ValidateOperation_Expect(&Operation);
KineticMessage_ConfigureKeyValue_Expect(&Request.message, &entry);
KineticBuilder_BuildGetNext(&Operation, &entry);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__GETNEXT,
Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_PTR(KineticCallbacks_Get, Operation.opCallback);
TEST_ASSERT_EQUAL_PTR(value.data, Operation.entry->value.array.data);
TEST_ASSERT_EQUAL(value.len, Operation.entry->value.array.len);
TEST_ASSERT_EQUAL(0, Operation.entry->value.bytesUsed);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
TEST_ASSERT_FALSE(Operation.entry->metadataOnly);
}
void test_KineticBuilder_BuildGetNext_should_build_a_GETNEXT_operation_with_metadata_only(void)
{
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),
};
entry.value.bytesUsed = 123; // Set to non-empty state, since it should be reset to 0 for a metadata-only request
KineticOperation_ValidateOperation_Expect(&Operation);
KineticMessage_ConfigureKeyValue_Expect(&Request.message, &entry);
KineticBuilder_BuildGetNext(&Operation, &entry);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__GETNEXT,
Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_PTR(KineticCallbacks_Get, Operation.opCallback);
TEST_ASSERT_EQUAL_PTR(value.data, Operation.entry->value.array.data);
TEST_ASSERT_EQUAL_PTR(value.len, Operation.entry->value.array.len);
TEST_ASSERT_EQUAL(0, Operation.entry->value.bytesUsed);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
TEST_ASSERT_TRUE(Operation.entry->metadataOnly);
}
void test_KineticBuilder_BuildGetPrevious_should_build_a_GETPREVIOUS_operation(void)
{
const ByteArray key = ByteArray_CreateWithCString("foobar");
ByteArray value = {.data = ValueData, .len = sizeof(ValueData)};
KineticEntry entry = {
.key = ByteBuffer_CreateWithArray(key),
.value = ByteBuffer_CreateWithArray(value),
};
entry.value.bytesUsed = 123; // Set to non-empty state, since it should be reset to 0
KineticOperation_ValidateOperation_Expect(&Operation);
KineticMessage_ConfigureKeyValue_Expect(&Request.message, &entry);
KineticBuilder_BuildGetPrevious(&Operation, &entry);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__GETPREVIOUS,
Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_PTR(KineticCallbacks_Get, Operation.opCallback);
TEST_ASSERT_EQUAL_PTR(value.data, Operation.entry->value.array.data);
TEST_ASSERT_EQUAL(value.len, Operation.entry->value.array.len);
TEST_ASSERT_EQUAL(0, Operation.entry->value.bytesUsed);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
TEST_ASSERT_FALSE(Operation.entry->metadataOnly);
}
void test_KineticBuilder_BuildGetPrevious_should_build_a_GETPREVIOUS_operation_with_metadata_only(void)
{
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),
};
entry.value.bytesUsed = 123; // Set to non-empty state, since it should be reset to 0 for a metadata-only request
KineticOperation_ValidateOperation_Expect(&Operation);
KineticMessage_ConfigureKeyValue_Expect(&Request.message, &entry);
KineticBuilder_BuildGetPrevious(&Operation, &entry);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__GETPREVIOUS,
Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_PTR(KineticCallbacks_Get, Operation.opCallback);
TEST_ASSERT_EQUAL_PTR(value.data, Operation.entry->value.array.data);
TEST_ASSERT_EQUAL_PTR(value.len, Operation.entry->value.array.len);
TEST_ASSERT_EQUAL(0, Operation.entry->value.bytesUsed);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
TEST_ASSERT_TRUE(Operation.entry->metadataOnly);
}
void test_KineticBuilder_BuildFlush_should_build_a_FLUSHALLDATA_operation(void)
{
KineticOperation_ValidateOperation_Expect(&Operation);
KineticBuilder_BuildFlush(&Operation);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__FLUSHALLDATA,
Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_PTR(KineticCallbacks_Basic, Operation.opCallback);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
}
void test_KineticBuilder_BuildDelete_should_build_a_DELETE_operation(void)
{
const ByteArray key = ByteArray_CreateWithCString("foobar");
ByteArray value = ByteArray_Create(ValueData, sizeof(ValueData));
KineticEntry entry = {.key = ByteBuffer_CreateWithArray(key), .value = ByteBuffer_CreateWithArray(value)};
KineticOperation_ValidateOperation_Expect(&Operation);
KineticMessage_ConfigureKeyValue_Expect(&Request.message, &entry);
KineticBuilder_BuildDelete(&Operation, &entry);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__DELETE,
Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_PTR(KineticCallbacks_Delete, Operation.opCallback);
TEST_ASSERT_EQUAL_PTR(value.data, Operation.entry->value.array.data);
TEST_ASSERT_EQUAL_PTR(value.len, Operation.entry->value.array.len);
TEST_ASSERT_EQUAL(0, Operation.entry->value.bytesUsed);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
}
void test_KineticBuilder_BuildGetKeyRange_should_build_a_GetKeyRange_request(void)
{
const int maxKeyLen = 32; // arbitrary key length for test
uint8_t startKeyData[maxKeyLen];
uint8_t endKeyData[maxKeyLen];
ByteBuffer startKey, endKey;
startKey = ByteBuffer_Create(startKeyData, sizeof(startKeyData), 0);
ByteBuffer_AppendCString(&startKey, "key_range_00_00");
endKey = ByteBuffer_Create(endKeyData, sizeof(endKeyData), 0);
ByteBuffer_AppendCString(&endKey, "key_range_00_03");
const int numKeysInRange = 4;
KineticKeyRange range = {
.startKey = startKey,
.endKey = endKey,
.startKeyInclusive = true,
.endKeyInclusive = true,
.maxReturned = numKeysInRange,
.reverse = false,
};
uint8_t keysData[numKeysInRange][maxKeyLen];
ByteBuffer keyBuffers[numKeysInRange];
for (int i = 0; i < numKeysInRange; i++) {
keyBuffers[i] = ByteBuffer_Create(keysData[i], maxKeyLen, 0);
}
ByteBufferArray keys = {.buffers = keyBuffers, .count = numKeysInRange};
KineticOperation_ValidateOperation_Expect(&Operation);
KineticMessage_ConfigureKeyRange_Expect(&Request.message, &range);
KineticBuilder_BuildGetKeyRange(&Operation, &range, &keys);
TEST_ASSERT_TRUE(Request.command->header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__GETKEYRANGE,
Request.command->header->messagetype);
TEST_ASSERT_EQUAL_PTR(KineticCallbacks_GetKeyRange, Operation.opCallback);
TEST_ASSERT_NULL(Operation.entry);
TEST_ASSERT_EQUAL_PTR(&Request, Operation.request);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
TEST_ASSERT_EQUAL_PTR(&Request.message.command, Request.command);
}
void test_KineticBuilder_BuildP2POperation_should_build_a_P2POperation_request(void)
{
ByteBuffer oldKey1 = ByteBuffer_Create((void*)0x1234, 10, 10);
ByteBuffer newKey1 = ByteBuffer_Create((void*)0x4321, 33, 33);
ByteBuffer version1 = ByteBuffer_Create((void*)0xABC, 6, 6);
ByteBuffer oldKey2 = ByteBuffer_Create((void*)0x5678, 12, 12);
ByteBuffer newKey2 = ByteBuffer_Create((void*)0x8765, 200, 200);
KineticP2P_OperationData ops2[] ={
{
.key = oldKey2,
.newKey = newKey2,
}
};
KineticP2P_Operation chained_p2pOp = {
.peer = {
.hostname = "hostname1",
.port = 4321,
},
.numOperations = 1,
.operations = ops2
};
KineticP2P_OperationData ops[] ={
{
.key = oldKey1,
.version = version1,
.newKey = newKey1,
.chainedOperation = &chained_p2pOp,
},
{
.key = oldKey2,
.newKey = newKey2,
}
};
KineticP2P_Operation p2pOp = {
.peer = {
.hostname = "hostname",
.port = 1234,
.tls = true,
},
.numOperations = 2,
.operations = ops
};
KineticOperation_ValidateOperation_Expect(&Operation);
KineticBuilder_BuildP2POperation(&Operation, &p2pOp);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__PEER2PEERPUSH,
Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_PTR(&Request.message.body, Request.command->body);
TEST_ASSERT_NOT_NULL(Request.command->body->p2poperation);
TEST_ASSERT_EQUAL("hostname",
Request.command->body->p2poperation->peer->hostname);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->peer->has_port);
TEST_ASSERT_EQUAL(1234,
Request.command->body->p2poperation->peer->port);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->peer->has_tls);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->peer->tls);
TEST_ASSERT_FALSE(Request.command->body->p2poperation->allchildoperationssucceeded);
TEST_ASSERT_FALSE(Request.command->body->p2poperation->has_allchildoperationssucceeded);
TEST_ASSERT_EQUAL(2,
Request.command->body->p2poperation->n_operation);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[0]->has_key);
TEST_ASSERT_EQUAL(oldKey1.array.data,
Request.command->body->p2poperation->operation[0]->key.data);
TEST_ASSERT_EQUAL(oldKey1.bytesUsed,
Request.command->body->p2poperation->operation[0]->key.len);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[0]->has_newkey);
TEST_ASSERT_EQUAL(newKey1.array.data,
Request.command->body->p2poperation->operation[0]->newkey.data);
TEST_ASSERT_EQUAL(newKey1.bytesUsed,
Request.command->body->p2poperation->operation[0]->newkey.len);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[0]->has_version);
TEST_ASSERT_EQUAL(version1.array.data,
Request.command->body->p2poperation->operation[0]->version.data);
TEST_ASSERT_EQUAL(version1.bytesUsed,
Request.command->body->p2poperation->operation[0]->version.len);
TEST_ASSERT_FALSE(Request.command->body->p2poperation->operation[0]->has_force);
TEST_ASSERT_FALSE(Request.command->body->p2poperation->operation[0]->force);
TEST_ASSERT_NOT_NULL(Request.command->body->p2poperation->operation[0]->p2pop);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[0]->p2pop->peer->has_port);
TEST_ASSERT_EQUAL(4321,
Request.command->body->p2poperation->operation[0]->p2pop->peer->port);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[0]->p2pop->peer->has_tls);
TEST_ASSERT_FALSE(Request.command->body->p2poperation->operation[0]->p2pop->peer->tls);
TEST_ASSERT_EQUAL(1,
Request.command->body->p2poperation->operation[0]->p2pop->n_operation);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[0]->p2pop->operation[0]->has_key);
TEST_ASSERT_EQUAL(oldKey2.array.data,
Request.command->body->p2poperation->operation[0]->p2pop->operation[0]->key.data);
TEST_ASSERT_EQUAL(oldKey2.bytesUsed,
Request.command->body->p2poperation->operation[0]->p2pop->operation[0]->key.len);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[0]->p2pop->operation[0]->has_newkey);
TEST_ASSERT_EQUAL(newKey2.array.data,
Request.command->body->p2poperation->operation[0]->p2pop->operation[0]->newkey.data);
TEST_ASSERT_EQUAL(newKey2.bytesUsed,
Request.command->body->p2poperation->operation[0]->p2pop->operation[0]->newkey.len);
TEST_ASSERT_FALSE(Request.command->body->p2poperation->operation[0]->p2pop->operation[0]->has_version);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[0]->p2pop->operation[0]->has_force);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[0]->p2pop->operation[0]->force);
TEST_ASSERT_NULL(Request.command->body->p2poperation->operation[0]->status);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[1]->has_key);
TEST_ASSERT_EQUAL(oldKey2.array.data,
Request.command->body->p2poperation->operation[1]->key.data);
TEST_ASSERT_EQUAL(oldKey2.bytesUsed,
Request.command->body->p2poperation->operation[1]->key.len);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[1]->has_newkey);
TEST_ASSERT_EQUAL(newKey2.array.data,
Request.command->body->p2poperation->operation[1]->newkey.data);
TEST_ASSERT_EQUAL(newKey2.bytesUsed,
Request.command->body->p2poperation->operation[1]->newkey.len);
TEST_ASSERT_FALSE(Request.command->body->p2poperation->operation[1]->has_version);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[1]->has_force);
TEST_ASSERT_TRUE(Request.command->body->p2poperation->operation[1]->force);
TEST_ASSERT_NULL(Request.command->body->p2poperation->operation[1]->p2pop);
TEST_ASSERT_NULL(Request.command->body->p2poperation->operation[1]->status);
TEST_ASSERT_EQUAL_PTR(&p2pOp, Operation.p2pOp);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
// This just free's the malloc'd memory and sets statuses to "invalid" (since no operation was actually performed)
KineticAllocator_FreeP2PProtobuf(Request.command->body->p2poperation);
}
/*******************************************************************************
* Admin Client Operations
*******************************************************************************/
void test_KineticBuilder_BuildGetLog_should_build_a_GetLog_request(void)
{
KineticLogInfo* pInfo;
KineticOperation_ValidateOperation_Expect(&Operation);
KineticStatus status = KineticBuilder_BuildGetLog(&Operation,
KINETIC_DEVICE_INFO_TYPE_STATISTICS, BYTE_ARRAY_NONE, &pInfo);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__GETLOG,
Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_PTR(&Request.message.body, Request.command->body);
TEST_ASSERT_EQUAL_PTR(&Request.message.getLog, Request.command->body->getlog);
TEST_ASSERT_NOT_NULL(Request.command->body->getlog->types);
TEST_ASSERT_EQUAL(1, Request.command->body->getlog->n_types);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__TYPE__STATISTICS,
Request.command->body->getlog->types[0]);
TEST_ASSERT_EQUAL_PTR(&pInfo, Operation.deviceInfo);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
}
void test_KineticBuilder_BuildGetLog_should_build_a_GetLog_request_to_retrieve_device_specific_log_info(void)
{
KineticLogInfo* pInfo;
const char nameData[] = "com.WD";
ByteArray name = ByteArray_CreateWithCString(nameData);
KineticOperation_ValidateOperation_Expect(&Operation);
KineticStatus status = KineticBuilder_BuildGetLog(&Operation, COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__TYPE__DEVICE, name, &pInfo);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_TRUE(Request.message.command.header->has_messagetype);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__MESSAGE_TYPE__GETLOG,
Request.message.command.header->messagetype);
TEST_ASSERT_EQUAL_PTR(&Request.message.body, Request.command->body);
TEST_ASSERT_EQUAL_PTR(&Request.message.getLog, Request.command->body->getlog);
TEST_ASSERT_NOT_NULL(Request.command->body->getlog->types);
TEST_ASSERT_EQUAL(1, Request.command->body->getlog->n_types);
TEST_ASSERT_EQUAL(COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__TYPE__DEVICE,
Request.command->body->getlog->types[0]);
TEST_ASSERT_EQUAL_PTR(&Request.message.getLogDevice, Request.command->body->getlog->device);
TEST_ASSERT_TRUE(Request.command->body->getlog->device->has_name);
TEST_ASSERT_EQUAL_PTR(nameData, Request.command->body->getlog->device->name.data);
TEST_ASSERT_EQUAL(strlen(nameData), Request.command->body->getlog->device->name.len);
TEST_ASSERT_EQUAL_PTR(&pInfo, Operation.deviceInfo);
TEST_ASSERT_FALSE(Request.pinAuth);
TEST_ASSERT_EQUAL(0, Operation.timeoutSeconds);
TEST_ASSERT_NULL(Operation.response);
}
void test_KineticBuilder_BuildGetLog_should_return_KINETIC_STATUS_DEVICE_NAME_REQUIRED_if_name_not_specified_correctly(void)
{
KineticLogInfo* pInfo;
char nameData[] = "com.WD";
ByteArray name;
KineticStatus status;
// Length is zero
name.data = (uint8_t*)nameData;
name.len = 0;
KineticOperation_ValidateOperation_Expect(&Operation);
status = KineticBuilder_BuildGetLog(&Operation,
COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__TYPE__DEVICE, name, &pInfo);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_DEVICE_NAME_REQUIRED, status);
// Data is NULL
name.data = NULL;
name.len = strlen(nameData);
KineticOperation_ValidateOperation_Expect(&Operation);
status = KineticBuilder_BuildGetLog(&Operation,
COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__TYPE__DEVICE, name, &pInfo);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_DEVICE_NAME_REQUIRED, status);
// Length is zero and data is NULL
name.data = NULL;
name.len = 0;
KineticOperation_ValidateOperation_Expect(&Operation);
status = KineticBuilder_BuildGetLog(&Operation,
COM__SEAGATE__KINETIC__PROTO__COMMAND__GET_LOG__TYPE__DEVICE, name, &pInfo);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_DEVICE_NAME_REQUIRED, 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);
}