1 files changed, 326 insertions, 0 deletions
diff --git a/Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestCookieManager.cpp b/Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestCookieManager.cpp
new file mode 100644
index 000000000..1e842cd04
--- /dev/null
+++ b/Tools/TestWebKitAPI/Tests/WebKit2Gtk/TestCookieManager.cpp
@@ -0,0 +1,326 @@
+/*
+ * Copyright (C) 2012 Igalia S.L.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+
+#include "WebKitTestServer.h"
+#include "WebViewTest.h"
+#include <glib/gstdio.h>
+
+static WebKitTestServer* kServer;
+
+static const char* kFirstPartyDomain = "127.0.0.1";
+static const char* kThirdPartyDomain = "localhost";
+static const char* kIndexHtmlFormat =
+    "<html><body>"
+    " <p>WebKitGTK+ Cookie Manager test</p>"
+    " <img src='http://localhost:%u/image.png' width=5 height=5></img>"
+    "</body></html>";
+
+class CookieManagerTest: public WebViewTest {
+public:
+    MAKE_GLIB_TEST_FIXTURE(CookieManagerTest);
+
+    static void cookiesChangedCallback(WebKitCookieManager*, CookieManagerTest* test)
+    {
+        test->m_cookiesChanged = true;
+        if (test->m_finishLoopWhenCookiesChange)
+            g_main_loop_quit(test->m_mainLoop);
+    }
+
+    CookieManagerTest()
+        : WebViewTest()
+        , m_cookieManager(webkit_web_context_get_cookie_manager(webkit_web_view_get_context(m_webView)))
+        , m_acceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY)
+        , m_domains(0)
+        , m_cookiesChanged(false)
+        , m_finishLoopWhenCookiesChange(false)
+    {
+        g_signal_connect(m_cookieManager, "changed", G_CALLBACK(cookiesChangedCallback), this);
+    }
+
+    ~CookieManagerTest()
+    {
+        g_strfreev(m_domains);
+        g_signal_handlers_disconnect_matched(m_cookieManager, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, this);
+        if (m_cookiesTextFile)
+            g_unlink(m_cookiesTextFile.get());
+        if (m_cookiesSQLiteFile)
+            g_unlink(m_cookiesSQLiteFile.get());
+    }
+
+    void setPersistentStorage(WebKitCookiePersistentStorage storage)
+    {
+        const char* filename = 0;
+        switch (storage) {
+        case WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT:
+            if (!m_cookiesTextFile)
+                m_cookiesTextFile.reset(g_build_filename(Test::dataDirectory(), "cookies.txt", nullptr));
+            filename = m_cookiesTextFile.get();
+            break;
+        case WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE:
+            if (!m_cookiesSQLiteFile)
+                m_cookiesSQLiteFile.reset(g_build_filename(Test::dataDirectory(), "cookies.db", nullptr));
+            filename = m_cookiesSQLiteFile.get();
+            break;
+        default:
+            g_assert_not_reached();
+        }
+        webkit_cookie_manager_set_persistent_storage(m_cookieManager, filename, storage);
+    }
+
+    static void getAcceptPolicyReadyCallback(GObject* object, GAsyncResult* result, gpointer userData)
+    {
+        GUniqueOutPtr<GError> error;
+        WebKitCookieAcceptPolicy policy = webkit_cookie_manager_get_accept_policy_finish(WEBKIT_COOKIE_MANAGER(object), result, &error.outPtr());
+        g_assert(!error.get());
+
+        CookieManagerTest* test = static_cast<CookieManagerTest*>(userData);
+        test->m_acceptPolicy = policy;
+        g_main_loop_quit(test->m_mainLoop);
+    }
+
+    WebKitCookieAcceptPolicy getAcceptPolicy()
+    {
+        m_acceptPolicy = WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY;
+        webkit_cookie_manager_get_accept_policy(m_cookieManager, 0, getAcceptPolicyReadyCallback, this);
+        g_main_loop_run(m_mainLoop);
+
+        return m_acceptPolicy;
+    }
+
+    void setAcceptPolicy(WebKitCookieAcceptPolicy policy)
+    {
+        webkit_cookie_manager_set_accept_policy(m_cookieManager, policy);
+    }
+
+    static void getDomainsReadyCallback(GObject* object, GAsyncResult* result, gpointer userData)
+    {
+        GUniqueOutPtr<GError> error;
+        char** domains = webkit_cookie_manager_get_domains_with_cookies_finish(WEBKIT_COOKIE_MANAGER(object), result, &error.outPtr());
+        g_assert(!error.get());
+
+        CookieManagerTest* test = static_cast<CookieManagerTest*>(userData);
+        test->m_domains = domains;
+        g_main_loop_quit(test->m_mainLoop);
+    }
+
+    char** getDomains()
+    {
+        g_strfreev(m_domains);
+        m_domains = 0;
+        webkit_cookie_manager_get_domains_with_cookies(m_cookieManager, 0, getDomainsReadyCallback, this);
+        g_main_loop_run(m_mainLoop);
+
+        return m_domains;
+    }
+
+    bool hasDomain(const char* domain)
+    {
+        if (!m_domains)
+            return false;
+
+        for (size_t i = 0; m_domains[i]; ++i)
+            if (g_str_equal(m_domains[i], domain))
+                return true;
+        return false;
+    }
+
+    void deleteCookiesForDomain(const char* domain)
+    {
+        webkit_cookie_manager_delete_cookies_for_domain(m_cookieManager, domain);
+    }
+
+    void deleteAllCookies()
+    {
+        webkit_cookie_manager_delete_all_cookies(m_cookieManager);
+    }
+
+    void waitUntilCookiesChanged()
+    {
+        m_cookiesChanged = false;
+        m_finishLoopWhenCookiesChange = true;
+        g_main_loop_run(m_mainLoop);
+        m_finishLoopWhenCookiesChange = false;
+    }
+
+    WebKitCookieManager* m_cookieManager;
+    WebKitCookieAcceptPolicy m_acceptPolicy;
+    char** m_domains;
+    bool m_cookiesChanged;
+    bool m_finishLoopWhenCookiesChange;
+    GUniquePtr<char> m_cookiesTextFile;
+    GUniquePtr<char> m_cookiesSQLiteFile;
+};
+
+static void testCookieManagerAcceptPolicy(CookieManagerTest* test, gconstpointer)
+{
+    // Default policy is NO_THIRD_PARTY.
+    g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NO_THIRD_PARTY);
+    test->loadURI(kServer->getURIForPath("/index.html").data());
+    test->waitUntilLoadFinished();
+    char** domains = test->getDomains();
+    g_assert(domains);
+    g_assert_cmpint(g_strv_length(domains), ==, 1);
+    g_assert_cmpstr(domains[0], ==, kFirstPartyDomain);
+    test->deleteAllCookies();
+
+    test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
+    g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
+    test->loadURI(kServer->getURIForPath("/index.html").data());
+    test->waitUntilLoadFinished();
+    domains = test->getDomains();
+    g_assert(domains);
+    g_assert_cmpint(g_strv_length(domains), ==, 2);
+    g_assert(test->hasDomain(kFirstPartyDomain));
+    g_assert(test->hasDomain(kThirdPartyDomain));
+    test->deleteAllCookies();
+
+    test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);
+    g_assert_cmpint(test->getAcceptPolicy(), ==, WEBKIT_COOKIE_POLICY_ACCEPT_NEVER);
+    test->loadURI(kServer->getURIForPath("/index.html").data());
+    test->waitUntilLoadFinished();
+    domains = test->getDomains();
+    g_assert(domains);
+    g_assert_cmpint(g_strv_length(domains), ==, 0);
+}
+
+static void testCookieManagerDeleteCookies(CookieManagerTest* test, gconstpointer)
+{
+    test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
+    test->loadURI(kServer->getURIForPath("/index.html").data());
+    test->waitUntilLoadFinished();
+    g_assert_cmpint(g_strv_length(test->getDomains()), ==, 2);
+
+    // Delete first party cookies.
+    test->deleteCookiesForDomain(kFirstPartyDomain);
+    g_assert_cmpint(g_strv_length(test->getDomains()), ==, 1);
+
+    // Delete third party cookies.
+    test->deleteCookiesForDomain(kThirdPartyDomain);
+    g_assert_cmpint(g_strv_length(test->getDomains()), ==, 0);
+
+    test->loadURI(kServer->getURIForPath("/index.html").data());
+    test->waitUntilLoadFinished();
+    g_assert_cmpint(g_strv_length(test->getDomains()), ==, 2);
+
+    // Delete all cookies.
+    test->deleteAllCookies();
+    g_assert_cmpint(g_strv_length(test->getDomains()), ==, 0);
+}
+
+static void testCookieManagerCookiesChanged(CookieManagerTest* test, gconstpointer)
+{
+    g_assert(!test->m_cookiesChanged);
+    test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
+    test->loadURI(kServer->getURIForPath("/index.html").data());
+    test->waitUntilLoadFinished();
+    g_assert(test->m_cookiesChanged);
+
+    test->deleteCookiesForDomain(kFirstPartyDomain);
+    test->waitUntilCookiesChanged();
+    g_assert(test->m_cookiesChanged);
+
+    test->deleteAllCookies();
+    test->waitUntilCookiesChanged();
+    g_assert(test->m_cookiesChanged);
+}
+
+static void testCookieManagerPersistentStorage(CookieManagerTest* test, gconstpointer)
+{
+    test->setAcceptPolicy(WEBKIT_COOKIE_POLICY_ACCEPT_ALWAYS);
+
+    // Text storage using a new file.
+    test->setPersistentStorage(WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT);
+    char** domains = test->getDomains();
+    g_assert(domains);
+    g_assert_cmpint(g_strv_length(domains), ==, 0);
+
+    test->loadURI(kServer->getURIForPath("/index.html").data());
+    test->waitUntilLoadFinished();
+    g_assert(test->m_cookiesChanged);
+    domains = test->getDomains();
+    g_assert(domains);
+    g_assert_cmpint(g_strv_length(domains), ==, 2);
+
+
+    // SQLite storage using a new file.
+    test->setPersistentStorage(WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE);
+    domains = test->getDomains();
+    g_assert(domains);
+    g_assert_cmpint(g_strv_length(domains), ==, 0);
+
+    test->loadURI(kServer->getURIForPath("/index.html").data());
+    test->waitUntilLoadFinished();
+    g_assert(test->m_cookiesChanged);
+    domains = test->getDomains();
+    g_assert(domains);
+    g_assert_cmpint(g_strv_length(domains), ==, 2);
+
+    // Text storage using an existing file.
+    test->setPersistentStorage(WEBKIT_COOKIE_PERSISTENT_STORAGE_TEXT);
+    domains = test->getDomains();
+    g_assert(domains);
+    g_assert_cmpint(g_strv_length(domains), ==, 2);
+    test->deleteAllCookies();
+    g_assert_cmpint(g_strv_length(test->getDomains()), ==, 0);
+
+    // SQLite storage with an existing file.
+    test->setPersistentStorage(WEBKIT_COOKIE_PERSISTENT_STORAGE_SQLITE);
+    domains = test->getDomains();
+    g_assert(domains);
+    g_assert_cmpint(g_strv_length(domains), ==, 2);
+    test->deleteAllCookies();
+    g_assert_cmpint(g_strv_length(test->getDomains()), ==, 0);
+}
+
+static void serverCallback(SoupServer* server, SoupMessage* message, const char* path, GHashTable*, SoupClientContext*, gpointer)
+{
+    if (message->method != SOUP_METHOD_GET) {
+        soup_message_set_status(message, SOUP_STATUS_NOT_IMPLEMENTED);
+        return;
+    }
+
+    soup_message_set_status(message, SOUP_STATUS_OK);
+    if (g_str_equal(path, "/index.html")) {
+        char* indexHtml = g_strdup_printf(kIndexHtmlFormat, soup_server_get_port(server));
+        soup_message_headers_replace(message->response_headers, "Set-Cookie", "foo=bar; Max-Age=60");
+        soup_message_body_append(message->response_body, SOUP_MEMORY_TAKE, indexHtml, strlen(indexHtml));
+    } else if (g_str_equal(path, "/image.png"))
+        soup_message_headers_replace(message->response_headers, "Set-Cookie", "baz=qux; Max-Age=60");
+    else
+        soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
+    soup_message_body_complete(message->response_body);
+}
+
+void beforeAll()
+{
+    kServer = new WebKitTestServer();
+    kServer->run(serverCallback);
+
+    CookieManagerTest::add("WebKitCookieManager", "accept-policy", testCookieManagerAcceptPolicy);
+    CookieManagerTest::add("WebKitCookieManager", "delete-cookies", testCookieManagerDeleteCookies);
+    CookieManagerTest::add("WebKitCookieManager", "cookies-changed", testCookieManagerCookiesChanged);
+    CookieManagerTest::add("WebKitCookieManager", "persistent-storage", testCookieManagerPersistentStorage);
+}
+
+void afterAll()
+{
+    delete kServer;
+}