diff options
| -rw-r--r-- | Makefile.am | 21 | ||||
| -rw-r--r-- | src/tests/cmocka/test_sss_sifp.c | 1552 |
2 files changed, 1573 insertions, 0 deletions
diff --git a/Makefile.am b/Makefile.am index 69347a032..bede2a440 100644 --- a/Makefile.am +++ b/Makefile.am @@ -181,6 +181,7 @@ if HAVE_CMOCKA dp_opt_tests \ responder-get-domains-tests \ sbus-internal-tests \ + sss_sifp-tests \ test_search_bases if BUILD_IFP @@ -1810,6 +1811,26 @@ ifp_tests_LDADD = \ $(SSSD_LIBS) \ $(SSSD_INTERNAL_LTLIBS) \ libsss_test_common.la + +sss_sifp_tests_SOURCES = \ + src/tests/cmocka/test_sss_sifp.c \ + src/lib/sifp/sss_sifp_attrs.c \ + src/lib/sifp/sss_sifp_parser.c \ + src/lib/sifp/sss_sifp_utils.c \ + src/lib/sifp/sss_sifp_dbus.c \ + src/lib/sifp/sss_sifp.c +sss_sifp_tests_CFLAGS = \ + $(AM_CFLAGS) \ + -I$(top_srcdir)/src/lib/sifp +sss_sifp_tests_LDFLAGS = \ + -Wl,-wrap,dbus_bus_get \ + -Wl,-wrap,dbus_connection_send_with_reply_and_block +sss_sifp_tests_LDADD = \ + $(CMOCKA_LIBS) \ + $(DBUS_LIBS) \ + $(TALLOC_LIBS) \ + $(POPT_LIBS) \ + $(SSSD_INTERNAL_LTLIBS) endif # BUILD_IFP endif # HAVE_CMOCKA diff --git a/src/tests/cmocka/test_sss_sifp.c b/src/tests/cmocka/test_sss_sifp.c new file mode 100644 index 000000000..cddc1ab1b --- /dev/null +++ b/src/tests/cmocka/test_sss_sifp.c @@ -0,0 +1,1552 @@ +/* + Authors: + Pavel Březina <pbrezina@redhat.com> + + Copyright (C) 2014 Red Hat + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include <dbus/dbus.h> +#include <popt.h> + +#include "tests/cmocka/common_mock.h" +#include "lib/sifp/sss_sifp.h" +#include "lib/sifp/sss_sifp_dbus.h" +#include "lib/sifp/sss_sifp_private.h" + +struct { + sss_sifp_ctx *dbus_ctx; + DBusMessage *reply; +} test_ctx; + +DBusConnection * +__wrap_dbus_bus_get(DBusBusType type, DBusError *error) +{ + /* we won't use the connection anywhere, so we can just return NULL */ + return NULL; +} + +DBusMessage * +__wrap_dbus_connection_send_with_reply_and_block(DBusConnection *connection, + DBusMessage *message, + int timeout_milliseconds, + DBusError *error) +{ + if (message == NULL || error == NULL) { + return NULL; + } + + return sss_mock_ptr_type(DBusMessage *); +} + +static void reply_variant_basic(DBusMessage *reply, + const char *type, + const void *val) +{ + DBusMessageIter iter; + DBusMessageIter variant_iter; + dbus_bool_t bret; + + dbus_message_iter_init_append(reply, &iter); + + + bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, + type, &variant_iter); + assert_true(bret); + + /* Now add the value */ + bret = dbus_message_iter_append_basic(&variant_iter, type[0], val); + assert_true(bret); + + bret = dbus_message_iter_close_container(&iter, &variant_iter); + assert_true(bret); +} + +static void reply_variant_array(DBusMessage *reply, + const char *type, + int num_vals, + uint8_t *vals, + unsigned int item_size) +{ + DBusMessageIter iter; + DBusMessageIter variant_iter; + DBusMessageIter array_iter; + dbus_bool_t bret; + char array_type[3]; + int i; + void *addr; + + array_type[0] = DBUS_TYPE_ARRAY; + array_type[1] = type[0]; + array_type[2] = '\0'; + + dbus_message_iter_init_append(reply, &iter); + + + bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, + array_type, &variant_iter); + assert_true(bret); + + bret = dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY, + type, &array_iter); + assert_true(bret); + + for (i = 0; i < num_vals; i++) { + addr = vals + i*item_size; + bret = dbus_message_iter_append_basic(&array_iter, type[0], addr); + assert_true(bret); + } + + bret = dbus_message_iter_close_container(&iter, &array_iter); + assert_true(bret); + + bret = dbus_message_iter_close_container(&iter, &variant_iter); + assert_true(bret); +} + +static void test_setup(void **state) +{ + sss_sifp_error ret; + + ret = sss_sifp_init(&test_ctx.dbus_ctx); + assert_int_equal(ret, SSS_SIFP_OK); + + test_ctx.reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); + assert_non_null(test_ctx.reply); +} + +static void test_teardown_parser(void **state) +{ + sss_sifp_free(&test_ctx.dbus_ctx); + assert_null(test_ctx.dbus_ctx); + + dbus_message_unref(test_ctx.reply); + test_ctx.reply = NULL; +} + +static void test_teardown_api(void **state) +{ + sss_sifp_free(&test_ctx.dbus_ctx); + assert_null(test_ctx.dbus_ctx); + + /* sss_sifp is responsible for freeing the reply */ +} + +void test_sss_sifp_strdup_valid(void **state) +{ + const char *str = "test_string"; + char *dup = sss_sifp_strdup(test_ctx.dbus_ctx, str); + assert_non_null(dup); + assert_string_equal(str, dup); + + sss_sifp_free_string(test_ctx.dbus_ctx, &dup); + assert_null(dup); +} + +void test_sss_sifp_strdup_null(void **state) +{ + char *dup = sss_sifp_strdup(test_ctx.dbus_ctx, NULL); + assert_null(dup); +} + +void test_sss_sifp_strcat_valid(void **state) +{ + char *cat = sss_sifp_strcat(test_ctx.dbus_ctx, "hello ", "world"); + assert_non_null(cat); + assert_string_equal("hello world", cat); + + sss_sifp_free_string(test_ctx.dbus_ctx, &cat); + assert_null(cat); +} + +void test_sss_sifp_strcat_left_null(void **state) +{ + char *cat = sss_sifp_strcat(test_ctx.dbus_ctx, NULL, "world"); + assert_non_null(cat); + assert_string_equal("world", cat); + + sss_sifp_free_string(test_ctx.dbus_ctx, &cat); + assert_null(cat); +} + +void test_sss_sifp_strcat_right_null(void **state) +{ + char *cat = sss_sifp_strcat(test_ctx.dbus_ctx, "hello ", NULL); + assert_non_null(cat); + assert_string_equal("hello ", cat); + + sss_sifp_free_string(test_ctx.dbus_ctx, &cat); + assert_null(cat); +} + +void test_sss_sifp_strcat_both_null(void **state) +{ + char *cat = sss_sifp_strcat(test_ctx.dbus_ctx, NULL, NULL); + assert_null(cat); +} + +void test_sss_sifp_parse_object_path_valid(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + dbus_bool_t bret; + sss_sifp_error ret; + const char *path_in = "/object/path"; + char *path_out = NULL; + + /* prepare message */ + bret = dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path_in, + DBUS_TYPE_INVALID); + assert_true(bret); + + /* test */ + ret = sss_sifp_parse_object_path(ctx, reply, &path_out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(path_out); + assert_string_equal(path_in, path_out); + + sss_sifp_free_string(ctx, &path_out); + assert_null(path_out); +} + +void test_sss_sifp_parse_object_path_invalid(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + dbus_bool_t bret; + sss_sifp_error ret; + uint16_t path_in = 10; + char *path_out = NULL; + + /* prepare message */ + bret = dbus_message_append_args(reply, DBUS_TYPE_UINT16, &path_in, + DBUS_TYPE_INVALID); + assert_true(bret); + + /* test */ + ret = sss_sifp_parse_object_path(ctx, reply, &path_out); + assert_int_not_equal(ret, SSS_SIFP_OK); + assert_null(path_out); +} + +void test_sss_sifp_parse_object_path_list_valid(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + dbus_bool_t bret; + sss_sifp_error ret; + char **path_out = NULL; + const char *path_in[] = {"/object/path1", "/object/path2"}; + const char **paths = path_in; + int path_in_len = 2; + int i; + + /* prepare message */ + bret = dbus_message_append_args(reply, DBUS_TYPE_ARRAY, + DBUS_TYPE_OBJECT_PATH, + &paths, path_in_len, + DBUS_TYPE_INVALID); + assert_true(bret); + + /* test */ + ret = sss_sifp_parse_object_path_list(ctx, reply, &path_out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(path_out); + + for (i = 0; path_out[i] != NULL; i++) { + assert_true(i < path_in_len); + assert_non_null(path_out[i]); + assert_string_equal(path_in[i], path_out[i]); + } + + sss_sifp_free_string_array(ctx, &path_out); + assert_null(path_out); +} + +void test_sss_sifp_parse_object_path_list_invalid(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + dbus_bool_t bret; + sss_sifp_error ret; + char **path_out = NULL; + const char *path_in = "/object/path"; + + /* prepare message */ + bret = dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path_in, + DBUS_TYPE_INVALID); + assert_true(bret); + + /* test */ + ret = sss_sifp_parse_object_path_list(ctx, reply, &path_out); + assert_int_not_equal(ret, SSS_SIFP_OK); + assert_null(path_out); +} + +void test_sss_sifp_parse_attr_bool(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + dbus_bool_t in = 1; + bool out; + + /* prepare message */ + reply_variant_basic(reply, DBUS_TYPE_BOOLEAN_AS_STRING, &in); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, 1); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_BOOL); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_bool(attrs, name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_true(in == out); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_int16(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + int16_t in = INT16_MIN; + int16_t out; + + /* prepare message */ + reply_variant_basic(reply, DBUS_TYPE_INT16_AS_STRING, &in); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, 1); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT16); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_int16(attrs, name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(in, out); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_uint16(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + uint16_t in = UINT16_MAX; + uint16_t out; + + /* prepare message */ + reply_variant_basic(reply, DBUS_TYPE_UINT16_AS_STRING, &in); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, 1); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT16); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_uint16(attrs, name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(in, out); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_int32(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + int32_t in = INT32_MIN; + int32_t out; + + /* prepare message */ + reply_variant_basic(reply, DBUS_TYPE_INT32_AS_STRING, &in); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, 1); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT32); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_int32(attrs, name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(in, out); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_uint32(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + uint32_t in = UINT32_MAX; + uint32_t out; + + /* prepare message */ + reply_variant_basic(reply, DBUS_TYPE_UINT32_AS_STRING, &in); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, 1); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT32); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_uint32(attrs, name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(in, out); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_int64(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + int64_t in = INT64_MIN; + int64_t out; + + /* prepare message */ + reply_variant_basic(reply, DBUS_TYPE_INT64_AS_STRING, &in); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, 1); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT64); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_int64(attrs, name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(in, out); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_uint64(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + uint64_t in = UINT64_MAX; + uint64_t out; + + /* prepare message */ + reply_variant_basic(reply, DBUS_TYPE_UINT64_AS_STRING, &in); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, 1); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT64); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_uint64(attrs, name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(in, out); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_string(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + const char *in = "test value"; + const char *out; + + /* prepare message */ + reply_variant_basic(reply, DBUS_TYPE_STRING_AS_STRING, &in); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, 1); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_STRING); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_string(attrs, name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_string_equal(in, out); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_object_path(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + const char *in = "/object/path"; + const char *out; + + /* prepare message */ + reply_variant_basic(reply, DBUS_TYPE_OBJECT_PATH_AS_STRING, &in); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, 1); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_STRING); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_string(attrs, name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_string_equal(in, out); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_bool_array(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + unsigned int num_values = 5; + dbus_bool_t in_array[] = {1, 1, 0, 0, 1}; + dbus_bool_t *in = in_array; + unsigned int out_num; + bool *out; + unsigned int i; + + /* prepare message */ + reply_variant_array(reply, DBUS_TYPE_BOOLEAN_AS_STRING, num_values, + (uint8_t*)in, sizeof(dbus_bool_t)); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, num_values); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_BOOL); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_bool_array(attrs, name, &out_num, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(num_values, out_num); + + for (i = 0; i < num_values; i++) { + assert_true(in[i] == out[i]); + } + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_int16_array(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + unsigned int num_values = 5; + int16_t in_array[] = {10, 15, -10, -15, 5559}; + int16_t *in = in_array; + unsigned int out_num; + int16_t *out; + unsigned int i; + + /* prepare message */ + reply_variant_array(reply, DBUS_TYPE_INT16_AS_STRING, num_values, + (uint8_t*)in, sizeof(int16_t)); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, num_values); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT16); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_int16_array(attrs, name, &out_num, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(num_values, out_num); + + for (i = 0; i < num_values; i++) { + assert_int_equal(in[i], out[i]); + } + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_uint16_array(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + unsigned int num_values = 5; + uint16_t in_array[] = {10, 15, 8885, 3224, 5559}; + uint16_t *in = in_array; + unsigned int out_num; + uint16_t *out; + unsigned int i; + + /* prepare message */ + reply_variant_array(reply, DBUS_TYPE_UINT16_AS_STRING, num_values, + (uint8_t*)in, sizeof(uint16_t)); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, num_values); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT16); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_uint16_array(attrs, name, &out_num, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(num_values, out_num); + + for (i = 0; i < num_values; i++) { + assert_int_equal(in[i], out[i]); + } + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_int32_array(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + unsigned int num_values = 5; + int32_t in_array[] = {10, 15, -10, -15, 5559}; + int32_t *in = in_array; + unsigned int out_num; + int32_t *out; + unsigned int i; + + /* prepare message */ + reply_variant_array(reply, DBUS_TYPE_INT32_AS_STRING, num_values, + (uint8_t*)in, sizeof(int32_t)); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, num_values); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT32); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_int32_array(attrs, name, &out_num, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(num_values, out_num); + + for (i = 0; i < num_values; i++) { + assert_int_equal(in[i], out[i]); + } + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_uint32_array(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + unsigned int num_values = 5; + uint32_t in_array[] = {10, 15, 8885, 3224, 5559}; + uint32_t *in = in_array; + unsigned int out_num; + uint32_t *out; + unsigned int i; + + /* prepare message */ + reply_variant_array(reply, DBUS_TYPE_UINT32_AS_STRING, num_values, + (uint8_t*)in, sizeof(uint32_t)); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, num_values); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT32); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_uint32_array(attrs, name, &out_num, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(num_values, out_num); + + for (i = 0; i < num_values; i++) { + assert_int_equal(in[i], out[i]); + } + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_int64_array(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + unsigned int num_values = 5; + int64_t in_array[] = {10, 15, -10, -15, 5559}; + int64_t *in = in_array; + unsigned int out_num; + int64_t *out; + unsigned int i; + + /* prepare message */ + reply_variant_array(reply, DBUS_TYPE_INT64_AS_STRING, num_values, + (uint8_t*)in, sizeof(int64_t)); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, num_values); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_INT64); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_int64_array(attrs, name, &out_num, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(num_values, out_num); + + for (i = 0; i < num_values; i++) { + assert_int_equal(in[i], out[i]); + } + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_uint64_array(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + unsigned int num_values = 5; + uint64_t in_array[] = {10, 15, 8885, 3224, 5559}; + uint64_t *in = in_array; + unsigned int out_num; + uint64_t *out; + unsigned int i; + + /* prepare message */ + reply_variant_array(reply, DBUS_TYPE_UINT64_AS_STRING, num_values, + (uint8_t*)in, sizeof(uint64_t)); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, num_values); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT64); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_uint64_array(attrs, name, &out_num, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(num_values, out_num); + + for (i = 0; i < num_values; i++) { + assert_int_equal(in[i], out[i]); + } + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_string_array(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + unsigned int num_values = 6; + const char *in_array[] = {"I", "don't", "like", "writing", "unit", "tests"}; + const char **in = in_array; + unsigned int out_num; + const char * const *out; + unsigned int i; + + /* prepare message */ + reply_variant_array(reply, DBUS_TYPE_STRING_AS_STRING, num_values, + (uint8_t*)in, sizeof(const char*)); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, num_values); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_STRING); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_string_array(attrs, name, &out_num, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(num_values, out_num); + + for (i = 0; i < num_values; i++) { + assert_string_equal(in[i], out[i]); + } + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_object_path_array(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + unsigned int num_values = 2; + const char *in_array[] = {"/object/path1", "/object/path2"}; + const char **in = in_array; + unsigned int out_num; + const char * const *out; + unsigned int i; + + /* prepare message */ + reply_variant_array(reply, DBUS_TYPE_STRING_AS_STRING, num_values, + (uint8_t*)in, sizeof(const char*)); + + /* test */ + ret = sss_sifp_parse_attr(ctx, name, reply, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, num_values); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_STRING); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_string_array(attrs, name, &out_num, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(num_values, out_num); + + for (i = 0; i < num_values; i++) { + assert_string_equal(in[i], out[i]); + } + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_list(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + DBusMessageIter iter; + DBusMessageIter array_iter; + DBusMessageIter dict_iter; + DBusMessageIter var_iter; + dbus_bool_t bret; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + struct { + const char *name; + uint32_t value; + } data[] = {{"attr1", 1}, {"attr2", 2}, {"attr3", 3}, {NULL, 0}}; + uint32_t out; + int i; + + /* prepare message */ + dbus_message_iter_init_append(reply, &iter); + + bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + DBUS_TYPE_STRING_AS_STRING + DBUS_TYPE_VARIANT_AS_STRING + DBUS_DICT_ENTRY_END_CHAR_AS_STRING, + &array_iter); + assert_true(bret); + + for (i = 0; data[i].name != NULL; i++) { + bret = dbus_message_iter_open_container(&array_iter, + DBUS_TYPE_DICT_ENTRY, + NULL, &dict_iter); + assert_true(bret); + + bret = dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, + &data[i].name); + assert_true(bret); + + bret = dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_VARIANT, + DBUS_TYPE_UINT32_AS_STRING, + &var_iter); + assert_true(bret); + + bret = dbus_message_iter_append_basic(&var_iter, DBUS_TYPE_UINT32, + &data[i].value); + assert_true(bret); + + bret = dbus_message_iter_close_container(&dict_iter, &var_iter); + assert_true(bret); + + bret = dbus_message_iter_close_container(&array_iter, &dict_iter); + assert_true(bret); + } + + bret = dbus_message_iter_close_container(&iter, &array_iter); + assert_true(bret); + + ret = sss_sifp_parse_attr_list(ctx, reply, &attrs); + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + + for (i = 0; data[i].name != NULL; i++) { + assert_non_null(attrs[i]); + assert_int_equal(attrs[i]->num_values, 1); + assert_int_equal(attrs[i]->type, SSS_SIFP_ATTR_TYPE_UINT32); + assert_string_equal(attrs[i]->name, data[i].name); + + ret = sss_sifp_find_attr_as_uint32(attrs, data[i].name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(data[i].value, out); + } + + assert_null(attrs[i]); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_parse_attr_list_empty(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + DBusMessageIter iter; + DBusMessageIter array_iter; + dbus_bool_t bret; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + + /* prepare message */ + dbus_message_iter_init_append(reply, &iter); + + bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + DBUS_TYPE_STRING_AS_STRING + DBUS_TYPE_VARIANT_AS_STRING + DBUS_DICT_ENTRY_END_CHAR_AS_STRING, + &array_iter); + assert_true(bret); + + bret = dbus_message_iter_close_container(&iter, &array_iter); + assert_true(bret); + + ret = sss_sifp_parse_attr_list(ctx, reply, &attrs); + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_null(attrs[0]); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_get_iface_for_object(void **state) +{ + int i; + const char *iface = NULL; + static struct { + const char *path; + const char *iface; + } data[] = {{SSS_SIFP_PATH_IFP "/Components/Monitor", + SSS_SIFP_IFACE_COMPONENTS}, + {SSS_SIFP_PATH_IFP "/Domains/LDAP", + SSS_SIFP_IFACE_DOMAINS}, + {SSS_SIFP_PATH_IFP "/Services/NSS", + SSS_SIFP_IFACE_SERVICES}, + {SSS_SIFP_PATH_IFP "/Users/2154", + SSS_SIFP_IFACE_USERS}, + {SSS_SIFP_PATH_IFP "/Groups/3441", + SSS_SIFP_IFACE_GROUPS}, + {NULL, NULL}}; + + for (i = 0; data[i].path != NULL; i++) { + iface = sss_sifp_get_iface_for_object(data[i].path); + assert_non_null(iface); + assert_string_equal(data[i].iface, iface); + } +} + +void test_sss_sifp_fetch_attr(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + const char *name = "test-attr"; + uint32_t in = UINT32_MAX; + uint32_t out; + + /* prepare message */ + reply_variant_basic(reply, DBUS_TYPE_UINT32_AS_STRING, &in); + will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); + + /* test */ + ret = sss_sifp_fetch_attr(ctx, "/test/object", "test.com", name, &attrs); + + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + assert_non_null(attrs[0]); + assert_null(attrs[1]); + + assert_int_equal(attrs[0]->num_values, 1); + assert_int_equal(attrs[0]->type, SSS_SIFP_ATTR_TYPE_UINT32); + assert_string_equal(attrs[0]->name, name); + + ret = sss_sifp_find_attr_as_uint32(attrs, name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(in, out); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_fetch_all_attrs(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + DBusMessageIter iter; + DBusMessageIter array_iter; + DBusMessageIter dict_iter; + DBusMessageIter var_iter; + dbus_bool_t bret; + sss_sifp_error ret; + sss_sifp_attr **attrs = NULL; + struct { + const char *name; + uint32_t value; + } data[] = {{"attr1", 1}, {"attr2", 2}, {"attr3", 3}, {NULL, 0}}; + uint32_t out; + int i; + + /* prepare message */ + dbus_message_iter_init_append(reply, &iter); + + bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + DBUS_TYPE_STRING_AS_STRING + DBUS_TYPE_VARIANT_AS_STRING + DBUS_DICT_ENTRY_END_CHAR_AS_STRING, + &array_iter); + assert_true(bret); + + for (i = 0; data[i].name != NULL; i++) { + bret = dbus_message_iter_open_container(&array_iter, + DBUS_TYPE_DICT_ENTRY, + NULL, &dict_iter); + assert_true(bret); + + bret = dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, + &data[i].name); + assert_true(bret); + + bret = dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_VARIANT, + DBUS_TYPE_UINT32_AS_STRING, + &var_iter); + assert_true(bret); + + bret = dbus_message_iter_append_basic(&var_iter, DBUS_TYPE_UINT32, + &data[i].value); + assert_true(bret); + + bret = dbus_message_iter_close_container(&dict_iter, &var_iter); + assert_true(bret); + + bret = dbus_message_iter_close_container(&array_iter, &dict_iter); + assert_true(bret); + } + + bret = dbus_message_iter_close_container(&iter, &array_iter); + assert_true(bret); + will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); + + ret = sss_sifp_fetch_all_attrs(ctx, "/test/object", "test.com", &attrs); + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(attrs); + + for (i = 0; data[i].name != NULL; i++) { + assert_non_null(attrs[i]); + assert_int_equal(attrs[i]->num_values, 1); + assert_int_equal(attrs[i]->type, SSS_SIFP_ATTR_TYPE_UINT32); + assert_string_equal(attrs[i]->name, data[i].name); + + ret = sss_sifp_find_attr_as_uint32(attrs, data[i].name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_int_equal(data[i].value, out); + } + + assert_null(attrs[i]); + + sss_sifp_free_attrs(ctx, &attrs); + assert_null(attrs); +} + +void test_sss_sifp_fetch_object(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + DBusMessageIter iter; + DBusMessageIter array_iter; + DBusMessageIter dict_iter; + DBusMessageIter var_iter; + const char *path = "/test/object"; + const char *iface = "test.com"; + dbus_bool_t bret; + sss_sifp_error ret; + sss_sifp_object *object = NULL; + struct { + const char *name; + const char *value; + } data[] = {{"name", "test-object"}, {"a1", "a"}, {"a2", "b"}, {NULL, 0}}; + const char *out; + int i; + + /* prepare message */ + dbus_message_iter_init_append(reply, &iter); + + bret = dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + DBUS_TYPE_STRING_AS_STRING + DBUS_TYPE_VARIANT_AS_STRING + DBUS_DICT_ENTRY_END_CHAR_AS_STRING, + &array_iter); + assert_true(bret); + + for (i = 0; data[i].name != NULL; i++) { + bret = dbus_message_iter_open_container(&array_iter, + DBUS_TYPE_DICT_ENTRY, + NULL, &dict_iter); + assert_true(bret); + + bret = dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, + &data[i].name); + assert_true(bret); + + bret = dbus_message_iter_open_container(&dict_iter, DBUS_TYPE_VARIANT, + DBUS_TYPE_STRING_AS_STRING, + &var_iter); + assert_true(bret); + + bret = dbus_message_iter_append_basic(&var_iter, DBUS_TYPE_STRING, + &data[i].value); + assert_true(bret); + + bret = dbus_message_iter_close_container(&dict_iter, &var_iter); + assert_true(bret); + + bret = dbus_message_iter_close_container(&array_iter, &dict_iter); + assert_true(bret); + } + + bret = dbus_message_iter_close_container(&iter, &array_iter); + assert_true(bret); + will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); + + ret = sss_sifp_fetch_object(ctx, path, iface, &object); + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(object); + assert_non_null(object->attrs); + assert_non_null(object->name); + assert_non_null(object->object_path); + assert_non_null(object->interface); + + assert_string_equal(object->name, "test-object"); + assert_string_equal(object->object_path, path); + assert_string_equal(object->interface, iface); + + for (i = 0; data[i].name != NULL; i++) { + assert_non_null(object->attrs[i]); + assert_int_equal(object->attrs[i]->num_values, 1); + assert_int_equal(object->attrs[i]->type, SSS_SIFP_ATTR_TYPE_STRING); + assert_string_equal(object->attrs[i]->name, data[i].name); + + ret = sss_sifp_find_attr_as_string(object->attrs, data[i].name, &out); + assert_int_equal(ret, SSS_SIFP_OK); + assert_string_equal(data[i].value, out); + } + + assert_null(object->attrs[i]); + + sss_sifp_free_object(ctx, &object); + assert_null(object); +} + +void test_sss_sifp_invoke_list_zeroargs(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + dbus_bool_t bret; + sss_sifp_error ret; + char **path_out = NULL; + const char *path_in[] = {"/object/path1", "/object/path2"}; + const char **paths = path_in; + int path_in_len = 2; + int i; + + /* prepare message */ + bret = dbus_message_append_args(reply, DBUS_TYPE_ARRAY, + DBUS_TYPE_OBJECT_PATH, + &paths, path_in_len, + DBUS_TYPE_INVALID); + assert_true(bret); + will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); + + /* test */ + ret = sss_sifp_invoke_list(ctx, "MyMethod", &path_out, DBUS_TYPE_INVALID); + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(path_out); + + for (i = 0; path_out[i] != NULL; i++) { + assert_true(i < path_in_len); + assert_non_null(path_out[i]); + assert_string_equal(path_in[i], path_out[i]); + } + + sss_sifp_free_string_array(ctx, &path_out); + assert_null(path_out); +} + +void test_sss_sifp_invoke_list_withargs(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + dbus_bool_t bret; + sss_sifp_error ret; + char **path_out = NULL; + const char *path_in[] = {"/object/path1", "/object/path2"}; + const char **paths = path_in; + const char *arg = "first-arg"; + int path_in_len = 2; + int i; + + /* prepare message */ + bret = dbus_message_append_args(reply, DBUS_TYPE_ARRAY, + DBUS_TYPE_OBJECT_PATH, + &paths, path_in_len, + DBUS_TYPE_INVALID); + assert_true(bret); + will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); + + /* test */ + ret = sss_sifp_invoke_list(ctx, "MyMethod", &path_out, + DBUS_TYPE_STRING, &arg, + DBUS_TYPE_INVALID); + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(path_out); + + for (i = 0; path_out[i] != NULL; i++) { + assert_true(i < path_in_len); + assert_non_null(path_out[i]); + assert_string_equal(path_in[i], path_out[i]); + } + + sss_sifp_free_string_array(ctx, &path_out); + assert_null(path_out); +} + +void test_sss_sifp_invoke_find_zeroargs(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + dbus_bool_t bret; + sss_sifp_error ret; + const char *path_in = "/object/path"; + char *path_out = NULL; + + /* prepare message */ + bret = dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path_in, + DBUS_TYPE_INVALID); + assert_true(bret); + will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); + + /* test */ + ret = sss_sifp_invoke_find(ctx, "MyMethod", &path_out, DBUS_TYPE_INVALID); + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(path_out); + assert_string_equal(path_in, path_out); + + sss_sifp_free_string(ctx, &path_out); + assert_null(path_out); +} + +void test_sss_sifp_invoke_find_withargs(void **state) +{ + sss_sifp_ctx *ctx = test_ctx.dbus_ctx; + DBusMessage *reply = test_ctx.reply; + dbus_bool_t bret; + sss_sifp_error ret; + const char *path_in = "/object/path"; + char *path_out = NULL; + const char *arg = "first-arg"; + + /* prepare message */ + bret = dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path_in, + DBUS_TYPE_INVALID); + assert_true(bret); + will_return(__wrap_dbus_connection_send_with_reply_and_block, reply); + + /* test */ + ret = sss_sifp_invoke_find(ctx, "MyMethod", &path_out, + DBUS_TYPE_STRING, &arg, + DBUS_TYPE_INVALID); + assert_int_equal(ret, SSS_SIFP_OK); + assert_non_null(path_out); + assert_string_equal(path_in, path_out); + + sss_sifp_free_string(ctx, &path_out); + assert_null(path_out); +} + +int main(int argc, const char *argv[]) +{ + int rv; + int no_cleanup = 0; + poptContext pc; + int opt; + struct poptOption long_options[] = { + POPT_AUTOHELP + SSSD_DEBUG_OPTS + {"no-cleanup", 'n', POPT_ARG_NONE, &no_cleanup, 0, + _("Do not delete the test database after a test run"), NULL }, + POPT_TABLEEND + }; + + const UnitTest tests[] = { + unit_test_setup_teardown(test_sss_sifp_strdup_valid, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_strdup_null, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_strcat_valid, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_strcat_left_null, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_strcat_right_null, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_strcat_both_null, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_object_path_valid, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_object_path_invalid, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_object_path_list_valid, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_object_path_list_invalid, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_bool, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_int16, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_uint16, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_int32, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_uint32, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_int64, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_uint64, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_string, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_object_path, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_bool_array, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_int32_array, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_uint32_array, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_int64_array, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_uint64_array, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_string_array, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_object_path_array, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_list, + test_setup, test_teardown_parser), + unit_test_setup_teardown(test_sss_sifp_parse_attr_list_empty, + test_setup, test_teardown_parser), + unit_test(test_sss_sifp_get_iface_for_object), + unit_test_setup_teardown(test_sss_sifp_fetch_attr, + test_setup, test_teardown_api), + unit_test_setup_teardown(test_sss_sifp_fetch_all_attrs, + test_setup, test_teardown_api), + unit_test_setup_teardown(test_sss_sifp_fetch_object, + test_setup, test_teardown_api), + unit_test_setup_teardown(test_sss_sifp_invoke_list_zeroargs, + test_setup, test_teardown_api), + unit_test_setup_teardown(test_sss_sifp_invoke_list_withargs, + test_setup, test_teardown_api), + unit_test_setup_teardown(test_sss_sifp_invoke_find_zeroargs, + test_setup, test_teardown_api), + unit_test_setup_teardown(test_sss_sifp_invoke_find_withargs, + test_setup, test_teardown_api), + }; + + /* Set debug level to invalid value so we can deside if -d 0 was used. */ + debug_level = SSSDBG_INVALID; + + pc = poptGetContext(argv[0], argc, argv, long_options, 0); + while((opt = poptGetNextOpt(pc)) != -1) { + switch(opt) { + default: + fprintf(stderr, "\nInvalid option %s: %s\n\n", + poptBadOption(pc, 0), poptStrerror(opt)); + poptPrintUsage(pc, stderr, 0); + return 1; + } + } + poptFreeContext(pc); + + DEBUG_INIT(debug_level); + + rv = run_tests(tests); + + return rv; +} |