void test_KineticClient_Connect_should_return_KINETIC_STATUS_SESSION_EMPTY_upon_NULL_session_config(void)
{
SessionHandle = 17;
KineticStatus status = KineticClient_Connect(NULL, &SessionHandle);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SESSION_EMPTY, status);
TEST_ASSERT_EQUAL(KINETIC_HANDLE_INVALID, SessionHandle);
}
void setUp(void)
{
KINETIC_CONNECTION_INIT(&Connection);
Connection.connected = false; // Ensure gets set appropriately by internal connect call
HmacKey = ByteArray_CreateWithCString("some hmac key");
KINETIC_SESSION_INIT(&Session, "somehost.com", ClusterVersion, Identity, HmacKey);
KineticConnection_NewConnection_ExpectAndReturn(&Session, DummyHandle);
KineticConnection_FromHandle_ExpectAndReturn(DummyHandle, &Connection);
KineticConnection_Connect_ExpectAndReturn(&Connection, KINETIC_STATUS_SUCCESS);
KineticStatus status = KineticClient_Connect(&Session, &SessionHandle);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL(DummyHandle, SessionHandle);
}
static void ConnectSession(void)
{
KINETIC_CONNECTION_INIT(&Connection);
Connection.connected = false; // Ensure gets set appropriately by internal connect call
Connection.connectionID = 12374626536; // Fake connection ID to allow connection to complete for these tests
HmacKey = ByteArray_CreateWithCString("some hmac key");
KINETIC_SESSION_INIT(&Session, "somehost.com", ClusterVersion, Identity, HmacKey);
KineticConnection_NewConnection_ExpectAndReturn(&Session, DummyHandle);
KineticConnection_FromHandle_ExpectAndReturn(DummyHandle, &Connection);
KineticConnection_Connect_ExpectAndReturn(&Connection, KINETIC_STATUS_SUCCESS);
// KineticConnection_ReceiveDeviceStatusMessage_ExpectAndReturn(&Connection, KINETIC_STATUS_SUCCESS);
KineticStatus status = KineticClient_Connect(&Session, &SessionHandle);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL(DummyHandle, SessionHandle);
}
void test_KineticClient_Connect_should_return_KINETIC_STATUS_HOST_EMPTY_upon_NULL_host(void)
{
ByteArray key = ByteArray_CreateWithCString("some_key");
KineticSession config = {
.host = "",
.hmacKey = key,
};
SessionHandle = 17;
KineticStatus status = KineticClient_Connect(&config, &SessionHandle);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_HOST_EMPTY, status);
TEST_ASSERT_EQUAL(KINETIC_HANDLE_INVALID, SessionHandle);
}
void test_KineticClient_Connect_should_return_KINETIC_STATUS_HMAC_EMPTY_upon_NULL_HMAC_key(void)
{
ByteArray key = {.len = 4, .data = NULL};
KineticSession config = {
.host = "somehost.com",
.hmacKey = key,
};
SessionHandle = 17;
KineticStatus status = KineticClient_Connect(&config, &SessionHandle);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_HMAC_EMPTY, status);
TEST_ASSERT_EQUAL(KINETIC_HANDLE_INVALID, SessionHandle);
}
void test_KineticClient_Connect_should_return_false_upon_empty_HMAC_key(void)
{
uint8_t keyData[] = {0, 1, 2, 3};
ByteArray key = {.len = 0, .data = keyData};
KineticSession config = {
.host = "somehost.com",
.hmacKey = key,
};
SessionHandle = 17;
KineticStatus status = KineticClient_Connect(&config, &SessionHandle);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_HMAC_EMPTY, status);
TEST_ASSERT_EQUAL(KINETIC_HANDLE_INVALID, SessionHandle);
}
void test_KineticClient_Connect_should_return_KINETIC_STATUS_SESSION_EMPTY_upon_NULL_handle(void)
{
KineticSession config = {
.host = "somehost.com",
.hmacKey = ByteArray_CreateWithCString("some_key"),
};
SessionHandle = 17;
KineticStatus status = KineticClient_Connect(&config, NULL);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SESSION_EMPTY, status);
}
void test_KineticClient_Connect_should_return_KINETIC_STATUS_SESSION_INVALID_if_connection_for_handle_is_NULL(void)
{
KineticSession config = {
.host = "somehost.com",
.hmacKey = ByteArray_CreateWithCString("some_key"),
};
SessionHandle = 17;
KineticConnection_NewConnection_ExpectAndReturn(&config, DummyHandle);
KineticConnection_FromHandle_ExpectAndReturn(DummyHandle, NULL);
KineticStatus status = KineticClient_Connect(&config, &SessionHandle);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_CONNECTION_ERROR, status);
}
void test_KineticClient_Connect_should_return_status_from_a_failed_connection(void)
{
KineticSession config = {
.host = "somehost.com",
.hmacKey = ByteArray_CreateWithCString("some_key"),
};
SessionHandle = 17;
KineticConnection_NewConnection_ExpectAndReturn(&config, DummyHandle);
KineticConnection_FromHandle_ExpectAndReturn(DummyHandle, &Connection);
KineticConnection_Connect_ExpectAndReturn(&Connection, KINETIC_STATUS_HMAC_EMPTY);
KineticConnection_FreeConnection_Expect(&SessionHandle);
KineticStatus status = KineticClient_Connect(&config, &SessionHandle);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_HMAC_EMPTY, status);
TEST_ASSERT_EQUAL(KINETIC_HANDLE_INVALID, SessionHandle);
}
void test_KineticClient_Disconnect_should_return_KINETIC_STATUS_CONNECTION_ERROR_upon_failure_to_get_connection_from_handle(void)
{
SessionHandle = DummyHandle;
KineticConnection_FromHandle_ExpectAndReturn(DummyHandle, NULL);
KineticStatus status = KineticClient_Disconnect(&SessionHandle);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_CONNECTION_ERROR, status);
}
void test_KineticClient_Disconnect_should_disconnect_and_free_the_connection_associated_with_handle(void)
{
SessionHandle = DummyHandle;
KineticConnection_FromHandle_ExpectAndReturn(DummyHandle, &Connection);
KineticConnection_Disconnect_ExpectAndReturn(&Connection, KINETIC_STATUS_SUCCESS);
KineticConnection_FreeConnection_Expect(&SessionHandle);
KineticStatus status = KineticClient_Disconnect(&SessionHandle);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SUCCESS, status);
TEST_ASSERT_EQUAL(KINETIC_HANDLE_INVALID, SessionHandle);
}
void test_KineticClient_Disconnect_should_return_status_from_KineticConnection_upon_faileure(void)
{
SessionHandle = DummyHandle;
KineticConnection_FromHandle_ExpectAndReturn(DummyHandle, &Connection);
KineticConnection_Disconnect_ExpectAndReturn(&Connection, KINETIC_STATUS_SESSION_INVALID);
KineticConnection_FreeConnection_Expect(&SessionHandle);
KineticStatus status = KineticClient_Disconnect(&SessionHandle);
TEST_ASSERT_EQUAL_KineticStatus(KINETIC_STATUS_SESSION_INVALID, status);
TEST_ASSERT_EQUAL(KINETIC_HANDLE_INVALID, SessionHandle);
}
void test_kinetic_client_should_be_able_to_store_an_arbitrarily_large_binary_object_and_split_across_entries_via_ovelapped_IO_operations(void)
{
const int maxIterations = 4;
const int numCopiesToStore = 4;
const KineticSession sessionConfig = {
.host = "localhost",
.port = KINETIC_PORT,
.nonBlocking = false,
.clusterVersion = 0,
.identity = 1,
.hmacKey = ByteArray_CreateWithCString("asdfasdf"),
};
for (int iteration = 0; iteration < maxIterations; iteration++) {
printf("Overlapped PUT operation (iteration %d of %d)\n",
iteration + 1, maxIterations);
char* buf = malloc(sizeof(char) * BUFSIZE);
int fd = open("test/support/data/test.data", O_RDONLY);
int dataLen = read(fd, buf, BUFSIZE);
close(fd);
TEST_ASSERT_MESSAGE(dataLen > 0, "read error");
/* thread structure */
struct kinetic_thread_arg* kt_arg;
pthread_t thread_id[KINETIC_MAX_THREADS];
kinetic_client = malloc(sizeof(KineticSessionHandle) * numCopiesToStore);
TEST_ASSERT_NOT_NULL_MESSAGE(kinetic_client, "kinetic_client malloc failed");
kt_arg = malloc(sizeof(struct kinetic_thread_arg) * numCopiesToStore);
TEST_ASSERT_NOT_NULL_MESSAGE(kt_arg, "kinetic_thread_arg malloc failed");
for (int i = 0; i < numCopiesToStore; i++) {
printf(" Overlapped PUT operations (writing copy %d of %d) on IP (iteration %d of %d):%s\n",
i + 1, numCopiesToStore, iteration + 1, maxIterations, sessionConfig.host);
// Establish connection
TEST_ASSERT_EQUAL_KineticStatus(
KINETIC_STATUS_SUCCESS,
KineticClient_Connect(&sessionConfig, &kinetic_client[i]));
strcpy(kt_arg[i].ip, sessionConfig.host);
// Configure the KineticEntry
char keyPrefix[128];
snprintf(keyPrefix, sizeof(keyPrefix), "pre_%02d%02d", iteration, i);
LOGF("NEW HUNK PREFIX: %s", keyPrefix);
ByteBuffer keyBuf = ByteBuffer_Create(kt_arg[i].key, sizeof(kt_arg[i].key));
ByteBuffer_AppendCString(&keyBuf, keyPrefix);
kt_arg[i].keyPrefixLength = keyBuf.bytesUsed;
ByteBuffer verBuf = ByteBuffer_Create(kt_arg[i].version, sizeof(kt_arg[i].version));
ByteBuffer_AppendCString(&verBuf, "v1.0");
ByteBuffer tagBuf = ByteBuffer_Create(kt_arg[i].tag, sizeof(kt_arg[i].tag));
ByteBuffer_AppendCString(&tagBuf, "some_value_tag...");
ByteBuffer valBuf = ByteBuffer_Create(kt_arg[i].value, sizeof(kt_arg[i].value));
kt_arg[i].entry = (KineticEntry) {
.key = keyBuf,
.newVersion = verBuf,
.tag = tagBuf,
.metadataOnly = false,
.algorithm = KINETIC_ALGORITHM_SHA1,
.value = valBuf,
};
// Create a ByteBuffer for consuming chunks of data out of for overlapped PUTs
kt_arg[i].data = ByteBuffer_Create(buf, dataLen);
// Spawn the worker thread
kt_arg[i].sessionHandle = kinetic_client[i];
int create_status = pthread_create(&thread_id[i], NULL, kinetic_put, &kt_arg[i]);
TEST_ASSERT_EQUAL_MESSAGE(0, create_status, "pthread create failed");
}
// Wait for each overlapped PUT operations to complete and cleanup
printf(" Waiting for PUT threads to exit...\n");
for (int i = 0; i < numCopiesToStore; i++) {
int join_status = pthread_join(thread_id[i], NULL);
TEST_ASSERT_EQUAL_MESSAGE(0, join_status, "pthread join failed");
KineticClient_Disconnect(&kinetic_client[i]);
}
// Cleanup the rest of the reources
free(kinetic_client);
free(kt_arg);
free(buf);
printf(" Iteration complete!\n");
}
printf("Overlapped PUT operation test complete!\n");
}