void test_specified_user_verifier(void **state)
{
(void)state;
ASSERT_EQUAL(kaa_user_manager_attach_to_user(user_manager, USER_EXTERNAL_ID, ACCESS_TOKEN, USER_VERIFIER), KAA_ERR_NONE);
size_t expected_size = 0;
ASSERT_EQUAL(kaa_user_request_get_size(user_manager, &expected_size), KAA_ERR_NONE);
uint8_t buffer[expected_size];
kaa_platform_message_writer_t *writer = NULL;
ASSERT_EQUAL(kaa_platform_message_writer_create(&writer, buffer, expected_size), KAA_ERR_NONE);
ASSERT_NOT_NULL(writer);
ASSERT_EQUAL(kaa_user_request_serialize(user_manager, writer), KAA_ERR_NONE);
uint8_t *buf_cursor = buffer;
ASSERT_EQUAL(KAA_EXTENSION_USER, KAA_HTONS(*(uint16_t*)buf_cursor));
buf_cursor += sizeof(uint16_t);
char options[] = { 0x00, 0x01 };
ASSERT_EQUAL(memcmp(buf_cursor, options, 2), 0);
buf_cursor += 2;
ASSERT_EQUAL(*(uint32_t * ) buf_cursor, KAA_HTONL(2 * sizeof(uint32_t)
+ kaa_aligned_size_get(strlen(USER_EXTERNAL_ID))
+ kaa_aligned_size_get(strlen(ACCESS_TOKEN)
+ kaa_aligned_size_get(strlen(USER_VERIFIER)))));
buf_cursor += sizeof(uint32_t);
ASSERT_EQUAL(0, *buf_cursor);
++buf_cursor;
ASSERT_EQUAL(strlen(USER_EXTERNAL_ID), *buf_cursor);
++buf_cursor;
ASSERT_EQUAL(KAA_HTONS(strlen(ACCESS_TOKEN)), *(uint16_t *) buf_cursor);
buf_cursor += sizeof(uint16_t);
ASSERT_EQUAL(KAA_HTONS(strlen(USER_VERIFIER)), *(uint16_t *) buf_cursor);
buf_cursor += sizeof(uint32_t); // + reserved 16B
ASSERT_EQUAL(memcmp(buf_cursor, USER_EXTERNAL_ID, strlen(USER_EXTERNAL_ID)), 0);
buf_cursor += kaa_aligned_size_get(strlen(USER_EXTERNAL_ID));
ASSERT_EQUAL(memcmp(buf_cursor, ACCESS_TOKEN, strlen(ACCESS_TOKEN)), 0);
buf_cursor += kaa_aligned_size_get(strlen(ACCESS_TOKEN));
ASSERT_EQUAL(memcmp(buf_cursor, USER_VERIFIER, strlen(USER_VERIFIER)), 0);
buf_cursor += kaa_aligned_size_get(strlen(USER_VERIFIER));
kaa_platform_message_writer_destroy(writer);
}
static kaa_error_t kaa_client_sync_get_size(kaa_platform_protocol_t *self
, const kaa_service_t services[]
, size_t services_count
, size_t *expected_size)
{
KAA_RETURN_IF_NIL4(self, services, services_count, expected_size, KAA_ERR_BADPARAM)
*expected_size = KAA_PROTOCOL_MESSAGE_HEADER_SIZE;
size_t extension_size = 0;
kaa_error_t err_code = kaa_meta_data_request_get_size(&extension_size);
if (err_code) {
KAA_LOG_ERROR(self->logger, err_code, "Failed to query size for meta extension");
return err_code;
}
*expected_size += extension_size;
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated meta extension size %u", extension_size);
while (!err_code && services_count--) {
switch (services[services_count]) {
case KAA_SERVICE_BOOTSTRAP: {
err_code = kaa_channel_manager_bootstrap_request_get_size(self->kaa_context->channel_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated bootstrap extension size %u", extension_size);
break;
}
case KAA_SERVICE_PROFILE: {
bool need_resync = false;
err_code = kaa_profile_need_profile_resync(self->kaa_context->profile_manager
, &need_resync);
if (err_code) {
KAA_LOG_ERROR(self->logger, err_code, "Failed to read 'need_resync' flag");
}
if (!err_code && need_resync) {
err_code = kaa_profile_request_get_size(self->kaa_context->profile_manager
, &extension_size);
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated profile extension size %u", extension_size);
}
break;
}
case KAA_SERVICE_USER: {
err_code = kaa_user_request_get_size(self->kaa_context->user_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated user extension size %u", extension_size);
break;
}
#ifndef KAA_DISABLE_FEATURE_EVENTS
case KAA_SERVICE_EVENT: {
err_code = kaa_event_request_get_size(self->kaa_context->event_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated event extension size %u", extension_size);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_LOGGING
case KAA_SERVICE_LOGGING: {
err_code = kaa_logging_request_get_size(self->kaa_context->log_collector
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated logging extension size %u", extension_size);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_CONFIGURATION
case KAA_SERVICE_CONFIGURATION: {
err_code = kaa_configuration_manager_get_size(self->kaa_context->configuration_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated configuration extension size %u", extension_size);
break;
}
#endif
#ifndef KAA_DISABLE_FEATURE_NOTIFICATION
case KAA_SERVICE_NOTIFICATION: {
err_code = kaa_notification_manager_get_size(self->kaa_context->notification_manager
, &extension_size);
if (!err_code)
KAA_LOG_TRACE(self->logger, KAA_ERR_NONE, "Calculated notification extension size %u", extension_size);
break;
}
#endif
default:
extension_size = 0;
break;
}
*expected_size += extension_size;
}
if (err_code) {
KAA_LOG_ERROR(self->logger, err_code, "Failed to query extension size in %u service"
, services[services_count]);
}
return err_code;
}
