From e25e9ee4704398f0f276f6f9e91d948b8924356e Mon Sep 17 00:00:00 2001
From: Dan Winship <danw@gnome.org>
Date: Tue, 25 Dec 2012 18:17:05 -0500
Subject: tests: add cache-test

Add a test of basic cache functionality (finally!)

Still needs more tests...
---
 tests/cache-test.c | 441 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 441 insertions(+)
 create mode 100644 tests/cache-test.c

(limited to 'tests/cache-test.c')

diff --git a/tests/cache-test.c b/tests/cache-test.c
new file mode 100644
index 00000000..8f8d2b04
--- /dev/null
+++ b/tests/cache-test.c
@@ -0,0 +1,441 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * Copyright 2012 Red Hat, Inc.
+ */
+
+#include "test-utils.h"
+
+static void
+server_callback (SoupServer *server, SoupMessage *msg,
+		 const char *path, GHashTable *query,
+		 SoupClientContext *context, gpointer data)
+{
+	const char *last_modified, *etag;
+	const char *header;
+	guint status = SOUP_STATUS_OK;
+
+	if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_POST) {
+		soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
+		return;
+	}
+
+	header = soup_message_headers_get_one (msg->request_headers,
+					       "Test-Set-Expires");
+	if (header) {
+		soup_message_headers_append (msg->response_headers,
+					     "Expires",
+					     header);
+	}
+
+	header = soup_message_headers_get_one (msg->request_headers,
+					       "Test-Set-Cache-Control");
+	if (header) {
+		soup_message_headers_append (msg->response_headers,
+					     "Cache-Control",
+					     header);
+	}
+
+	last_modified = soup_message_headers_get_one (msg->request_headers,
+						      "Test-Set-Last-Modified");
+	if (last_modified) {
+		soup_message_headers_append (msg->response_headers,
+					     "Last-Modified",
+					     last_modified);
+	}
+
+	etag = soup_message_headers_get_one (msg->request_headers,
+					     "Test-Set-ETag");
+	if (etag) {
+		soup_message_headers_append (msg->response_headers,
+					     "ETag",
+					     etag);
+	}
+
+
+	header = soup_message_headers_get_one (msg->request_headers,
+					       "If-Modified-Since");
+	if (header && last_modified) {
+		SoupDate *date;
+		time_t lastmod, check;
+
+		date = soup_date_new_from_string (last_modified);
+		lastmod = soup_date_to_time_t (date);
+		soup_date_free (date);
+
+		date = soup_date_new_from_string (header);
+		check = soup_date_to_time_t (date);
+		soup_date_free (date);
+
+		if (lastmod <= check)
+			status = SOUP_STATUS_NOT_MODIFIED;
+	}
+
+	header = soup_message_headers_get_one (msg->request_headers,
+					       "If-None-Match");
+	if (header && etag) {
+		if (!strcmp (header, etag))
+			status = SOUP_STATUS_NOT_MODIFIED;
+	}
+
+	if (status == SOUP_STATUS_OK) {
+		GChecksum *sum;
+		const char *body;
+
+		sum = g_checksum_new (G_CHECKSUM_SHA256);
+		g_checksum_update (sum, (guchar *)path, strlen (path));
+		if (last_modified)
+			g_checksum_update (sum, (guchar *)last_modified, strlen (last_modified));
+		if (etag)
+			g_checksum_update (sum, (guchar *)etag, strlen (etag));
+		body = g_checksum_get_string (sum);
+		soup_message_set_response (msg, "text/plain",
+					   SOUP_MEMORY_COPY,
+					   body, strlen (body) + 1);
+		g_checksum_free (sum);
+	}
+	soup_message_set_status (msg, status);
+}
+
+static gboolean
+is_network_stream (GInputStream *stream)
+{
+	while (G_IS_FILTER_INPUT_STREAM (stream))
+		stream = G_FILTER_INPUT_STREAM (stream)->base_stream;
+
+	return !G_IS_FILE_INPUT_STREAM (stream);
+}
+
+static char *do_request (SoupSession *session,
+			 SoupURI     *base_uri,
+			 const char  *method,
+			 const char  *path,
+			 ...) G_GNUC_NULL_TERMINATED;
+
+static gboolean last_request_hit_network;
+static gboolean last_request_validated;
+
+static char *
+do_request (SoupSession *session,
+	    SoupURI     *base_uri,
+	    const char  *method,
+	    const char  *path,
+	    ...)
+{
+	SoupRequestHTTP *req;
+	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);
+
+	va_start (ap, path);
+	while ((header = va_arg (ap, const char *))) {
+		value = va_arg (ap, const char *);
+		soup_message_headers_append (req->request_headers,
+					     header, value);
+	}
+
+	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 ("");
+}
+
+static void
+request_started (SoupSession *session, SoupMessage *msg,
+		 SoupSocket *socket)
+{
+	if (soup_message_headers_get_one (msg->request_headers,
+					  "If-Modified-Since") ||
+	    soup_message_headers_get_one (msg->request_headers,
+					  "If-None-Match")) {
+		debug_printf (2, "    Conditional request for %s\n",
+			      soup_message_get_uri (msg)->path);
+		last_request_validated = TRUE;
+	}
+}
+
+static void
+do_basics_test (SoupURI *base_uri)
+{
+	SoupSession *session;
+	SoupCache *cache;
+	char *cache_dir;
+	char *body1, *body2, *body3, *body4, *body5, *cmp;
+
+	debug_printf (1, "Cache basics\n");
+
+	cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
+	debug_printf (2, "  Caching to %s\n", cache_dir);
+	cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
+	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
+					 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
+					 SOUP_SESSION_ADD_FEATURE, cache,
+					 NULL);
+	g_signal_connect (session, "request-started",
+			  G_CALLBACK (request_started), NULL);
+
+	debug_printf (2, "  Initial requests\n");
+	body1 = do_request (session, base_uri, "GET", "/1",
+			    "Test-Set-Expires", "Fri, 01 Jan 2100 00:00:00 GMT",
+			    NULL);
+	body2 = do_request (session, base_uri, "GET", "/2",
+			    "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
+			    NULL);
+	body3 = do_request (session, base_uri, "GET", "/3",
+			    "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
+			    "Test-Set-Cache-Control", "must-revalidate",
+			    NULL);
+	body4 = do_request (session, base_uri, "GET", "/4",
+			    "Test-Set-ETag", "\"abcdefg\"",
+			    "Test-Set-Cache-Control", "must-revalidate",
+			    NULL);
+	body5 = do_request (session, base_uri, "GET", "/5",
+			    "Test-Set-Cache-Control", "no-cache",
+			    NULL);
+
+
+	/* Resource with future Expires should have been cached */
+	debug_printf (1, "  Fresh cached resource\n");
+	cmp = do_request (session, base_uri, "GET", "/1",
+			  NULL);
+	if (last_request_hit_network) {
+		debug_printf (1, "    Request for /1 not filled from cache!\n");
+		errors++;
+	}
+	if (strcmp (body1, cmp) != 0) {
+		debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
+			      cmp, body1);
+		errors++;
+	}
+	g_free (cmp);
+
+
+	/* Resource with long-ago Last-Modified should have been cached */
+	debug_printf (1, "  Heuristically-fresh cached resource\n");
+	cmp = do_request (session, base_uri, "GET", "/2",
+			  NULL);
+	if (last_request_hit_network) {
+		debug_printf (1, "    Request for /2 not filled from cache!\n");
+		errors++;
+	}
+	if (strcmp (body2, cmp) != 0) {
+		debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
+			      cmp, body2);
+		errors++;
+	}
+	g_free (cmp);
+
+
+	/* Adding a query string should bypass the cache but not invalidate it */
+	debug_printf (1, "  Fresh cached resource with a query\n");
+	cmp = do_request (session, base_uri, "GET", "/1?attr=value",
+			  NULL);
+	if (!last_request_hit_network) {
+		debug_printf (1, "    Request for /1?attr=value filled from cache!\n");
+		errors++;
+	}
+	g_free (cmp);
+	debug_printf (2, "  Second request\n");
+	cmp = do_request (session, base_uri, "GET", "/1",
+			  NULL);
+	if (last_request_hit_network) {
+		debug_printf (1, "    Second request for /1 not filled from cache!\n");
+		errors++;
+	}
+	if (strcmp (body1, cmp) != 0) {
+		debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
+			      cmp, body1);
+		errors++;
+	}
+	g_free (cmp);
+
+
+	/* Last-Modified + must-revalidate causes a conditional request */
+	debug_printf (1, "  Unchanged must-revalidate resource w/ Last-Modified\n");
+	cmp = do_request (session, base_uri, "GET", "/3",
+			  "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
+			  "Test-Set-Cache-Control", "must-revalidate",
+			  NULL);
+	if (!last_request_validated) {
+		debug_printf (1, "    Request for /3 not validated!\n");
+		errors++;
+	}
+	if (last_request_hit_network) {
+		debug_printf (1, "    Request for /3 not filled from cache!\n");
+		errors++;
+	}
+	if (strcmp (body3, cmp) != 0) {
+		debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
+			      cmp, body3);
+		errors++;
+	}
+	g_free (cmp);
+
+
+	/* Validation failure should update cache */
+	debug_printf (1, "  Changed must-revalidate resource w/ Last-Modified\n");
+	cmp = do_request (session, base_uri, "GET", "/3",
+			  "Test-Set-Last-Modified", "Sat, 02 Jan 2010 00:00:00 GMT",
+			  "Test-Set-Cache-Control", "must-revalidate",
+			  NULL);
+	if (!last_request_validated) {
+		debug_printf (1, "    Request for /3 not validated!\n");
+		errors++;
+	}
+	if (!last_request_hit_network) {
+		debug_printf (1, "    Request for /3 filled from cache!\n");
+		errors++;
+	}
+	if (strcmp (body3, cmp) == 0) {
+		debug_printf (1, "    Request for /3 returned cached response\n");
+		errors++;
+	}
+	g_free (cmp);
+
+#if 0 /* This doesn't work... is the test wrong or is SoupCache? */
+	debug_printf (2, "  Second request\n");
+	cmp = do_request (session, base_uri, "GET", "/3",
+			  "Test-Set-Last-Modified", "Sat, 02 Jan 2010 00:00:00 GMT",
+			  "Test-Set-Cache-Control", "must-revalidate",
+			  NULL);
+	if (!last_request_validated) {
+		debug_printf (1, "    Second request for /3 not validated!\n");
+		errors++;
+	}
+	if (last_request_hit_network) {
+		debug_printf (1, "    Second request for /3 not filled from cache!\n");
+		errors++;
+	}
+	if (strcmp (body3, cmp) == 0) {
+		debug_printf (1, "    Replacement body for /3 not cached!\n");
+		errors++;
+	}
+	g_free (cmp);
+#endif
+
+
+	/* ETag + must-revalidate causes a conditional request */
+	debug_printf (1, "  Unchanged must-revalidate resource w/ ETag\n");
+	cmp = do_request (session, base_uri, "GET", "/4",
+			  "Test-Set-ETag", "\"abcdefg\"",
+			  NULL);
+	if (!last_request_validated) {
+		debug_printf (1, "    Request for /4 not validated!\n");
+		errors++;
+	}
+	if (last_request_hit_network) {
+		debug_printf (1, "    Request for /4 not filled from cache!\n");
+		errors++;
+	}
+	if (strcmp (body4, cmp) != 0) {
+		debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
+			      cmp, body4);
+		errors++;
+	}
+	g_free (cmp);
+
+
+	/* Cache-Control: no-cache prevents caching */
+	debug_printf (1, "  Uncacheable resource\n");
+	cmp = do_request (session, base_uri, "GET", "/5",
+			  "Test-Set-Cache-Control", "no-cache",
+			  NULL);
+	if (!last_request_hit_network) {
+		debug_printf (1, "    Request for /5 filled from cache!\n");
+		errors++;
+	}
+	if (strcmp (body5, cmp) != 0) {
+		debug_printf (1, "    Re-retrieved response (%s) did not match original (%s)\n",
+			      cmp, body5);
+		errors++;
+	}
+	g_free (cmp);
+
+
+	/* PUT to a URI invalidates the cache entry */
+	debug_printf (1, "  Invalidating and re-requesting a cached resource\n");
+	cmp = do_request (session, base_uri, "PUT", "/1",
+			  NULL);
+	if (!last_request_hit_network) {
+		debug_printf (1, "    PUT filled from cache!\n");
+		errors++;
+	}
+	g_free (cmp);
+	cmp = do_request (session, base_uri, "GET", "/1",
+			  NULL);
+	if (!last_request_hit_network) {
+		debug_printf (1, "    PUT failed to invalidate cache entry!\n");
+		errors++;
+	}
+	g_free (cmp);
+
+
+	soup_test_session_abort_unref (session);
+	g_object_unref (cache);
+
+	g_free (cache_dir);
+	g_free (body1);
+	g_free (body2);
+	g_free (body3);
+	g_free (body4);
+	g_free (body5);
+}
+
+int
+main (int argc, char **argv)
+{
+	SoupServer *server;
+	SoupURI *base_uri;
+
+	test_init (argc, argv, NULL);
+
+	server = soup_test_server_new (TRUE);
+	soup_server_add_handler (server, NULL, server_callback, NULL, NULL);
+	base_uri = soup_uri_new ("http://127.0.0.1/");
+	soup_uri_set_port (base_uri, soup_server_get_port (server));
+
+	do_basics_test (base_uri);
+
+	soup_uri_free (base_uri);
+	soup_test_server_quit_unref (server);
+
+	test_cleanup ();
+	return errors != 0;
+}
-- 
cgit v1.2.1


From 2357f3501718967003914da4f1f7659b6593aa0d Mon Sep 17 00:00:00 2001
From: Dan Winship <danw@gnome.org>
Date: Fri, 28 Dec 2012 10:41:20 -0500
Subject: Revert the mirroring of SoupMessage API onto SoupRequestHTTP.

SoupMessage isn't being deprecated, and mirroring its API onto
SoupRequestHTTP is just going to result in always having to add every
new API twice. Also, it turns out to be less useful than originally
expected anyway, since you end up having to cast between SoupRequest
and SoupRequestHTTP frequently anyway.

This reverts commit d7117329400e47d2187ed033099d921d555f8d71 and most of
commit 53c270d0e2868fa5ad48ce864f10a9486b11a071.
---
 tests/cache-test.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'tests/cache-test.c')

diff --git a/tests/cache-test.c b/tests/cache-test.c
index 8f8d2b04..ac19bfe5 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -122,6 +122,7 @@ do_request (SoupSession *session,
 	    ...)
 {
 	SoupRequestHTTP *req;
+	SoupMessage *msg;
 	GInputStream *stream;
 	SoupURI *uri;
 	va_list ap;
@@ -135,13 +136,15 @@ do_request (SoupSession *session,
 	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 (req->request_headers,
+		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) {
-- 
cgit v1.2.1


From b980d54cb2b77b6b9c54168e9c7ff772734caaac Mon Sep 17 00:00:00 2001
From: Sergio Villar Senin <svillar@igalia.com>
Date: Wed, 30 Jan 2013 17:56:38 +0100
Subject: test-utils: add cancellation support to soup_test_request_send

The function gets a new parametter used to enable request cancellation for
both sync and async sessions. The cancellation could be performed by either
using the GCancellable or by directly cancelling the SoupMessage.

Also the GMainContext used to simulate sync operations with async ones will
now try to execute all its pending events before quiting the main loop.

https://bugzilla.gnome.org/show_bug.cgi?id=692310
---
 tests/cache-test.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests/cache-test.c')

diff --git a/tests/cache-test.c b/tests/cache-test.c
index ac19bfe5..22ca6f86 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -146,7 +146,7 @@ do_request (SoupSession *session,
 	}
 	g_object_unref (msg);
 
-	stream = soup_test_request_send (SOUP_REQUEST (req), NULL, &error);
+	stream = soup_test_request_send (SOUP_REQUEST (req), NULL, 0, &error);
 	if (!stream) {
 		debug_printf (1, "    could not send request: %s\n",
 			      error->message);
-- 
cgit v1.2.1


From 8e7cb1cc11fff189c5d69940d9e714d5b84c2fed Mon Sep 17 00:00:00 2001
From: Sergio Villar Senin <svillar@igalia.com>
Date: Wed, 30 Jan 2013 18:16:32 +0100
Subject: cache-test: added cancellation tests

Added cancellation tests for both fresh and under revalidation resources.
These tests ensure that cancellations happen flawlessly and that any
potential revalidation process is also cancelled.

https://bugzilla.gnome.org/show_bug.cgi?id=692310
---
 tests/cache-test.c | 125 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 125 insertions(+)

(limited to 'tests/cache-test.c')

diff --git a/tests/cache-test.c b/tests/cache-test.c
index 22ca6f86..ed8ca453 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -113,6 +113,7 @@ static char *do_request (SoupSession *session,
 
 static gboolean last_request_hit_network;
 static gboolean last_request_validated;
+static guint cancelled_requests;
 
 static char *
 do_request (SoupSession *session,
@@ -180,6 +181,41 @@ do_request (SoupSession *session,
 	return nread ? g_memdup (buf, nread) : g_strdup ("");
 }
 
+static void
+do_request_with_cancel (SoupSession          *session,
+			SoupURI              *base_uri,
+			const char           *method,
+			const char           *path,
+			SoupTestRequestFlags  flags)
+{
+	SoupRequestHTTP *req;
+	GInputStream *stream;
+	SoupURI *uri;
+	GError *error = NULL;
+	GCancellable *cancellable;
+
+	last_request_validated = last_request_hit_network = FALSE;
+	cancelled_requests = 0;
+
+	uri = soup_uri_new_with_base (base_uri, path);
+	req = soup_session_request_http_uri (session, method, uri, NULL);
+	soup_uri_free (uri);
+	cancellable = flags & SOUP_TEST_REQUEST_CANCEL_CANCELLABLE ? g_cancellable_new () : NULL;
+	stream = soup_test_request_send (SOUP_REQUEST (req), cancellable, flags, &error);
+	if (stream) {
+		debug_printf (1, "    could not cancel the request\n");
+		g_object_unref (stream);
+		g_object_unref (req);
+		return;
+	}
+
+	g_clear_object (&cancellable);
+	g_clear_object (&stream);
+	g_clear_object (&req);
+
+	soup_cache_flush ((SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE));
+}
+
 static void
 request_started (SoupSession *session, SoupMessage *msg,
 		 SoupSocket *socket)
@@ -194,6 +230,14 @@ request_started (SoupSession *session, SoupMessage *msg,
 	}
 }
 
+static void
+request_unqueued (SoupSession *session, SoupMessage *msg,
+		  gpointer data)
+{
+	if (msg->status_code == SOUP_STATUS_CANCELLED)
+		cancelled_requests++;
+}
+
 static void
 do_basics_test (SoupURI *base_uri)
 {
@@ -421,6 +465,86 @@ do_basics_test (SoupURI *base_uri)
 	g_free (body5);
 }
 
+static void
+do_cancel_test (SoupURI *base_uri)
+{
+	SoupSession *session;
+	SoupCache *cache;
+	char *cache_dir;
+	char *body1, *body2;
+
+	debug_printf (1, "Cache cancel tests\n");
+
+	cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
+	debug_printf (2, "  Caching to %s\n", cache_dir);
+	cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
+	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
+					 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
+					 SOUP_SESSION_ADD_FEATURE, cache,
+					 NULL);
+	g_signal_connect (session, "request-unqueued",
+			  G_CALLBACK (request_unqueued), NULL);
+
+	debug_printf (2, "  Initial requests\n");
+	body1 = do_request (session, base_uri, "GET", "/1",
+			    "Test-Set-Expires", "Fri, 01 Jan 2100 00:00:00 GMT",
+			    NULL);
+	body2 = do_request (session, base_uri, "GET", "/2",
+			    "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
+			    "Test-Set-Cache-Control", "must-revalidate",
+			    NULL);
+
+	/* Check that messages are correctly processed on cancellations. */
+	debug_printf (1, "  Cancel fresh resource with soup_session_message_cancel()\n");
+	do_request_with_cancel (session, base_uri, "GET", "/1", SOUP_TEST_REQUEST_CANCEL_MESSAGE);
+	if (cancelled_requests != 1) {
+		debug_printf (1, "    invalid number of cancelled requests: %d (1 expected)\n",
+			      cancelled_requests);
+		errors++;
+	}
+
+	debug_printf (1, "  Cancel fresh resource with g_cancellable_cancel()\n");
+	do_request_with_cancel (session, base_uri, "GET", "/1", SOUP_TEST_REQUEST_CANCEL_CANCELLABLE);
+	if (cancelled_requests != 1) {
+		debug_printf (1, "    invalid number of cancelled requests: %d (1 expected)\n",
+			      cancelled_requests);
+		errors++;
+	}
+
+	soup_test_session_abort_unref (session);
+
+	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
+					 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
+					 SOUP_SESSION_ADD_FEATURE, cache,
+					 NULL);
+	g_signal_connect (session, "request-unqueued",
+			  G_CALLBACK (request_unqueued), NULL);
+
+	/* Check that messages are correctly processed on cancellations. */
+	debug_printf (1, "  Cancel a revalidating resource with soup_session_message_cancel()\n");
+	do_request_with_cancel (session, base_uri, "GET", "/2", SOUP_TEST_REQUEST_CANCEL_MESSAGE);
+	if (cancelled_requests != 2) {
+		debug_printf (1, "    invalid number of cancelled requests: %d (2 expected)\n",
+			      cancelled_requests);
+		errors++;
+	}
+
+	debug_printf (1, "  Cancel a revalidating resource with g_cancellable_cancel()\n");
+	do_request_with_cancel (session, base_uri, "GET", "/2", SOUP_TEST_REQUEST_CANCEL_CANCELLABLE);
+	if (cancelled_requests != 2) {
+		debug_printf (1, "    invalid number of cancelled requests: %d (2 expected)\n",
+			      cancelled_requests);
+		errors++;
+	}
+
+	soup_test_session_abort_unref (session);
+
+	g_object_unref (cache);
+	g_free (cache_dir);
+	g_free (body1);
+	g_free (body2);
+}
+
 int
 main (int argc, char **argv)
 {
@@ -435,6 +559,7 @@ main (int argc, char **argv)
 	soup_uri_set_port (base_uri, soup_server_get_port (server));
 
 	do_basics_test (base_uri);
+	do_cancel_test (base_uri);
 
 	soup_uri_free (base_uri);
 	soup_test_server_quit_unref (server);
-- 
cgit v1.2.1


From 3f294a7b6661df7d8dfad3dff175f8807b257c44 Mon Sep 17 00:00:00 2001
From: Sergio Villar Senin <svillar@igalia.com>
Date: Fri, 15 Feb 2013 21:15:08 +0100
Subject: test-utils: Added SOUP_TEST_REQUEST_CANCEL_IMMEDIATE flag

We were assuming that if the SOUP_TEST_REQUEST_CANCEL_SOON flag was not
present then we wanted an immediate cancelation. That worked but now we need
to add it to support more cancellation types.

https://bugzilla.gnome.org/show_bug.cgi?id=682527
---
 tests/cache-test.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

(limited to 'tests/cache-test.c')

diff --git a/tests/cache-test.c b/tests/cache-test.c
index ed8ca453..9469dc12 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -472,6 +472,7 @@ do_cancel_test (SoupURI *base_uri)
 	SoupCache *cache;
 	char *cache_dir;
 	char *body1, *body2;
+	guint flags;
 
 	debug_printf (1, "Cache cancel tests\n");
 
@@ -496,7 +497,8 @@ do_cancel_test (SoupURI *base_uri)
 
 	/* Check that messages are correctly processed on cancellations. */
 	debug_printf (1, "  Cancel fresh resource with soup_session_message_cancel()\n");
-	do_request_with_cancel (session, base_uri, "GET", "/1", SOUP_TEST_REQUEST_CANCEL_MESSAGE);
+	flags = SOUP_TEST_REQUEST_CANCEL_MESSAGE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
+	do_request_with_cancel (session, base_uri, "GET", "/1", flags);
 	if (cancelled_requests != 1) {
 		debug_printf (1, "    invalid number of cancelled requests: %d (1 expected)\n",
 			      cancelled_requests);
@@ -504,7 +506,8 @@ do_cancel_test (SoupURI *base_uri)
 	}
 
 	debug_printf (1, "  Cancel fresh resource with g_cancellable_cancel()\n");
-	do_request_with_cancel (session, base_uri, "GET", "/1", SOUP_TEST_REQUEST_CANCEL_CANCELLABLE);
+	flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
+	do_request_with_cancel (session, base_uri, "GET", "/1", flags);
 	if (cancelled_requests != 1) {
 		debug_printf (1, "    invalid number of cancelled requests: %d (1 expected)\n",
 			      cancelled_requests);
@@ -522,7 +525,8 @@ do_cancel_test (SoupURI *base_uri)
 
 	/* Check that messages are correctly processed on cancellations. */
 	debug_printf (1, "  Cancel a revalidating resource with soup_session_message_cancel()\n");
-	do_request_with_cancel (session, base_uri, "GET", "/2", SOUP_TEST_REQUEST_CANCEL_MESSAGE);
+	flags = SOUP_TEST_REQUEST_CANCEL_MESSAGE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
+	do_request_with_cancel (session, base_uri, "GET", "/2", flags);
 	if (cancelled_requests != 2) {
 		debug_printf (1, "    invalid number of cancelled requests: %d (2 expected)\n",
 			      cancelled_requests);
@@ -530,7 +534,8 @@ do_cancel_test (SoupURI *base_uri)
 	}
 
 	debug_printf (1, "  Cancel a revalidating resource with g_cancellable_cancel()\n");
-	do_request_with_cancel (session, base_uri, "GET", "/2", SOUP_TEST_REQUEST_CANCEL_CANCELLABLE);
+	flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
+	do_request_with_cancel (session, base_uri, "GET", "/2", flags);
 	if (cancelled_requests != 2) {
 		debug_printf (1, "    invalid number of cancelled requests: %d (2 expected)\n",
 			      cancelled_requests);
-- 
cgit v1.2.1


From 054b1e3059f5b9b677d2117ecc3130fa6cd79f1a Mon Sep 17 00:00:00 2001
From: Sergio Villar Senin <svillar@igalia.com>
Date: Fri, 15 Feb 2013 21:40:37 +0100
Subject: cache-test: added a new cancellation test

Added do_refcounting_test that checks that streams do not leak any
reference when a message is cancelled just before starting to read.

This test also need a new cancel flag called
SOUP_TEST_REQUEST_CANCEL_AFTER_SEND_FINISH.

https://bugzilla.gnome.org/show_bug.cgi?id=682527
---
 tests/cache-test.c | 61 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

(limited to 'tests/cache-test.c')

diff --git a/tests/cache-test.c b/tests/cache-test.c
index 9469dc12..d9400fe5 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -550,6 +550,66 @@ do_cancel_test (SoupURI *base_uri)
 	g_free (body2);
 }
 
+static void
+do_refcounting_test (SoupURI *base_uri)
+{
+	SoupSession *session;
+	SoupCache *cache;
+	char *cache_dir;
+	SoupRequestHTTP *req;
+	GInputStream *stream, *base_stream;
+	SoupURI *uri;
+	GError *error = NULL;
+	guint flags;
+
+	debug_printf (1, "Cache refcounting tests\n");
+
+	cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
+	debug_printf (2, "  Caching to %s\n", cache_dir);
+	cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
+	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
+					 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
+					 SOUP_SESSION_ADD_FEATURE, cache,
+					 NULL);
+
+	last_request_validated = last_request_hit_network = FALSE;
+	cancelled_requests = 0;
+
+	uri = soup_uri_new_with_base (base_uri, "/1");
+	req = soup_session_request_http_uri (session, "GET", uri, NULL);
+	soup_uri_free (uri);
+
+	flags = SOUP_TEST_REQUEST_CANCEL_AFTER_SEND_FINISH | SOUP_TEST_REQUEST_CANCEL_MESSAGE;
+	stream = soup_test_request_send (SOUP_REQUEST (req), NULL, flags, &error);
+	if (!stream) {
+		debug_printf (1, "    could not send request: %s\n",
+			      error->message);
+		g_error_free (error);
+		g_object_unref (req);
+		return;
+	}
+
+	base_stream = g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (stream));
+	g_object_add_weak_pointer (G_OBJECT (base_stream), (gpointer *)&base_stream);
+
+	g_clear_object (&req);
+	g_object_unref (stream);
+
+	debug_printf (1, " Checking that the base stream is properly unref'ed\n");
+	if (base_stream) {
+		errors++;
+		debug_printf (1, "leaked GInputStream!\n");
+		g_object_remove_weak_pointer (G_OBJECT (base_stream), (gpointer *)&base_stream);
+	}
+
+	soup_cache_flush ((SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE));
+
+	soup_test_session_abort_unref (session);
+
+	g_object_unref (cache);
+	g_free (cache_dir);
+}
+
 int
 main (int argc, char **argv)
 {
@@ -565,6 +625,7 @@ main (int argc, char **argv)
 
 	do_basics_test (base_uri);
 	do_cancel_test (base_uri);
+	do_refcounting_test (base_uri);
 
 	soup_uri_free (base_uri);
 	soup_test_server_quit_unref (server);
-- 
cgit v1.2.1


From 74f914e293a112ee53ec4c87c925c5e56199f4b3 Mon Sep 17 00:00:00 2001
From: Sergio Villar Senin <svillar@igalia.com>
Date: Mon, 4 Mar 2013 17:58:41 +0100
Subject: soup-cache: update cached headers on revalidations

SoupCache was not updating the cached headers on conditional requests. We
were only doing it for revalidations started by libsoup clients.

This also properly reset the values of freshness_lifetime and
must_revalidate on revalidations. These two fields were keeping their
original values even if the server wasn't providing such information.

Finally this adds a new cache test (do_header_test) and fixes the one
disabled with #ifdefs (second revalidations).

https://bugzilla.gnome.org/show_bug.cgi?id=695121
---
 tests/cache-test.c | 161 ++++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 130 insertions(+), 31 deletions(-)

(limited to 'tests/cache-test.c')

diff --git a/tests/cache-test.c b/tests/cache-test.c
index d9400fe5..34389f8e 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -77,6 +77,14 @@ server_callback (SoupServer *server, SoupMessage *msg,
 			status = SOUP_STATUS_NOT_MODIFIED;
 	}
 
+	header = soup_message_headers_get_one (msg->request_headers,
+					       "Test-Set-My-Header");
+	if (header) {
+		soup_message_headers_append (msg->response_headers,
+					     "My-Header",
+					     header);
+	}
+
 	if (status == SOUP_STATUS_OK) {
 		GChecksum *sum;
 		const char *body;
@@ -105,21 +113,32 @@ is_network_stream (GInputStream *stream)
 	return !G_IS_FILE_INPUT_STREAM (stream);
 }
 
-static char *do_request (SoupSession *session,
-			 SoupURI     *base_uri,
-			 const char  *method,
-			 const char  *path,
+static char *do_request (SoupSession        *session,
+			 SoupURI            *base_uri,
+			 const char         *method,
+			 const char         *path,
+			 SoupMessageHeaders *response_headers,
 			 ...) G_GNUC_NULL_TERMINATED;
 
 static gboolean last_request_hit_network;
 static gboolean last_request_validated;
 static guint cancelled_requests;
 
+static void
+copy_headers (const char         *name,
+	      const char         *value,
+	      gpointer            user_data)
+{
+	SoupMessageHeaders *headers = (SoupMessageHeaders *) user_data;
+	soup_message_headers_append (headers, name, value);
+}
+
 static char *
-do_request (SoupSession *session,
-	    SoupURI     *base_uri,
-	    const char  *method,
-	    const char  *path,
+do_request (SoupSession        *session,
+	    SoupURI            *base_uri,
+	    const char         *method,
+	    const char         *path,
+	    SoupMessageHeaders *response_headers,
 	    ...)
 {
 	SoupRequestHTTP *req;
@@ -139,13 +158,12 @@ do_request (SoupSession *session,
 	soup_uri_free (uri);
 	msg = soup_request_http_get_message (req);
 
-	va_start (ap, path);
+	va_start (ap, response_headers);
 	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, 0, &error);
 	if (!stream) {
@@ -153,9 +171,15 @@ do_request (SoupSession *session,
 			      error->message);
 		g_error_free (error);
 		g_object_unref (req);
+		g_object_unref (msg);
 		return NULL;
 	}
 
+	if (response_headers)
+		soup_message_headers_foreach (msg->response_headers, copy_headers, response_headers);
+
+	g_object_unref (msg);
+
 	last_request_hit_network = is_network_stream (stream);
 
 	g_input_stream_read_all (stream, buf, sizeof (buf), &nread,
@@ -259,28 +283,28 @@ do_basics_test (SoupURI *base_uri)
 			  G_CALLBACK (request_started), NULL);
 
 	debug_printf (2, "  Initial requests\n");
-	body1 = do_request (session, base_uri, "GET", "/1",
+	body1 = do_request (session, base_uri, "GET", "/1", NULL,
 			    "Test-Set-Expires", "Fri, 01 Jan 2100 00:00:00 GMT",
 			    NULL);
-	body2 = do_request (session, base_uri, "GET", "/2",
+	body2 = do_request (session, base_uri, "GET", "/2", NULL,
 			    "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
 			    NULL);
-	body3 = do_request (session, base_uri, "GET", "/3",
+	body3 = do_request (session, base_uri, "GET", "/3", NULL,
 			    "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
 			    "Test-Set-Cache-Control", "must-revalidate",
 			    NULL);
-	body4 = do_request (session, base_uri, "GET", "/4",
+	body4 = do_request (session, base_uri, "GET", "/4", NULL,
 			    "Test-Set-ETag", "\"abcdefg\"",
 			    "Test-Set-Cache-Control", "must-revalidate",
 			    NULL);
-	body5 = do_request (session, base_uri, "GET", "/5",
+	body5 = do_request (session, base_uri, "GET", "/5", NULL,
 			    "Test-Set-Cache-Control", "no-cache",
 			    NULL);
 
 
 	/* Resource with future Expires should have been cached */
 	debug_printf (1, "  Fresh cached resource\n");
-	cmp = do_request (session, base_uri, "GET", "/1",
+	cmp = do_request (session, base_uri, "GET", "/1", NULL,
 			  NULL);
 	if (last_request_hit_network) {
 		debug_printf (1, "    Request for /1 not filled from cache!\n");
@@ -296,7 +320,7 @@ do_basics_test (SoupURI *base_uri)
 
 	/* Resource with long-ago Last-Modified should have been cached */
 	debug_printf (1, "  Heuristically-fresh cached resource\n");
-	cmp = do_request (session, base_uri, "GET", "/2",
+	cmp = do_request (session, base_uri, "GET", "/2", NULL,
 			  NULL);
 	if (last_request_hit_network) {
 		debug_printf (1, "    Request for /2 not filled from cache!\n");
@@ -312,7 +336,7 @@ do_basics_test (SoupURI *base_uri)
 
 	/* Adding a query string should bypass the cache but not invalidate it */
 	debug_printf (1, "  Fresh cached resource with a query\n");
-	cmp = do_request (session, base_uri, "GET", "/1?attr=value",
+	cmp = do_request (session, base_uri, "GET", "/1?attr=value", NULL,
 			  NULL);
 	if (!last_request_hit_network) {
 		debug_printf (1, "    Request for /1?attr=value filled from cache!\n");
@@ -320,7 +344,7 @@ do_basics_test (SoupURI *base_uri)
 	}
 	g_free (cmp);
 	debug_printf (2, "  Second request\n");
-	cmp = do_request (session, base_uri, "GET", "/1",
+	cmp = do_request (session, base_uri, "GET", "/1", NULL,
 			  NULL);
 	if (last_request_hit_network) {
 		debug_printf (1, "    Second request for /1 not filled from cache!\n");
@@ -336,7 +360,7 @@ do_basics_test (SoupURI *base_uri)
 
 	/* Last-Modified + must-revalidate causes a conditional request */
 	debug_printf (1, "  Unchanged must-revalidate resource w/ Last-Modified\n");
-	cmp = do_request (session, base_uri, "GET", "/3",
+	cmp = do_request (session, base_uri, "GET", "/3", NULL,
 			  "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
 			  "Test-Set-Cache-Control", "must-revalidate",
 			  NULL);
@@ -358,7 +382,7 @@ do_basics_test (SoupURI *base_uri)
 
 	/* Validation failure should update cache */
 	debug_printf (1, "  Changed must-revalidate resource w/ Last-Modified\n");
-	cmp = do_request (session, base_uri, "GET", "/3",
+	cmp = do_request (session, base_uri, "GET", "/3", NULL,
 			  "Test-Set-Last-Modified", "Sat, 02 Jan 2010 00:00:00 GMT",
 			  "Test-Set-Cache-Control", "must-revalidate",
 			  NULL);
@@ -376,9 +400,8 @@ do_basics_test (SoupURI *base_uri)
 	}
 	g_free (cmp);
 
-#if 0 /* This doesn't work... is the test wrong or is SoupCache? */
 	debug_printf (2, "  Second request\n");
-	cmp = do_request (session, base_uri, "GET", "/3",
+	cmp = do_request (session, base_uri, "GET", "/3", NULL,
 			  "Test-Set-Last-Modified", "Sat, 02 Jan 2010 00:00:00 GMT",
 			  "Test-Set-Cache-Control", "must-revalidate",
 			  NULL);
@@ -395,12 +418,10 @@ do_basics_test (SoupURI *base_uri)
 		errors++;
 	}
 	g_free (cmp);
-#endif
-
 
 	/* ETag + must-revalidate causes a conditional request */
 	debug_printf (1, "  Unchanged must-revalidate resource w/ ETag\n");
-	cmp = do_request (session, base_uri, "GET", "/4",
+	cmp = do_request (session, base_uri, "GET", "/4", NULL,
 			  "Test-Set-ETag", "\"abcdefg\"",
 			  NULL);
 	if (!last_request_validated) {
@@ -421,7 +442,7 @@ do_basics_test (SoupURI *base_uri)
 
 	/* Cache-Control: no-cache prevents caching */
 	debug_printf (1, "  Uncacheable resource\n");
-	cmp = do_request (session, base_uri, "GET", "/5",
+	cmp = do_request (session, base_uri, "GET", "/5", NULL,
 			  "Test-Set-Cache-Control", "no-cache",
 			  NULL);
 	if (!last_request_hit_network) {
@@ -438,14 +459,14 @@ do_basics_test (SoupURI *base_uri)
 
 	/* PUT to a URI invalidates the cache entry */
 	debug_printf (1, "  Invalidating and re-requesting a cached resource\n");
-	cmp = do_request (session, base_uri, "PUT", "/1",
+	cmp = do_request (session, base_uri, "PUT", "/1", NULL,
 			  NULL);
 	if (!last_request_hit_network) {
 		debug_printf (1, "    PUT filled from cache!\n");
 		errors++;
 	}
 	g_free (cmp);
-	cmp = do_request (session, base_uri, "GET", "/1",
+	cmp = do_request (session, base_uri, "GET", "/1", NULL,
 			  NULL);
 	if (!last_request_hit_network) {
 		debug_printf (1, "    PUT failed to invalidate cache entry!\n");
@@ -487,10 +508,10 @@ do_cancel_test (SoupURI *base_uri)
 			  G_CALLBACK (request_unqueued), NULL);
 
 	debug_printf (2, "  Initial requests\n");
-	body1 = do_request (session, base_uri, "GET", "/1",
+	body1 = do_request (session, base_uri, "GET", "/1", NULL,
 			    "Test-Set-Expires", "Fri, 01 Jan 2100 00:00:00 GMT",
 			    NULL);
-	body2 = do_request (session, base_uri, "GET", "/2",
+	body2 = do_request (session, base_uri, "GET", "/2", NULL,
 			    "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
 			    "Test-Set-Cache-Control", "must-revalidate",
 			    NULL);
@@ -610,6 +631,83 @@ do_refcounting_test (SoupURI *base_uri)
 	g_free (cache_dir);
 }
 
+static void
+do_headers_test (SoupURI *base_uri)
+{
+	SoupSession *session;
+	SoupMessageHeaders *headers;
+	SoupCache *cache;
+	char *cache_dir;
+	char *body1, *cmp;
+	const char *header_value;
+
+	debug_printf (1, "Cache basics\n");
+
+	cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
+	debug_printf (2, "  Caching to %s\n", cache_dir);
+	cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
+	session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
+					 SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
+					 SOUP_SESSION_ADD_FEATURE, cache,
+					 NULL);
+
+	g_signal_connect (session, "request-started",
+			  G_CALLBACK (request_started), NULL);
+
+	debug_printf (2, "  Initial requests\n");
+	body1 = do_request (session, base_uri, "GET", "/1", NULL,
+			    "Test-Set-Last-Modified", "Fri, 01 Jan 2100 00:00:00 GMT",
+			    "Test-Set-My-Header", "My header value",
+			    NULL);
+
+	/* My-Header new value should be updated in cache */
+	debug_printf (2, "  Fresh cached resource which updates My-Header\n");
+	cmp = do_request (session, base_uri, "GET", "/1", NULL,
+			  "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
+			  "Test-Set-My-Header", "My header NEW value",
+			  NULL);
+	if (!last_request_validated) {
+		debug_printf (1, "    Request for /1 not validated!\n");
+		errors++;
+	}
+	if (last_request_hit_network) {
+		debug_printf (1, "    Request for /1 not filled from cache!\n");
+		errors++;
+	}
+	g_free (cmp);
+
+	/* Check that cache returns the updated header */
+	debug_printf (2, "  Fresh cached resource with new value for My-Header\n");
+	headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_RESPONSE);
+	cmp = do_request (session, base_uri, "GET", "/1", headers,
+			  "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
+			  NULL);
+	if (last_request_hit_network) {
+		debug_printf (1, "    Request for /1 not filled from cache!\n");
+		errors++;
+	}
+	g_free (cmp);
+
+	header_value = soup_message_headers_get_list (headers, "My-Header");
+	if (!header_value) {
+		debug_printf (1, "    Header \"My-Header\" not present!\n");
+		errors++;
+	}
+	if (strcmp (header_value, "My header NEW value") != 0) {
+		debug_printf (1, "    \"My-Header = %s\" and should be \"%s\"\n",
+			      header_value,
+			      "My header NEW value");
+		errors++;
+	}
+	soup_message_headers_free (headers);
+
+	soup_test_session_abort_unref (session);
+	g_object_unref (cache);
+
+	g_free (cache_dir);
+	g_free (body1);
+}
+
 int
 main (int argc, char **argv)
 {
@@ -626,6 +724,7 @@ main (int argc, char **argv)
 	do_basics_test (base_uri);
 	do_cancel_test (base_uri);
 	do_refcounting_test (base_uri);
+	do_headers_test (base_uri);
 
 	soup_uri_free (base_uri);
 	soup_test_server_quit_unref (server);
-- 
cgit v1.2.1


From 164e49a27eeeedca800f466b0b14a4e61a162007 Mon Sep 17 00:00:00 2001
From: Dan Winship <danw@gnome.org>
Date: Fri, 23 Aug 2013 13:34:37 -0400
Subject: cache-test: fix race condition

The refcounting test had a race condition. Fix it by just waiting for
the stream to be destroyed, rather than asserting it already has been.

https://bugzilla.gnome.org/show_bug.cgi?id=698305
---
 tests/cache-test.c | 29 ++++++++++++++++++++---------
 1 file changed, 20 insertions(+), 9 deletions(-)

(limited to 'tests/cache-test.c')

diff --git a/tests/cache-test.c b/tests/cache-test.c
index 34389f8e..a8d01ebf 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -571,6 +571,19 @@ do_cancel_test (SoupURI *base_uri)
 	g_free (body2);
 }
 
+static gboolean
+unref_stream (gpointer stream)
+{
+	g_object_unref (stream);
+	return FALSE;
+}
+
+static void
+base_stream_unreffed (gpointer loop, GObject *ex_base_stream)
+{
+	g_main_loop_quit (loop);
+}
+
 static void
 do_refcounting_test (SoupURI *base_uri)
 {
@@ -582,6 +595,7 @@ do_refcounting_test (SoupURI *base_uri)
 	SoupURI *uri;
 	GError *error = NULL;
 	guint flags;
+	GMainLoop *loop;
 
 	debug_printf (1, "Cache refcounting tests\n");
 
@@ -609,19 +623,16 @@ do_refcounting_test (SoupURI *base_uri)
 		g_object_unref (req);
 		return;
 	}
+	g_object_unref (req);
 
 	base_stream = g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (stream));
-	g_object_add_weak_pointer (G_OBJECT (base_stream), (gpointer *)&base_stream);
-
-	g_clear_object (&req);
-	g_object_unref (stream);
 
 	debug_printf (1, " Checking that the base stream is properly unref'ed\n");
-	if (base_stream) {
-		errors++;
-		debug_printf (1, "leaked GInputStream!\n");
-		g_object_remove_weak_pointer (G_OBJECT (base_stream), (gpointer *)&base_stream);
-	}
+	loop = g_main_loop_new (NULL, FALSE);
+	g_object_weak_ref (G_OBJECT (base_stream), base_stream_unreffed, loop);
+	g_idle_add (unref_stream, stream);
+	g_main_loop_run (loop);
+	g_main_loop_unref (loop);
 
 	soup_cache_flush ((SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE));
 
-- 
cgit v1.2.1


From 03fd6fdc23e0652dda8cb11a16d3fe9b41e16ba9 Mon Sep 17 00:00:00 2001
From: Dan Winship <danw@gnome.org>
Date: Wed, 11 Sep 2013 15:33:04 -0400
Subject: cache-test: fix some minor things pointed out by coverity

---
 tests/cache-test.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'tests/cache-test.c')

diff --git a/tests/cache-test.c b/tests/cache-test.c
index a8d01ebf..a19e9747 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -164,6 +164,7 @@ do_request (SoupSession        *session,
 		soup_message_headers_append (msg->request_headers,
 					     header, value);
 	}
+	va_end (ap);
 
 	stream = soup_test_request_send (SOUP_REQUEST (req), NULL, 0, &error);
 	if (!stream) {
@@ -703,8 +704,7 @@ do_headers_test (SoupURI *base_uri)
 	if (!header_value) {
 		debug_printf (1, "    Header \"My-Header\" not present!\n");
 		errors++;
-	}
-	if (strcmp (header_value, "My header NEW value") != 0) {
+	} else if (strcmp (header_value, "My header NEW value") != 0) {
 		debug_printf (1, "    \"My-Header = %s\" and should be \"%s\"\n",
 			      header_value,
 			      "My header NEW value");
-- 
cgit v1.2.1


From 64e667bda5009c8f1acd03659c457e26b16457a6 Mon Sep 17 00:00:00 2001
From: Dan Winship <danw@gnome.org>
Date: Tue, 10 Dec 2013 15:47:34 +0100
Subject: tests: initial port to the gtestutils framework

Some programs need to be split up into more tests, and the debug
output is mostly not updated for the new format.
---
 tests/cache-test.c | 214 +++++++++++++++++------------------------------------
 1 file changed, 66 insertions(+), 148 deletions(-)

(limited to 'tests/cache-test.c')

diff --git a/tests/cache-test.c b/tests/cache-test.c
index a19e9747..b60fb9c1 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -264,8 +264,9 @@ request_unqueued (SoupSession *session, SoupMessage *msg,
 }
 
 static void
-do_basics_test (SoupURI *base_uri)
+do_basics_test (gconstpointer data)
 {
+	SoupURI *base_uri = (SoupURI *)data;
 	SoupSession *session;
 	SoupCache *cache;
 	char *cache_dir;
@@ -307,15 +308,9 @@ do_basics_test (SoupURI *base_uri)
 	debug_printf (1, "  Fresh cached resource\n");
 	cmp = do_request (session, base_uri, "GET", "/1", NULL,
 			  NULL);
-	if (last_request_hit_network) {
-		debug_printf (1, "    Request for /1 not filled from cache!\n");
-		errors++;
-	}
-	if (strcmp (body1, cmp) != 0) {
-		debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
-			      cmp, body1);
-		errors++;
-	}
+	soup_test_assert (!last_request_hit_network,
+			  "Request for /1 not filled from cache");
+	g_assert_cmpstr (body1, ==, cmp);
 	g_free (cmp);
 
 
@@ -323,15 +318,9 @@ do_basics_test (SoupURI *base_uri)
 	debug_printf (1, "  Heuristically-fresh cached resource\n");
 	cmp = do_request (session, base_uri, "GET", "/2", NULL,
 			  NULL);
-	if (last_request_hit_network) {
-		debug_printf (1, "    Request for /2 not filled from cache!\n");
-		errors++;
-	}
-	if (strcmp (body2, cmp) != 0) {
-		debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
-			      cmp, body2);
-		errors++;
-	}
+	soup_test_assert (!last_request_hit_network,
+			  "Request for /2 not filled from cache");
+	g_assert_cmpstr (body2, ==, cmp);
 	g_free (cmp);
 
 
@@ -339,23 +328,15 @@ do_basics_test (SoupURI *base_uri)
 	debug_printf (1, "  Fresh cached resource with a query\n");
 	cmp = do_request (session, base_uri, "GET", "/1?attr=value", NULL,
 			  NULL);
-	if (!last_request_hit_network) {
-		debug_printf (1, "    Request for /1?attr=value filled from cache!\n");
-		errors++;
-	}
+	soup_test_assert (last_request_hit_network,
+			  "Request for /1?attr=value filled from cache");
 	g_free (cmp);
 	debug_printf (2, "  Second request\n");
 	cmp = do_request (session, base_uri, "GET", "/1", NULL,
 			  NULL);
-	if (last_request_hit_network) {
-		debug_printf (1, "    Second request for /1 not filled from cache!\n");
-		errors++;
-	}
-	if (strcmp (body1, cmp) != 0) {
-		debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
-			      cmp, body1);
-		errors++;
-	}
+	soup_test_assert (!last_request_hit_network,
+			  "Second request for /1 not filled from cache");
+	g_assert_cmpstr (body1, ==, cmp);
 	g_free (cmp);
 
 
@@ -365,19 +346,11 @@ do_basics_test (SoupURI *base_uri)
 			  "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
 			  "Test-Set-Cache-Control", "must-revalidate",
 			  NULL);
-	if (!last_request_validated) {
-		debug_printf (1, "    Request for /3 not validated!\n");
-		errors++;
-	}
-	if (last_request_hit_network) {
-		debug_printf (1, "    Request for /3 not filled from cache!\n");
-		errors++;
-	}
-	if (strcmp (body3, cmp) != 0) {
-		debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
-			      cmp, body3);
-		errors++;
-	}
+	soup_test_assert (last_request_validated,
+			  "Request for /3 not validated");
+	soup_test_assert (!last_request_hit_network,
+			  "Request for /3 not filled from cache");
+	g_assert_cmpstr (body3, ==, cmp);
 	g_free (cmp);
 
 
@@ -387,18 +360,11 @@ do_basics_test (SoupURI *base_uri)
 			  "Test-Set-Last-Modified", "Sat, 02 Jan 2010 00:00:00 GMT",
 			  "Test-Set-Cache-Control", "must-revalidate",
 			  NULL);
-	if (!last_request_validated) {
-		debug_printf (1, "    Request for /3 not validated!\n");
-		errors++;
-	}
-	if (!last_request_hit_network) {
-		debug_printf (1, "    Request for /3 filled from cache!\n");
-		errors++;
-	}
-	if (strcmp (body3, cmp) == 0) {
-		debug_printf (1, "    Request for /3 returned cached response\n");
-		errors++;
-	}
+	soup_test_assert (last_request_validated,
+			  "Request for /3 not validated");
+	soup_test_assert (last_request_hit_network,
+			  "Request for /3 filled from cache");
+	g_assert_cmpstr (body3, !=, cmp);
 	g_free (cmp);
 
 	debug_printf (2, "  Second request\n");
@@ -406,18 +372,11 @@ do_basics_test (SoupURI *base_uri)
 			  "Test-Set-Last-Modified", "Sat, 02 Jan 2010 00:00:00 GMT",
 			  "Test-Set-Cache-Control", "must-revalidate",
 			  NULL);
-	if (!last_request_validated) {
-		debug_printf (1, "    Second request for /3 not validated!\n");
-		errors++;
-	}
-	if (last_request_hit_network) {
-		debug_printf (1, "    Second request for /3 not filled from cache!\n");
-		errors++;
-	}
-	if (strcmp (body3, cmp) == 0) {
-		debug_printf (1, "    Replacement body for /3 not cached!\n");
-		errors++;
-	}
+	soup_test_assert (last_request_validated,
+			  "Second request for /3 not validated");
+	soup_test_assert (!last_request_hit_network,
+			  "Second request for /3 not filled from cache");
+	g_assert_cmpstr (body3, !=, cmp);
 	g_free (cmp);
 
 	/* ETag + must-revalidate causes a conditional request */
@@ -425,19 +384,11 @@ do_basics_test (SoupURI *base_uri)
 	cmp = do_request (session, base_uri, "GET", "/4", NULL,
 			  "Test-Set-ETag", "\"abcdefg\"",
 			  NULL);
-	if (!last_request_validated) {
-		debug_printf (1, "    Request for /4 not validated!\n");
-		errors++;
-	}
-	if (last_request_hit_network) {
-		debug_printf (1, "    Request for /4 not filled from cache!\n");
-		errors++;
-	}
-	if (strcmp (body4, cmp) != 0) {
-		debug_printf (1, "    Cached response (%s) did not match original (%s)\n",
-			      cmp, body4);
-		errors++;
-	}
+	soup_test_assert (last_request_validated,
+			  "Request for /4 not validated");
+	soup_test_assert (!last_request_hit_network,
+			  "Request for /4 not filled from cache");
+	g_assert_cmpstr (body4, ==, cmp);
 	g_free (cmp);
 
 
@@ -446,15 +397,9 @@ do_basics_test (SoupURI *base_uri)
 	cmp = do_request (session, base_uri, "GET", "/5", NULL,
 			  "Test-Set-Cache-Control", "no-cache",
 			  NULL);
-	if (!last_request_hit_network) {
-		debug_printf (1, "    Request for /5 filled from cache!\n");
-		errors++;
-	}
-	if (strcmp (body5, cmp) != 0) {
-		debug_printf (1, "    Re-retrieved response (%s) did not match original (%s)\n",
-			      cmp, body5);
-		errors++;
-	}
+	soup_test_assert (last_request_hit_network,
+			  "Request for /5 filled from cache");
+	g_assert_cmpstr (body5, ==, cmp);
 	g_free (cmp);
 
 
@@ -462,17 +407,14 @@ do_basics_test (SoupURI *base_uri)
 	debug_printf (1, "  Invalidating and re-requesting a cached resource\n");
 	cmp = do_request (session, base_uri, "PUT", "/1", NULL,
 			  NULL);
-	if (!last_request_hit_network) {
-		debug_printf (1, "    PUT filled from cache!\n");
-		errors++;
-	}
+	soup_test_assert (last_request_hit_network,
+			  "PUT filled from cache");
 	g_free (cmp);
 	cmp = do_request (session, base_uri, "GET", "/1", NULL,
 			  NULL);
-	if (!last_request_hit_network) {
-		debug_printf (1, "    PUT failed to invalidate cache entry!\n");
-		errors++;
-	}
+	soup_test_assert (last_request_hit_network,
+			  "PUT failed to invalidate cache entry");
+	g_assert_true (last_request_hit_network);
 	g_free (cmp);
 
 
@@ -488,8 +430,9 @@ do_basics_test (SoupURI *base_uri)
 }
 
 static void
-do_cancel_test (SoupURI *base_uri)
+do_cancel_test (gconstpointer data)
 {
+	SoupURI *base_uri = (SoupURI *)data;
 	SoupSession *session;
 	SoupCache *cache;
 	char *cache_dir;
@@ -521,20 +464,12 @@ do_cancel_test (SoupURI *base_uri)
 	debug_printf (1, "  Cancel fresh resource with soup_session_message_cancel()\n");
 	flags = SOUP_TEST_REQUEST_CANCEL_MESSAGE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
 	do_request_with_cancel (session, base_uri, "GET", "/1", flags);
-	if (cancelled_requests != 1) {
-		debug_printf (1, "    invalid number of cancelled requests: %d (1 expected)\n",
-			      cancelled_requests);
-		errors++;
-	}
+	g_assert_cmpint (cancelled_requests, ==, 1);
 
 	debug_printf (1, "  Cancel fresh resource with g_cancellable_cancel()\n");
 	flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
 	do_request_with_cancel (session, base_uri, "GET", "/1", flags);
-	if (cancelled_requests != 1) {
-		debug_printf (1, "    invalid number of cancelled requests: %d (1 expected)\n",
-			      cancelled_requests);
-		errors++;
-	}
+	g_assert_cmpint (cancelled_requests, ==, 1);
 
 	soup_test_session_abort_unref (session);
 
@@ -549,20 +484,12 @@ do_cancel_test (SoupURI *base_uri)
 	debug_printf (1, "  Cancel a revalidating resource with soup_session_message_cancel()\n");
 	flags = SOUP_TEST_REQUEST_CANCEL_MESSAGE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
 	do_request_with_cancel (session, base_uri, "GET", "/2", flags);
-	if (cancelled_requests != 2) {
-		debug_printf (1, "    invalid number of cancelled requests: %d (2 expected)\n",
-			      cancelled_requests);
-		errors++;
-	}
+	g_assert_cmpint (cancelled_requests, ==, 2);
 
 	debug_printf (1, "  Cancel a revalidating resource with g_cancellable_cancel()\n");
 	flags = SOUP_TEST_REQUEST_CANCEL_CANCELLABLE | SOUP_TEST_REQUEST_CANCEL_IMMEDIATE;
 	do_request_with_cancel (session, base_uri, "GET", "/2", flags);
-	if (cancelled_requests != 2) {
-		debug_printf (1, "    invalid number of cancelled requests: %d (2 expected)\n",
-			      cancelled_requests);
-		errors++;
-	}
+	g_assert_cmpint (cancelled_requests, ==, 2);
 
 	soup_test_session_abort_unref (session);
 
@@ -586,8 +513,9 @@ base_stream_unreffed (gpointer loop, GObject *ex_base_stream)
 }
 
 static void
-do_refcounting_test (SoupURI *base_uri)
+do_refcounting_test (gconstpointer data)
 {
+	SoupURI *base_uri = (SoupURI *)data;
 	SoupSession *session;
 	SoupCache *cache;
 	char *cache_dir;
@@ -644,8 +572,9 @@ do_refcounting_test (SoupURI *base_uri)
 }
 
 static void
-do_headers_test (SoupURI *base_uri)
+do_headers_test (gconstpointer data)
 {
+	SoupURI *base_uri = (SoupURI *)data;
 	SoupSession *session;
 	SoupMessageHeaders *headers;
 	SoupCache *cache;
@@ -678,14 +607,10 @@ do_headers_test (SoupURI *base_uri)
 			  "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
 			  "Test-Set-My-Header", "My header NEW value",
 			  NULL);
-	if (!last_request_validated) {
-		debug_printf (1, "    Request for /1 not validated!\n");
-		errors++;
-	}
-	if (last_request_hit_network) {
-		debug_printf (1, "    Request for /1 not filled from cache!\n");
-		errors++;
-	}
+	soup_test_assert (last_request_validated,
+			  "Request for /1 not validated");
+	soup_test_assert (!last_request_hit_network,
+			  "Request for /1 not filled from cache");
 	g_free (cmp);
 
 	/* Check that cache returns the updated header */
@@ -694,22 +619,12 @@ do_headers_test (SoupURI *base_uri)
 	cmp = do_request (session, base_uri, "GET", "/1", headers,
 			  "Test-Set-Last-Modified", "Fri, 01 Jan 2010 00:00:00 GMT",
 			  NULL);
-	if (last_request_hit_network) {
-		debug_printf (1, "    Request for /1 not filled from cache!\n");
-		errors++;
-	}
+	soup_test_assert (!last_request_hit_network,
+			  "Request for /1 not filled from cache");
 	g_free (cmp);
 
 	header_value = soup_message_headers_get_list (headers, "My-Header");
-	if (!header_value) {
-		debug_printf (1, "    Header \"My-Header\" not present!\n");
-		errors++;
-	} else if (strcmp (header_value, "My header NEW value") != 0) {
-		debug_printf (1, "    \"My-Header = %s\" and should be \"%s\"\n",
-			      header_value,
-			      "My header NEW value");
-		errors++;
-	}
+	g_assert_cmpstr (header_value, ==, "My header NEW value");
 	soup_message_headers_free (headers);
 
 	soup_test_session_abort_unref (session);
@@ -724,6 +639,7 @@ main (int argc, char **argv)
 {
 	SoupServer *server;
 	SoupURI *base_uri;
+	int ret;
 
 	test_init (argc, argv, NULL);
 
@@ -732,14 +648,16 @@ main (int argc, char **argv)
 	base_uri = soup_uri_new ("http://127.0.0.1/");
 	soup_uri_set_port (base_uri, soup_server_get_port (server));
 
-	do_basics_test (base_uri);
-	do_cancel_test (base_uri);
-	do_refcounting_test (base_uri);
-	do_headers_test (base_uri);
+	g_test_add_data_func ("/cache/basics", base_uri, do_basics_test);
+	g_test_add_data_func ("/cache/cancellation", base_uri, do_cancel_test);
+	g_test_add_data_func ("/cache/refcounting", base_uri, do_refcounting_test);
+	g_test_add_data_func ("/cache/headers", base_uri, do_headers_test);
+
+	ret = g_test_run ();
 
 	soup_uri_free (base_uri);
 	soup_test_server_quit_unref (server);
 
 	test_cleanup ();
-	return errors != 0;
+	return ret;
 }
-- 
cgit v1.2.1


From 8e2402651807403c6d42ecb75563f480405e8660 Mon Sep 17 00:00:00 2001
From: Dan Winship <danw@gnome.org>
Date: Sat, 15 Mar 2014 11:57:34 -0400
Subject: tests: remove debug_printf()s that are redundant with test names

---
 tests/cache-test.c | 8 --------
 1 file changed, 8 deletions(-)

(limited to 'tests/cache-test.c')

diff --git a/tests/cache-test.c b/tests/cache-test.c
index b60fb9c1..c499a776 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -272,8 +272,6 @@ do_basics_test (gconstpointer data)
 	char *cache_dir;
 	char *body1, *body2, *body3, *body4, *body5, *cmp;
 
-	debug_printf (1, "Cache basics\n");
-
 	cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
 	debug_printf (2, "  Caching to %s\n", cache_dir);
 	cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
@@ -439,8 +437,6 @@ do_cancel_test (gconstpointer data)
 	char *body1, *body2;
 	guint flags;
 
-	debug_printf (1, "Cache cancel tests\n");
-
 	cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
 	debug_printf (2, "  Caching to %s\n", cache_dir);
 	cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
@@ -526,8 +522,6 @@ do_refcounting_test (gconstpointer data)
 	guint flags;
 	GMainLoop *loop;
 
-	debug_printf (1, "Cache refcounting tests\n");
-
 	cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
 	debug_printf (2, "  Caching to %s\n", cache_dir);
 	cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
@@ -582,8 +576,6 @@ do_headers_test (gconstpointer data)
 	char *body1, *cmp;
 	const char *header_value;
 
-	debug_printf (1, "Cache basics\n");
-
 	cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
 	debug_printf (2, "  Caching to %s\n", cache_dir);
 	cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
-- 
cgit v1.2.1


From a1591e15bf2c4a690e79698cdd078f6ed01e48d3 Mon Sep 17 00:00:00 2001
From: Dan Winship <danw@gnome.org>
Date: Sat, 15 Mar 2014 14:19:45 -0400
Subject: tests: use g_test_bug() to annotate test cases

---
 tests/cache-test.c | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'tests/cache-test.c')

diff --git a/tests/cache-test.c b/tests/cache-test.c
index c499a776..3478f377 100644
--- a/tests/cache-test.c
+++ b/tests/cache-test.c
@@ -437,6 +437,8 @@ do_cancel_test (gconstpointer data)
 	char *body1, *body2;
 	guint flags;
 
+	g_test_bug ("692310");
+
 	cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
 	debug_printf (2, "  Caching to %s\n", cache_dir);
 	cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
@@ -522,6 +524,8 @@ do_refcounting_test (gconstpointer data)
 	guint flags;
 	GMainLoop *loop;
 
+	g_test_bug ("682527");
+
 	cache_dir = g_dir_make_tmp ("cache-test-XXXXXX", NULL);
 	debug_printf (2, "  Caching to %s\n", cache_dir);
 	cache = soup_cache_new (cache_dir, SOUP_CACHE_SINGLE_USER);
-- 
cgit v1.2.1