* [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers @ 2015-08-27 10:52 marcandre.lureau 2015-08-27 10:52 ` [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent marcandre.lureau 2015-09-09 20:05 ` [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers Michael Roth 0 siblings, 2 replies; 7+ messages in thread From: marcandre.lureau @ 2015-08-27 10:52 UTC (permalink / raw) To: qemu-devel; +Cc: Marc-André Lureau, mdroth From: Marc-André Lureau <marcandre.lureau@redhat.com> Add a few functions to interact with qmp via a simple fd. Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com> --- tests/libqtest.c | 45 +++++++++++++++++++++++++++++++++++++++++---- tests/libqtest.h | 7 +++++++ 2 files changed, 48 insertions(+), 4 deletions(-) diff --git a/tests/libqtest.c b/tests/libqtest.c index e5188e0..11e541d 100644 --- a/tests/libqtest.c +++ b/tests/libqtest.c @@ -357,7 +357,7 @@ static void qmp_response(JSONMessageParser *parser, QList *tokens) qmp->response = (QDict *)obj; } -QDict *qtest_qmp_receive(QTestState *s) +QDict *qmp_fd_receive(int fd) { QMPResponseParser qmp; bool log = getenv("QTEST_LOG") != NULL; @@ -368,7 +368,7 @@ QDict *qtest_qmp_receive(QTestState *s) ssize_t len; char c; - len = read(s->qmp_fd, &c, 1); + len = read(fd, &c, 1); if (len == -1 && errno == EINTR) { continue; } @@ -388,12 +388,17 @@ QDict *qtest_qmp_receive(QTestState *s) return qmp.response; } +QDict *qtest_qmp_receive(QTestState *s) +{ + return qmp_fd_receive(s->qmp_fd); +} + /** * Allow users to send a message without waiting for the reply, * in the case that they choose to discard all replies up until * a particular EVENT is received. */ -void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap) +void qmp_fd_sendv(int fd, const char *fmt, va_list ap) { va_list ap_copy; QObject *qobj; @@ -417,13 +422,25 @@ void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap) fprintf(stderr, "%s", str); } /* Send QMP request */ - socket_send(s->qmp_fd, str, size); + socket_send(fd, str, size); QDECREF(qstr); qobject_decref(qobj); } } +void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap) +{ + qmp_fd_sendv(s->qmp_fd, fmt, ap); +} + +QDict *qmp_fdv(int fd, const char *fmt, va_list ap) +{ + qmp_fd_sendv(fd, fmt, ap); + + return qmp_fd_receive(fd); +} + QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap) { qtest_async_qmpv(s, fmt, ap); @@ -432,6 +449,26 @@ QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap) return qtest_qmp_receive(s); } +QDict *qmp_fd(int fd, const char *fmt, ...) +{ + va_list ap; + QDict *response; + + va_start(ap, fmt); + response = qmp_fdv(fd, fmt, ap); + va_end(ap); + return response; +} + +void qmp_fd_send(int fd, const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + qmp_fd_sendv(fd, fmt, ap); + va_end(ap); +} + QDict *qtest_qmp(QTestState *s, const char *fmt, ...) { va_list ap; diff --git a/tests/libqtest.h b/tests/libqtest.h index ec42031..ecd9872 100644 --- a/tests/libqtest.h +++ b/tests/libqtest.h @@ -818,4 +818,11 @@ static inline int64_t clock_set(int64_t val) */ bool qtest_big_endian(void); + +QDict *qmp_fd_receive(int fd); +void qmp_fd_sendv(int fd, const char *fmt, va_list ap); +void qmp_fd_send(int fd, const char *fmt, ...); +QDict *qmp_fdv(int fd, const char *fmt, va_list ap); +QDict *qmp_fd(int fd, const char *fmt, ...); + #endif -- 2.4.3 ^ permalink raw reply related [flat|nested] 7+ messages in thread
* [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent 2015-08-27 10:52 [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers marcandre.lureau @ 2015-08-27 10:52 ` marcandre.lureau 2015-08-27 11:36 ` Marc-André Lureau 2015-09-09 21:53 ` Michael Roth 2015-09-09 20:05 ` [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers Michael Roth 1 sibling, 2 replies; 7+ messages in thread From: marcandre.lureau @ 2015-08-27 10:52 UTC (permalink / raw) To: qemu-devel; +Cc: Marc-André Lureau, mdroth From: Marc-André Lureau <marcandre.lureau@redhat.com> Add some local guest agent tests (as it is better than nothing). They can be run inside or outside a VM, when run inside a VM, they will do a bit more side effects, such as freezing/thawing the FS or changing the time. A better test would involve a managed VM (or container), but it might be better to leave that off to autotest/avocado. Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com> --- tests/Makefile | 3 + tests/test-qga.c | 686 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 689 insertions(+) create mode 100644 tests/test-qga.c diff --git a/tests/Makefile b/tests/Makefile index 5271123..35671a1 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -76,6 +76,7 @@ check-unit-y += tests/test-write-threshold$(EXESUF) gcov-files-test-write-threshold-y = block/write-threshold.c check-unit-$(CONFIG_GNUTLS_HASH) += tests/test-crypto-hash$(EXESUF) check-unit-y += tests/test-crypto-cipher$(EXESUF) +check-unit-y += tests/test-qga$(EXESUF) check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh @@ -425,6 +426,8 @@ endif qtest-obj-y = tests/libqtest.o libqemuutil.a libqemustub.a $(check-qtest-y): $(qtest-obj-y) +tests/test-qga: tests/test-qga.o $(qtest-obj-y) + .PHONY: check-help check-help: @echo "Regression testing targets:" diff --git a/tests/test-qga.c b/tests/test-qga.c new file mode 100644 index 0000000..1fb58ec --- /dev/null +++ b/tests/test-qga.c @@ -0,0 +1,686 @@ +#include <locale.h> +#include <glib.h> +#include <glib/gstdio.h> +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> +#include <string.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <unistd.h> + +#include "libqtest.h" +#include "config-host.h" + +typedef struct { + char *test_dir; + GMainLoop *loop; + int fd; + GPid pid; +} TestFixture; + +static int connect_qga(char *path) +{ + int s, ret, len; + struct sockaddr_un remote; + + s = socket(AF_UNIX, SOCK_STREAM, 0); + g_assert(s != -1); + + remote.sun_family = AF_UNIX; + do { + strcpy(remote.sun_path, path); + len = strlen(remote.sun_path) + sizeof(remote.sun_family); + ret = connect(s, (struct sockaddr *)&remote, len); + if (ret == -1) { + g_usleep(G_USEC_PER_SEC); + } + } while (ret == -1); + + return s; +} + +static void qga_watch(GPid pid, gint status, gpointer user_data) +{ + TestFixture *fixture = user_data; + + g_assert_cmpint(status, ==, 0); + g_main_loop_quit(fixture->loop); +} + +static void +fixture_setup(TestFixture *fixture, gconstpointer data) +{ + const gchar *extra_arg = data; + GError *error = NULL; + gchar *cwd, *path, *cmd, **argv = NULL; + + fixture->loop = g_main_loop_new(NULL, FALSE); + + fixture->test_dir = g_strdup("/tmp/qgatest.XXXXXX"); + g_assert_nonnull(g_mkdtemp(fixture->test_dir)); + + path = g_build_filename(fixture->test_dir, "sock", NULL); + cwd = g_get_current_dir(); + cmd = g_strdup_printf("%s%cqemu-ga -m unix-listen -t %s -p %s %s %s", + cwd, G_DIR_SEPARATOR, + fixture->test_dir, path, + getenv("QTEST_LOG") ? "-v" : "", + extra_arg ?: ""); + g_shell_parse_argv(cmd, NULL, &argv, &error); + g_assert_no_error(error); + + g_spawn_async(fixture->test_dir, argv, NULL, + G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD, + NULL, NULL, &fixture->pid, &error); + g_assert_no_error(error); + + g_child_watch_add(fixture->pid, qga_watch, fixture); + + fixture->fd = connect_qga(path); + + g_strfreev(argv); + g_free(cmd); + g_free(cwd); + g_free(path); +} + +static void +fixture_tear_down(TestFixture *fixture, gconstpointer data) +{ + gchar *tmp; + + kill(fixture->pid, SIGTERM); + + g_main_loop_run(fixture->loop); + g_main_loop_unref(fixture->loop); + + g_spawn_close_pid(fixture->pid); + + tmp = g_build_filename(fixture->test_dir, "foo", NULL); + g_unlink(tmp); + g_free(tmp); + + tmp = g_build_filename(fixture->test_dir, "qga.state", NULL); + g_unlink(tmp); + g_free(tmp); + + tmp = g_build_filename(fixture->test_dir, "sock", NULL); + g_unlink(tmp); + g_free(tmp); + + g_rmdir(fixture->test_dir); + g_free(fixture->test_dir); +} + +static void qmp_assertion_message_error(const char *domain, + const char *file, + int line, + const char *func, + const char *expr, + QDict *dict) +{ + const char *class, *desc; + char *s; + QDict *error; + + error = qdict_get_qdict(dict, "error"); + class = qdict_get_try_str(error, "class"); + desc = qdict_get_try_str(error, "desc"); + + s = g_strdup_printf("assertion failed %s: %s %s", expr, class, desc); + g_assertion_message(domain, file, line, func, s); + g_free(s); +} + +#define qmp_assert_no_error(err) do { \ + if (qdict_haskey(err, "error")) { \ + qmp_assertion_message_error(G_LOG_DOMAIN, __FILE__, __LINE__, \ + G_STRFUNC, #err, err); \ + } \ +} while (0) + +static void test_qga_sync_delimited(gconstpointer fix) +{ + const TestFixture *fixture = fix; + guint32 v, r = g_random_int(); + unsigned char c; + QDict *ret; + gchar *cmd; + + cmd = g_strdup_printf("%c{'execute': 'guest-sync-delimited'," + " 'arguments': {'id': %u } }", 0xff, r); + qmp_fd_send(fixture->fd, cmd); + g_free(cmd); + + v = read(fixture->fd, &c, 1); + g_assert_cmpint(v, ==, 1); + g_assert_cmpint(c, ==, 0xff); + + ret = qmp_fd_receive(fixture->fd); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + + v = qdict_get_int(ret, "return"); + g_assert_cmpint(r, ==, v); + + QDECREF(ret); +} + +static void test_qga_sync(gconstpointer fix) +{ + const TestFixture *fixture = fix; + guint32 v, r = g_random_int(); + QDict *ret; + gchar *cmd; + + cmd = g_strdup_printf("%c{'execute': 'guest-sync'," + " 'arguments': {'id': %u } }", 0xff, r); + ret = qmp_fd(fixture->fd, cmd); + g_free(cmd); + + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + + v = qdict_get_int(ret, "return"); + g_assert_cmpint(r, ==, v); + + QDECREF(ret); +} + +static void test_qga_ping(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret; + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + + QDECREF(ret); +} + +static void test_qga_invalid_cmd(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret, *error; + const gchar *class, *desc; + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-invalid-cmd'}"); + g_assert_nonnull(ret); + + error = qdict_get_qdict(ret, "error"); + class = qdict_get_try_str(error, "class"); + desc = qdict_get_try_str(error, "desc"); + + g_assert_cmpstr(class, ==, "CommandNotFound"); + g_assert_cmpint(strlen(desc), >, 0); + + QDECREF(ret); +} + +static void test_qga_info(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret, *val; + const gchar *version; + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-info'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + + val = qdict_get_qdict(ret, "return"); + version = qdict_get_try_str(val, "version"); + g_assert_cmpstr(version, ==, QEMU_VERSION); + + QDECREF(ret); +} + +static void test_qga_get_vcpus(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret; + QList *list; + const QListEntry *entry; + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-vcpus'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + + /* check there is at least a cpu */ + list = qdict_get_qlist(ret, "return"); + entry = qlist_first(list); + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online")); + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "logical-id")); + + QDECREF(ret); +} + +static void test_qga_get_fsinfo(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret; + QList *list; + const QListEntry *entry; + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-fsinfo'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + + /* check there is at least a fs */ + list = qdict_get_qlist(ret, "return"); + entry = qlist_first(list); + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name")); + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "mountpoint")); + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "type")); + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "disk")); + + QDECREF(ret); +} + +static void test_qga_get_memory_block_info(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret, *val; + int64_t size; + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-block-info'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + + /* check there is at least some memory */ + val = qdict_get_qdict(ret, "return"); + size = qdict_get_int(val, "size"); + g_assert_cmpint(size, >, 0); + + QDECREF(ret); +} + +static void test_qga_get_memory_blocks(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret; + QList *list; + const QListEntry *entry; + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-blocks'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + + list = qdict_get_qlist(ret, "return"); + entry = qlist_first(list); + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "phys-index")); + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online")); + + QDECREF(ret); +} + +static void test_qga_network_get_interfaces(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret; + QList *list; + const QListEntry *entry; + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-network-get-interfaces'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + + /* check there is at least a cpu */ + list = qdict_get_qlist(ret, "return"); + entry = qlist_first(list); + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name")); + + QDECREF(ret); +} + +static void test_qga_file_ops(gconstpointer fix) +{ + const TestFixture *fixture = fix; + gchar *cmd, *path; + const gchar *b64; + QDict *ret, *val; + int64_t id, count, eof; + FILE *f; + char tmp[100]; + + /* open */ + ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open'," + " 'arguments': { 'path': 'foo', 'mode': 'w+' } }"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + id = qdict_get_int(ret, "return"); + QDECREF(ret); + + /* write */ + cmd = g_strdup_printf("{'execute': 'guest-file-write'," + " 'arguments': { 'handle': %" G_GINT64_FORMAT "," + " 'buf-b64': 'aGVsbG8gd29ybGQK' } }", id); + ret = qmp_fd(fixture->fd, cmd); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + + val = qdict_get_qdict(ret, "return"); + count = qdict_get_int(val, "count"); + eof = qdict_get_bool(val, "eof"); + g_assert_cmpint(count, ==, 12); + g_assert_cmpint(eof, ==, 0); + QDECREF(ret); + g_free(cmd); + + /* flush */ + cmd = g_strdup_printf("{'execute': 'guest-file-flush'," + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }", + id); + ret = qmp_fd(fixture->fd, cmd); + QDECREF(ret); + g_free(cmd); + + /* close */ + cmd = g_strdup_printf("{'execute': 'guest-file-close'," + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }", + id); + ret = qmp_fd(fixture->fd, cmd); + QDECREF(ret); + g_free(cmd); + + /* check content */ + path = g_build_filename(fixture->test_dir, "foo", NULL); + f = fopen(path, "r"); + g_assert_nonnull(f); + count = fread(tmp, 1, sizeof(tmp), f); + g_assert_cmpint(count, ==, 12); + tmp[count] = 0; + g_assert_cmpstr(tmp, ==, "hello world\n"); + fclose(f); + + /* open */ + ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open'," + " 'arguments': { 'path': 'foo', 'mode': 'r' } }"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + id = qdict_get_int(ret, "return"); + QDECREF(ret); + + /* read */ + cmd = g_strdup_printf("{'execute': 'guest-file-read'," + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }", + id); + ret = qmp_fd(fixture->fd, cmd); + val = qdict_get_qdict(ret, "return"); + count = qdict_get_int(val, "count"); + eof = qdict_get_bool(val, "eof"); + b64 = qdict_get_str(val, "buf-b64"); + g_assert_cmpint(count, ==, 12); + g_assert(eof); + g_assert_cmpstr(b64, ==, "aGVsbG8gd29ybGQK"); + + QDECREF(ret); + g_free(cmd); + + /* read eof */ + cmd = g_strdup_printf("{'execute': 'guest-file-read'," + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }", + id); + ret = qmp_fd(fixture->fd, cmd); + val = qdict_get_qdict(ret, "return"); + count = qdict_get_int(val, "count"); + eof = qdict_get_bool(val, "eof"); + b64 = qdict_get_str(val, "buf-b64"); + g_assert_cmpint(count, ==, 0); + g_assert(eof); + g_assert_cmpstr(b64, ==, ""); + QDECREF(ret); + g_free(cmd); + + /* seek */ + cmd = g_strdup_printf("{'execute': 'guest-file-seek'," + " 'arguments': { 'handle': %" G_GINT64_FORMAT ", " + " 'offset': %d, 'whence': %d } }", + id, 6, SEEK_SET); + ret = qmp_fd(fixture->fd, cmd); + qmp_assert_no_error(ret); + val = qdict_get_qdict(ret, "return"); + count = qdict_get_int(val, "position"); + eof = qdict_get_bool(val, "eof"); + g_assert_cmpint(count, ==, 6); + g_assert(!eof); + QDECREF(ret); + g_free(cmd); + + /* partial read */ + cmd = g_strdup_printf("{'execute': 'guest-file-read'," + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }", + id); + ret = qmp_fd(fixture->fd, cmd); + val = qdict_get_qdict(ret, "return"); + count = qdict_get_int(val, "count"); + eof = qdict_get_bool(val, "eof"); + b64 = qdict_get_str(val, "buf-b64"); + g_assert_cmpint(count, ==, 6); + g_assert(eof); + g_assert_cmpstr(b64, ==, "d29ybGQK"); + + QDECREF(ret); + g_free(cmd); + + /* close */ + cmd = g_strdup_printf("{'execute': 'guest-file-close'," + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }", + id); + ret = qmp_fd(fixture->fd, cmd); + QDECREF(ret); + g_free(cmd); +} + +static void test_qga_get_time(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret; + int64_t time; + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + + time = qdict_get_int(ret, "return"); + g_assert_cmpint(time, >, 0); + + QDECREF(ret); +} + +static void test_qga_set_time(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret; + int64_t current, time; + gchar *cmd; + + /* get current time */ + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + current = qdict_get_int(ret, "return"); + g_assert_cmpint(current, >, 0); + QDECREF(ret); + + /* set some old time */ + ret = qmp_fd(fixture->fd, "{'execute': 'guest-set-time'," + " 'arguments': { 'time': 1000 } }"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + QDECREF(ret); + + /* check old time */ + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + time = qdict_get_int(ret, "return"); + g_assert_cmpint(time / 1000, <, G_USEC_PER_SEC * 10); + QDECREF(ret); + + /* set back current time */ + cmd = g_strdup_printf("{'execute': 'guest-set-time'," + " 'arguments': { 'time': %" G_GINT64_FORMAT " } }", + current + time * 1000); + ret = qmp_fd(fixture->fd, cmd); + g_free(cmd); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + QDECREF(ret); +} + +static void test_qga_fstrim(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret; + QList *list; + const QListEntry *entry; + + /* get current time */ + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fstrim'," + " arguments: { minimum: 4194304 } }"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + list = qdict_get_qlist(ret, "return"); + entry = qlist_first(list); + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "paths")); + + QDECREF(ret); +} + +static void test_qga_blacklist(gconstpointer data) +{ + TestFixture fix; + QDict *ret, *error; + const gchar *class, *desc; + + fixture_setup(&fix, "-b guest-ping,guest-get-time"); + + /* check blacklist */ + ret = qmp_fd(fix.fd, "{'execute': 'guest-ping'}"); + g_assert_nonnull(ret); + error = qdict_get_qdict(ret, "error"); + class = qdict_get_try_str(error, "class"); + desc = qdict_get_try_str(error, "desc"); + g_assert_cmpstr(class, ==, "GenericError"); + g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled")); + QDECREF(ret); + + ret = qmp_fd(fix.fd, "{'execute': 'guest-get-time'}"); + g_assert_nonnull(ret); + error = qdict_get_qdict(ret, "error"); + class = qdict_get_try_str(error, "class"); + desc = qdict_get_try_str(error, "desc"); + g_assert_cmpstr(class, ==, "GenericError"); + g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled")); + QDECREF(ret); + + /* check something work */ + ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}"); + qmp_assert_no_error(ret); + QDECREF(ret); + + fixture_tear_down(&fix, NULL); +} + +static void test_qga_fsfreeze_status(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret; + const gchar *status; + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-status'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + + status = qdict_get_try_str(ret, "return"); + g_assert_cmpstr(status, ==, "thawed"); + + QDECREF(ret); +} + +static void test_qga_fsfreeze_and_thaw(gconstpointer fix) +{ + const TestFixture *fixture = fix; + QDict *ret; + const gchar *status; + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-freeze'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + QDECREF(ret); + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-status'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + status = qdict_get_try_str(ret, "return"); + g_assert_cmpstr(status, ==, "frozen"); + QDECREF(ret); + + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-thaw'}"); + g_assert_nonnull(ret); + qmp_assert_no_error(ret); + QDECREF(ret); +} + +static gboolean running_in_virt(const gchar *virt) +{ + gchar *virt_what = NULL; + gint status; + gboolean success; + + success = g_spawn_command_line_sync("virt-what", &virt_what, NULL, + &status, NULL); + + success = success && status == 0 && g_strcmp0(virt_what, virt); + + g_free(virt_what); + + return success; +} +int main(int argc, char **argv) +{ + TestFixture fix; + int ret; + + setlocale (LC_ALL, ""); + g_test_init(&argc, &argv, NULL); + fixture_setup(&fix, NULL); + + g_test_add_data_func("/qga/sync-delimited", &fix, test_qga_sync_delimited); + g_test_add_data_func("/qga/sync", &fix, test_qga_sync); + g_test_add_data_func("/qga/ping", &fix, test_qga_ping); + g_test_add_data_func("/qga/info", &fix, test_qga_info); + g_test_add_data_func("/qga/network-get-interfaces", &fix, + test_qga_network_get_interfaces); + g_test_add_data_func("/qga/get-vcpus", &fix, test_qga_get_vcpus); + g_test_add_data_func("/qga/get-fsinfo", &fix, test_qga_get_fsinfo); + g_test_add_data_func("/qga/get-memory-block-info", &fix, + test_qga_get_memory_block_info); + g_test_add_data_func("/qga/get-memory-blocks", &fix, + test_qga_get_memory_blocks); + g_test_add_data_func("/qga/file-ops", &fix, test_qga_file_ops); + g_test_add_data_func("/qga/get-time", &fix, test_qga_get_time); + g_test_add_data_func("/qga/invalid-cmd", &fix, test_qga_invalid_cmd); + g_test_add_data_func("/qga/fsfreeze-status", &fix, + test_qga_fsfreeze_status); + + g_test_add_data_func("/qga/blacklist", NULL, test_qga_blacklist); + + if (running_in_virt("kvm")) { + g_test_add_data_func("/qga/fsfreeze-and-thaw", &fix, + test_qga_fsfreeze_and_thaw); + g_test_add_data_func("/qga/set-time", &fix, test_qga_set_time); + if (g_test_thorough()) { + g_test_add_data_func("/qga/fstrim", &fix, test_qga_fstrim); + } + } + + ret = g_test_run(); + + fixture_tear_down(&fix, NULL); + + return ret; +} -- 2.4.3 ^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent 2015-08-27 10:52 ` [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent marcandre.lureau @ 2015-08-27 11:36 ` Marc-André Lureau 2015-09-09 17:36 ` Michael Roth 2015-09-09 21:53 ` Michael Roth 1 sibling, 1 reply; 7+ messages in thread From: Marc-André Lureau @ 2015-08-27 11:36 UTC (permalink / raw) To: QEMU; +Cc: Marc-André Lureau, Michael Roth On Thu, Aug 27, 2015 at 12:52 PM, <marcandre.lureau@redhat.com> wrote: > + success = success && status == 0 && g_strcmp0(virt_what, virt); this is now: g_strcmp0(g_strstrip(virt_what), virt) == 0 -- Marc-André Lureau ^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent 2015-08-27 11:36 ` Marc-André Lureau @ 2015-09-09 17:36 ` Michael Roth 0 siblings, 0 replies; 7+ messages in thread From: Michael Roth @ 2015-09-09 17:36 UTC (permalink / raw) To: Marc-André Lureau, QEMU; +Cc: Marc-André Lureau Quoting Marc-André Lureau (2015-08-27 06:36:43) > On Thu, Aug 27, 2015 at 12:52 PM, <marcandre.lureau@redhat.com> wrote: > > + success = success && status == 0 && g_strcmp0(virt_what, virt); > > this is now: > g_strcmp0(g_strstrip(virt_what), virt) == 0 Just to be sure, is this the change you intended? diff --git a/tests/test-qga.c b/tests/test-qga.c index 1fb58ec..ca4bcb5 100644 --- a/tests/test-qga.c +++ b/tests/test-qga.c @@ -634,7 +634,8 @@ static gboolean running_in_virt(const gchar *virt) success = g_spawn_command_line_sync("virt-what", &virt_what, NULL, &status, NULL); - success = success && status == 0 && g_strcmp0(virt_what, virt); + success = success && status == 0 && + g_strcmp0(g_strstrip(virt_what), virt) == 0; g_free(virt_what); > > -- > Marc-André Lureau > ^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent 2015-08-27 10:52 ` [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent marcandre.lureau 2015-08-27 11:36 ` Marc-André Lureau @ 2015-09-09 21:53 ` Michael Roth 2015-09-11 17:46 ` Marc-André Lureau 1 sibling, 1 reply; 7+ messages in thread From: Michael Roth @ 2015-09-09 21:53 UTC (permalink / raw) To: marcandre.lureau, qemu-devel Quoting marcandre.lureau@redhat.com (2015-08-27 05:52:07) > From: Marc-André Lureau <marcandre.lureau@redhat.com> > > Add some local guest agent tests (as it is better than nothing). > > They can be run inside or outside a VM, when run inside a VM, they will > do a bit more side effects, such as freezing/thawing the FS or changing > the time. > > A better test would involve a managed VM (or container), but it might be > better to leave that off to autotest/avocado. > > Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com> > --- > tests/Makefile | 3 + > tests/test-qga.c | 686 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ > 2 files changed, 689 insertions(+) > create mode 100644 tests/test-qga.c > > diff --git a/tests/Makefile b/tests/Makefile > index 5271123..35671a1 100644 > --- a/tests/Makefile > +++ b/tests/Makefile > @@ -76,6 +76,7 @@ check-unit-y += tests/test-write-threshold$(EXESUF) > gcov-files-test-write-threshold-y = block/write-threshold.c > check-unit-$(CONFIG_GNUTLS_HASH) += tests/test-crypto-hash$(EXESUF) > check-unit-y += tests/test-crypto-cipher$(EXESUF) > +check-unit-y += tests/test-qga$(EXESUF) > > check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh > > @@ -425,6 +426,8 @@ endif > qtest-obj-y = tests/libqtest.o libqemuutil.a libqemustub.a > $(check-qtest-y): $(qtest-obj-y) > > +tests/test-qga: tests/test-qga.o $(qtest-obj-y) > + > .PHONY: check-help > check-help: > @echo "Regression testing targets:" > diff --git a/tests/test-qga.c b/tests/test-qga.c > new file mode 100644 > index 0000000..1fb58ec > --- /dev/null > +++ b/tests/test-qga.c > @@ -0,0 +1,686 @@ > +#include <locale.h> > +#include <glib.h> > +#include <glib/gstdio.h> > +#include <stdio.h> > +#include <stdlib.h> > +#include <errno.h> > +#include <string.h> > +#include <sys/types.h> > +#include <sys/socket.h> > +#include <sys/un.h> > +#include <unistd.h> > + > +#include "libqtest.h" > +#include "config-host.h" > + > +typedef struct { > + char *test_dir; > + GMainLoop *loop; > + int fd; > + GPid pid; > +} TestFixture; > + > +static int connect_qga(char *path) > +{ > + int s, ret, len; > + struct sockaddr_un remote; > + > + s = socket(AF_UNIX, SOCK_STREAM, 0); > + g_assert(s != -1); > + > + remote.sun_family = AF_UNIX; > + do { > + strcpy(remote.sun_path, path); > + len = strlen(remote.sun_path) + sizeof(remote.sun_family); > + ret = connect(s, (struct sockaddr *)&remote, len); > + if (ret == -1) { > + g_usleep(G_USEC_PER_SEC); > + } > + } while (ret == -1); I think we should loop on ECONNREFUSED (or whatever corresponds to the socket not yet being created/bound), and the usual suspects like EINTR. If it's anything else I don't think we'd want this to loop indefinitely. > + > + return s; > +} > + > +static void qga_watch(GPid pid, gint status, gpointer user_data) > +{ > + TestFixture *fixture = user_data; > + > + g_assert_cmpint(status, ==, 0); > + g_main_loop_quit(fixture->loop); > +} > + > +static void > +fixture_setup(TestFixture *fixture, gconstpointer data) > +{ > + const gchar *extra_arg = data; > + GError *error = NULL; > + gchar *cwd, *path, *cmd, **argv = NULL; > + > + fixture->loop = g_main_loop_new(NULL, FALSE); > + > + fixture->test_dir = g_strdup("/tmp/qgatest.XXXXXX"); > + g_assert_nonnull(g_mkdtemp(fixture->test_dir)); > + > + path = g_build_filename(fixture->test_dir, "sock", NULL); > + cwd = g_get_current_dir(); > + cmd = g_strdup_printf("%s%cqemu-ga -m unix-listen -t %s -p %s %s %s", Would be nice if we could also run qemu-ga.exe for a w32 build with binfmt set up like some of the other tests, but no idea how we'd get at it through wine. I guess it would have to be a serial connection or something... Probably too environment-specific for a useful unit test. I guess in the future we could plumb in custom qemu-ga invocation/script that does some extra setup on the backend (VM/container/wine) and exposes that via a local socket like we'd get via -chardev. > + cwd, G_DIR_SEPARATOR, > + fixture->test_dir, path, > + getenv("QTEST_LOG") ? "-v" : "", > + extra_arg ?: ""); > + g_shell_parse_argv(cmd, NULL, &argv, &error); > + g_assert_no_error(error); > + > + g_spawn_async(fixture->test_dir, argv, NULL, > + G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD, > + NULL, NULL, &fixture->pid, &error); > + g_assert_no_error(error); > + > + g_child_watch_add(fixture->pid, qga_watch, fixture); > + > + fixture->fd = connect_qga(path); > + > + g_strfreev(argv); > + g_free(cmd); > + g_free(cwd); > + g_free(path); > +} > + > +static void > +fixture_tear_down(TestFixture *fixture, gconstpointer data) > +{ > + gchar *tmp; > + > + kill(fixture->pid, SIGTERM); > + > + g_main_loop_run(fixture->loop); > + g_main_loop_unref(fixture->loop); > + > + g_spawn_close_pid(fixture->pid); > + > + tmp = g_build_filename(fixture->test_dir, "foo", NULL); > + g_unlink(tmp); > + g_free(tmp); Shouldn't the individual unit tests clean these up? I think a flag determining whether or not we're running locally (set by default obviously) would be useful for determining whether it makes sense for us to clean them up or not. > + > + tmp = g_build_filename(fixture->test_dir, "qga.state", NULL); > + g_unlink(tmp); > + g_free(tmp); > + > + tmp = g_build_filename(fixture->test_dir, "sock", NULL); > + g_unlink(tmp); > + g_free(tmp); > + > + g_rmdir(fixture->test_dir); > + g_free(fixture->test_dir); > +} > + > +static void qmp_assertion_message_error(const char *domain, > + const char *file, > + int line, > + const char *func, > + const char *expr, > + QDict *dict) > +{ > + const char *class, *desc; > + char *s; > + QDict *error; > + > + error = qdict_get_qdict(dict, "error"); > + class = qdict_get_try_str(error, "class"); > + desc = qdict_get_try_str(error, "desc"); > + > + s = g_strdup_printf("assertion failed %s: %s %s", expr, class, desc); > + g_assertion_message(domain, file, line, func, s); > + g_free(s); > +} > + > +#define qmp_assert_no_error(err) do { \ > + if (qdict_haskey(err, "error")) { \ > + qmp_assertion_message_error(G_LOG_DOMAIN, __FILE__, __LINE__, \ > + G_STRFUNC, #err, err); \ > + } \ > +} while (0) > + > +static void test_qga_sync_delimited(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + guint32 v, r = g_random_int(); > + unsigned char c; > + QDict *ret; > + gchar *cmd; > + > + cmd = g_strdup_printf("%c{'execute': 'guest-sync-delimited'," > + " 'arguments': {'id': %u } }", 0xff, r); > + qmp_fd_send(fixture->fd, cmd); > + g_free(cmd); > + > + v = read(fixture->fd, &c, 1); > + g_assert_cmpint(v, ==, 1); > + g_assert_cmpint(c, ==, 0xff); > + > + ret = qmp_fd_receive(fixture->fd); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + > + v = qdict_get_int(ret, "return"); > + g_assert_cmpint(r, ==, v); > + > + QDECREF(ret); > +} > + > +static void test_qga_sync(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + guint32 v, r = g_random_int(); > + QDict *ret; > + gchar *cmd; > + > + cmd = g_strdup_printf("%c{'execute': 'guest-sync'," > + " 'arguments': {'id': %u } }", 0xff, r); > + ret = qmp_fd(fixture->fd, cmd); > + g_free(cmd); > + > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + > + v = qdict_get_int(ret, "return"); > + g_assert_cmpint(r, ==, v); > + > + QDECREF(ret); > +} > + > +static void test_qga_ping(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret; > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + > + QDECREF(ret); > +} > + > +static void test_qga_invalid_cmd(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret, *error; > + const gchar *class, *desc; > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-invalid-cmd'}"); > + g_assert_nonnull(ret); > + > + error = qdict_get_qdict(ret, "error"); > + class = qdict_get_try_str(error, "class"); > + desc = qdict_get_try_str(error, "desc"); > + > + g_assert_cmpstr(class, ==, "CommandNotFound"); > + g_assert_cmpint(strlen(desc), >, 0); > + > + QDECREF(ret); > +} > + > +static void test_qga_info(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret, *val; > + const gchar *version; > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-info'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + > + val = qdict_get_qdict(ret, "return"); > + version = qdict_get_try_str(val, "version"); > + g_assert_cmpstr(version, ==, QEMU_VERSION); > + > + QDECREF(ret); > +} > + > +static void test_qga_get_vcpus(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret; > + QList *list; > + const QListEntry *entry; > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-vcpus'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + > + /* check there is at least a cpu */ > + list = qdict_get_qlist(ret, "return"); > + entry = qlist_first(list); > + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online")); > + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "logical-id")); > + > + QDECREF(ret); > +} > + > +static void test_qga_get_fsinfo(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret; > + QList *list; > + const QListEntry *entry; > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-fsinfo'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + > + /* check there is at least a fs */ > + list = qdict_get_qlist(ret, "return"); > + entry = qlist_first(list); > + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name")); > + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "mountpoint")); > + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "type")); > + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "disk")); > + > + QDECREF(ret); > +} > + > +static void test_qga_get_memory_block_info(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret, *val; > + int64_t size; > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-block-info'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + > + /* check there is at least some memory */ > + val = qdict_get_qdict(ret, "return"); > + size = qdict_get_int(val, "size"); > + g_assert_cmpint(size, >, 0); > + > + QDECREF(ret); > +} > + > +static void test_qga_get_memory_blocks(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret; > + QList *list; > + const QListEntry *entry; > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-blocks'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + > + list = qdict_get_qlist(ret, "return"); > + entry = qlist_first(list); > + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "phys-index")); > + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online")); > + > + QDECREF(ret); > +} > + > +static void test_qga_network_get_interfaces(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret; > + QList *list; > + const QListEntry *entry; > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-network-get-interfaces'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + > + /* check there is at least a cpu */ copy/paste artifact > + list = qdict_get_qlist(ret, "return"); > + entry = qlist_first(list); > + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name")); > + > + QDECREF(ret); > +} > + > +static void test_qga_file_ops(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + gchar *cmd, *path; > + const gchar *b64; > + QDict *ret, *val; > + int64_t id, count, eof; > + FILE *f; > + char tmp[100]; > + > + /* open */ > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open'," > + " 'arguments': { 'path': 'foo', 'mode': 'w+' } }"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + id = qdict_get_int(ret, "return"); > + QDECREF(ret); > + > + /* write */ > + cmd = g_strdup_printf("{'execute': 'guest-file-write'," > + " 'arguments': { 'handle': %" G_GINT64_FORMAT "," > + " 'buf-b64': 'aGVsbG8gd29ybGQK' } }", id); > + ret = qmp_fd(fixture->fd, cmd); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + > + val = qdict_get_qdict(ret, "return"); > + count = qdict_get_int(val, "count"); > + eof = qdict_get_bool(val, "eof"); > + g_assert_cmpint(count, ==, 12); > + g_assert_cmpint(eof, ==, 0); > + QDECREF(ret); > + g_free(cmd); > + > + /* flush */ > + cmd = g_strdup_printf("{'execute': 'guest-file-flush'," > + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }", > + id); > + ret = qmp_fd(fixture->fd, cmd); > + QDECREF(ret); > + g_free(cmd); > + > + /* close */ > + cmd = g_strdup_printf("{'execute': 'guest-file-close'," > + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }", > + id); > + ret = qmp_fd(fixture->fd, cmd); > + QDECREF(ret); > + g_free(cmd); > + > + /* check content */ > + path = g_build_filename(fixture->test_dir, "foo", NULL); > + f = fopen(path, "r"); > + g_assert_nonnull(f); > + count = fread(tmp, 1, sizeof(tmp), f); > + g_assert_cmpint(count, ==, 12); > + tmp[count] = 0; > + g_assert_cmpstr(tmp, ==, "hello world\n"); > + fclose(f); > + > + /* open */ > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open'," > + " 'arguments': { 'path': 'foo', 'mode': 'r' } }"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + id = qdict_get_int(ret, "return"); > + QDECREF(ret); > + > + /* read */ > + cmd = g_strdup_printf("{'execute': 'guest-file-read'," > + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }", > + id); > + ret = qmp_fd(fixture->fd, cmd); > + val = qdict_get_qdict(ret, "return"); > + count = qdict_get_int(val, "count"); > + eof = qdict_get_bool(val, "eof"); > + b64 = qdict_get_str(val, "buf-b64"); > + g_assert_cmpint(count, ==, 12); > + g_assert(eof); > + g_assert_cmpstr(b64, ==, "aGVsbG8gd29ybGQK"); > + > + QDECREF(ret); > + g_free(cmd); > + > + /* read eof */ > + cmd = g_strdup_printf("{'execute': 'guest-file-read'," > + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }", > + id); > + ret = qmp_fd(fixture->fd, cmd); > + val = qdict_get_qdict(ret, "return"); > + count = qdict_get_int(val, "count"); > + eof = qdict_get_bool(val, "eof"); > + b64 = qdict_get_str(val, "buf-b64"); > + g_assert_cmpint(count, ==, 0); > + g_assert(eof); > + g_assert_cmpstr(b64, ==, ""); > + QDECREF(ret); > + g_free(cmd); > + > + /* seek */ > + cmd = g_strdup_printf("{'execute': 'guest-file-seek'," > + " 'arguments': { 'handle': %" G_GINT64_FORMAT ", " > + " 'offset': %d, 'whence': %d } }", > + id, 6, SEEK_SET); > + ret = qmp_fd(fixture->fd, cmd); > + qmp_assert_no_error(ret); > + val = qdict_get_qdict(ret, "return"); > + count = qdict_get_int(val, "position"); > + eof = qdict_get_bool(val, "eof"); > + g_assert_cmpint(count, ==, 6); > + g_assert(!eof); > + QDECREF(ret); > + g_free(cmd); > + > + /* partial read */ > + cmd = g_strdup_printf("{'execute': 'guest-file-read'," > + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }", > + id); > + ret = qmp_fd(fixture->fd, cmd); > + val = qdict_get_qdict(ret, "return"); > + count = qdict_get_int(val, "count"); > + eof = qdict_get_bool(val, "eof"); > + b64 = qdict_get_str(val, "buf-b64"); > + g_assert_cmpint(count, ==, 6); > + g_assert(eof); > + g_assert_cmpstr(b64, ==, "d29ybGQK"); > + > + QDECREF(ret); > + g_free(cmd); > + > + /* close */ > + cmd = g_strdup_printf("{'execute': 'guest-file-close'," > + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }", > + id); > + ret = qmp_fd(fixture->fd, cmd); I like having a complex test to make sure all the guest-file-* commands interact properly, but would be good if we could preceed this with simpler guest-file-* tests that test each command more granularly. That could be added as a follow-up though, since this is still a good test to have. > + QDECREF(ret); > + g_free(cmd); > +} > + > +static void test_qga_get_time(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret; > + int64_t time; > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + > + time = qdict_get_int(ret, "return"); > + g_assert_cmpint(time, >, 0); > + > + QDECREF(ret); > +} > + > +static void test_qga_set_time(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret; > + int64_t current, time; > + gchar *cmd; > + > + /* get current time */ > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + current = qdict_get_int(ret, "return"); > + g_assert_cmpint(current, >, 0); > + QDECREF(ret); > + > + /* set some old time */ > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-set-time'," > + " 'arguments': { 'time': 1000 } }"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + QDECREF(ret); > + > + /* check old time */ > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + time = qdict_get_int(ret, "return"); > + g_assert_cmpint(time / 1000, <, G_USEC_PER_SEC * 10); > + QDECREF(ret); > + > + /* set back current time */ > + cmd = g_strdup_printf("{'execute': 'guest-set-time'," > + " 'arguments': { 'time': %" G_GINT64_FORMAT " } }", > + current + time * 1000); > + ret = qmp_fd(fixture->fd, cmd); Little concerned about playing with host time in our unit tests. Maybe this sort of test should only be enabled if a flag is set, and turned of by default? Ah, I see that's where running_in_virt() comes into play. Nice :) > + g_free(cmd); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + QDECREF(ret); > +} > + > +static void test_qga_fstrim(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret; > + QList *list; > + const QListEntry *entry; > + > + /* get current time */ copy/paste artifact > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fstrim'," > + " arguments: { minimum: 4194304 } }"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + list = qdict_get_qlist(ret, "return"); > + entry = qlist_first(list); > + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "paths")); > + > + QDECREF(ret); > +} > + > +static void test_qga_blacklist(gconstpointer data) > +{ > + TestFixture fix; > + QDict *ret, *error; > + const gchar *class, *desc; > + > + fixture_setup(&fix, "-b guest-ping,guest-get-time"); > + > + /* check blacklist */ > + ret = qmp_fd(fix.fd, "{'execute': 'guest-ping'}"); > + g_assert_nonnull(ret); > + error = qdict_get_qdict(ret, "error"); > + class = qdict_get_try_str(error, "class"); > + desc = qdict_get_try_str(error, "desc"); > + g_assert_cmpstr(class, ==, "GenericError"); > + g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled")); > + QDECREF(ret); > + > + ret = qmp_fd(fix.fd, "{'execute': 'guest-get-time'}"); > + g_assert_nonnull(ret); > + error = qdict_get_qdict(ret, "error"); > + class = qdict_get_try_str(error, "class"); > + desc = qdict_get_try_str(error, "desc"); > + g_assert_cmpstr(class, ==, "GenericError"); > + g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled")); > + QDECREF(ret); > + > + /* check something work */ > + ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}"); > + qmp_assert_no_error(ret); > + QDECREF(ret); > + > + fixture_tear_down(&fix, NULL); > +} > + > +static void test_qga_fsfreeze_status(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret; > + const gchar *status; > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-status'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + > + status = qdict_get_try_str(ret, "return"); > + g_assert_cmpstr(status, ==, "thawed"); > + > + QDECREF(ret); > +} > + > +static void test_qga_fsfreeze_and_thaw(gconstpointer fix) > +{ > + const TestFixture *fixture = fix; > + QDict *ret; > + const gchar *status; > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-freeze'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + QDECREF(ret); > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-status'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + status = qdict_get_try_str(ret, "return"); > + g_assert_cmpstr(status, ==, "frozen"); > + QDECREF(ret); > + > + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-thaw'}"); > + g_assert_nonnull(ret); > + qmp_assert_no_error(ret); > + QDECREF(ret); > +} > + > +static gboolean running_in_virt(const gchar *virt) > +{ > + gchar *virt_what = NULL; > + gint status; > + gboolean success; > + > + success = g_spawn_command_line_sync("virt-what", &virt_what, NULL, > + &status, NULL); > + > + success = success && status == 0 && g_strcmp0(virt_what, virt); > + > + g_free(virt_what); > + > + return success; > +} > +int main(int argc, char **argv) > +{ > + TestFixture fix; > + int ret; > + > + setlocale (LC_ALL, ""); > + g_test_init(&argc, &argv, NULL); > + fixture_setup(&fix, NULL); > + > + g_test_add_data_func("/qga/sync-delimited", &fix, test_qga_sync_delimited); > + g_test_add_data_func("/qga/sync", &fix, test_qga_sync); > + g_test_add_data_func("/qga/ping", &fix, test_qga_ping); > + g_test_add_data_func("/qga/info", &fix, test_qga_info); > + g_test_add_data_func("/qga/network-get-interfaces", &fix, > + test_qga_network_get_interfaces); > + g_test_add_data_func("/qga/get-vcpus", &fix, test_qga_get_vcpus); > + g_test_add_data_func("/qga/get-fsinfo", &fix, test_qga_get_fsinfo); > + g_test_add_data_func("/qga/get-memory-block-info", &fix, > + test_qga_get_memory_block_info); > + g_test_add_data_func("/qga/get-memory-blocks", &fix, > + test_qga_get_memory_blocks); > + g_test_add_data_func("/qga/file-ops", &fix, test_qga_file_ops); > + g_test_add_data_func("/qga/get-time", &fix, test_qga_get_time); > + g_test_add_data_func("/qga/invalid-cmd", &fix, test_qga_invalid_cmd); > + g_test_add_data_func("/qga/fsfreeze-status", &fix, > + test_qga_fsfreeze_status); > + > + g_test_add_data_func("/qga/blacklist", NULL, test_qga_blacklist); > + > + if (running_in_virt("kvm")) { > + g_test_add_data_func("/qga/fsfreeze-and-thaw", &fix, > + test_qga_fsfreeze_and_thaw); > + g_test_add_data_func("/qga/set-time", &fix, test_qga_set_time); > + if (g_test_thorough()) { > + g_test_add_data_func("/qga/fstrim", &fix, test_qga_fstrim); > + } > + } > + > + ret = g_test_run(); > + > + fixture_tear_down(&fix, NULL); > + > + return ret; > +} > -- > 2.4.3 > ^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent 2015-09-09 21:53 ` Michael Roth @ 2015-09-11 17:46 ` Marc-André Lureau 0 siblings, 0 replies; 7+ messages in thread From: Marc-André Lureau @ 2015-09-11 17:46 UTC (permalink / raw) To: Michael Roth; +Cc: QEMU Hi On Wed, Sep 9, 2015 at 11:53 PM, Michael Roth <mdroth@linux.vnet.ibm.com> wrote: > Quoting marcandre.lureau@redhat.com (2015-08-27 05:52:07) >> From: Marc-André Lureau <marcandre.lureau@redhat.com> >> >> Add some local guest agent tests (as it is better than nothing). >> >> They can be run inside or outside a VM, when run inside a VM, they will >> do a bit more side effects, such as freezing/thawing the FS or changing >> the time. >> >> A better test would involve a managed VM (or container), but it might be >> better to leave that off to autotest/avocado. >> >> Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com> >> --- >> tests/Makefile | 3 + >> tests/test-qga.c | 686 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ >> 2 files changed, 689 insertions(+) >> create mode 100644 tests/test-qga.c >> >> diff --git a/tests/Makefile b/tests/Makefile >> index 5271123..35671a1 100644 >> --- a/tests/Makefile >> +++ b/tests/Makefile >> @@ -76,6 +76,7 @@ check-unit-y += tests/test-write-threshold$(EXESUF) >> gcov-files-test-write-threshold-y = block/write-threshold.c >> check-unit-$(CONFIG_GNUTLS_HASH) += tests/test-crypto-hash$(EXESUF) >> check-unit-y += tests/test-crypto-cipher$(EXESUF) >> +check-unit-y += tests/test-qga$(EXESUF) >> >> check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh >> >> @@ -425,6 +426,8 @@ endif >> qtest-obj-y = tests/libqtest.o libqemuutil.a libqemustub.a >> $(check-qtest-y): $(qtest-obj-y) >> >> +tests/test-qga: tests/test-qga.o $(qtest-obj-y) >> + >> .PHONY: check-help >> check-help: >> @echo "Regression testing targets:" >> diff --git a/tests/test-qga.c b/tests/test-qga.c >> new file mode 100644 >> index 0000000..1fb58ec >> --- /dev/null >> +++ b/tests/test-qga.c >> @@ -0,0 +1,686 @@ >> +#include <locale.h> >> +#include <glib.h> >> +#include <glib/gstdio.h> >> +#include <stdio.h> >> +#include <stdlib.h> >> +#include <errno.h> >> +#include <string.h> >> +#include <sys/types.h> >> +#include <sys/socket.h> >> +#include <sys/un.h> >> +#include <unistd.h> >> + >> +#include "libqtest.h" >> +#include "config-host.h" >> + >> +typedef struct { >> + char *test_dir; >> + GMainLoop *loop; >> + int fd; >> + GPid pid; >> +} TestFixture; >> + >> +static int connect_qga(char *path) >> +{ >> + int s, ret, len; >> + struct sockaddr_un remote; >> + >> + s = socket(AF_UNIX, SOCK_STREAM, 0); >> + g_assert(s != -1); >> + >> + remote.sun_family = AF_UNIX; >> + do { >> + strcpy(remote.sun_path, path); >> + len = strlen(remote.sun_path) + sizeof(remote.sun_family); >> + ret = connect(s, (struct sockaddr *)&remote, len); >> + if (ret == -1) { >> + g_usleep(G_USEC_PER_SEC); >> + } >> + } while (ret == -1); > > I think we should loop on ECONNREFUSED (or whatever corresponds to > the socket not yet being created/bound), and the usual suspects > like EINTR. If it's anything else I don't think we'd want this to > loop indefinitely. You get ENOENT while qga starts. I will just give up after 5 tries instead. >> + >> + return s; >> +} >> + >> +static void qga_watch(GPid pid, gint status, gpointer user_data) >> +{ >> + TestFixture *fixture = user_data; >> + >> + g_assert_cmpint(status, ==, 0); >> + g_main_loop_quit(fixture->loop); >> +} >> + >> +static void >> +fixture_setup(TestFixture *fixture, gconstpointer data) >> +{ >> + const gchar *extra_arg = data; >> + GError *error = NULL; >> + gchar *cwd, *path, *cmd, **argv = NULL; >> + >> + fixture->loop = g_main_loop_new(NULL, FALSE); >> + >> + fixture->test_dir = g_strdup("/tmp/qgatest.XXXXXX"); >> + g_assert_nonnull(g_mkdtemp(fixture->test_dir)); >> + >> + path = g_build_filename(fixture->test_dir, "sock", NULL); >> + cwd = g_get_current_dir(); >> + cmd = g_strdup_printf("%s%cqemu-ga -m unix-listen -t %s -p %s %s %s", > > Would be nice if we could also run qemu-ga.exe for a w32 build with > binfmt set up like some of the other tests, but no idea how we'd get > at it through wine. I guess it would have to be a serial connection > or something... > > Probably too environment-specific for a useful unit test. I guess in > the future we could plumb in custom qemu-ga invocation/script that > does some extra setup on the backend (VM/container/wine) and exposes > that via a local socket like we'd get via -chardev. Perhaps it would be just too much at this point for a make check test, better to leave that to autotest etc. At this point, I propose we make it check-unit-$(CONFIG_LINUX). > >> + cwd, G_DIR_SEPARATOR, >> + fixture->test_dir, path, >> + getenv("QTEST_LOG") ? "-v" : "", >> + extra_arg ?: ""); >> + g_shell_parse_argv(cmd, NULL, &argv, &error); >> + g_assert_no_error(error); >> + >> + g_spawn_async(fixture->test_dir, argv, NULL, >> + G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD, >> + NULL, NULL, &fixture->pid, &error); >> + g_assert_no_error(error); >> + >> + g_child_watch_add(fixture->pid, qga_watch, fixture); >> + >> + fixture->fd = connect_qga(path); >> + >> + g_strfreev(argv); >> + g_free(cmd); >> + g_free(cwd); >> + g_free(path); >> +} >> + >> +static void >> +fixture_tear_down(TestFixture *fixture, gconstpointer data) >> +{ >> + gchar *tmp; >> + >> + kill(fixture->pid, SIGTERM); >> + >> + g_main_loop_run(fixture->loop); >> + g_main_loop_unref(fixture->loop); >> + >> + g_spawn_close_pid(fixture->pid); >> + >> + tmp = g_build_filename(fixture->test_dir, "foo", NULL); >> + g_unlink(tmp); >> + g_free(tmp); > > Shouldn't the individual unit tests clean these up? I think a flag > determining whether or not we're running locally (set by default > obviously) would be useful for determining whether it makes sense > for us to clean them up or not. I started writing tests using test_add(), so qga would be started for each tests, but the overhead was unnecessary. So it's just final cleanup now. > >> + >> + tmp = g_build_filename(fixture->test_dir, "qga.state", NULL); >> + g_unlink(tmp); >> + g_free(tmp); >> + >> + tmp = g_build_filename(fixture->test_dir, "sock", NULL); >> + g_unlink(tmp); >> + g_free(tmp); >> + >> + g_rmdir(fixture->test_dir); >> + g_free(fixture->test_dir); >> +} >> + >> +static void qmp_assertion_message_error(const char *domain, >> + const char *file, >> + int line, >> + const char *func, >> + const char *expr, >> + QDict *dict) >> +{ >> + const char *class, *desc; >> + char *s; >> + QDict *error; >> + >> + error = qdict_get_qdict(dict, "error"); >> + class = qdict_get_try_str(error, "class"); >> + desc = qdict_get_try_str(error, "desc"); >> + >> + s = g_strdup_printf("assertion failed %s: %s %s", expr, class, desc); >> + g_assertion_message(domain, file, line, func, s); >> + g_free(s); >> +} >> + >> +#define qmp_assert_no_error(err) do { \ >> + if (qdict_haskey(err, "error")) { \ >> + qmp_assertion_message_error(G_LOG_DOMAIN, __FILE__, __LINE__, \ >> + G_STRFUNC, #err, err); \ >> + } \ >> +} while (0) >> + >> +static void test_qga_sync_delimited(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + guint32 v, r = g_random_int(); >> + unsigned char c; >> + QDict *ret; >> + gchar *cmd; >> + >> + cmd = g_strdup_printf("%c{'execute': 'guest-sync-delimited'," >> + " 'arguments': {'id': %u } }", 0xff, r); >> + qmp_fd_send(fixture->fd, cmd); >> + g_free(cmd); >> + >> + v = read(fixture->fd, &c, 1); >> + g_assert_cmpint(v, ==, 1); >> + g_assert_cmpint(c, ==, 0xff); >> + >> + ret = qmp_fd_receive(fixture->fd); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + >> + v = qdict_get_int(ret, "return"); >> + g_assert_cmpint(r, ==, v); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_sync(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + guint32 v, r = g_random_int(); >> + QDict *ret; >> + gchar *cmd; >> + >> + cmd = g_strdup_printf("%c{'execute': 'guest-sync'," >> + " 'arguments': {'id': %u } }", 0xff, r); >> + ret = qmp_fd(fixture->fd, cmd); >> + g_free(cmd); >> + >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + >> + v = qdict_get_int(ret, "return"); >> + g_assert_cmpint(r, ==, v); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_ping(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret; >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_invalid_cmd(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret, *error; >> + const gchar *class, *desc; >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-invalid-cmd'}"); >> + g_assert_nonnull(ret); >> + >> + error = qdict_get_qdict(ret, "error"); >> + class = qdict_get_try_str(error, "class"); >> + desc = qdict_get_try_str(error, "desc"); >> + >> + g_assert_cmpstr(class, ==, "CommandNotFound"); >> + g_assert_cmpint(strlen(desc), >, 0); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_info(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret, *val; >> + const gchar *version; >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-info'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + >> + val = qdict_get_qdict(ret, "return"); >> + version = qdict_get_try_str(val, "version"); >> + g_assert_cmpstr(version, ==, QEMU_VERSION); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_get_vcpus(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret; >> + QList *list; >> + const QListEntry *entry; >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-vcpus'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + >> + /* check there is at least a cpu */ >> + list = qdict_get_qlist(ret, "return"); >> + entry = qlist_first(list); >> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online")); >> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "logical-id")); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_get_fsinfo(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret; >> + QList *list; >> + const QListEntry *entry; >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-fsinfo'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + >> + /* check there is at least a fs */ >> + list = qdict_get_qlist(ret, "return"); >> + entry = qlist_first(list); >> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name")); >> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "mountpoint")); >> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "type")); >> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "disk")); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_get_memory_block_info(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret, *val; >> + int64_t size; >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-block-info'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + >> + /* check there is at least some memory */ >> + val = qdict_get_qdict(ret, "return"); >> + size = qdict_get_int(val, "size"); >> + g_assert_cmpint(size, >, 0); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_get_memory_blocks(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret; >> + QList *list; >> + const QListEntry *entry; >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-blocks'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + >> + list = qdict_get_qlist(ret, "return"); >> + entry = qlist_first(list); >> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "phys-index")); >> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online")); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_network_get_interfaces(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret; >> + QList *list; >> + const QListEntry *entry; >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-network-get-interfaces'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + >> + /* check there is at least a cpu */ > > copy/paste artifact > >> + list = qdict_get_qlist(ret, "return"); >> + entry = qlist_first(list); >> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name")); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_file_ops(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + gchar *cmd, *path; >> + const gchar *b64; >> + QDict *ret, *val; >> + int64_t id, count, eof; >> + FILE *f; >> + char tmp[100]; >> + >> + /* open */ >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open'," >> + " 'arguments': { 'path': 'foo', 'mode': 'w+' } }"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + id = qdict_get_int(ret, "return"); >> + QDECREF(ret); >> + >> + /* write */ >> + cmd = g_strdup_printf("{'execute': 'guest-file-write'," >> + " 'arguments': { 'handle': %" G_GINT64_FORMAT "," >> + " 'buf-b64': 'aGVsbG8gd29ybGQK' } }", id); >> + ret = qmp_fd(fixture->fd, cmd); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + >> + val = qdict_get_qdict(ret, "return"); >> + count = qdict_get_int(val, "count"); >> + eof = qdict_get_bool(val, "eof"); >> + g_assert_cmpint(count, ==, 12); >> + g_assert_cmpint(eof, ==, 0); >> + QDECREF(ret); >> + g_free(cmd); >> + >> + /* flush */ >> + cmd = g_strdup_printf("{'execute': 'guest-file-flush'," >> + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }", >> + id); >> + ret = qmp_fd(fixture->fd, cmd); >> + QDECREF(ret); >> + g_free(cmd); >> + >> + /* close */ >> + cmd = g_strdup_printf("{'execute': 'guest-file-close'," >> + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }", >> + id); >> + ret = qmp_fd(fixture->fd, cmd); >> + QDECREF(ret); >> + g_free(cmd); >> + >> + /* check content */ >> + path = g_build_filename(fixture->test_dir, "foo", NULL); >> + f = fopen(path, "r"); >> + g_assert_nonnull(f); >> + count = fread(tmp, 1, sizeof(tmp), f); >> + g_assert_cmpint(count, ==, 12); >> + tmp[count] = 0; >> + g_assert_cmpstr(tmp, ==, "hello world\n"); >> + fclose(f); >> + >> + /* open */ >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open'," >> + " 'arguments': { 'path': 'foo', 'mode': 'r' } }"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + id = qdict_get_int(ret, "return"); >> + QDECREF(ret); >> + >> + /* read */ >> + cmd = g_strdup_printf("{'execute': 'guest-file-read'," >> + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }", >> + id); >> + ret = qmp_fd(fixture->fd, cmd); >> + val = qdict_get_qdict(ret, "return"); >> + count = qdict_get_int(val, "count"); >> + eof = qdict_get_bool(val, "eof"); >> + b64 = qdict_get_str(val, "buf-b64"); >> + g_assert_cmpint(count, ==, 12); >> + g_assert(eof); >> + g_assert_cmpstr(b64, ==, "aGVsbG8gd29ybGQK"); >> + >> + QDECREF(ret); >> + g_free(cmd); >> + >> + /* read eof */ >> + cmd = g_strdup_printf("{'execute': 'guest-file-read'," >> + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }", >> + id); >> + ret = qmp_fd(fixture->fd, cmd); >> + val = qdict_get_qdict(ret, "return"); >> + count = qdict_get_int(val, "count"); >> + eof = qdict_get_bool(val, "eof"); >> + b64 = qdict_get_str(val, "buf-b64"); >> + g_assert_cmpint(count, ==, 0); >> + g_assert(eof); >> + g_assert_cmpstr(b64, ==, ""); >> + QDECREF(ret); >> + g_free(cmd); >> + >> + /* seek */ >> + cmd = g_strdup_printf("{'execute': 'guest-file-seek'," >> + " 'arguments': { 'handle': %" G_GINT64_FORMAT ", " >> + " 'offset': %d, 'whence': %d } }", >> + id, 6, SEEK_SET); >> + ret = qmp_fd(fixture->fd, cmd); >> + qmp_assert_no_error(ret); >> + val = qdict_get_qdict(ret, "return"); >> + count = qdict_get_int(val, "position"); >> + eof = qdict_get_bool(val, "eof"); >> + g_assert_cmpint(count, ==, 6); >> + g_assert(!eof); >> + QDECREF(ret); >> + g_free(cmd); >> + >> + /* partial read */ >> + cmd = g_strdup_printf("{'execute': 'guest-file-read'," >> + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }", >> + id); >> + ret = qmp_fd(fixture->fd, cmd); >> + val = qdict_get_qdict(ret, "return"); >> + count = qdict_get_int(val, "count"); >> + eof = qdict_get_bool(val, "eof"); >> + b64 = qdict_get_str(val, "buf-b64"); >> + g_assert_cmpint(count, ==, 6); >> + g_assert(eof); >> + g_assert_cmpstr(b64, ==, "d29ybGQK"); >> + >> + QDECREF(ret); >> + g_free(cmd); >> + >> + /* close */ >> + cmd = g_strdup_printf("{'execute': 'guest-file-close'," >> + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }", >> + id); >> + ret = qmp_fd(fixture->fd, cmd); > > I like having a complex test to make sure all the guest-file-* commands > interact properly, but would be good if we could preceed this with > simpler guest-file-* tests that test each command more granularly. > > That could be added as a follow-up though, since this is still a good > test to have. Ok, I'll leave this for now > >> + QDECREF(ret); >> + g_free(cmd); >> +} >> + >> +static void test_qga_get_time(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret; >> + int64_t time; >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + >> + time = qdict_get_int(ret, "return"); >> + g_assert_cmpint(time, >, 0); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_set_time(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret; >> + int64_t current, time; >> + gchar *cmd; >> + >> + /* get current time */ >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + current = qdict_get_int(ret, "return"); >> + g_assert_cmpint(current, >, 0); >> + QDECREF(ret); >> + >> + /* set some old time */ >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-set-time'," >> + " 'arguments': { 'time': 1000 } }"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + QDECREF(ret); >> + >> + /* check old time */ >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + time = qdict_get_int(ret, "return"); >> + g_assert_cmpint(time / 1000, <, G_USEC_PER_SEC * 10); >> + QDECREF(ret); >> + >> + /* set back current time */ >> + cmd = g_strdup_printf("{'execute': 'guest-set-time'," >> + " 'arguments': { 'time': %" G_GINT64_FORMAT " } }", >> + current + time * 1000); >> + ret = qmp_fd(fixture->fd, cmd); > > Little concerned about playing with host time in our unit tests. Maybe > this sort of test should only be enabled if a flag is set, and turned > of by default? > > Ah, I see that's where running_in_virt() comes into play. Nice :) Yes, but what are the odds to run the qga test on kvm guest with root privileges? so I think it's fairly safe and still useful. > >> + g_free(cmd); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + QDECREF(ret); >> +} >> + >> +static void test_qga_fstrim(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret; >> + QList *list; >> + const QListEntry *entry; >> + >> + /* get current time */ > > copy/paste artifact correct, removed > >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fstrim'," >> + " arguments: { minimum: 4194304 } }"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + list = qdict_get_qlist(ret, "return"); >> + entry = qlist_first(list); >> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "paths")); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_blacklist(gconstpointer data) >> +{ >> + TestFixture fix; >> + QDict *ret, *error; >> + const gchar *class, *desc; >> + >> + fixture_setup(&fix, "-b guest-ping,guest-get-time"); >> + >> + /* check blacklist */ >> + ret = qmp_fd(fix.fd, "{'execute': 'guest-ping'}"); >> + g_assert_nonnull(ret); >> + error = qdict_get_qdict(ret, "error"); >> + class = qdict_get_try_str(error, "class"); >> + desc = qdict_get_try_str(error, "desc"); >> + g_assert_cmpstr(class, ==, "GenericError"); >> + g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled")); >> + QDECREF(ret); >> + >> + ret = qmp_fd(fix.fd, "{'execute': 'guest-get-time'}"); >> + g_assert_nonnull(ret); >> + error = qdict_get_qdict(ret, "error"); >> + class = qdict_get_try_str(error, "class"); >> + desc = qdict_get_try_str(error, "desc"); >> + g_assert_cmpstr(class, ==, "GenericError"); >> + g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled")); >> + QDECREF(ret); >> + >> + /* check something work */ >> + ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}"); >> + qmp_assert_no_error(ret); >> + QDECREF(ret); >> + >> + fixture_tear_down(&fix, NULL); >> +} >> + >> +static void test_qga_fsfreeze_status(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret; >> + const gchar *status; >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-status'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + >> + status = qdict_get_try_str(ret, "return"); >> + g_assert_cmpstr(status, ==, "thawed"); >> + >> + QDECREF(ret); >> +} >> + >> +static void test_qga_fsfreeze_and_thaw(gconstpointer fix) >> +{ >> + const TestFixture *fixture = fix; >> + QDict *ret; >> + const gchar *status; >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-freeze'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + QDECREF(ret); >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-status'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + status = qdict_get_try_str(ret, "return"); >> + g_assert_cmpstr(status, ==, "frozen"); >> + QDECREF(ret); >> + >> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-thaw'}"); >> + g_assert_nonnull(ret); >> + qmp_assert_no_error(ret); >> + QDECREF(ret); >> +} >> + >> +static gboolean running_in_virt(const gchar *virt) >> +{ >> + gchar *virt_what = NULL; >> + gint status; >> + gboolean success; >> + >> + success = g_spawn_command_line_sync("virt-what", &virt_what, NULL, >> + &status, NULL); >> + >> + success = success && status == 0 && g_strcmp0(virt_what, virt); >> + >> + g_free(virt_what); >> + >> + return success; >> +} >> +int main(int argc, char **argv) >> +{ >> + TestFixture fix; >> + int ret; >> + >> + setlocale (LC_ALL, ""); >> + g_test_init(&argc, &argv, NULL); >> + fixture_setup(&fix, NULL); >> + >> + g_test_add_data_func("/qga/sync-delimited", &fix, test_qga_sync_delimited); >> + g_test_add_data_func("/qga/sync", &fix, test_qga_sync); >> + g_test_add_data_func("/qga/ping", &fix, test_qga_ping); >> + g_test_add_data_func("/qga/info", &fix, test_qga_info); >> + g_test_add_data_func("/qga/network-get-interfaces", &fix, >> + test_qga_network_get_interfaces); >> + g_test_add_data_func("/qga/get-vcpus", &fix, test_qga_get_vcpus); >> + g_test_add_data_func("/qga/get-fsinfo", &fix, test_qga_get_fsinfo); >> + g_test_add_data_func("/qga/get-memory-block-info", &fix, >> + test_qga_get_memory_block_info); >> + g_test_add_data_func("/qga/get-memory-blocks", &fix, >> + test_qga_get_memory_blocks); >> + g_test_add_data_func("/qga/file-ops", &fix, test_qga_file_ops); >> + g_test_add_data_func("/qga/get-time", &fix, test_qga_get_time); >> + g_test_add_data_func("/qga/invalid-cmd", &fix, test_qga_invalid_cmd); >> + g_test_add_data_func("/qga/fsfreeze-status", &fix, >> + test_qga_fsfreeze_status); >> + >> + g_test_add_data_func("/qga/blacklist", NULL, test_qga_blacklist); >> + >> + if (running_in_virt("kvm")) { >> + g_test_add_data_func("/qga/fsfreeze-and-thaw", &fix, >> + test_qga_fsfreeze_and_thaw); >> + g_test_add_data_func("/qga/set-time", &fix, test_qga_set_time); >> + if (g_test_thorough()) { >> + g_test_add_data_func("/qga/fstrim", &fix, test_qga_fstrim); >> + } >> + } >> + >> + ret = g_test_run(); >> + >> + fixture_tear_down(&fix, NULL); >> + >> + return ret; >> +} >> -- >> 2.4.3 >> > > thanks -- Marc-André Lureau ^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers 2015-08-27 10:52 [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers marcandre.lureau 2015-08-27 10:52 ` [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent marcandre.lureau @ 2015-09-09 20:05 ` Michael Roth 1 sibling, 0 replies; 7+ messages in thread From: Michael Roth @ 2015-09-09 20:05 UTC (permalink / raw) To: marcandre.lureau, qemu-devel Quoting marcandre.lureau@redhat.com (2015-08-27 05:52:06) > From: Marc-André Lureau <marcandre.lureau@redhat.com> > > Add a few functions to interact with qmp via a simple fd. > > Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com> Reviewed-by: Michael Roth <mdroth@linux.vnet.ibm.com> > --- > tests/libqtest.c | 45 +++++++++++++++++++++++++++++++++++++++++---- > tests/libqtest.h | 7 +++++++ > 2 files changed, 48 insertions(+), 4 deletions(-) > > diff --git a/tests/libqtest.c b/tests/libqtest.c > index e5188e0..11e541d 100644 > --- a/tests/libqtest.c > +++ b/tests/libqtest.c > @@ -357,7 +357,7 @@ static void qmp_response(JSONMessageParser *parser, QList *tokens) > qmp->response = (QDict *)obj; > } > > -QDict *qtest_qmp_receive(QTestState *s) > +QDict *qmp_fd_receive(int fd) > { > QMPResponseParser qmp; > bool log = getenv("QTEST_LOG") != NULL; > @@ -368,7 +368,7 @@ QDict *qtest_qmp_receive(QTestState *s) > ssize_t len; > char c; > > - len = read(s->qmp_fd, &c, 1); > + len = read(fd, &c, 1); > if (len == -1 && errno == EINTR) { > continue; > } > @@ -388,12 +388,17 @@ QDict *qtest_qmp_receive(QTestState *s) > return qmp.response; > } > > +QDict *qtest_qmp_receive(QTestState *s) > +{ > + return qmp_fd_receive(s->qmp_fd); > +} > + > /** > * Allow users to send a message without waiting for the reply, > * in the case that they choose to discard all replies up until > * a particular EVENT is received. > */ > -void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap) > +void qmp_fd_sendv(int fd, const char *fmt, va_list ap) > { > va_list ap_copy; > QObject *qobj; > @@ -417,13 +422,25 @@ void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap) > fprintf(stderr, "%s", str); > } > /* Send QMP request */ > - socket_send(s->qmp_fd, str, size); > + socket_send(fd, str, size); > > QDECREF(qstr); > qobject_decref(qobj); > } > } > > +void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap) > +{ > + qmp_fd_sendv(s->qmp_fd, fmt, ap); > +} > + > +QDict *qmp_fdv(int fd, const char *fmt, va_list ap) > +{ > + qmp_fd_sendv(fd, fmt, ap); > + > + return qmp_fd_receive(fd); > +} > + > QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap) > { > qtest_async_qmpv(s, fmt, ap); > @@ -432,6 +449,26 @@ QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap) > return qtest_qmp_receive(s); > } > > +QDict *qmp_fd(int fd, const char *fmt, ...) > +{ > + va_list ap; > + QDict *response; > + > + va_start(ap, fmt); > + response = qmp_fdv(fd, fmt, ap); > + va_end(ap); > + return response; > +} > + > +void qmp_fd_send(int fd, const char *fmt, ...) > +{ > + va_list ap; > + > + va_start(ap, fmt); > + qmp_fd_sendv(fd, fmt, ap); > + va_end(ap); > +} > + > QDict *qtest_qmp(QTestState *s, const char *fmt, ...) > { > va_list ap; > diff --git a/tests/libqtest.h b/tests/libqtest.h > index ec42031..ecd9872 100644 > --- a/tests/libqtest.h > +++ b/tests/libqtest.h > @@ -818,4 +818,11 @@ static inline int64_t clock_set(int64_t val) > */ > bool qtest_big_endian(void); > > + > +QDict *qmp_fd_receive(int fd); > +void qmp_fd_sendv(int fd, const char *fmt, va_list ap); > +void qmp_fd_send(int fd, const char *fmt, ...); > +QDict *qmp_fdv(int fd, const char *fmt, va_list ap); > +QDict *qmp_fd(int fd, const char *fmt, ...); > + > #endif > -- > 2.4.3 > > ^ permalink raw reply [flat|nested] 7+ messages in thread
end of thread, other threads:[~2015-09-11 17:46 UTC | newest] Thread overview: 7+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2015-08-27 10:52 [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers marcandre.lureau 2015-08-27 10:52 ` [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent marcandre.lureau 2015-08-27 11:36 ` Marc-André Lureau 2015-09-09 17:36 ` Michael Roth 2015-09-09 21:53 ` Michael Roth 2015-09-11 17:46 ` Marc-André Lureau 2015-09-09 20:05 ` [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers Michael Roth
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).