static GByteArray * do_single_coding_req_test (SoupRequest *req, const char *expected_encoding, const char *expected_content_type, MessageContentStatus status) { GInputStream *stream; SoupMessage *msg; GByteArray *data; guchar buf[1024]; gssize nread; GError *error = NULL; data = g_byte_array_new (); msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req)); stream = soup_test_request_send (req, NULL, &error); if (error) { debug_printf (1, " Error sending request: %s\n", error->message); g_error_free (error); errors++; return data; } do { nread = -2; g_input_stream_read_async (stream, buf, sizeof (buf), G_PRIORITY_DEFAULT, NULL, read_finished, &nread); while (nread == -2) g_main_context_iteration (NULL, TRUE); if (nread > 0) g_byte_array_append (data, buf, nread); } while (nread > 0); soup_test_request_close_stream (req, stream, NULL, &error); if (error) { debug_printf (1, " error closing stream: %s\n", error->message); g_error_free (error); errors++; } g_object_unref (stream); check_response (msg, expected_encoding, expected_content_type, status); g_object_unref (msg); return data; }
static void do_cancel_while_reading_req_test_for_session (SoupSession *session) { SoupRequest *req; SoupURI *uri; GCancellable *cancellable; GError *error = NULL; uri = soup_uri_new_with_base (base_uri, "/slow"); req = soup_session_request_uri (session, uri, NULL); soup_uri_free (uri); cancellable = g_cancellable_new (); if (SOUP_IS_SESSION_ASYNC (soup_request_get_session (req))) { g_timeout_add (100, cancel_request_timeout, cancellable); soup_test_request_send (req, cancellable, &error); } else { GThread *thread; thread = g_thread_new ("cancel_request_thread", cancel_request_thread, g_object_ref (cancellable)); soup_test_request_send (req, cancellable, &error); g_thread_unref (thread); } if (!error) { debug_printf (1, " Request succeeded?\n"); errors++; } else if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { debug_printf (1, " Unexpected error: %s\n", error->message); errors++; } g_clear_error (&error); g_object_unref (req); g_object_unref (cancellable); }
static void do_request_to_session (SoupSession *session, const char *uri, const char *comment, gboolean expect_timeout) { SoupRequest *req; SoupMessage *msg; GInputStream *stream; GError *error = NULL; gboolean finished = FALSE; debug_printf (1, " req %s\n", comment); req = soup_session_request (session, uri, NULL); msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req)); g_signal_connect (msg, "finished", G_CALLBACK (message_finished), &finished); stream = soup_test_request_send (req, NULL, &error); if (expect_timeout && !error) { debug_printf (1, " FAILED: request did not time out\n"); errors++; } else if (expect_timeout && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_TIMED_OUT)) { debug_printf (1, " FAILED: wrong error: %s\n", error->message); errors++; } else if (!expect_timeout && error) { debug_printf (1, " FAILED: expected success but got error: %s\n", error->message); errors++; } g_clear_error (&error); if (stream) { soup_test_request_close_stream (req, stream, NULL, &error); if (error) { debug_printf (1, " ERROR closing string: %s", error->message); errors++; } g_object_unref (stream); } if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code) && !soup_message_is_keepalive (msg)) { debug_printf (1, " ERROR: message is not keepalive!\n"); errors++; } if (!finished) { debug_printf (1, " ERROR: 'finished' was not emitted\n"); errors++; } g_signal_handlers_disconnect_by_func (msg, G_CALLBACK (message_finished), &finished); g_object_unref (msg); g_object_unref (req); }
static void do_timeout_req_test_for_session (SoupSession *session) { SoupRequester *requester; SoupRequest *req; SoupMessage *msg; GInputStream *stream; SoupSocket *sockets[4] = { NULL, NULL, NULL, NULL }; SoupURI *timeout_uri; GError *error = NULL; int i; requester = soup_requester_new (); soup_session_add_feature (session, SOUP_SESSION_FEATURE (requester)); g_object_unref (requester); g_signal_connect (session, "request-started", G_CALLBACK (request_started_socket_collector), &sockets); debug_printf (1, " First request\n"); timeout_uri = soup_uri_new_with_base (base_uri, "/timeout-persistent"); req = soup_requester_request_uri (requester, timeout_uri, NULL); soup_uri_free (timeout_uri); stream = soup_test_request_send (req, NULL, &error); if (!stream) { debug_printf (1, " Unexpected error on send: %s\n", error->message); errors++; g_clear_error (&error); } else { soup_test_request_close_stream (req, stream, NULL, &error); if (error) { debug_printf (1, " Unexpected error on close: %s\n", error->message); errors++; g_clear_error (&error); } g_object_unref (stream); } if (sockets[1]) { debug_printf (1, " Message was retried??\n"); errors++; sockets[1] = sockets[2] = sockets[3] = NULL; } g_object_unref (req); debug_printf (1, " Second request\n"); req = soup_requester_request_uri (requester, base_uri, NULL); stream = soup_test_request_send (req, NULL, &error); if (!stream) { debug_printf (1, " Unexpected error on send: %s\n", error->message); errors++; g_clear_error (&error); } else { soup_test_request_close_stream (req, stream, NULL, &error); if (error) { debug_printf (1, " Unexpected error on close: %s\n", error->message); errors++; g_clear_error (&error); } g_object_unref (stream); } msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req)); if (msg->status_code != SOUP_STATUS_OK) { debug_printf (1, " Unexpected response: %d %s\n", msg->status_code, msg->reason_phrase); errors++; } if (sockets[1] != sockets[0]) { debug_printf (1, " Message was not retried on existing connection\n"); errors++; } else if (!sockets[2]) { debug_printf (1, " Message was not retried after disconnect\n"); errors++; } else if (sockets[2] == sockets[1]) { debug_printf (1, " Message was retried on closed connection??\n"); errors++; } else if (sockets[3]) { debug_printf (1, " Message was retried again??\n"); errors++; } g_object_unref (msg); g_object_unref (req); for (i = 0; sockets[i]; i++) g_object_unref (sockets[i]); }
static void test_url_new_api (const char *url, int proxy, guint expected, gboolean sync, gboolean close) { SoupSession *session; SoupURI *proxy_uri; SoupMessage *msg; SoupRequester *requester; SoupRequest *request; GInputStream *stream; GError *error = NULL; if (!tls_available && g_str_has_prefix (url, "https:")) return; debug_printf (1, " GET (requester API) %s via %s%s\n", url, proxy_names[proxy], close ? " (with Connection: close)" : ""); if (proxy == UNAUTH_PROXY && expected != SOUP_STATUS_FORBIDDEN) expected = SOUP_STATUS_PROXY_UNAUTHORIZED; /* We create a new session for each request to ensure that * connections/auth aren't cached between tests. */ proxy_uri = soup_uri_new (proxies[proxy]); session = soup_test_session_new (sync ? SOUP_TYPE_SESSION_SYNC : SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER, SOUP_SESSION_USE_THREAD_CONTEXT, TRUE, SOUP_SESSION_PROXY_URI, proxy_uri, NULL); soup_uri_free (proxy_uri); g_signal_connect (session, "authenticate", G_CALLBACK (authenticate), NULL); if (close) { g_signal_connect (session, "request-started", G_CALLBACK (set_close_on_connect), NULL); } requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER); request = soup_requester_request (requester, url, NULL); msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (request)); stream = soup_test_request_send (request, NULL, &error); if (!stream) { debug_printf (1, " Unexpected error on Request: %s\n", error->message); errors++; g_clear_error (&error); } if (stream) { soup_test_request_close_stream (request, stream, NULL, NULL); if (error) { debug_printf (1, " Unexpected error on close: %s\n", error->message); errors++; g_clear_error (&error); } g_object_unref (stream); } debug_printf (1, " %d %s\n", msg->status_code, msg->reason_phrase); if (msg->status_code != expected) { debug_printf (1, " EXPECTED %d!\n", expected); errors++; } g_object_unref (msg); g_object_unref (request); soup_test_session_abort_unref (session); }
static char * do_request (SoupSession *session, SoupURI *base_uri, const char *method, const char *path, ...) { SoupRequestHTTP *req; SoupMessage *msg; GInputStream *stream; SoupURI *uri; va_list ap; const char *header, *value; char buf[256]; gsize nread; GError *error = NULL; last_request_validated = last_request_hit_network = FALSE; uri = soup_uri_new_with_base (base_uri, path); req = soup_session_request_http_uri (session, method, uri, NULL); soup_uri_free (uri); msg = soup_request_http_get_message (req); va_start (ap, path); while ((header = va_arg (ap, const char *))) { value = va_arg (ap, const char *); soup_message_headers_append (msg->request_headers, header, value); } g_object_unref (msg); stream = soup_test_request_send (SOUP_REQUEST (req), NULL, &error); if (!stream) { debug_printf (1, " could not send request: %s\n", error->message); g_error_free (error); g_object_unref (req); return NULL; } last_request_hit_network = is_network_stream (stream); g_input_stream_read_all (stream, buf, sizeof (buf), &nread, NULL, &error); if (error) { debug_printf (1, " could not read response: %s\n", error->message); g_clear_error (&error); } soup_test_request_close_stream (SOUP_REQUEST (req), stream, NULL, &error); if (error) { debug_printf (1, " could not close stream: %s\n", error->message); g_clear_error (&error); } g_object_unref (stream); g_object_unref (req); /* Cache writes are G_PRIORITY_LOW, so they won't have happened yet... */ soup_cache_flush ((SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE)); return nread ? g_memdup (buf, nread) : g_strdup (""); }