src.dualinventive.com/fw/dncm/libdi/tests/rpc_deserialize_msg_params.cpp

/** Verify if the params map is correctly extracted */
#include <string>
#include <memory>

#include <di/rpc.h>
#include <mpack/mpack.h>
#include <di/time.h>
#include <gtest/gtest.h>

/* Used because serialize message header loads di_time_get_stamp */
TEST(time, init)
{
	di_time_init();
}

static void rpc_deserialize_msg_params_dump(const char *filename, const uint8_t *buffer, size_t size)
{
	mpack_tree_t tree;
	mpack_node_t root;
	mpack_tree_init(&tree, (const char *)buffer, size);

	FILE *f = fopen(filename, "w");

	if (mpack_tree_error(&tree) != mpack_ok) {
		fclose(f);
		fprintf(stderr, "(%s) mpack_tree_error(%u): %s\n",
			filename,
			mpack_tree_error(&tree),
			mpack_error_to_string(mpack_tree_error(&tree))
		);
		exit(1);
	}

	root = mpack_tree_root(&tree);
	mpack_node_print_file(root, f);
	fclose(f);
	mpack_tree_destroy(&tree);
}

/**
 Deserialize
 ```
 {
    "dinetrpc": 1,
    "req": "action:set",
    "device:uid": "00000000000000000000000000000000",
    "time": null,
    "id": 1234,
    "params": {
       "uid" : 1,
       "value" : true
    }
 }
 ```
 */
TEST(rpc, deserialize_rpc_msg_params)
{
	mpack_reader_t r;
	struct di_rpc_msg msg;

	mpack_reader_init_file(&r, "data/rpc_deserialize_msg_params_1.mp");
	di_rpc_deserialize_msg(&r, &msg);

	ASSERT_EQ(1U, msg.dinetrpc);
	ASSERT_EQ(DI_RPC_MSG_TYPE_REQUEST, msg.msg_type);
	ASSERT_EQ(DI_RPC_TYPE_ACTION_SET,  msg.type);
	ASSERT_EQ(1234U, msg.id);

	printf("msg.params.buffer: %p\n", msg.params.buffer);
	printf("msg.params.buffer: %02x\n", msg.params.buffer[0]);
	printf("msg.params.size:   %zu\n", msg.params.size);

	ASSERT_NE((void *)NULL, msg.params.buffer);

	rpc_deserialize_msg_params_dump("log/rpc_deserialize_msg_params_1.json", msg.params.buffer, msg.params.size);
	mpack_reader_destroy(&r);
}

/**
 Deserialize params as di_rpc_data
 */
TEST(rpc, deserialize_rpc_data_bool) {
	mpack_reader_t r;
	struct di_rpc_data d;

	mpack_reader_init_file(&r, "data/rpc_deserialize_rpc_data_1.mp");
	di_rpc_deserialize_rpc_data(&r, &d, NULL, 0);

	ASSERT_EQ(1234UL, d.uid);
	ASSERT_EQ(DI_RPC_DATA_FIELD_BOOL, d.field);
	ASSERT_EQ(false, d.value.b);

	mpack_reader_destroy(&r);
}

/**
 Deserialize params as di_rpc_data
 */
TEST(rpc, deserialize_rpc_data_double) {
	mpack_reader_t r;
	struct di_rpc_data d;

	mpack_reader_init_file(&r, "data/rpc_deserialize_rpc_data_2.mp");
	di_rpc_deserialize_rpc_data(&r, &d, NULL, 0);

	ASSERT_EQ(666UL, d.uid);
	/** @note Converting JSON floats most of the time result in msgpack emitted
		double precision floats */
	ASSERT_EQ(DI_RPC_DATA_FIELD_DOUBLE, d.field);
	ASSERT_FLOAT_EQ(1234.5678, d.value.d);

	mpack_reader_destroy(&r);
}

/**
Deserialize params as di_rpc_data
*/
TEST(rpc, deserialize_rpc_data_uint) {
	mpack_reader_t r;
	struct di_rpc_data d;

	mpack_reader_init_file(&r, "data/rpc_deserialize_rpc_data_3.mp");
	di_rpc_deserialize_rpc_data(&r, &d, NULL, 0);

	ASSERT_EQ(123UL, d.uid);
	ASSERT_EQ(DI_RPC_DATA_FIELD_UINT64, d.field);
	ASSERT_EQ(99887766, d.value.u64);

	mpack_reader_destroy(&r);
}

/**
Deserialize params as di_rpc_data
*/
TEST(rpc, deserialize_rpc_data_int) {
	mpack_reader_t r;
	struct di_rpc_data d;

	mpack_reader_init_file(&r, "data/rpc_deserialize_rpc_data_4.mp");
	di_rpc_deserialize_rpc_data(&r, &d, NULL, 0);

	ASSERT_EQ(5678UL, d.uid);
	ASSERT_EQ(DI_RPC_DATA_FIELD_INT64, d.field);
	ASSERT_EQ(-1234567890, d.value.s64);

	mpack_reader_destroy(&r);
}

/**
Deserialize params as di_rpc_data with string value
*/
TEST(rpc, deserialize_rpc_data_str) {
	mpack_reader_t r;
	struct di_rpc_data d;
	char str[1024];

	/* Without buffer */
	mpack_reader_init_file(&r, "data/rpc_deserialize_rpc_data_5.mp");
	di_rpc_deserialize_rpc_data(&r, &d, NULL, 0);

	ASSERT_EQ(1234UL, d.uid);
	ASSERT_EQ(DI_RPC_DATA_FIELD_UNKNOWN, d.field);
	ASSERT_EQ((void *)NULL, d.value.s);

	mpack_reader_destroy(&r);

	/* With buffer */
	mpack_reader_init_file(&r, "data/rpc_deserialize_rpc_data_5.mp");
	di_rpc_deserialize_rpc_data(&r, &d, str, sizeof(str));

	ASSERT_EQ(1234UL, d.uid);
	ASSERT_EQ(DI_RPC_DATA_FIELD_STRING, d.field);
	ASSERT_STREQ("boembats pow tjow trrr poef", str);
	ASSERT_STREQ("boembats pow tjow trrr poef", d.value.s);

	mpack_reader_destroy(&r);
}