static int EscalateTestMockHelperProcess(int stdin_fd, int stdout_fd) {
GIOChannel *stdin_stream = g_io_channel_unix_new(stdin_fd);
GIOChannel *stdout_stream = g_io_channel_unix_new(stdout_fd);
GError *error = NULL;
gboolean success = FALSE;
g_assert(mock_helper_expected_messages);
g_assert(mock_helper_response_messages);
for (guint i = 0; i < g_strv_length(mock_helper_expected_messages); i++) {
EscalateMessage *expected = NULL;
EscalateMessage *message = NULL;
EscalateMessage *response = NULL;
expected = EscalateMessageLoad(mock_helper_expected_messages[i], &error);
g_assert_no_error(error);
g_assert(expected);
message = EscalateMessageRead(stdin_stream, &error);
g_assert_no_error(error);
g_assert(message);
if (mock_helper_response_messages[i]) {
response = EscalateMessageLoad(mock_helper_response_messages[i], &error);
g_assert_no_error(error);
g_assert(response);
}
g_assert_cmpint(expected->type, ==, message->type);
if (!g_variant_equal(expected->values, message->values)) {
gchar *variant_str = g_variant_print(expected->values, FALSE);
g_message("Expected: %s", variant_str);
g_free(variant_str);
variant_str = g_variant_print(message->values, FALSE);
g_message("Got: %s", variant_str);
g_free(variant_str);
g_error("Message values didn't match what was expected");
}
if (response) {
success = EscalateMessageWrite(response, stdout_stream, &error);
g_assert_no_error(error);
g_assert(success);
EscalateMessageUnref(response);
}
EscalateMessageUnref(expected);
EscalateMessageUnref(message);
}
g_io_channel_shutdown(stdin_stream, FALSE, NULL);
g_io_channel_shutdown(stdout_stream, FALSE, NULL);
g_io_channel_unref(stdin_stream);
g_io_channel_unref(stdout_stream);
return 0;
}
static void TestWrite(gconstpointer user_data) {
guint index = GPOINTER_TO_UINT(user_data);
gint fds [] = { 0, 0 };
GIOChannel *reader = NULL;
GIOChannel *writer = NULL;
GThread *thread = NULL;
EscalateMessage *message = NULL;
GError *error = NULL;
gboolean success = FALSE;
gchar *result = NULL;
g_assert(g_unix_open_pipe(fds, 0, NULL));
reader = g_io_channel_unix_new(fds[0]);
writer = g_io_channel_unix_new(fds[1]);
thread = g_thread_new("Reader", (GThreadFunc) ReaderThread, reader);
message = EscalateMessageLoad(example_messages[index], NULL);
g_assert(message);
success = EscalateMessageWrite(message, writer, &error);
g_assert_no_error(error);
g_assert(success);
g_assert_cmpint(G_IO_STATUS_NORMAL, ==,
g_io_channel_shutdown(writer, TRUE, NULL));
result = (gchar *) g_thread_join(thread);
result[strlen(result)-1] = '\0'; // Cut off newline.
g_assert_cmpstr(example_messages[index], ==, result);
g_io_channel_unref(reader);
g_io_channel_unref(writer);
EscalateMessageUnref(message);
g_free(result);
}
static void WriteMessage(GIOChannel *channel, const gchar *message_str) {
GError *error = NULL;
EscalateMessage *message = EscalateMessageLoad(message_str, &error);
g_assert_no_error(error);
g_assert(message);
gboolean success = EscalateMessageWrite(message, channel, &error);
g_assert_no_error(error);
g_assert(success);
EscalateMessageUnref(message);
}
static void AssertMessage(GIOChannel *channel, const gchar *expected_str) {
GError *error = NULL;
EscalateMessage *expected = EscalateMessageLoad(expected_str, &error);
g_assert_no_error(error);
g_assert(expected);
EscalateMessage *message = EscalateMessageRead(channel, &error);
g_assert_no_error(error);
g_assert(message);
g_assert_cmpint(expected->type, ==, message->type);
g_assert(g_variant_equal(expected->values, message->values));
EscalateMessageUnref(expected);
EscalateMessageUnref(message);
}
static void TestDump(gconstpointer user_data) {
guint index = GPOINTER_TO_UINT(user_data);
GError *error = NULL;
EscalateMessage *message = EscalateMessageLoad(example_messages[index],
&error);
g_assert_no_error(error);
g_assert(message);
gchar *message_str = EscalateMessageDump(message);
g_assert_cmpstr(example_messages[index], ==, message_str);
g_free(message_str);
EscalateMessageUnref(message);
}
static void TestLoad(gconstpointer user_data) {
guint index = GPOINTER_TO_UINT(user_data);
GError *error = NULL;
GVariant *expected_values = CreateExampleMessageValues(index);
EscalateMessage *message = EscalateMessageLoad(example_messages[index],
&error);
g_assert_no_error(error);
g_assert(message);
g_assert_cmpint(EscalateMessageGetType(message), ==,
example_message_types[index]);
g_assert(g_variant_equal(expected_values, message->values));
g_variant_unref(expected_values);
EscalateMessageUnref(message);
}
static void TestGetValues(gconstpointer user_data) {
guint index = GPOINTER_TO_UINT(user_data);
EscalateMessage *message = NULL;
gint action = 0;
gint flags = 0;
gchar *username = NULL;
gchar *value = NULL;
gint item_key = 0;
gchar *item_value = NULL;
GVariantIter *items_iter = NULL;
gchar *env_key = NULL;
gchar *env_value = NULL;
GVariantIter *env_iter = NULL;
message = EscalateMessageLoad(example_messages[index], NULL);
g_assert(message);
switch (index) {
case 0:
EscalateMessageGetValues(message, &action, &flags, &username, &items_iter,
&env_iter);
g_assert_cmpint(1, ==, action);
g_assert_cmpint(0, ==, flags);
g_assert_cmpstr("testuser", ==, username);
g_assert(g_variant_iter_next(items_iter, "{ims}", &item_key,
&item_value));
g_assert_cmpint(2, ==, item_key);
g_assert_cmpstr("testuser", ==, item_value);
g_assert(!g_variant_iter_next(items_iter, "{ims}", NULL, NULL));
g_variant_iter_free(items_iter);
g_assert(g_variant_iter_next(env_iter, "{ss}", &env_key, &env_value));
g_assert_cmpstr("PATH", ==, env_key);
g_assert_cmpstr("/path", ==, env_value);
g_assert(!g_variant_iter_next(env_iter, "{ss}", NULL, NULL));
g_variant_iter_free(env_iter);
break;
case 1:
EscalateMessageGetValues(message, &flags, &value);
g_assert_cmpint(1, ==, flags);
g_assert_cmpstr("Password: "******"testpass", ==, value);
g_assert_cmpint(0, ==, flags);
break;
case 3:
EscalateMessageGetValues(message, &flags, &env_iter);
g_assert_cmpint(0, ==, flags);
g_assert(g_variant_iter_next(env_iter, "{ss}", &env_key, &env_value));
g_assert_cmpstr("PATH", ==, env_key);
g_assert_cmpstr("/path", ==, env_value);
g_assert(!g_variant_iter_next(env_iter, "{ss}", NULL, NULL));
g_variant_iter_free(env_iter);
break;
default:
g_error("No message available for index %d", index);
}
g_free(username);
g_free(value);
g_free(item_value);
g_free(env_key);
g_free(env_value);
EscalateMessageUnref(message);
}
