void test_success_response(void **state)
{
(void)state;
uint8_t success_response[] = {
/* bit 0 */ 0x00, 0x00, 0x00, 0x00, /* User attach response field. Result - success */
/* bit 32 */ 0x01, 0x07, 0x00, 0x05, /* User attach notification field */
/* bit 64 */ 'u', 's', 'e', 'r',
/* bit 96 */ '@', 'i', 'd', 0x00,
/* bit 128 */ 't', 'o', 'k', 'e',
/* bit 160 */ 'n', 0x00, 0x00, 0x00,
/* bit 192 */ 0x02, 0x00, 0x00, 0x05, /* User detach notification field */
/* bit 224 */ 't', 'o', 'k', 'e',
/* bit 256 */ 'n', 0x00, 0x00, 0x00
};
kaa_platform_message_reader_t *reader = NULL;
ASSERT_EQUAL(kaa_platform_message_reader_create(&reader, success_response, 36), KAA_ERR_NONE);
ASSERT_NOT_NULL(reader);
ASSERT_EQUAL(kaa_user_handle_server_sync(user_manager, reader, 0, 36), KAA_ERR_NONE);
ASSERT_TRUE(is_on_attached_invoked);
ASSERT_TRUE(is_on_detached_invoked);
ASSERT_TRUE(is_attach_success_invoked);
ASSERT_TRUE(last_is_attached_result);
kaa_platform_message_reader_destroy(reader);
}
void test_read_protocol_message_header(void)
{
kaa_platform_message_reader_t *reader = NULL;
const char serialized_header[KAA_PROTOCOL_MESSAGE_HEADER_SIZE] = {0x00, 0x00, 0x30, 0x39, 0x01, 0x00, 0x00, 0x05};
kaa_error_t error_code = KAA_ERR_NONE;
error_code = kaa_platform_message_reader_create(&reader, serialized_header, KAA_PROTOCOL_MESSAGE_HEADER_SIZE);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
const uint32_t protocol_id = 12345;
const uint16_t protocol_version = 256;
const uint16_t extension_count = 5;
uint32_t read_protocol_id = 0;
uint16_t read_protocol_version = 0;
uint16_t read_extension_count = 0;
error_code = kaa_platform_message_header_read(reader, &read_protocol_id, &read_protocol_version, &read_extension_count);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(read_protocol_id, protocol_id);
ASSERT_EQUAL(read_protocol_version, protocol_version);
ASSERT_EQUAL(read_extension_count, extension_count);
kaa_platform_message_reader_destroy(reader);
}
void test_read_extension_header(void)
{
kaa_platform_message_reader_t *reader = NULL;
const char serialized_header[KAA_EXTENSION_HEADER_SIZE] = {0xfa, 0x10, 0x11, 0x12, 0xaa, 0xbb, 0xcc, 0xff};
kaa_error_t error_code = KAA_ERR_NONE;
error_code = kaa_platform_message_reader_create(&reader, serialized_header, KAA_PROTOCOL_MESSAGE_HEADER_SIZE);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
const uint8_t extension_type = 250;
const uint32_t extension_options = (0x10 << 16) | (0x11 << 8) | 0x12;
const uint32_t extension_payload_length = 0xaabbccff;
uint8_t read_extension_type = 0;
uint32_t read_extension_options = 0;
uint32_t read_extension_payload_length = 0;
error_code = kaa_platform_message_read_extension_header(
reader, &read_extension_type, &read_extension_options, &read_extension_payload_length);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(read_extension_type, extension_type);
ASSERT_EQUAL(read_extension_options, extension_options);
ASSERT_EQUAL(read_extension_payload_length, extension_payload_length);
kaa_platform_message_reader_destroy(reader);
}
void test_create_destroy_reader(void)
{
kaa_platform_message_reader_t *reader = NULL;
char buffer[16];
size_t buffer_size = sizeof(buffer) / sizeof(char);
kaa_error_t error_code = KAA_ERR_NONE;
error_code = kaa_platform_message_reader_create(NULL, buffer, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
ASSERT_NULL(reader);
error_code = kaa_platform_message_reader_create(&reader, NULL, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
ASSERT_NULL(reader);
error_code = kaa_platform_message_reader_create(&reader, buffer, 0);
ASSERT_EQUAL(error_code, KAA_ERR_BADPARAM);
ASSERT_NULL(reader);
error_code = kaa_platform_message_reader_create(&reader, buffer, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(reader);
ASSERT_EQUAL((reader->end - reader->begin), buffer_size);
ASSERT_EQUAL(reader->begin, reader->current);
kaa_platform_message_reader_destroy(reader);
}
void test_read(void)
{
kaa_platform_message_reader_t *reader = NULL;
char write_buffer[16];
char read_buffer[16];
size_t buffer_size = sizeof(write_buffer) / sizeof(char);
char *serialized_data = "big serialized data";
memcpy(write_buffer, serialized_data, buffer_size);
kaa_error_t error_code = KAA_ERR_NONE;
error_code = kaa_platform_message_reader_create(&reader, write_buffer, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t sub_buffer_size = buffer_size / 2;
error_code = kaa_platform_message_read(reader, read_buffer, sub_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = (memcmp(read_buffer, serialized_data, sub_buffer_size) == 0 ? KAA_ERR_NONE : KAA_ERR_READ_FAILED);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_read(reader, read_buffer + sub_buffer_size, sub_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = (memcmp(read_buffer + sub_buffer_size, serialized_data + sub_buffer_size, sub_buffer_size) == 0 ? KAA_ERR_NONE : KAA_ERR_READ_FAILED);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_platform_message_reader_destroy(reader);
}
void test_profile_handle_sync(void)
{
KAA_TRACE_IN(logger);
bool need_resync = false;
kaa_error_t error_code = KAA_ERR_NONE;
uint16_t extension_options = 0x1; /* Need resync */
const size_t buffer_size = 6;
char buffer[buffer_size];
kaa_platform_message_reader_t *reader;
error_code = kaa_platform_message_reader_create(&reader, buffer, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_profile_handle_server_sync(profile_manager, reader, extension_options, 0);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_profile_need_profile_resync(profile_manager, &need_resync);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_TRUE(need_resync);
extension_options = 0x0; /* Need resync */
error_code = kaa_profile_handle_server_sync(profile_manager, reader, extension_options, 0);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_profile_need_profile_resync(profile_manager, &need_resync);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_FALSE(need_resync);
kaa_platform_message_reader_destroy(reader);
KAA_TRACE_OUT(logger);
}
void test_response(void **state)
{
(void)state;
const size_t response_size = kaa_aligned_size_get(KAA_CONFIGURATION_DATA_LENGTH) + sizeof(uint32_t);
uint8_t response[response_size];
uint8_t *response_cursor = response;
*((uint32_t *) response_cursor) = KAA_HTONL(KAA_CONFIGURATION_DATA_LENGTH);
response_cursor += sizeof(uint32_t);
memcpy(response_cursor, KAA_CONFIGURATION_DATA, KAA_CONFIGURATION_DATA_LENGTH);
kaa_platform_message_reader_t *reader = NULL;
ASSERT_EQUAL(kaa_platform_message_reader_create(&reader, response, response_size), KAA_ERR_NONE);
bool is_callback_invoked = false;
kaa_configuration_root_receiver_t receiver = { &is_callback_invoked, &on_configuration_updated };
ASSERT_EQUAL(kaa_configuration_manager_set_root_receiver(config_manager, &receiver), KAA_ERR_NONE);
ASSERT_EQUAL(kaa_configuration_manager_handle_server_sync(config_manager, reader, CONFIG_RESPONSE_FLAGS, response_size), KAA_ERR_NONE);
ASSERT_EQUAL(is_callback_invoked, true);
const kaa_root_configuration_t *root_config = kaa_configuration_manager_get_configuration(config_manager);
ASSERT_EQUAL(strcmp(root_config->data->data, CONFIG_DATA_FIELD), 0);
kaa_bytes_t *uuid = (kaa_bytes_t *) root_config->__uuid->data;
ASSERT_EQUAL(uuid->size, CONFIG_UUID_SIZE);
ASSERT_EQUAL(memcmp(uuid->buffer, CONFIG_UUID, uuid->size), 0);
kaa_platform_message_reader_destroy(reader);
}
void test_read_eof(void)
{
kaa_platform_message_reader_t *reader = NULL;
char write_buffer[2 * KAA_ALIGNMENT];
char read_buffer[KAA_ALIGNMENT];
size_t buffer_size = sizeof(write_buffer) / sizeof(char);
kaa_error_t error_code = KAA_ERR_NONE;
error_code = kaa_platform_message_reader_create(&reader, write_buffer, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_read(reader, read_buffer, KAA_ALIGNMENT);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_read(reader, read_buffer, KAA_ALIGNMENT);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_read(reader, read_buffer, KAA_ALIGNMENT);
ASSERT_EQUAL(error_code, KAA_ERR_READ_FAILED);
kaa_platform_message_reader_destroy(reader);
}
void test_read_aligned(void)
{
kaa_platform_message_reader_t *reader = NULL;
char write_buffer[3 * KAA_ALIGNMENT];
char read_buffer[2 * KAA_ALIGNMENT];
size_t buffer_size = sizeof(write_buffer) / sizeof(char);
kaa_error_t error_code = KAA_ERR_NONE;
error_code = kaa_platform_message_reader_create(&reader, write_buffer, buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_read_aligned(reader, read_buffer, KAA_ALIGNMENT + 1);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL((reader->current - reader->begin), 2 * KAA_ALIGNMENT);
const char* begin = reader->current;
error_code = kaa_platform_message_read_aligned(reader, read_buffer, KAA_ALIGNMENT);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL((reader->current - begin), KAA_ALIGNMENT);
kaa_platform_message_reader_destroy(reader);
}
void test_failed_response(void **state)
{
(void)state;
uint8_t failed_response[] = {
/* bit 0 */ 0x00, 0x00, 0x01, 0x00, /* User attach response field. Result - success */
/* bit 32 */ 0x00, 0x04, 0x00, 0x14, /* User attach notification field */
/* bit 64 */ 'B', 'a', 'd', ' ',
/* bit 96 */ 'u', 's', 'e', 'r',
/* bit 128 */ ' ', 'c', 'r', 'e',
/* bit 160 */ 'd', 'e', 'n', 't',
/* bit 192 */ 'i', 'a', 'l', 's'
};
kaa_platform_message_reader_t *reader = NULL;
ASSERT_EQUAL(kaa_platform_message_reader_create(&reader, failed_response, 28), KAA_ERR_NONE);
ASSERT_NOT_NULL(reader);
ASSERT_EQUAL(kaa_user_handle_server_sync(user_manager, reader, 0, 28), KAA_ERR_NONE);
ASSERT_TRUE(is_attach_failed_invoked);
kaa_platform_message_reader_destroy(reader);
}
void test_create_request(void **state)
{
(void)state;
kaa_user_log_record_t *test_log_record = kaa_test_log_record_create();
test_log_record->data = kaa_string_copy_create(TEST_LOG_BUFFER);
size_t test_log_record_size = test_log_record->get_size(test_log_record);
kaa_log_collector_t *log_collector = NULL;
kaa_error_t error_code = kaa_log_collector_create(&log_collector, status,
channel_manager, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
mock_strategy_context_t strategy;
memset(&strategy, 0, sizeof(mock_strategy_context_t));
strategy.decision = NOOP;
strategy.max_parallel_uploads = UINT32_MAX;
kaa_log_bucket_constraints_t constraints = {
.max_bucket_size = 2 * test_log_record_size,
.max_bucket_log_count = UINT32_MAX,
};
error_code = kaa_logging_init(log_collector, create_mock_storage(), &strategy, &constraints);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t expected_size = 0;
error_code = kaa_logging_request_get_size(log_collector, &expected_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
uint8_t buffer[expected_size];
kaa_platform_message_writer_t *writer = NULL;
error_code = kaa_platform_message_writer_create(&writer, buffer, expected_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(writer);
error_code = kaa_logging_request_serialize(log_collector, writer);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_platform_message_writer_destroy(writer);
uint8_t *buf_cursor = buffer;
ASSERT_EQUAL(KAA_EXTENSION_LOGGING, KAA_HTONS(*(uint16_t *)buf_cursor));
buf_cursor += sizeof(uint16_t);
uint8_t options[] = { 0x00, 0x01 };
ASSERT_EQUAL(memcmp(buf_cursor, options, 2), 0);
buf_cursor += 2;
ASSERT_EQUAL(*(uint32_t *) buf_cursor, KAA_HTONL(20));
buf_cursor += sizeof(uint32_t);
uint8_t request_id_records_count[] = { 0x00, 0x01, 0x00, 0x01 };
ASSERT_EQUAL(memcmp(buf_cursor, request_id_records_count, 4), 0);
buf_cursor += 4;
uint8_t record_buf[test_log_record_size];
avro_writer_t avro_writer = avro_writer_memory((char *)record_buf, test_log_record_size);
test_log_record->serialize(avro_writer, test_log_record);
avro_writer_free(avro_writer);
ASSERT_EQUAL(*(uint32_t *) buf_cursor, KAA_HTONL(test_log_record_size));
buf_cursor += sizeof(uint32_t);
ASSERT_EQUAL(memcmp(buf_cursor, record_buf, test_log_record_size), 0);
kaa_log_collector_destroy(log_collector);
test_log_record->destroy(test_log_record);
}
void test_response(void **state)
{
(void)state;
srand(time(NULL));
kaa_log_collector_t *log_collector = NULL;
kaa_error_t error_code = kaa_log_collector_create(&log_collector, status, channel_manager, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
mock_strategy_context_t strategy;
memset(&strategy, 0, sizeof(mock_strategy_context_t));
mock_storage_context_t *storage = create_mock_storage();
kaa_log_bucket_constraints_t constraints = {
.max_bucket_size = 1024,
.max_bucket_log_count = UINT32_MAX,
};
error_code = kaa_logging_init(log_collector, storage, &strategy, &constraints);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
uint32_t response_count = 2;
size_t response_buffer_size = sizeof(uint32_t) + sizeof(uint32_t) * response_count;
uint8_t response_buffer[response_buffer_size];
uint8_t *response = response_buffer;
*((uint32_t *)response) = KAA_HTONL(response_count);
response += sizeof(uint32_t);
/* First response */
*((uint16_t *)response) = KAA_HTONS(rand());
response += sizeof(uint16_t);
*((uint8_t *)response) = 0x0; // SUCCESS
response += sizeof(uint8_t);
*((uint8_t *)response) = 0;
response += sizeof(uint8_t);
/* Second response */
*((uint16_t *)response) = KAA_HTONS(rand());
response += sizeof(uint16_t);
*((uint8_t *)response) = 0x1; // FAILURE
response += sizeof(uint8_t);
*((uint8_t *)response) = rand() % 4;
response += sizeof(uint8_t);
kaa_platform_message_reader_t *reader = NULL;
error_code = kaa_platform_message_reader_create(&reader, response_buffer, response_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(reader);
error_code = kaa_logging_handle_server_sync(log_collector, reader, 0, response_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_TRUE(strategy.on_failure_count);
ASSERT_TRUE(storage->on_remove_by_id_count);
ASSERT_TRUE(storage->on_unmark_by_id_count);
kaa_platform_message_reader_destroy(reader);
kaa_log_collector_destroy(log_collector);
}
void test_timeout(void **state)
{
(void)state;
kaa_log_collector_t *log_collector = NULL;
kaa_error_t error_code = kaa_log_collector_create(&log_collector,
status, channel_manager, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_user_log_record_t *test_log_record = kaa_test_log_record_create();
test_log_record->data = kaa_string_copy_create(TEST_LOG_BUFFER);
size_t test_log_record_size = test_log_record->get_size(test_log_record);
mock_strategy_context_t strategy;
memset(&strategy, 0, sizeof(mock_strategy_context_t));
strategy.timeout = TEST_TIMEOUT;
strategy.decision = NOOP;
strategy.max_parallel_uploads = UINT32_MAX;
kaa_log_bucket_constraints_t constraints = {
.max_bucket_size = 2 * test_log_record_size,
.max_bucket_log_count = UINT32_MAX,
};
error_code = kaa_logging_init(log_collector, create_mock_storage(), &strategy, &constraints);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t request_buffer_size = 256;
uint8_t request_buffer[request_buffer_size];
kaa_platform_message_writer_t *writer = NULL;
error_code = kaa_platform_message_writer_create(&writer, request_buffer, request_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_request_serialize(log_collector, writer);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
sleep(TEST_TIMEOUT + 1);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_TRUE(strategy.on_timeout_count);
test_log_record->destroy(test_log_record);
kaa_platform_message_writer_destroy(writer);
kaa_log_collector_destroy(log_collector);
}
void test_decline_timeout(void **state)
{
(void)state;
kaa_log_collector_t *log_collector = NULL;
kaa_error_t error_code = kaa_log_collector_create(&log_collector, status, channel_manager, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_user_log_record_t *test_log_record = kaa_test_log_record_create();
test_log_record->data = kaa_string_copy_create(TEST_LOG_BUFFER);
size_t test_log_record_size = test_log_record->get_size(test_log_record);
mock_strategy_context_t strategy;
memset(&strategy, 0, sizeof(mock_strategy_context_t));
strategy.timeout = TEST_TIMEOUT;
strategy.decision = NOOP;
strategy.max_parallel_uploads = UINT32_MAX;
mock_storage_context_t *storage = create_mock_storage();
ASSERT_NOT_NULL(storage);
kaa_log_bucket_constraints_t constraints = {
.max_bucket_size = 2 * test_log_record_size,
.max_bucket_log_count = UINT32_MAX,
};
error_code = kaa_logging_init(log_collector, storage, &strategy, &constraints);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t request_buffer_size = 256;
uint8_t request_buffer[request_buffer_size];
kaa_platform_message_writer_t *writer = NULL;
error_code = kaa_platform_message_writer_create(&writer, request_buffer, request_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_request_serialize(log_collector, writer);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
sleep(TEST_TIMEOUT + 1);
uint16_t bucket_id = *((uint16_t *)(request_buffer + KAA_EXTENSION_HEADER_SIZE));
bucket_id = KAA_NTOHS(bucket_id);
uint32_t response_count = 1;
size_t response_buffer_size = sizeof(uint32_t) + sizeof(uint32_t) * response_count;
uint8_t response_buffer[response_buffer_size];
uint8_t *response = response_buffer;
*((uint32_t *)response) = KAA_HTONL(response_count);
response += sizeof(uint32_t);
/* First response */
*((uint16_t *)response) = KAA_HTONS(bucket_id);
response += sizeof(uint16_t);
*((uint8_t *)response) = 0x0; // SUCCESS
response += sizeof(uint8_t);
*((uint8_t *)response) = 0;
response += sizeof(uint8_t);
kaa_platform_message_reader_t *reader = NULL;
error_code = kaa_platform_message_reader_create(&reader, response_buffer, response_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_NOT_NULL(reader);
error_code = kaa_logging_handle_server_sync(log_collector, reader, 0, response_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_TRUE(storage->on_remove_by_id_count);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_FALSE(strategy.on_timeout_count);
test_log_record->destroy(test_log_record);
kaa_platform_message_writer_destroy(writer);
kaa_platform_message_reader_destroy(reader);
kaa_log_collector_destroy(log_collector);
}
void test_max_parallel_uploads_with_log_sync(void **state)
{
(void)state;
uint32_t channel_id = 0;
kaa_transport_channel_interface_t transport_context;
test_kaa_channel_create(&transport_context);
kaa_channel_manager_add_transport_channel(channel_manager, &transport_context, &channel_id);
kaa_log_collector_t *log_collector = NULL;
kaa_error_t error_code = kaa_log_collector_create(&log_collector, status, channel_manager, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_user_log_record_t *test_log_record = kaa_test_log_record_create();
test_log_record->data = kaa_string_copy_create(TEST_LOG_BUFFER);
size_t test_log_size = test_log_record->get_size(test_log_record);
mock_strategy_context_t strategy;
memset(&strategy, 0, sizeof(mock_strategy_context_t));
strategy.timeout = INT16_MAX;
strategy.decision = UPLOAD;
mock_storage_context_t *storage = create_mock_storage();
ASSERT_NOT_NULL(storage);
kaa_log_bucket_constraints_t constraints = {
.max_bucket_size = 2 * test_log_size,
.max_bucket_log_count = UINT32_MAX,
};
error_code = kaa_logging_init(log_collector, storage, &strategy, &constraints);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
/*
* Ensure the log delivery is forbidden at all.
*/
strategy.max_parallel_uploads = 0;
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(((mock_transport_channel_context_t *)transport_context.context)->on_sync_count, 0);
/*
* Ensure the first request is allowed.
*/
strategy.max_parallel_uploads = 1;
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(((mock_transport_channel_context_t *)transport_context.context)->on_sync_count, 1);
/*
* Do the first request to remember the delivery timeout of the log batch.
*/
size_t request_buffer_size = 256;
uint8_t request_buffer[request_buffer_size];
kaa_platform_message_writer_t *writer = NULL;
error_code = kaa_platform_message_writer_create(&writer, request_buffer, request_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_request_serialize(log_collector, writer);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
/*
* Ensure the second request is forbidden.
*/
ASSERT_EQUAL(((mock_transport_channel_context_t *)transport_context.context)->on_sync_count, 1);
/*
* Clean up.
*/
error_code = kaa_channel_manager_remove_transport_channel(channel_manager, channel_id);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
test_log_record->destroy(test_log_record);
kaa_log_collector_destroy(log_collector);
}
void test_max_parallel_uploads_with_sync_all(void **state)
{
(void)state;
uint32_t channel_id = 0;
kaa_transport_channel_interface_t transport_context;
test_kaa_channel_create(&transport_context);
kaa_channel_manager_add_transport_channel(channel_manager, &transport_context, &channel_id);
kaa_log_collector_t *log_collector = NULL;
kaa_error_t error_code = kaa_log_collector_create(&log_collector,
status, channel_manager, logger);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_user_log_record_t *test_log_record = kaa_test_log_record_create();
test_log_record->data = kaa_string_copy_create(TEST_LOG_BUFFER);
size_t test_log_size = test_log_record->get_size(test_log_record);
mock_strategy_context_t strategy;
memset(&strategy, 0, sizeof(mock_strategy_context_t));
strategy.timeout = INT16_MAX;
strategy.decision = UPLOAD;
mock_storage_context_t *storage = create_mock_storage();
ASSERT_NOT_NULL(storage);
kaa_log_bucket_constraints_t constraints = {
.max_bucket_size = 2 * test_log_size,
.max_bucket_log_count = UINT32_MAX,
};
error_code = kaa_logging_init(log_collector, storage, &strategy, &constraints);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
/*
* Ensure the log delivery is forbidden at all.
*/
strategy.max_parallel_uploads = 0;
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
size_t expected_size = 0;
error_code = kaa_logging_request_get_size(log_collector, &expected_size);
assert_int_equal(KAA_ERR_NONE, error_code);
ASSERT_FALSE(expected_size);
/*
* Ensure the first request is allowed.
*/
strategy.max_parallel_uploads = 1;
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
/*
* Do the first request to remember the delivery timeout of the log batch.
*/
error_code = kaa_logging_request_get_size(log_collector, &expected_size);
assert_int_equal(KAA_ERR_NONE, error_code);
ASSERT_TRUE(expected_size);
size_t request_buffer_size = 256;
uint8_t request_buffer[request_buffer_size];
kaa_platform_message_writer_t *writer = NULL;
error_code = kaa_platform_message_writer_create(&writer, request_buffer, request_buffer_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_request_serialize(log_collector, writer);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_logging_add_record(log_collector, test_log_record, NULL);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
/*
* Ensure the second request is forbidden.
*/
error_code = kaa_logging_request_get_size(log_collector, &expected_size);
assert_int_equal(KAA_ERR_NONE, error_code);
ASSERT_FALSE(expected_size);
/*
* Clean up.
*/
error_code = kaa_channel_manager_remove_transport_channel(channel_manager, channel_id);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
test_log_record->destroy(test_log_record);
kaa_log_collector_destroy(log_collector);
}
/* ---------------------------------------------------------------------------*/
/* Log delivery tests */
/* ---------------------------------------------------------------------------*/
/* Server chunk, managed by a corresponding reader object.
* Perfectly packed. Packed attribute is intentionally avoided. */
struct response_chunk {
uint8_t bucket_id[2]; /* 16 bits for bucket ID */
uint8_t resp_code; /* 8 bits for response code. 0 == SUCCESS, 1 == FAILURE */
// cppcheck-suppress unusedStructMember
uint8_t reserved; /* Should be 0 */
};
struct response_packet {
uint8_t resp_cnt[4]; /* 32 bits for amount of responces in buffer */
struct response_chunk resps[]; /* Responses itself */
};
#define RESP_PACKETS 2 /* Amount of response packets */
#define RESP_SUCCESS_IDX 0 /* Index of successfull response */
#define RESP_FAILURE_IDX 1 /* Index of failed response */
#define TEST_BUFFER_SIZE 1024
#define TEST_EXT_OP 0 /* Simple stub */
static mock_strategy_context_t test_strategy1;
static mock_strategy_context_t test_strategy2;
static mock_storage_context_t *test_storage1;
static mock_storage_context_t *test_storage2;
static kaa_log_collector_t *log_collector;
static size_t test_log_record_size = TEST_BUFFER_SIZE;
/* Will contain response_packet. Thus required to be aligned. */
static uint32_t test_reader_buffer[TEST_BUFFER_SIZE / 4];
static uint32_t test_writer_buffer[TEST_BUFFER_SIZE / 4];
/* Portion of the test buffer filled with valid data */
static size_t test_filled_size;
static kaa_platform_message_reader_t *test_reader;
static kaa_platform_message_writer_t *test_writer;
static kaa_user_log_record_t *test_log_record;
/* Values to be checked inside mock event function */
static void *expected_ctx;
static int check_bucket;
static uint16_t expected_bucked_id;
/* Required to trace generic mock function calls */
static int call_is_expected;
static int call_completed;
/* Required to trace on fail mock function calls */
static int failed_call_is_expected;
static int failed_call_completed;
/* Required to trace on success mock function calls */
static int success_call_is_expected;
static int success_call_completed;
/* Required to trace on timeout mock function calls */
static int timeout_call_is_expected;
static int timeout_call_completed;
/* Mock event functions */
static void mock_log_event_generic_fn(void *ctx, const kaa_log_bucket_info_t *bucket)
{
ASSERT_TRUE(call_is_expected);
ASSERT_NOT_NULL(bucket); /* Shouldn't be NULL no matter what */
if (check_bucket) {
ASSERT_EQUAL(expected_bucked_id, bucket->bucket_id);
}
ASSERT_EQUAL(expected_ctx, ctx);
call_completed++;
}
kaa_error_t kaa_platform_protocol_process_server_sync(kaa_platform_protocol_t *self
, const char *buffer
, size_t buffer_size)
{
KAA_RETURN_IF_NIL3(self, buffer, buffer_size, KAA_ERR_BADPARAM);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Processing server sync...");
kaa_platform_message_reader_t *reader = NULL;
kaa_error_t error_code = kaa_platform_message_reader_create(&reader, buffer, buffer_size);
KAA_RETURN_IF_ERR(error_code);
uint32_t protocol_id = 0;
uint16_t protocol_version = 0;
uint16_t extension_count = 0;
error_code = kaa_platform_message_header_read(reader, &protocol_id, &protocol_version, &extension_count);
KAA_RETURN_IF_ERR(error_code);
if (protocol_id != KAA_PLATFORM_PROTOCOL_ID) {
KAA_LOG_ERROR(self->logger, KAA_ERR_BAD_PROTOCOL_ID, "Unsupported protocol ID %x", protocol_id);
return KAA_ERR_BAD_PROTOCOL_ID;
}
if (protocol_version != KAA_PLATFORM_PROTOCOL_VERSION) {
KAA_LOG_ERROR(self->logger, KAA_ERR_BAD_PROTOCOL_VERSION, "Unsupported protocol version %u", protocol_version);
return KAA_ERR_BAD_PROTOCOL_VERSION;
}
uint32_t request_id = 0;
uint8_t extension_type = 0;
uint32_t extension_options = 0;
uint32_t extension_length = 0;
while (!error_code && kaa_platform_message_is_buffer_large_enough(reader, KAA_PROTOCOL_MESSAGE_HEADER_SIZE)) {
error_code = kaa_platform_message_read_extension_header(reader
, &extension_type
, &extension_options
, &extension_length);
KAA_RETURN_IF_ERR(error_code);
switch (extension_type) {
case KAA_BOOTSTRAP_EXTENSION_TYPE: {
error_code = kaa_bootstrap_manager_handle_server_sync(self->kaa_context->bootstrap_manager
, reader
, extension_options
, extension_length);
break;
}
case KAA_META_DATA_EXTENSION_TYPE: {
error_code = kaa_platform_message_read(reader, &request_id, sizeof(uint32_t));
request_id = KAA_NTOHL(request_id);
break;
}
case KAA_PROFILE_EXTENSION_TYPE: {
error_code = kaa_profile_handle_server_sync(self->kaa_context->profile_manager
, reader
, extension_options
, extension_length);
break;
}
case KAA_USER_EXTENSION_TYPE: {
error_code = kaa_user_handle_server_sync(self->kaa_context->user_manager
, reader
, extension_options
, extension_length);
break;
}
#ifndef KAA_DISABLE_FEATURE_LOGGING
case KAA_LOGGING_EXTENSION_TYPE: {
error_code = kaa_logging_handle_server_sync(self->kaa_context->log_collector
, reader
, extension_options
, extension_length);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_EVENTS
case KAA_EVENT_EXTENSION_TYPE: {
error_code = kaa_event_handle_server_sync(self->kaa_context->event_manager
, reader
, extension_options
, extension_length
, request_id);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_CONFIGURATION
case KAA_CONFIGURATION_EXTENSION_TYPE: {
error_code = kaa_configuration_manager_handle_server_sync(self->kaa_context->configuration_manager
, reader
, extension_options
, extension_length);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_NOTIFICATION
case KAA_NOTIFICATION_EXTENSION_TYPE: {
error_code = kaa_notification_manager_handle_server_sync(self->kaa_context->notification_manager
, reader
, extension_length);
break;
}
#endif
default:
KAA_LOG_WARN(self->logger, KAA_ERR_UNSUPPORTED,
"Unsupported extension received (type = %u)", extension_type);
break;
}
}
kaa_platform_message_reader_destroy(reader);
if (!error_code) {
error_code = kaa_status_save(self->status);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Server sync successfully processed");
} else {
KAA_LOG_ERROR(self->logger, error_code,
"Server sync is corrupted. Failed to read extension with type %u", extension_type);
}
return error_code;
}
void test_meta_extension_serialize(void)
{
KAA_TRACE_IN(logger);
size_t meta_extension_size;
kaa_error_t error_code = kaa_meta_data_request_get_size(&meta_extension_size);
char buffer[meta_extension_size];
kaa_platform_message_writer_t *writer;
error_code = kaa_platform_message_writer_create(&writer, buffer, meta_extension_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
uint32_t expected_timeout = KAA_SYNC_TIMEOUT;
kaa_digest expected_public_key_hash = {0x74, 0xc7, 0x51, 0x43, 0x00, 0xf7, 0xb8, 0x21, 0x2c, 0xc3, 0x6b, 0xa5, 0x9c, 0xb4, 0x03, 0xef, 0xc2, 0x5c, 0x65, 0x6c};
kaa_digest expected_profile_hash = {0xfa, 0x71, 0xb5, 0x02, 0xe7, 0xdf, 0x96, 0x86, 0x6c, 0xdc, 0xe1, 0x4a, 0x17, 0x35, 0x7f, 0xd9, 0xa8, 0xfb, 0x71, 0x09};
error_code = ext_copy_sha_hash(status->endpoint_public_key_hash, expected_public_key_hash);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = ext_copy_sha_hash(status->profile_hash, expected_profile_hash);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_context_t *context = NULL;
kaa_init(&context);
kaa_platform_protocol_t *protocol = NULL;
kaa_platform_protocol_create(&protocol, context, status);
error_code = kaa_meta_data_request_serialize(protocol, writer, 1);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_deinit(context);
kaa_platform_message_reader_t *reader;
error_code = kaa_platform_message_reader_create(&reader, buffer, meta_extension_size);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
uint8_t extension_type;
uint32_t extension_options;
uint32_t extension_payload;
error_code = kaa_platform_message_read_extension_header(
reader, &extension_type, &extension_options, &extension_payload);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(extension_type, KAA_META_DATA_EXTENSION_TYPE);
ASSERT_EQUAL(extension_options, (TIMEOUT_VALUE | PUBLIC_KEY_HASH_VALUE | PROFILE_HASH_VALUE | APP_TOKEN_VALUE));
ASSERT_EQUAL(extension_payload, meta_extension_size - KAA_EXTENSION_HEADER_SIZE);
uint32_t request_id;
uint32_t timeout;
kaa_digest public_key_hash;
kaa_digest profile_hash;
char sdk_token[KAA_SDK_TOKEN_LENGTH];
error_code = kaa_platform_message_read(reader, &request_id, sizeof(uint32_t));
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
ASSERT_EQUAL(KAA_NTOHL(request_id), 1);
error_code = kaa_platform_message_read(reader, &timeout, sizeof(uint32_t));
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
timeout = KAA_NTOHL(timeout);
ASSERT_EQUAL(expected_timeout, timeout);
error_code = kaa_platform_message_read_aligned(reader, public_key_hash, SHA_1_DIGEST_LENGTH);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = (memcmp(public_key_hash, expected_public_key_hash, SHA_1_DIGEST_LENGTH) == 0 ? KAA_ERR_NONE : KAA_ERR_READ_FAILED);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_read_aligned(reader, profile_hash, SHA_1_DIGEST_LENGTH);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = (memcmp(profile_hash, expected_profile_hash, SHA_1_DIGEST_LENGTH) == 0 ? KAA_ERR_NONE : KAA_ERR_READ_FAILED);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = kaa_platform_message_read_aligned(reader, sdk_token, KAA_SDK_TOKEN_LENGTH);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
error_code = (memcmp(sdk_token, KAA_SDK_TOKEN, KAA_SDK_TOKEN_LENGTH) == 0 ? KAA_ERR_NONE : KAA_ERR_READ_FAILED);
ASSERT_EQUAL(error_code, KAA_ERR_NONE);
kaa_platform_message_reader_destroy(reader);
kaa_platform_message_writer_destroy(writer);
}
