static void do_persistent_connection_timeout_test (void) { SoupSession *session; debug_printf (1, "\nUnexpected timing out of persistent connections\n"); debug_printf (1, " Async session, message API\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); do_timeout_test_for_session (session); soup_test_session_abort_unref (session); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_USE_THREAD_CONTEXT, TRUE, NULL); do_timeout_req_test_for_session (session); soup_test_session_abort_unref (session); debug_printf (1, " Sync session, message API\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); do_timeout_test_for_session (session); soup_test_session_abort_unref (session); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); do_timeout_req_test_for_session (session); soup_test_session_abort_unref (session); }
static void do_aliases_test (void) { SoupSession *session; char *aliases[] = { "foo", NULL }; debug_printf (1, "\nhttp-aliases / https-aliases\n"); debug_printf (1, " Default behavior\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); do_aliases_test_for_session (session, "http"); soup_test_session_abort_unref (session); debug_printf (1, " foo-means-https\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_HTTPS_ALIASES, aliases, NULL); do_aliases_test_for_session (session, "https"); soup_test_session_abort_unref (session); debug_printf (1, " foo-means-nothing\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_HTTP_ALIASES, NULL, NULL); do_aliases_test_for_session (session, NULL); soup_test_session_abort_unref (session); }
static void do_timeout_tests (char *fast_uri, char *slow_uri) { SoupSession *timeout_session, *idle_session, *plain_session; debug_printf (1, " async\n"); timeout_session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_TIMEOUT, 1, NULL); idle_session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_IDLE_TIMEOUT, 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 (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_IDLE_TIMEOUT, 2, NULL); do_tests_for_session (timeout_session, idle_session, plain_session, fast_uri, slow_uri); soup_test_session_abort_unref (timeout_session); soup_test_session_abort_unref (idle_session); soup_test_session_abort_unref (plain_session); debug_printf (1, " sync\n"); timeout_session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, SOUP_SESSION_TIMEOUT, 1, NULL); /* SOUP_SESSION_TIMEOUT doesn't work with sync sessions */ plain_session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); do_tests_for_session (timeout_session, NULL, plain_session, fast_uri, slow_uri); soup_test_session_abort_unref (timeout_session); }
static gpointer test1_thread (gpointer use_thread_context) { SoupSession *session; GMainContext *async_context; char *uri; SoupMessage *msg; GMainLoop *loop; /* Wait for main thread to be waiting on test1_cond */ g_mutex_lock (&test1_mutex); g_mutex_unlock (&test1_mutex); async_context = g_main_context_new (); if (use_thread_context) { g_main_context_push_thread_default (async_context); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_USE_THREAD_CONTEXT, TRUE, NULL); } else { session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_ASYNC_CONTEXT, async_context, NULL); } g_main_context_unref (async_context); uri = g_build_filename (base_uri, "slow", NULL); debug_printf (1, " send_message\n"); msg = soup_message_new ("GET", uri); soup_session_send_message (session, msg); soup_test_assert_message_status (msg, SOUP_STATUS_OK); g_object_unref (msg); debug_printf (1, " queue_message\n"); msg = soup_message_new ("GET", uri); loop = g_main_loop_new (async_context, FALSE); g_object_ref (msg); soup_session_queue_message (session, msg, test1_finished, loop); g_main_loop_run (loop); g_main_loop_unref (loop); soup_test_assert_message_status (msg, SOUP_STATUS_OK); g_object_unref (msg); soup_test_session_abort_unref (session); g_free (uri); g_cond_signal (&test1_cond); if (use_thread_context) g_main_context_pop_thread_default (async_context); return NULL; }
int main (int argc, char **argv) { SoupSession *session; const char *base_uri; test_init (argc, argv, NULL); apache_init (); base_uri = "http://127.0.0.1:47524/"; get_correct_response (base_uri); debug_printf (1, "\nFully async, fast requests\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); g_signal_connect (session, "authenticate", G_CALLBACK (authenticate), NULL); do_fully_async_test (session, base_uri, "/", TRUE, SOUP_STATUS_OK); do_fully_async_test (session, base_uri, "/Basic/realm1/", TRUE, SOUP_STATUS_UNAUTHORIZED); do_fully_async_test (session, base_uri, "/Basic/realm2/", TRUE, SOUP_STATUS_OK); soup_test_session_abort_unref (session); debug_printf (1, "\nFully async, slow requests\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); g_signal_connect (session, "authenticate", G_CALLBACK (authenticate), NULL); do_fully_async_test (session, base_uri, "/", FALSE, SOUP_STATUS_OK); do_fully_async_test (session, base_uri, "/Basic/realm1/", FALSE, SOUP_STATUS_UNAUTHORIZED); do_fully_async_test (session, base_uri, "/Basic/realm2/", FALSE, SOUP_STATUS_OK); soup_test_session_abort_unref (session); debug_printf (1, "\nSynchronously async\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); g_signal_connect (session, "authenticate", G_CALLBACK (authenticate), NULL); do_synchronously_async_test (session, base_uri, "/", SOUP_STATUS_OK); do_synchronously_async_test (session, base_uri, "/Basic/realm1/", SOUP_STATUS_UNAUTHORIZED); do_synchronously_async_test (session, base_uri, "/Basic/realm2/", SOUP_STATUS_OK); soup_test_session_abort_unref (session); soup_buffer_free (correct_response); test_cleanup (); return errors != 0; }
static void do_infinite_auth_test (void) { SoupSession *session; SoupMessage *msg; char *uri; int timeout; SOUP_TEST_SKIP_IF_NO_APACHE; session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); g_signal_connect (session, "authenticate", G_CALLBACK (infinite_authenticate), NULL); uri = g_strconcat (base_uri, "Basic/realm1/", NULL); msg = soup_message_new ("GET", uri); g_free (uri); timeout = g_timeout_add (500, infinite_cancel, session); g_test_expect_message ("libsoup", G_LOG_LEVEL_WARNING, "*stuck in infinite loop*"); soup_session_send_message (session, msg); g_test_assert_expected_messages (); soup_test_assert (msg->status_code != SOUP_STATUS_CANCELLED, "Got stuck in loop"); soup_test_assert_message_status (msg, SOUP_STATUS_UNAUTHORIZED); g_source_remove (timeout); soup_test_session_abort_unref (session); g_object_unref (msg); }
static void do_infinite_auth_test (const char *base_uri) { SoupSession *session; SoupMessage *msg; char *uri; int timeout; debug_printf (1, "\nTesting broken infinite-loop auth:\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); g_signal_connect (session, "authenticate", G_CALLBACK (infinite_authenticate), NULL); uri = g_strconcat (base_uri, "Basic/realm1/", NULL); msg = soup_message_new ("GET", uri); g_free (uri); timeout = g_timeout_add (500, infinite_cancel, session); expect_warning = TRUE; soup_session_send_message (session, msg); if (msg->status_code == SOUP_STATUS_CANCELLED) { debug_printf (1, " FAILED: Got stuck in loop"); errors++; } else if (msg->status_code != SOUP_STATUS_UNAUTHORIZED) { debug_printf (1, " Final status wrong: expected 401, got %u\n", msg->status_code); errors++; } g_source_remove (timeout); soup_test_session_abort_unref (session); g_object_unref (msg); }
static void force_io_streams_init (void) { SoupServer *server; SoupSession *session; guint port; SoupURI *base_uri; SoupMessage *msg; /* Poke libsoup enough to cause SoupBodyInputStream and * SoupBodyOutputStream to get defined, so we can find them * via g_type_from_name() later. */ server = soup_test_server_new (TRUE); port = soup_server_get_port (server); base_uri = soup_uri_new ("http://127.0.0.1"); soup_uri_set_port (base_uri, port); session = soup_test_session_new (SOUP_TYPE_SESSION, NULL); msg = soup_message_new_from_uri ("POST", base_uri); soup_session_send_message (session, msg); g_object_unref (msg); soup_test_session_abort_unref (session); soup_uri_free (base_uri); soup_test_server_quit_unref (server); }
static void do_idle_on_dispose_test (void) { SoupSession *session; SoupMessage *msg; GMainContext *async_context; debug_printf (1, "\nTesting SoupSessionAsync dispose behavior\n"); async_context = g_main_context_new (); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_ASYNC_CONTEXT, async_context, NULL); msg = soup_message_new_from_uri ("GET", base_uri); soup_session_send_message (session, msg); g_object_unref (msg); while (g_main_context_iteration (async_context, FALSE)) ; g_object_run_dispose (G_OBJECT (session)); if (g_main_context_iteration (async_context, FALSE)) { debug_printf (1, " idle was queued!\n"); errors++; } g_object_unref (session); g_main_context_unref (async_context); }
static void do_dot_dot_test (void) { SoupSession *session; SoupMessage *msg; SoupURI *uri; debug_printf (1, "\n'..' smuggling test\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); uri = soup_uri_new_with_base (base_uri, "/..%2ftest"); msg = soup_message_new_from_uri ("GET", uri); soup_uri_free (uri); soup_session_send_message (session, msg); if (msg->status_code != SOUP_STATUS_BAD_REQUEST) { debug_printf (1, " FAILED: %d %s (expected Bad Request)\n", msg->status_code, msg->reason_phrase); errors++; } g_object_unref (msg); soup_test_session_abort_unref (session); }
static void do_pipelined_auth_test (const char *base_uri) { SoupSession *session; SoupMessage *msg; gboolean authenticated; char *uri; int i; debug_printf (1, "Testing pipelined auth (bug 271540):\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); authenticated = FALSE; g_signal_connect (session, "authenticate", G_CALLBACK (bug271540_authenticate), &authenticated); uri = g_strconcat (base_uri, "Basic/realm1/", NULL); for (i = 0; i < 10; i++) { msg = soup_message_new (SOUP_METHOD_GET, uri); g_object_set_data (G_OBJECT (msg), "#", GINT_TO_POINTER (i + 1)); g_signal_connect (msg, "wrote_headers", G_CALLBACK (bug271540_sent), &authenticated); soup_session_queue_message (session, msg, bug271540_finished, &i); } g_free (uri); loop = g_main_loop_new (NULL, TRUE); g_main_loop_run (loop); g_main_loop_unref (loop); soup_test_session_abort_unref (session); }
static void do_proxy_fragment_test (SoupURI *base_uri) { SoupSession *session; SoupURI *proxy_uri, *req_uri; SoupMessage *msg; debug_printf (1, "\nTesting request with fragment via proxy\n"); proxy_uri = soup_uri_new (proxies[SIMPLE_PROXY]); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_PROXY_URI, proxy_uri, NULL); soup_uri_free (proxy_uri); req_uri = soup_uri_new_with_base (base_uri, "/#foo"); msg = soup_message_new_from_uri (SOUP_METHOD_GET, req_uri); soup_uri_free (req_uri); soup_session_send_message (session, msg); if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { debug_printf (1, " unexpected status %d %s!\n", msg->status_code, msg->reason_phrase); errors++; } g_object_unref (msg); soup_test_session_abort_unref (session); }
static void do_ntlm_round (SoupURI *base_uri, gboolean use_ntlm, const char *user) { SoupSession *session; gboolean alice = use_ntlm && !strcmp (user, "alice"); gboolean bob = use_ntlm && !strcmp (user, "bob"); g_return_if_fail (use_ntlm || !alice); session = soup_test_session_new ( SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_USE_NTLM, use_ntlm, NULL); if (user) { g_signal_connect (session, "authenticate", G_CALLBACK (authenticate), (char *)user); } do_message (session, base_uri, "/noauth", FALSE, use_ntlm, FALSE, FALSE, SOUP_STATUS_OK); do_message (session, base_uri, "/alice", !use_ntlm || bob, FALSE, FALSE, FALSE, alice ? SOUP_STATUS_OK : SOUP_STATUS_UNAUTHORIZED); do_message (session, base_uri, "/alice/404", !use_ntlm, bob, FALSE, FALSE, alice ? SOUP_STATUS_NOT_FOUND : SOUP_STATUS_UNAUTHORIZED); do_message (session, base_uri, "/alice", !use_ntlm, bob, FALSE, FALSE, alice ? SOUP_STATUS_OK : SOUP_STATUS_UNAUTHORIZED); do_message (session, base_uri, "/bob", !use_ntlm || alice, bob, FALSE, FALSE, bob ? SOUP_STATUS_OK : SOUP_STATUS_UNAUTHORIZED); do_message (session, base_uri, "/alice", !use_ntlm || bob, alice, FALSE, FALSE, alice ? SOUP_STATUS_OK : SOUP_STATUS_UNAUTHORIZED); do_message (session, base_uri, "/basic", FALSE, bob, TRUE, user != NULL, user != NULL ? SOUP_STATUS_OK : SOUP_STATUS_UNAUTHORIZED); do_message (session, base_uri, "/either", !use_ntlm, FALSE, !use_ntlm, !use_ntlm && user != NULL, user != NULL ? SOUP_STATUS_OK : SOUP_STATUS_UNAUTHORIZED); soup_test_session_abort_unref (session); }
static void do_one_accept_language_test (const char *language, const char *expected_header) { SoupSession *session; SoupMessage *msg; const char *val; debug_printf (1, " LANGUAGE=%s\n", language); g_setenv ("LANGUAGE", language, TRUE); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, SOUP_SESSION_ACCEPT_LANGUAGE_AUTO, TRUE, NULL); msg = soup_message_new_from_uri ("GET", base_uri); soup_session_send_message (session, msg); soup_test_session_abort_unref (session); if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { debug_printf (1, " Message failed? %d %s\n", msg->status_code, msg->reason_phrase); errors++; } val = soup_message_headers_get_list (msg->request_headers, "Accept-Language"); if (!val) { debug_printf (1, " No Accept-Language set!\n"); errors++; } else if (strcmp (val, expected_header) != 0) { debug_printf (1, " Wrong Accept-Language: expected '%s', got '%s'\n", expected_header, val); errors++; } g_object_unref (msg); }
static void do_async_auth_no_password_test (void) { SoupSession *session; SoupMessage *msg; guint auth_id; char *uri; int remaining; gboolean been_there; /* Test that giving no password doesn't cause multiple * authenticate signals the second time. */ g_test_bug ("583462"); SOUP_TEST_SKIP_IF_NO_APACHE; loop = g_main_loop_new (NULL, TRUE); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); uri = g_strconcat (base_uri, "Basic/realm1/", NULL); remaining = 0; /* Send a message that doesn't actually authenticate */ msg = soup_message_new ("GET", uri); g_object_set_data (G_OBJECT (msg), "id", GINT_TO_POINTER (1)); auth_id = g_signal_connect (session, "authenticate", G_CALLBACK (async_authenticate), NULL); g_object_ref (msg); remaining++; soup_session_queue_message (session, msg, async_finished, &remaining); g_main_loop_run (loop); g_signal_handler_disconnect (session, auth_id); soup_session_unpause_message (session, msg); g_main_loop_run (loop); g_object_unref(msg); /* Now send a second message */ msg = soup_message_new ("GET", uri); g_object_set_data (G_OBJECT (msg), "id", GINT_TO_POINTER (2)); g_object_ref (msg); been_there = FALSE; auth_id = g_signal_connect (session, "authenticate", G_CALLBACK (async_authenticate_assert_once_and_stop), &been_there); remaining++; soup_session_queue_message (session, msg, async_finished, &remaining); g_main_loop_run (loop); soup_session_unpause_message (session, msg); g_main_loop_run (loop); g_signal_handler_disconnect (session, auth_id); soup_test_session_abort_unref (session); g_object_unref (msg); g_free (uri); g_main_loop_unref (loop); }
/* Server handlers for "*" work but are separate from handlers for * all other URIs. #590751 */ static void do_star_test (void) { SoupSession *session; SoupMessage *msg; SoupURI *star_uri; const char *handled_by; debug_printf (1, "\nOPTIONS *\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); star_uri = soup_uri_copy (base_uri); soup_uri_set_path (star_uri, "*"); debug_printf (1, " Testing with no handler\n"); msg = soup_message_new_from_uri ("OPTIONS", star_uri); soup_session_send_message (session, msg); if (msg->status_code != SOUP_STATUS_NOT_FOUND) { debug_printf (1, " Unexpected response: %d %s\n", msg->status_code, msg->reason_phrase); errors++; } handled_by = soup_message_headers_get_one (msg->response_headers, "X-Handled-By"); if (handled_by) { /* Should have been rejected by SoupServer directly */ debug_printf (1, " Message reached handler '%s'\n", handled_by); errors++; } g_object_unref (msg); soup_server_add_handler (server, "*", server_star_callback, NULL, NULL); debug_printf (1, " Testing with handler\n"); msg = soup_message_new_from_uri ("OPTIONS", star_uri); soup_session_send_message (session, msg); if (msg->status_code != SOUP_STATUS_OK) { debug_printf (1, " Unexpected response: %d %s\n", msg->status_code, msg->reason_phrase); errors++; } handled_by = soup_message_headers_get_one (msg->response_headers, "X-Handled-By"); if (!handled_by) { debug_printf (1, " Message did not reach handler!\n"); errors++; } else if (strcmp (handled_by, "star_callback") != 0) { debug_printf (1, " Message reached incorrect handler '%s'\n", handled_by); errors++; } g_object_unref (msg); soup_test_session_abort_unref (session); soup_uri_free (star_uri); }
static void do_cancel_while_reading_test (void) { SoupSession *session; debug_printf (1, "\nCancelling message while reading response (msg api)\n"); debug_printf (1, " Async session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); do_cancel_while_reading_test_for_session (session); soup_test_session_abort_unref (session); debug_printf (1, " Sync session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); do_cancel_while_reading_test_for_session (session); soup_test_session_abort_unref (session); }
static void do_connection_event_test (void) { SoupSession *session; debug_printf (1, "\nConnection events\n"); debug_printf (1, " Async session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); do_connection_event_test_for_session (session); soup_test_session_abort_unref (session); debug_printf (1, " Sync session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); do_connection_event_test_for_session (session); soup_test_session_abort_unref (session); }
static void do_non_persistent_connection_test (void) { SoupSession *session; debug_printf (1, "\nNon-persistent connections are closed immediately\n"); debug_printf (1, " Async session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); do_non_persistent_test_for_session (session); soup_test_session_abort_unref (session); debug_printf (1, " Sync session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); do_non_persistent_test_for_session (session); soup_test_session_abort_unref (session); }
static void do_non_idempotent_connection_test (void) { SoupSession *session; debug_printf (1, "\nNon-idempotent methods are always sent on new connections\n"); debug_printf (1, " Async session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); do_non_idempotent_test_for_session (session); soup_test_session_abort_unref (session); debug_printf (1, " Sync session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); do_non_idempotent_test_for_session (session); soup_test_session_abort_unref (session); }
static void do_content_length_framing_test (void) { SoupSession *session; SoupMessage *msg; SoupURI *request_uri; goffset declared_length; debug_printf (1, "\nInvalid Content-Length framing tests\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); debug_printf (1, " Content-Length larger than message body length\n"); request_uri = soup_uri_new_with_base (base_uri, "/content-length/long"); msg = soup_message_new_from_uri ("GET", request_uri); soup_session_send_message (session, msg); if (msg->status_code != SOUP_STATUS_OK) { debug_printf (1, " Unexpected response: %d %s\n", msg->status_code, msg->reason_phrase); errors++; } else { declared_length = soup_message_headers_get_content_length (msg->response_headers); debug_printf (2, " Content-Length: %lu, body: %s\n", (gulong)declared_length, msg->response_body->data); if (msg->response_body->length >= declared_length) { debug_printf (1, " Body length %lu >= declared length %lu\n", (gulong)msg->response_body->length, (gulong)declared_length); errors++; } } soup_uri_free (request_uri); g_object_unref (msg); debug_printf (1, " Server claims 'Connection: close' but doesn't\n"); request_uri = soup_uri_new_with_base (base_uri, "/content-length/noclose"); msg = soup_message_new_from_uri ("GET", request_uri); soup_session_send_message (session, msg); if (msg->status_code != SOUP_STATUS_OK) { debug_printf (1, " Unexpected response: %d %s\n", msg->status_code, msg->reason_phrase); errors++; } else { declared_length = soup_message_headers_get_content_length (msg->response_headers); debug_printf (2, " Content-Length: %lu, body: %s\n", (gulong)declared_length, msg->response_body->data); if (msg->response_body->length != declared_length) { debug_printf (1, " Body length %lu != declared length %lu\n", (gulong)msg->response_body->length, (gulong)declared_length); errors++; } } soup_uri_free (request_uri); g_object_unref (msg); soup_test_session_abort_unref (session); }
static void do_redirect_tests (SoupURI *base_uri) { SoupSession *session; int n; session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); debug_printf (1, "Async session\n"); for (n = 0; n < n_tests; n++) do_test (session, base_uri, n); soup_test_session_abort_unref (session); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); debug_printf (1, "Sync session\n"); for (n = 0; n < n_tests; n++) do_test (session, base_uri, n); soup_test_session_abort_unref (session); }
static void do_early_abort_test (void) { SoupSession *session; SoupMessage *msg; GMainContext *context; GMainLoop *loop; debug_printf (1, "\nAbort with pending connection\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); msg = soup_message_new_from_uri ("GET", base_uri); context = g_main_context_default (); loop = g_main_loop_new (context, TRUE); soup_session_queue_message (session, msg, ea_msg_completed_one, loop); g_main_context_iteration (context, FALSE); soup_session_abort (session); while (g_main_context_pending (context)) g_main_context_iteration (context, FALSE); g_main_loop_unref (loop); soup_test_session_abort_unref (session); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); msg = soup_message_new_from_uri ("GET", base_uri); g_signal_connect (session, "connection-created", G_CALLBACK (ea_connection_created), NULL); soup_session_send_message (session, msg); debug_printf (2, " Message 2 completed\n"); if (msg->status_code != SOUP_STATUS_CANCELLED) { debug_printf (1, " Unexpected response: %d %s\n", msg->status_code, msg->reason_phrase); errors++; } g_object_unref (msg); while (g_main_context_pending (context)) g_main_context_iteration (context, FALSE); soup_test_session_abort_unref (session); }
static void do_cookies_accept_policy_test (void) { SoupSession *session; SoupMessage *msg; SoupURI *uri; SoupCookieJar *jar; GSList *l, *p; int i; debug_printf (1, "SoupCookieJarAcceptPolicy test\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); soup_session_add_feature_by_type (session, SOUP_TYPE_COOKIE_JAR); jar = SOUP_COOKIE_JAR (soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR)); for (i = 0; i < G_N_ELEMENTS (validResults); i++) { soup_cookie_jar_set_accept_policy (jar, validResults[i].policy); uri = soup_uri_new_with_base (first_party_uri, "/index.html"); msg = soup_message_new_from_uri ("GET", uri); soup_message_set_first_party (msg, first_party_uri); soup_session_send_message (session, msg); soup_uri_free (uri); g_object_unref (msg); /* We can't use two servers due to limitations in * test_server, so let's swap first and third party here * to simulate a cookie coming from a third party. */ uri = soup_uri_new_with_base (first_party_uri, "/foo.jpg"); msg = soup_message_new_from_uri ("GET", uri); soup_message_set_first_party (msg, third_party_uri); soup_session_send_message (session, msg); soup_uri_free (uri); g_object_unref (msg); l = soup_cookie_jar_all_cookies (jar); if (g_slist_length (l) < validResults[i].n_cookies) { debug_printf (1, " accepted less cookies than it should have\n"); errors++; } else if (g_slist_length (l) > validResults[i].n_cookies) { debug_printf (1, " accepted more cookies than it should have\n"); errors++; } for (p = l; p; p = p->next) { soup_cookie_jar_delete_cookie (jar, p->data); soup_cookie_free (p->data); } g_slist_free (l); } soup_test_session_abort_unref (session); }
static void do_timeout_tests (char *fast_uri, char *slow_uri) { SoupSession *session; debug_printf (1, " async\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_TIMEOUT, 1, NULL); do_tests_for_session (session, fast_uri, slow_uri); soup_test_session_abort_unref (session); debug_printf (1, " sync\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, SOUP_SESSION_TIMEOUT, 1, NULL); do_tests_for_session (session, fast_uri, slow_uri); soup_test_session_abort_unref (session); }
static void do_message_has_authorization_header_test (void) { SoupSession *session; SoupMessage *msg; SoupAuthManager *manager; SoupAuth *auth = NULL; char *token; guint auth_id; char *uri; g_test_bug ("775882"); SOUP_TEST_SKIP_IF_NO_APACHE; session = soup_test_session_new (SOUP_TYPE_SESSION, NULL); uri = g_strconcat (base_uri, "Digest/realm1/", NULL); msg = soup_message_new ("GET", uri); auth_id = g_signal_connect (session, "authenticate", G_CALLBACK (has_authorization_header_authenticate), &auth); soup_session_send_message (session, msg); soup_test_assert_message_status (msg, SOUP_STATUS_OK); soup_test_assert (SOUP_IS_AUTH (auth), "Expected a SoupAuth"); token = soup_auth_get_authorization (auth, msg); g_object_unref (auth); g_object_unref (msg); g_signal_handler_disconnect (session, auth_id); manager = SOUP_AUTH_MANAGER (soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER)); soup_auth_manager_clear_cached_credentials (manager); msg = soup_message_new ("GET", uri); soup_message_headers_replace (msg->request_headers, "Authorization", token); auth_id = g_signal_connect (session, "authenticate", G_CALLBACK (has_authorization_header_authenticate_assert), NULL); soup_session_send_message (session, msg); soup_test_assert_message_status (msg, SOUP_STATUS_OK); g_object_unref (msg); /* Check that we can also provide our own Authorization header when not using credentials cache. */ soup_auth_manager_clear_cached_credentials (manager); msg = soup_message_new ("GET", uri); soup_message_headers_replace (msg->request_headers, "Authorization", token); soup_message_set_flags (msg, soup_message_get_flags (msg) | SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE); soup_session_send_message (session, msg); soup_test_assert_message_status (msg, SOUP_STATUS_OK); g_object_unref (msg); g_free (token); g_signal_handler_disconnect (session, auth_id); g_free (uri); soup_test_session_abort_unref (session); }
static void do_test2 (gconstpointer data) { gboolean use_thread_context = GPOINTER_TO_INT (data); guint idle; GMainContext *async_context; SoupSession *session; char *uri; SoupMessage *msg; idle = g_idle_add_full (G_PRIORITY_HIGH, idle_test2_fail, NULL, NULL); async_context = g_main_context_new (); if (use_thread_context) { g_main_context_push_thread_default (async_context); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_USE_THREAD_CONTEXT, TRUE, NULL); } else { session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_ASYNC_CONTEXT, async_context, NULL); } g_main_context_unref (async_context); uri = g_build_filename (base_uri, "slow", NULL); debug_printf (1, " send_message\n"); msg = soup_message_new ("GET", uri); soup_session_send_message (session, msg); soup_test_assert_message_status (msg, SOUP_STATUS_OK); g_object_unref (msg); soup_test_session_abort_unref (session); g_free (uri); g_source_remove (idle); if (use_thread_context) g_main_context_pop_thread_default (async_context); }
static void do_max_conns_test (void) { SoupSession *session; debug_printf (1, "\nExceeding max-conns\n"); debug_printf (1, " Async session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, SOUP_SESSION_MAX_CONNS, MAX_CONNS, NULL); do_max_conns_test_for_session (session); soup_test_session_abort_unref (session); debug_printf (1, " Sync session\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, SOUP_SESSION_MAX_CONNS, MAX_CONNS, NULL); do_max_conns_test_for_session (session); soup_test_session_abort_unref (session); }
static void do_msg_reuse_test (void) { SoupSession *session; SoupMessage *msg; SoupURI *uri; guint *signal_ids, n_signal_ids; debug_printf (1, "\nSoupMessage reuse\n"); signal_ids = g_signal_list_ids (SOUP_TYPE_MESSAGE, &n_signal_ids); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); g_signal_connect (session, "authenticate", G_CALLBACK (reuse_test_authenticate), NULL); debug_printf (1, " First message\n"); msg = soup_message_new_from_uri ("GET", base_uri); soup_session_send_message (session, msg); ensure_no_signal_handlers (msg, signal_ids, n_signal_ids); debug_printf (1, " Redirect message\n"); uri = soup_uri_new_with_base (base_uri, "/redirect"); soup_message_set_uri (msg, uri); soup_uri_free (uri); soup_session_send_message (session, msg); if (!soup_uri_equal (soup_message_get_uri (msg), base_uri)) { debug_printf (1, " Message did not get redirected!\n"); errors++; } ensure_no_signal_handlers (msg, signal_ids, n_signal_ids); debug_printf (1, " Auth message\n"); uri = soup_uri_new_with_base (base_uri, "/auth"); soup_message_set_uri (msg, uri); soup_uri_free (uri); soup_session_send_message (session, msg); if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { debug_printf (1, " Message did not get authenticated!\n"); errors++; } ensure_no_signal_handlers (msg, signal_ids, n_signal_ids); /* One last try to make sure the auth stuff got cleaned up */ debug_printf (1, " Last message\n"); soup_message_set_uri (msg, base_uri); soup_session_send_message (session, msg); ensure_no_signal_handlers (msg, signal_ids, n_signal_ids); soup_test_session_abort_unref (session); g_object_unref (msg); g_free (signal_ids); }
static void do_async_auth_bad_password_test (void) { SoupSession *session; SoupMessage *msg; guint auth_id; char *uri; SoupAuth *auth = NULL; int remaining; gboolean been_there; /* Test that giving the wrong password doesn't cause multiple * authenticate signals the second time. */ g_test_bug ("522601"); SOUP_TEST_SKIP_IF_NO_APACHE; loop = g_main_loop_new (NULL, TRUE); session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL); uri = g_strconcat (base_uri, "Basic/realm1/", NULL); remaining = 0; auth = NULL; msg = soup_message_new ("GET", uri); g_object_set_data (G_OBJECT (msg), "id", GINT_TO_POINTER (1)); auth_id = g_signal_connect (session, "authenticate", G_CALLBACK (async_authenticate), &auth); g_object_ref (msg); remaining++; soup_session_queue_message (session, msg, async_finished, &remaining); g_main_loop_run (loop); g_signal_handler_disconnect (session, auth_id); soup_auth_authenticate (auth, "user1", "wrong"); g_object_unref (auth); soup_session_unpause_message (session, msg); been_there = FALSE; auth_id = g_signal_connect (session, "authenticate", G_CALLBACK (async_authenticate_assert_once), &been_there); g_main_loop_run (loop); g_signal_handler_disconnect (session, auth_id); soup_test_assert (been_there, "authenticate not emitted"); soup_test_session_abort_unref (session); g_object_unref (msg); g_free (uri); g_main_loop_unref (loop); }