[libsoup/carlosgc/unskip-tests: 2/2] timeout-test: port the new API and unskip it

[Carlos Garcia Campos <carlosgc src gnome org>]

commit 0ec80e2958ad5d2f68dc36da89aba81268ac5dca
Author: Carlos Garcia Campos <cgarcia igalia com>
Date:   Wed Feb 24 13:17:11 2021 +0100

    timeout-test: port the new API and unskip it

 tests/timeout-test.c | 74 ++++++++++++++++++++++++----------------------------
 1 file changed, 34 insertions(+), 40 deletions(-)
---
diff --git a/tests/timeout-test.c b/tests/timeout-test.c
index d04fcd37..20dbc509 100644
--- a/tests/timeout-test.c
+++ b/tests/timeout-test.c
@@ -3,10 +3,10 @@
 #include "test-utils.h"
 #include "soup-message-private.h"
 #include "soup-connection.h"
+#include "soup-uri-utils-private.h"
 
 static gboolean slow_https;
 
-#if 0
 static void
 message_finished (SoupMessage *msg, gpointer user_data)
 {
@@ -16,21 +16,32 @@ message_finished (SoupMessage *msg, gpointer user_data)
 }
 
 static void
-request_started_cb (SoupSession *session, SoupMessage *msg, gpointer user_data)
+message_starting_cb (SoupMessage *msg,
+                    GSocket    **ret)
 {
-       GSocket **ret = user_data;
         SoupConnection *conn = soup_message_get_connection (msg);
 
        *ret = soup_connection_get_socket (conn);
 }
 
+static void
+request_queued_cb (SoupSession *session,
+                  SoupMessage *msg,
+                  GSocket    **ret)
+{
+       g_signal_connect (msg, "starting",
+                         G_CALLBACK (message_starting_cb),
+                         ret);
+}
 
 static void
 do_message_to_session (SoupSession *session, GUri *uri,
                       const char *comment, guint expected_status)
 {
        SoupMessage *msg;
+       GBytes *body;
        gboolean finished = FALSE;
+       GError *error = NULL;
 
        if (comment)
                debug_printf (1, "    msg %s\n", comment);
@@ -38,18 +49,22 @@ do_message_to_session (SoupSession *session, GUri *uri,
 
        g_signal_connect (msg, "finished",
                          G_CALLBACK (message_finished), &finished);
-#if 0
-       soup_test_session_async_send_message (session, msg, NULL);
-#endif
 
-       soup_test_assert_message_status (msg, expected_status);
-       if (SOUP_STATUS_IS_SUCCESSFUL (soup_message_get_status (msg)))
+       body = soup_test_session_async_send (session, msg, NULL, &error);
+       if (expected_status != SOUP_STATUS_NONE) {
+               g_assert_no_error (error);
+               soup_test_assert_message_status (msg, expected_status);
                g_assert_true (soup_message_is_keepalive (msg));
+       } else {
+               g_assert_error (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT);
+       }
+       g_clear_error (&error);
        g_assert_true (finished);
 
        g_signal_handlers_disconnect_by_func (msg,
                                              G_CALLBACK (message_finished),
                                              &finished);
+       g_clear_pointer (&body, g_bytes_unref);
        g_object_unref (msg);
 }
 
@@ -64,29 +79,27 @@ do_msg_tests_for_session (SoupSession *timeout_session,
        GSocket *plain_first = NULL, *plain_second;
 
        if (idle_session) {
-               g_signal_connect (idle_session, "request-started",
-                                 G_CALLBACK (request_started_cb), &ret);
+               g_signal_connect (idle_session, "request-queued",
+                                 G_CALLBACK (request_queued_cb), &ret);
                do_message_to_session (idle_session, fast_uri, "fast to idle", SOUP_STATUS_OK);
                idle_first = g_object_ref (ret);
        }
 
        if (plain_session) {
-               g_signal_connect (plain_session, "request-started",
-                                 G_CALLBACK (request_started_cb), &ret);
+               g_signal_connect (plain_session, "request-queued",
+                                 G_CALLBACK (request_queued_cb), &ret);
                do_message_to_session (plain_session, fast_uri, "fast to plain", SOUP_STATUS_OK);
                plain_first = g_object_ref (ret);
        }
 
        do_message_to_session (timeout_session, fast_uri, "fast to timeout", SOUP_STATUS_OK);
-#if 0
-       do_message_to_session (timeout_session, slow_uri, "slow to timeout", SOUP_STATUS_IO_ERROR);
-#endif
+       do_message_to_session (timeout_session, slow_uri, "slow to timeout", SOUP_STATUS_NONE);
 
        if (idle_session) {
                do_message_to_session (idle_session, fast_uri, "fast to idle", SOUP_STATUS_OK);
                idle_second = ret;
                g_signal_handlers_disconnect_by_func (idle_session,
-                                                     (gpointer)request_started_cb,
+                                                     (gpointer)request_queued_cb,
                                                      &ret);
 
                soup_test_assert (idle_first != idle_second,
@@ -98,7 +111,7 @@ do_msg_tests_for_session (SoupSession *timeout_session,
                do_message_to_session (plain_session, fast_uri, "fast to plain", SOUP_STATUS_OK);
                plain_second = ret;
                g_signal_handlers_disconnect_by_func (plain_session,
-                                                     (gpointer)request_started_cb,
+                                                     (gpointer)request_queued_cb,
                                                      &ret);
 
                soup_test_assert (plain_first == plain_second,
@@ -106,37 +119,28 @@ do_msg_tests_for_session (SoupSession *timeout_session,
                g_object_unref (plain_first);
        }
 }
-#endif
 
 static void
 do_async_timeout_tests (gconstpointer data)
 {
-       g_test_skip ("FIXME");
-       return;
-#if 0
        SoupSession *timeout_session, *idle_session, *plain_session;
        GUri *fast_uri = (GUri *)data;
        GUri *slow_uri = g_uri_parse_relative (fast_uri, "/slow", SOUP_HTTP_URI_FLAGS, NULL);
        gboolean extra_slow;
 
-
-
        if (soup_uri_is_https (fast_uri)) {
                SOUP_TEST_SKIP_IF_NO_TLS;
                extra_slow = slow_https;
        } else
                extra_slow = FALSE;
 
-       timeout_session = soup_test_session_new ("timeout", extra_slow ? 3 : 1,
-                                                NULL);
-       idle_session = soup_test_session_new ("idle-timeout", extra_slow ? 2 : 1,
-                                             NULL);
+       timeout_session = soup_test_session_new ("timeout", extra_slow ? 3 : 1, NULL);
+       idle_session = soup_test_session_new ("idle-timeout", extra_slow ? 2 : 1, NULL);
        /* The "plain" session also has an idle timeout, but it's longer
         * than the test takes, so for our purposes it should behave like
         * it has no timeout.
         */
-       plain_session = soup_test_session_new ("idle-timeout", 20,
-                                              NULL);
+       plain_session = soup_test_session_new ("idle-timeout", 20, NULL);
 
        do_msg_tests_for_session (timeout_session, idle_session, plain_session,
                                  fast_uri, slow_uri);
@@ -145,22 +149,16 @@ do_async_timeout_tests (gconstpointer data)
        soup_test_session_abort_unref (plain_session);
 
        g_uri_unref (slow_uri);
-#endif
 }
 
 static void
 do_sync_timeout_tests (gconstpointer data)
 {
-        g_test_skip ("FIXME");
-       return;
-#if 0
        SoupSession *timeout_session, *plain_session;
        GUri *fast_uri = (GUri *)data;
        GUri *slow_uri = g_uri_parse_relative (fast_uri, "/slow", SOUP_HTTP_URI_FLAGS, NULL);
        gboolean extra_slow;
 
-
-
        if (soup_uri_is_https (fast_uri)) {
                SOUP_TEST_SKIP_IF_NO_TLS;
 
@@ -168,8 +166,7 @@ do_sync_timeout_tests (gconstpointer data)
        } else
                extra_slow = FALSE;
 
-       timeout_session = soup_test_session_new ("timeout", extra_slow ? 3 : 1,
-                                                NULL);
+       timeout_session = soup_test_session_new ("timeout", extra_slow ? 3 : 1, NULL);
        /* SoupSession:timeout doesn't work with sync sessions */
        plain_session = soup_test_session_new (NULL);
        do_msg_tests_for_session (timeout_session, NULL, plain_session, fast_uri, slow_uri);
@@ -177,7 +174,6 @@ do_sync_timeout_tests (gconstpointer data)
        soup_test_session_abort_unref (plain_session);
 
        g_uri_unref (slow_uri);
-#endif
 }
 
 static gboolean
@@ -235,9 +231,7 @@ main (int argc, char **argv)
                /* The 1-second timeouts are too fast for some machines... */
                test_session = soup_test_session_new (NULL);
                start = g_get_monotonic_time ();
-#if 0
                do_message_to_session (test_session, uri, NULL, SOUP_STATUS_OK);
-#endif
                end = g_get_monotonic_time ();
                soup_test_session_abort_unref (test_session);
                debug_printf (2, "  (https request took %0.3fs)\n", (end - start) / 1000000.0);