Merge lp:pay-service/devel into lp:pay-service/14.10

[Ted Gould]

Fixes from integration work to make the pay demo come together.

Release prep.

[Ted Gould (ted)]

Marking for review to get Jenkin's opinion. Needs a acceptance test branch before fully ready.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:13
http://jenkins.qa.ubuntu.com/job/pay-service-ci/8/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-amd64-ci/9
    SUCCESS: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-armhf-ci/8
        deb: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-armhf-ci/8/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/pay-service-ci/8/rebuild

review: Approve (continuous-integration)

[lp:pay-service/devel]

14. By Ted Gould on 2014-06-13

Fix scoping of root objects

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:14
http://jenkins.qa.ubuntu.com/job/pay-service-ci/9/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-amd64-ci/10
    SUCCESS: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-armhf-ci/9
        deb: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-armhf-ci/9/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/pay-service-ci/9/rebuild

review: Approve (continuous-integration)

[lp:pay-service/devel]

15. By Ted Gould on 2014-06-13

Check to ensure that the package is available to start

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:15
http://jenkins.qa.ubuntu.com/job/pay-service-ci/10/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-amd64-ci/11
    SUCCESS: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-armhf-ci/10
        deb: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-armhf-ci/10/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/pay-service-ci/10/rebuild

review: Approve (continuous-integration)

[lp:pay-service/devel]

16. By Ted Gould on 2014-06-13

Bringing in tests and merge commit rules

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:16
http://jenkins.qa.ubuntu.com/job/pay-service-ci/11/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-amd64-ci/12
    SUCCESS: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-armhf-ci/11
        deb: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-armhf-ci/11/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/pay-service-ci/11/rebuild

review: Approve (continuous-integration)

[lp:pay-service/devel]

17. By Ted Gould on 2014-06-18

Ensure that the debian changelog matches the trunk

18. By Ted Gould on 2014-06-18

Doing the changelog manually for CI Train

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:17
http://jenkins.qa.ubuntu.com/job/pay-service-ci/12/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-amd64-ci/13
    FAILURE: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-armhf-ci/12/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/pay-service-ci/12/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:18
http://jenkins.qa.ubuntu.com/job/pay-service-ci/13/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-amd64-ci/14
    FAILURE: http://jenkins.qa.ubuntu.com/job/pay-service-utopic-armhf-ci/13/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/pay-service-ci/13/rebuild

review: Needs Fixing (continuous-integration)

=== modified file '.bzrignore'
--- .bzrignore	2014-05-20 19:06:37 +0000
+++ .bzrignore	2014-06-18 18:46:48 +0000
@@ -10,7 +10,9 @@
 item-memory-tests
 pay-service.conf
 verification-curl-tests
-tests/verification-curl-endpoints/good-simple
+tests/verification-curl-endpoints/good/simple
 purchase-ual-tests
+click-db/test.conf
 libpay.so.1.0.0
 libpay-tests
+verification-curl-endpoints/package-name

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-05-26 14:01:00 +0000
+++ CMakeLists.txt	2014-06-18 18:46:48 +0000
@@ -29,19 +29,22 @@
 ##  Check for prerequisites
 ##
 
+set(CMAKE_AUTOMOC ON)
+
 find_package (PkgConfig REQUIRED)
+find_package (Qt5Core REQUIRED)
 include (FindPkgConfig)
 
-pkg_check_modules (PROCESS_CPP REQUIRED process-cpp)
-
 pkg_check_modules (SERVICE_DEPS REQUIRED
                    libcurl
                    ubuntu-app-launch-2
                    dbustest-1
                    gio-2.0
                    gio-unix-2.0
-                   process-cpp)
-include_directories (SYSTEM ${PROCESS_CPP_INCLUDE_DIRS} ${SERVICE_DEPS_INCLUDE_DIRS})
+                   process-cpp
+                   properties-cpp
+                   ubuntuoneauth-2.0)
+include_directories (SYSTEM ${SERVICE_DEPS_INCLUDE_DIRS})
 
 ##
 ##  Gdbus

=== added file 'MERGE-REVIEW'
--- MERGE-REVIEW	1970-01-01 00:00:00 +0000
+++ MERGE-REVIEW	2014-06-18 18:46:48 +0000
@@ -0,0 +1,14 @@
+
+This documents the expections that the project has on what both submitters
+and reviewers should ensure that they've done for a merge into the project.
+
+== Submitter Responsibilities ==
+
+ * Ensure the project compiles and the test suite executes without error
+ * Ensure that non-obvious code has comments explaining it
+
+== Reviewer Responsibilities ==
+
+ * Did the Jenkins build compile?  Pass?  Run unit tests successfully?
+ * Are there appropriate tests to cover any new functionality?
+

=== modified file 'data/pay-service.conf.in'
--- data/pay-service.conf.in	2014-05-26 10:40:36 +0000
+++ data/pay-service.conf.in	2014-06-18 18:46:48 +0000
@@ -1,6 +1,8 @@
 description "Service to process payments"
 
-start on desktop-start
+start on desktop-start or started unity8
 stop on desktop-end
 
+respawn
+
 exec @CMAKE_INSTALL_FULL_LIBEXECDIR@/pay-service/pay-service

=== modified file 'debian/changelog'
--- debian/changelog	2014-06-01 21:16:48 +0000
+++ debian/changelog	2014-06-18 18:46:48 +0000
@@ -1,3 +1,14 @@
+pay-service (0.1+14.10.20140601-0ubuntu2) UNRELEASED; urgency=medium
+
+  * Add acceptance tests and merge commit rules
+  * Fix scoping of root object
+  * Allow purchasing items without verifications
+  * Use proper URLs for verification
+  * Launch Pay UI for finishing payment
+  * Add a dummy click hook to allow for usage in Pay UI
+
+ -- Ted Gould <[e-mail]>  Wed, 18 Jun 2014 13:44:26 -0500
+
 pay-service (0.1+14.10.20140601-0ubuntu1) utopic; urgency=low
 
   [ Ted Gould ]

=== modified file 'debian/control'
--- debian/control	2014-05-28 09:20:54 +0000
+++ debian/control	2014-06-18 18:46:48 +0000
@@ -3,6 +3,7 @@
 Priority: optional
 Maintainer: Ubuntu Developers <[e-mail]>
 Build-Depends: astyle,
+               click-dev,
                cmake,
                dbus,
                dbus-test-runner,
@@ -10,10 +11,13 @@
                google-mock,
                libcurl4-gnutls-dev,
                libdbustest1-dev,
+               libglib2.0-dev,
                libgtest-dev,
                libprocess-cpp-dev,
                libubuntu-app-launch2-dev,
+               libubuntuoneauth-2.0-dev,
                python3-dbusmock,
+               qtbase5-dev,
 Standards-Version: 3.9.5
 Homepage: http://launchpad.net/pay-service
 # If you aren't a member of ~indicator-applet-developers but need to upload

=== added file 'debian/pay-service.click-hook'
--- debian/pay-service.click-hook	1970-01-01 00:00:00 +0000
+++ debian/pay-service.click-hook	2014-06-18 18:46:48 +0000
@@ -0,0 +1,5 @@
+# NOTE: Temporary until trusted sessions land
+Pattern: ${home}/.local/share/applications/${id}.desktop
+Exec: /bin/true
+User-Level: yes
+Hook-Name: pay-ui

=== modified file 'debian/rules'
--- debian/rules	2014-05-21 03:44:48 +0000
+++ debian/rules	2014-06-18 18:46:48 +0000
@@ -8,4 +8,4 @@
 	dh_auto_configure -- -DCMAKE_INSTALL_LIBEXECDIR=/usr/lib/$(DEB_HOST_MULTIARCH)/pay-service -DCMAKE_INSTALL_INCLUDEDIR=/usr/include/$(DEB_HOST_MULTIARCH)/
 
 %:
-	dh $@ --fail-missing
+	dh $@ --fail-missing --with click

=== modified file 'libpay/pay-package.cpp'
--- libpay/pay-package.cpp	2014-05-20 22:12:48 +0000
+++ libpay/pay-package.cpp	2014-06-18 18:46:48 +0000
@@ -31,6 +31,7 @@
 class Package
 {
     std::string id;
+    std::string path;
     /* NOTE: Using the shared_ptr here because gcc 4.7 map doesn't have emplace */
     std::map <std::pair<PayPackageItemObserver, void*>, std::shared_ptr<core::ScopedConnection>> observers;
     core::Signal<std::string, PayPackageItemStatus> itemChanged;
@@ -46,6 +47,9 @@
 public:
     Package (const char* packageid) : id(packageid), cancellable(g_cancellable_new()), loop(nullptr)
     {
+        path = std::string("/com/canonical/pay/");
+        path += encodePath(id);
+
         /* Keeps item cache up-to-data as we get signals about it */
         itemChanged.connect([this](std::string itemid, PayPackageItemStatus status)
         {
@@ -62,13 +66,11 @@
             g_main_context_push_thread_default(context);
             context_mutex.unlock();
 
-            std::string path("/com/canonical/pay/");
-            path += id; /* TODO: encode */
             proxy = proxy_pay_package_proxy_new_for_bus_sync(G_BUS_TYPE_SESSION,
                                                              G_DBUS_PROXY_FLAGS_NONE,
                                                              "com.canonical.pay",
                                                              path.c_str(),
-                                                             cancellable,
+                                                             NULL,
                                                              &error);
 
             if (error != nullptr)
@@ -248,6 +250,36 @@
     {
         return functionCall(proxy_pay_package_call_purchase_item, proxy_pay_package_call_purchase_item_finish, itemid);
     }
+
+    std::string
+    encodePath (const std::string& input)
+    {
+        std::string output = "";
+        bool first = true;
+
+        for (unsigned char c : input)
+        {
+            std::string retval;
+
+            if ((c >= 'a' && c <= 'z') ||
+                    (c >= 'A' && c <= 'Z') ||
+                    (c >= '0' && c <= '9' && !first))
+            {
+                retval = std::string((char*)&c, 1);
+            }
+            else
+            {
+                char buffer[5] = {0};
+                std::snprintf(buffer, 4, "_%2X", c);
+                retval = std::string(buffer);
+            }
+
+            output += retval;
+            first = false;
+        }
+
+        return output;
+    }
 };
 
 

=== modified file 'service/CMakeLists.txt'
--- service/CMakeLists.txt	2014-05-15 20:11:25 +0000
+++ service/CMakeLists.txt	2014-06-18 18:46:48 +0000
@@ -1,5 +1,5 @@
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -g ${GCOV_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -g -fPIE ${GCOV_FLAGS}")
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
 
@@ -14,11 +14,16 @@
     item-null.h
     item-memory.h
     item-memory.cpp
+    qtbridge.h
+    qtbridge.cpp
     purchase-factory.h
     purchase-null.h
     purchase-null.cpp
     purchase-ual.h
     purchase-ual.cpp
+    token-grabber.h
+    token-grabber-u1.h
+    token-grabber-u1.cpp
     verification-curl.cpp
     verification-null.cpp)
 
@@ -34,8 +39,7 @@
 
 add_executable(pay-service main.cpp)
 target_link_libraries(pay-service
-                      pay-service-lib
-                      ${PROCESS_CPP_LIBRARIES})
+                      pay-service-lib)
 
 install(TARGETS pay-service RUNTIME DESTINATION ${CMAKE_INSTALL_FULL_PKGLIBEXECDIR})
 

=== modified file 'service/dbus-interface.cpp'
--- service/dbus-interface.cpp	2014-05-19 22:03:01 +0000
+++ service/dbus-interface.cpp	2014-06-18 18:46:48 +0000
@@ -51,7 +51,11 @@
         bus(nullptr),
         serviceProxy(nullptr),
         packageProxy(nullptr),
-        errorQuark(g_quark_from_static_string("dbus-interface-impl"))
+        errorQuark(g_quark_from_static_string("dbus-interface-impl")),
+        subtree_registration(0)
+    { }
+
+    void run ()
     {
         t = std::thread([this]()
         {
@@ -398,6 +402,8 @@
     {
         connectionReady();
     });
+
+    impl->run();
 }
 
 bool

=== modified file 'service/dbus-interface.h'
--- service/dbus-interface.h	2014-05-19 21:03:42 +0000
+++ service/dbus-interface.h	2014-06-18 18:46:48 +0000
@@ -39,6 +39,8 @@
 
     core::Signal<> connectionReady;
 
+    typedef std::shared_ptr<DBusInterface> Ptr;
+
 private:
     std::shared_ptr<DBusInterfaceImpl> impl;
 };

=== modified file 'service/item-memory.cpp'
--- service/item-memory.cpp	2014-05-08 20:48:54 +0000
+++ service/item-memory.cpp	2014-06-18 18:46:48 +0000
@@ -105,43 +105,41 @@
     bool purchase (void)
     {
         /* First check to see if a purchase makes sense */
-        if (status != NOT_PURCHASED)
-        {
-            return false;
-        }
-
-        if (pitem != nullptr)
+        if (status == PURCHASED)
         {
             return true;
         }
 
-        pitem = pfactory->purchaseItem(app, id);
         if (pitem == nullptr)
         {
-            /* Uhg, failed */
-            return false;
+            pitem = pfactory->purchaseItem(app, id);
+            if (pitem == nullptr)
+            {
+                /* Uhg, failed */
+                return false;
+            }
+
+            pitem->purchaseComplete.connect([this](Purchase::Item::Status status)
+            {
+                switch (status)
+                {
+                    case Purchase::Item::PURCHASED:
+                        setStatus(Item::Status::PURCHASED);
+                        break;
+                    case Purchase::Item::ERROR:
+                    case Purchase::Item::NOT_PURCHASED:
+                    default: /* Fall through, an error is same as status we don't know */
+                        /* We know we were not purchased before, so let's stay that way */
+                        setStatus(Item::Status::NOT_PURCHASED);
+                        break;
+                }
+                return;
+            });
         }
 
         /* New purchase instance, tell the world! */
         setStatus(Item::Status::PURCHASING);
 
-        pitem->purchaseComplete.connect([this](Purchase::Item::Status status)
-        {
-            switch (status)
-            {
-                case Purchase::Item::PURCHASED:
-                    setStatus(Item::Status::PURCHASED);
-                    break;
-                case Purchase::Item::ERROR:
-                case Purchase::Item::NOT_PURCHASED:
-                default: /* Fall through, an error is same as status we don't know */
-                    /* We know we were not purchased before, so let's stay that way */
-                    setStatus(Item::Status::NOT_PURCHASED);
-                    break;
-            }
-            return;
-        });
-
         return pitem->run();
     }
 

=== modified file 'service/main.cpp'
--- service/main.cpp	2014-05-14 03:35:25 +0000
+++ service/main.cpp	2014-06-18 18:46:48 +0000
@@ -17,33 +17,34 @@
  *   Ted Gould <[e-mail]>
  */
 
-#include <core/posix/signal.h>
-
 #include "dbus-interface.h"
 #include "item-memory.h"
 #include "verification-curl.h"
 #include "purchase-ual.h"
+#include "qtbridge.h"
+#include "token-grabber-u1.h"
 
 int
 main (int argv, char* argc[])
 {
-    auto trap = core::posix::trap_signals_for_all_subsequent_threads(
-    {
-        core::posix::Signal::sig_int,
-        core::posix::Signal::sig_term
-    });
-
-    trap->signal_raised().connect([trap](core::posix::Signal)
-    {
-        trap->stop();
-    });
-
-    auto vfactory = std::make_shared<Verification::CurlFactory>();
-    auto pfactory = std::make_shared<Purchase::UalFactory>();
-    auto items = std::make_shared<Item::MemoryStore>(vfactory, pfactory);
-    auto dbus = std::make_shared<DBusInterface>(items);
-
-    trap->run();
+    TokenGrabber::Ptr token;
+    Verification::Factory::Ptr vfactory;
+    Purchase::Factory::Ptr pfactory;
+    Item::Store::Ptr items;
+    DBusInterface::Ptr dbus;
+
+    qt::core::world::build_and_run(argv, argc, [&token, &vfactory, &pfactory, &items, &dbus]()
+    {
+        /* Initialize the other object after Qt is built */
+        token = std::make_shared<TokenGrabberU1>();
+        vfactory = std::make_shared<Verification::CurlFactory>(token);
+        pfactory = std::make_shared<Purchase::UalFactory>();
+        items = std::make_shared<Item::MemoryStore>(vfactory, pfactory);
+        dbus = std::make_shared<DBusInterface>(items);
+    });
+
+    qt::core::world::destroy();
 
     return EXIT_SUCCESS;
 }
+

=== modified file 'service/purchase-ual.cpp'
--- service/purchase-ual.cpp	2014-05-26 14:01:00 +0000
+++ service/purchase-ual.cpp	2014-06-18 18:46:48 +0000
@@ -31,10 +31,20 @@
     typedef std::shared_ptr<Item> Ptr;
 
     UalItem (std::string& in_appid, std::string& in_itemid) :
-        appid(in_appid), itemid(in_itemid), loop(nullptr), status(Item::ERROR)
+        appid(in_appid),
+        itemid(in_itemid),
+        loop(nullptr),
+        status(Item::ERROR)
     {
         /* TODO: ui_appid needs to be grabbed from the click hook */
-        ui_appid = "gedit";
+        gchar* appidc = ubuntu_app_launch_triplet_to_app_id("com.canonical.payui",
+                                                            nullptr,
+                                                            nullptr);
+        if (appidc != nullptr)
+        {
+            ui_appid = appidc;
+            g_free(appidc);
+        }
     }
 
     ~UalItem ()
@@ -79,9 +89,14 @@
             /* Building a URL so that we can pass this information today without
                using trusted helpers and setting environment vars */
             /* TODO: Use trusted helpers */
-            std::string purchase_url = "purchase:///";
-            purchase_url += appid;
-            purchase_url += "/";
+            std::string purchase_url = "purchase://";
+
+            if (appid != "click-scope")
+            {
+                purchase_url += appid;
+                purchase_url += "/";
+            }
+
             purchase_url += itemid;
             const gchar* urls[2] = {0};
             urls[0] = purchase_url.c_str();

=== added file 'service/qtbridge.cpp'
--- service/qtbridge.cpp	1970-01-01 00:00:00 +0000
+++ service/qtbridge.cpp	2014-06-18 18:46:48 +0000
@@ -0,0 +1,189 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ *              Thomas Voß <[e-mail]>
+ */
+
+#include "qtbridge.h"
+
+#include<QCoreApplication>
+#include<QNetworkAccessManager>
+#include<QNetworkRequest>
+#include<QNetworkReply>
+#include<QThread>
+#include<QDebug>
+
+#include <iostream>
+
+namespace
+{
+QCoreApplication* app = nullptr;
+}
+
+namespace qt
+{
+namespace core
+{
+namespace world
+{
+namespace detail
+{
+QEvent::Type qt_core_world_task_event_type()
+{
+    static QEvent::Type event_type = static_cast<QEvent::Type>(QEvent::registerEventType());
+    return event_type;
+}
+
+class TaskEvent : public QEvent
+{
+public:
+    TaskEvent(const std::function<void()>& task)
+        : QEvent(qt_core_world_task_event_type()),
+          task(task)
+    {
+    }
+
+    void run()
+    {
+        try
+        {
+            task();
+            promise.set_value();
+        }
+        catch (...)
+        {
+            promise.set_exception(std::current_exception());
+        }
+    }
+
+    std::future<void> get_future()
+    {
+        return promise.get_future();
+    }
+
+private:
+    std::function<void()> task;
+    std::promise<void> promise;
+};
+
+class TaskHandler : public QObject
+{
+    Q_OBJECT
+
+public:
+    TaskHandler(QObject* parent) : QObject(parent)
+    {
+    }
+
+    bool event(QEvent* e);
+};
+
+
+
+void createCoreApplicationInstanceWithArgs(int argc, char** argv)
+{
+    app = new QCoreApplication(argc, argv);
+}
+
+void destroyCoreApplicationInstace()
+{
+    delete app;
+}
+
+QCoreApplication* coreApplicationInstance()
+{
+    return app;
+}
+
+TaskHandler* task_handler()
+{
+    static TaskHandler* instance = new TaskHandler(coreApplicationInstance());
+    return instance;
+}
+
+bool TaskHandler::event(QEvent* e)
+{
+    if (e->type() != qt_core_world_task_event_type())
+    {
+        return QObject::event(e);
+    }
+
+    auto te = dynamic_cast<TaskEvent*>(e);
+    if (te)
+    {
+        te->run();
+        return true;
+    }
+
+    return false;
+}
+}
+
+void build_and_run(int argc, char** argv, const std::function<void()>& ready)
+{
+    QThread::currentThread();
+    if (QCoreApplication::instance() != nullptr)
+        throw std::runtime_error(
+            "qt::core::world::build_and_run: "
+            "There is already a QCoreApplication running.");
+
+    detail::createCoreApplicationInstanceWithArgs(argc, argv);
+
+    detail::task_handler()->moveToThread(
+        detail::coreApplicationInstance()->thread());
+
+    // Signal to other worlds that we are good to go.
+    ready();
+
+    detail::coreApplicationInstance()->exec();
+
+    // Someone has called quit and we clean up on the correct thread here.
+    detail::destroyCoreApplicationInstace();
+}
+
+void destroy()
+{
+    enter_with_task([]()
+    {
+        // We make sure that all tasks have completed before quitting the app.
+        QEventLoopLocker locker;
+    }).wait_for(std::chrono::seconds {1});
+}
+
+std::future<void> enter_with_task(const std::function<void()>& task)
+{
+    QCoreApplication* instance = QCoreApplication::instance();
+
+    if (!instance)
+    {
+        throw std::runtime_error("Qt world has not been built before calling this function.");
+    }
+
+    detail::TaskEvent* te = new detail::TaskEvent(task);
+    auto future = te->get_future();
+
+    // We hand over ownership of te here. The event is deleted later after it has
+    // been processed by the event loop.
+    instance->postEvent(detail::task_handler(), te);
+
+    return future;
+}
+
+}
+}
+}
+
+#include "qtbridge.moc"

=== added file 'service/qtbridge.h'
--- service/qtbridge.h	1970-01-01 00:00:00 +0000
+++ service/qtbridge.h	2014-06-18 18:46:48 +0000
@@ -0,0 +1,88 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ *              Thomas Voß <[e-mail]>
+ */
+
+#ifndef QT_CORE_WORLD_BRIDGE_H_
+#define QT_CORE_WORLD_BRIDGE_H_
+
+#include <QObject>
+
+#include <functional>
+#include <future>
+#include <iostream>
+
+namespace qt
+{
+namespace core
+{
+namespace world
+{
+/**
+ * @brief Sets up the Qt core world and executes its event loop. Blocks until destroy() is called.
+ * @param argc Number of arguments in argv.
+ * @param argv Array of command-line arguments.
+ * @param ready Functor be called when the world has been setup and is about to be executed.
+ * @throw std::runtime_error in case of errors.
+ */
+void build_and_run(int argc, char** argv, const std::function<void()>& ready);
+
+/**
+ * @brief Destroys the Qt core world and quits its event loop.
+ */
+void destroy();
+
+/**
+ * @brief Enters the Qt core world and schedules the given task for execution.
+ * @param task The task to be executed in the Qt core world.
+ * @return A std::future that can be waited for to synchronize to the world's internal event loop.
+ */
+std::future<void> enter_with_task(const std::function<void()>& task);
+
+
+/**
+ * @brief Enters the Qt core world and schedules the given task for execution.
+ * @param task The task to be executed in the Qt core world.
+ * @return A std::future that can be waited for to get hold of the result of the task.
+ */
+template<typename T>
+inline std::future<T> enter_with_task_and_expect_result(const std::function<T()>& task)
+{
+    std::shared_ptr<std::promise<T>> promise = std::make_shared<std::promise<T>>();
+    std::future<T> future = promise->get_future();
+
+    auto t = [promise, task]()
+    {
+        try
+        {
+            promise->set_value(task());
+        }
+        catch (...)
+        {
+            promise->set_exception(std::current_exception());
+        }
+    };
+
+    enter_with_task(t);
+
+    return future;
+}
+}
+}
+}
+
+#endif // QT_CORE_WORLD_BRIDGE_H_

=== added file 'service/token-grabber-u1.cpp'
--- service/token-grabber-u1.cpp	1970-01-01 00:00:00 +0000
+++ service/token-grabber-u1.cpp	2014-06-18 18:46:48 +0000
@@ -0,0 +1,113 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+#include "token-grabber-u1.h"
+#include "qtbridge.h"
+
+#include <ssoservice.h>
+#include <token.h>
+
+class TokenGrabberU1Qt: public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit TokenGrabberU1Qt (QObject* parent = 0);
+    void run (void);
+    std::string signUrl(std::string url, std::string type);
+
+private Q_SLOTS:
+    void handleCredentialsFound(const UbuntuOne::Token& token);
+    void handleCredentialsNotFound();
+
+private:
+    UbuntuOne::Token token;
+    UbuntuOne::SSOService service;
+};
+
+TokenGrabberU1Qt::TokenGrabberU1Qt (QObject* parent) :
+    QObject(parent)
+{
+    std::cout << "Token grabber built" << std::endl;
+}
+
+void TokenGrabberU1Qt::run (void)
+{
+    std::cout << "Token grabber running" << std::endl;
+
+    QObject::connect(&service,
+                     &UbuntuOne::SSOService::credentialsFound,
+                     this,
+                     &TokenGrabberU1Qt::handleCredentialsFound);
+    QObject::connect(&service,
+                     &UbuntuOne::SSOService::credentialsNotFound,
+                     this,
+                     &TokenGrabberU1Qt::handleCredentialsNotFound);
+
+    service.getCredentials();
+}
+
+void TokenGrabberU1Qt::handleCredentialsFound(const UbuntuOne::Token& in_token)
+{
+    token = in_token;
+    std::cout << "Got a Token" << std::endl;
+}
+
+void TokenGrabberU1Qt::handleCredentialsNotFound()
+{
+    std::cout << "No Token :-(" << std::endl;
+}
+
+std::string TokenGrabberU1Qt::signUrl (std::string url, std::string type)
+{
+    std::string retval;
+
+    auto qretval = token.signUrl(url.c_str(), type.c_str());
+    retval = std::string(qretval.toUtf8());
+
+    return retval;
+}
+
+TokenGrabberU1::TokenGrabberU1 (void)
+{
+    //qt = std::make_shared<TokenGrabberU1Qt>();
+    qtfuture = qt::core::world::enter_with_task_and_expect_result<std::shared_ptr<TokenGrabberU1Qt>>([]()
+    {
+        auto qtgrabber = std::make_shared<TokenGrabberU1Qt>();
+        qtgrabber->run();
+        return qtgrabber;
+    });
+}
+
+TokenGrabberU1::~TokenGrabberU1 (void)
+{
+}
+
+std::string TokenGrabberU1::signUrl (std::string url, std::string type)
+{
+    if (qtfuture.valid())
+    {
+        return qtfuture.get()->signUrl(url, type);
+    }
+
+    std::string retval;
+    return retval;
+}
+
+#include "token-grabber-u1.moc"

=== added file 'service/token-grabber-u1.h'
--- service/token-grabber-u1.h	1970-01-01 00:00:00 +0000
+++ service/token-grabber-u1.h	2014-06-18 18:46:48 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+#ifndef TOKEN_GRABBER_U1_HPP__
+#define TOKEN_GRABBER_U1_HPP__ 1
+
+#include <future>
+#include "token-grabber.h"
+
+class TokenGrabberU1Qt;
+
+class TokenGrabberU1 : public TokenGrabber
+{
+public:
+    TokenGrabberU1 (void);
+    virtual ~TokenGrabberU1 (void);
+
+    virtual std::string signUrl(std::string url, std::string type);
+
+private:
+    std::future<std::shared_ptr<TokenGrabberU1Qt>> qtfuture;
+};
+
+
+#endif /* TOKEN_GRABBER_U1_HPP__ */

=== added file 'service/token-grabber.h'
--- service/token-grabber.h	1970-01-01 00:00:00 +0000
+++ service/token-grabber.h	2014-06-18 18:46:48 +0000
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+#ifndef TOKEN_GRABBER_HPP__
+#define TOKEN_GRABBER_HPP__ 1
+
+#include <string>
+#include <memory>
+
+#include <core/signal.h>
+
+class TokenGrabber
+{
+public:
+    virtual std::string signUrl(std::string url, std::string type) = 0;
+
+    typedef std::shared_ptr<TokenGrabber> Ptr;
+
+    /* Signals */
+    core::Signal<bool> tokenUpdated;
+};
+
+#endif /* TOKEN_GRABBER_HPP__ */

=== modified file 'service/verification-curl.cpp'
--- service/verification-curl.cpp	2014-05-14 03:35:34 +0000
+++ service/verification-curl.cpp	2014-06-18 18:46:48 +0000
@@ -30,9 +30,39 @@
 class CurlItem : public Item
 {
 public:
-    CurlItem (std::string& app, std::string& item, std::string& endpoint) : exec(nullptr)
+    CurlItem (std::string& app,
+              std::string& item,
+              std::string& endpoint,
+              std::string& device,
+              TokenGrabber::Ptr token) :
+        stop(false),
+        handle(nullptr),
+        curlHeaders(nullptr)
     {
-        url = (endpoint + "/" + app + "-" + item);
+        url = endpoint;
+
+        if (app != "click-scope")
+        {
+            url += "/" + app;
+        }
+        url += "/" + item;
+        if (!device.empty())
+        {
+            url += "?device=" + device;
+        }
+
+        /* Sign the request */
+        auto auth = token->signUrl(url, "GET");
+        if (!auth.empty())
+        {
+            std::string header("Authorization: ");
+            header += auth;
+            curlHeaders = curl_slist_append(curlHeaders, auth.c_str());
+        }
+
+        /* Ensure we get JSON back */
+        curlHeaders = curl_slist_append(curlHeaders, "Accept: application/json");
+
         handle = curl_easy_init();
 
         /* Helps with threads */
@@ -40,16 +70,28 @@
         curl_easy_setopt(handle, CURLOPT_URL, url.c_str());
         curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, curlWrite);
         curl_easy_setopt(handle, CURLOPT_WRITEDATA, this);
+        if (curlHeaders != nullptr)
+        {
+            curl_easy_setopt(handle, CURLOPT_HTTPHEADER, curlHeaders);
+        }
     }
 
     ~CurlItem (void)
     {
-        if (exec->joinable())
+        stop = true;
+
+        if (exec.joinable())
         {
-            exec->join();
+            exec.join();
         }
 
         curl_easy_cleanup(handle);
+
+        if (curlHeaders != nullptr)
+        {
+            curl_slist_free_all (curlHeaders) ;
+            curlHeaders = nullptr;
+        }
     }
 
     virtual bool run (void)
@@ -58,14 +100,23 @@
 
         /* Do the execution in another thread so we can wait on the
            network socket. */
-        exec = std::make_shared<std::thread>([this]()
+        exec = std::thread([this]()
         {
             auto status = curl_easy_perform(handle);
 
             if (status == CURLE_OK)
             {
-                /* TODO: Clearly we need to be a bit more sophisticated here */
-                verificationComplete(Status::NOT_PURCHASED);
+                long responsecode = 0;
+                curl_easy_getinfo(handle, CURLINFO_RESPONSE_CODE, &responsecode);
+
+                if (responsecode == 200)
+                {
+                    verificationComplete(Status::PURCHASED);
+                }
+                else
+                {
+                    verificationComplete(Status::NOT_PURCHASED);
+                }
             }
             else
             {
@@ -79,8 +130,10 @@
 private:
     CURL* handle;
     std::string transferBuffer;
-    std::shared_ptr<std::thread> exec;
+    std::thread exec;
     std::string url;
+    bool stop;
+    struct curl_slist* curlHeaders;
 
     /* This is the callback from cURL as it does the transfer. We're
        pretty simple in that we're just putting it into a string. */
@@ -89,14 +142,33 @@
         auto datasize = size * nmemb;
         //std::cout << "Got data: " << datasize << std::endl;
         CurlItem* item = static_cast<CurlItem*>(user_data);
+        if (item->stop)
+        {
+            std::cout << "cURL transaction stopped prematurely" << std::endl;
+            return 0;
+        }
         item->transferBuffer.append(static_cast<char*>(buffer), datasize);
         return datasize;
     }
 };
 
-CurlFactory::CurlFactory () :
-    endpoint("https://launchpad.net")
+/*********************
+ * CurlFactory
+ *********************/
+
+CurlFactory::CurlFactory (TokenGrabber::Ptr token) :
+    endpoint("https://sc.ubuntu.com/api/2.0/click/purchases"),
+    tokenGrabber(token)
 {
+    /* This is how we enable staging */
+    const char* envendpoint(getenv("PAY_BASE_URL"));
+    if (envendpoint != nullptr)
+    {
+        endpoint = envendpoint;
+        /* Our endpoint is slightly more specific */
+        endpoint += "/purchases";
+    }
+
     /* TODO: We should check to see if we have networking someday */
     curl_global_init(CURL_GLOBAL_SSL);
 }
@@ -116,7 +188,7 @@
 Item::Ptr
 CurlFactory::verifyItem (std::string& appid, std::string& itemid)
 {
-    return std::make_shared<CurlItem>(appid, itemid, endpoint);
+    return std::make_shared<CurlItem>(appid, itemid, endpoint, device, tokenGrabber);
 }
 
 void
@@ -125,4 +197,11 @@
     endpoint = in_endpoint;
 }
 
+void
+CurlFactory::setDevice (std::string& in_device)
+{
+    device = in_device;
+}
+
 } // ns Verification
+

=== modified file 'service/verification-curl.h'
--- service/verification-curl.h	2014-05-07 21:01:52 +0000
+++ service/verification-curl.h	2014-06-18 18:46:48 +0000
@@ -18,6 +18,9 @@
  */
 
 #include "verification-factory.h"
+#include "token-grabber.h"
+
+#include <memory>
 
 #ifndef VERIFICATION_CURL_HPP__
 #define VERIFICATION_CURL_HPP__ 1
@@ -26,7 +29,7 @@
 
 class CurlFactory : public Factory {
 public:
-	CurlFactory ();
+	CurlFactory (TokenGrabber::Ptr token);
 	CurlFactory (const std::string& endpoint);
 	~CurlFactory ();
 
@@ -34,9 +37,12 @@
 	virtual Item::Ptr verifyItem (std::string& appid, std::string& itemid);
 
 	void setEndpoint (std::string& endpoint);
+	void setDevice (std::string& device);
 
 private:
 	std::string endpoint;
+	std::string device;
+	TokenGrabber::Ptr tokenGrabber;
 };
 
 } // ns Verification

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-05-20 19:06:37 +0000
+++ tests/CMakeLists.txt	2014-06-18 18:46:48 +0000
@@ -18,7 +18,6 @@
 
   ${GMOCK_INCLUDE_DIR}
   ${GTEST_INCLUDE_DIR}
-  ${PROCESS_CPP_INCLUDE_DIRS}
 )
 
 #############################
@@ -36,7 +35,6 @@
   pay-service-lib
 
   ${SERVICE_DEPS_LIBRARIES}
-  ${PROCESS_CPP_LIBRARIES}
   ${CMAKE_THREAD_LIBS_INIT}
   ${GMOCK_BOTH_LIBRARIES}
 )
@@ -84,8 +82,14 @@
 )
 
 configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/verification-curl-endpoints/good-simple.in
-  ${CMAKE_CURRENT_BINARY_DIR}/verification-curl-endpoints/good-simple @ONLY)
+  ${CMAKE_CURRENT_SOURCE_DIR}/verification-curl-endpoints/good/simple.in
+  ${CMAKE_CURRENT_BINARY_DIR}/verification-curl-endpoints/good/simple @ONLY)
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/verification-curl-endpoints/good/device-id.in
+  ${CMAKE_CURRENT_BINARY_DIR}/verification-curl-endpoints/good/device-id @ONLY)
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/verification-curl-endpoints/package-name.in
+  ${CMAKE_CURRENT_BINARY_DIR}/verification-curl-endpoints/package-name @ONLY)
 
 add_test(verification-curl-tests ${CMAKE_CURRENT_BINARY_DIR}/verification-curl-tests)
 
@@ -93,6 +97,13 @@
 # Purchase UAL
 #############################
 
+configure_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/click-db/test.conf.in
+  ${CMAKE_CURRENT_BINARY_DIR}/click-db/test.conf @ONLY)
+
+add_definitions(-DCMAKE_BINARY_DIR="${CMAKE_CURRENT_BINARY_DIR}")
+add_definitions(-DCMAKE_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}")
+
 add_executable(
   purchase-ual-tests
   purchase-ual-tests.cpp
@@ -126,3 +137,8 @@
 
 add_test(libpay-tests ${CMAKE_CURRENT_BINARY_DIR}/libpay-tests)
 
+#############################
+# staging script
+#############################
+
+install(PROGRAMS setup-staging.sh DESTINATION ${CMAKE_INSTALL_FULL_PKGLIBEXECDIR})

=== added directory 'tests/click-data'
=== added directory 'tests/click-data/.click'
=== added directory 'tests/click-data/.click/users'
=== added directory 'tests/click-data/.click/users/test-user'
=== added symlink 'tests/click-data/.click/users/test-user/com.canonical.payui'
=== target is u'../../../com.canonical.payui/0.1/'
=== added directory 'tests/click-data/com.canonical.payui'
=== added directory 'tests/click-data/com.canonical.payui/0.1'
=== added directory 'tests/click-data/com.canonical.payui/0.1/.click'
=== added directory 'tests/click-data/com.canonical.payui/0.1/.click/info'
=== added file 'tests/click-data/com.canonical.payui/0.1/.click/info/com.canonical.payui.manifest'
--- tests/click-data/com.canonical.payui/0.1/.click/info/com.canonical.payui.manifest	1970-01-01 00:00:00 +0000
+++ tests/click-data/com.canonical.payui/0.1/.click/info/com.canonical.payui.manifest	2014-06-18 18:46:48 +0000
@@ -0,0 +1,9 @@
+{
+	"version": "0.1",
+	"name": "com.canonical.payui",
+	"hooks": {
+		"app1": {
+			"desktop": "test.desktop"
+		}
+	}
+}

=== added file 'tests/click-data/com.canonical.payui/0.1/test.desktop'
--- tests/click-data/com.canonical.payui/0.1/test.desktop	1970-01-01 00:00:00 +0000
+++ tests/click-data/com.canonical.payui/0.1/test.desktop	2014-06-18 18:46:48 +0000
@@ -0,0 +1,3 @@
+[Desktop Entry]
+Name=Test
+Exec=test

=== added directory 'tests/click-db'
=== added file 'tests/click-db/test.conf.in'
--- tests/click-db/test.conf.in	1970-01-01 00:00:00 +0000
+++ tests/click-db/test.conf.in	2014-06-18 18:46:48 +0000
@@ -0,0 +1,2 @@
+[Click Database]
+root = @CMAKE_CURRENT_SOURCE_DIR@/click-data

=== modified file 'tests/dbus-interface-tests.cpp'
--- tests/dbus-interface-tests.cpp	2014-05-28 14:57:59 +0000
+++ tests/dbus-interface-tests.cpp	2014-06-18 18:46:48 +0000
@@ -143,10 +143,18 @@
 
 void signalAppend (GObject* obj, const gchar* itemid, const gchar* status, std::vector<std::string>& list)
 {
+    std::cout << "Signal append: " << itemid << ", " << status << std::endl;
     ASSERT_STREQ("fooitem", itemid);
     list.push_back(status);
 }
 
+int loop_quit (void* data)
+{
+    auto loop = reinterpret_cast<GMainLoop*>(data);
+    g_main_loop_quit(loop);
+    return G_SOURCE_REMOVE;
+}
+
 TEST_F(DbusInterfaceTests, ItemSignalTests)
 {
     core::testing::CrossProcessSync cps1;
@@ -178,6 +186,9 @@
         titem->test_setStatus(Item::Item::NOT_PURCHASED, true);
         titem->test_setStatus(Item::Item::PURCHASED, true);
 
+        /* Let the signals escape before we shut things down */
+        usleep(100000);
+
         /* Force deallocation so we can catch stuff from it */
         test_store.reset();
         pay_service.reset();
@@ -185,7 +196,7 @@
         return ::testing::Test::HasFailure() ? core::posix::exit::Status::failure : core::posix::exit::Status::success;
     };
 
-    auto client = [this, &cps1, &cps2]()
+    auto client = [this, &cps1, &cps2]() -> core::posix::exit::Status
     {
         GMainContext* context = g_main_context_new();
         g_main_context_push_thread_default(context);
@@ -220,8 +231,19 @@
         trap->run();
 
         /* Pull the events through */
-        while (g_main_context_iteration(context, FALSE)) {}
+        auto loop = g_main_loop_new(context, FALSE);
+        auto timeout = g_timeout_source_new(200);
+        g_source_set_callback(timeout, loop_quit, loop, nullptr);
+        g_source_attach(timeout, context);
+        g_main_loop_run(loop);
+        g_main_loop_unref(loop);
 
+        /* Can't use assert in lambdas */
+        if (4 != itemsignals.size())
+        {
+            std::cerr << "ERROR: Item signals isn't correct size (4): " << itemsignals.size() << std::endl;
+            throw;
+        }
         EXPECT_EQ("verifying", itemsignals[0]);
         EXPECT_EQ("purchasing", itemsignals[1]);
         EXPECT_EQ("not purchased", itemsignals[2]);

=== modified file 'tests/libpay-tests.cpp'
--- tests/libpay-tests.cpp	2014-05-29 06:51:32 +0000
+++ tests/libpay-tests.cpp	2014-06-18 18:46:48 +0000
@@ -44,10 +44,10 @@
                                               "ListPackages",
                                               nullptr,
                                               G_VARIANT_TYPE("ao"), /* out */
-                                              "ret = [ dbus.ObjectPath('/com/canonical/pay/package') ]", /* python */
+                                              "ret = [ dbus.ObjectPath('/com/canonical/pay/package_2Dname') ]", /* python */
                                               nullptr); /* error */
 
-        pkgobj = dbus_test_dbus_mock_get_object(mock, "/com/canonical/pay/package", "com.canonical.pay.package", nullptr);
+        pkgobj = dbus_test_dbus_mock_get_object(mock, "/com/canonical/pay/package_2Dname", "com.canonical.pay.package", nullptr);
 
         dbus_test_dbus_mock_object_add_method(mock, pkgobj,
                                               "VerifyItem",
@@ -94,13 +94,13 @@
 
 TEST_F(LibPayTests, InitTest)
 {
-    auto package = pay_package_new("package");
+    auto package = pay_package_new("package-name");
     pay_package_delete(package);
 }
 
 TEST_F(LibPayTests, ItemLifecycle)
 {
-    auto package = pay_package_new("package");
+    auto package = pay_package_new("package-name");
 
     EXPECT_EQ(PAY_PACKAGE_ITEM_STATUS_UNKNOWN, pay_package_item_status(package, "item"));
 
@@ -187,7 +187,7 @@
 {
     GError* error = nullptr;
     guint callcount = 0;
-    auto package = pay_package_new("package");
+    auto package = pay_package_new("package-name");
 
     EXPECT_TRUE(pay_package_item_start_verification(package, "item"));
 

=== added file 'tests/manual'
--- tests/manual	1970-01-01 00:00:00 +0000
+++ tests/manual	2014-06-18 18:46:48 +0000
@@ -0,0 +1,30 @@
+Test-case pay-service/setup-staging-account
+<dl>
+    <dt>Ensure that no U1 accounts are configured on the device</dt>
+        <dd>Going to System Settings → Accounts shouldn't have any "Ubuntu One" entries shown</dd>
+        <dd>Delete the account if there is one shown and exit system settings</dd>
+    <dt>Set up the device to use the staging servers for Ubuntu One</dt>
+        <dd>Execute the script: /usr/lib/*/pay-service/setup-staging.sh</dd>
+        <dd>It should run to completion without error</dd>
+    <dt>Create an Ubuntu One account: ${your name}+${unique number}@canonical.com</dt>
+        <dd>NOTE: This is only currently available to Canonical employees. There is work underway to make it more widely available but it is not complete yet.</dd>
+        <dd>The System Settings app should allow creating the account and the account show show up in the list of accounts on the device</dd>
+    <dt>Add a testing credit card to your account</dt>
+        <dd>The System Settings pane for Payment Options should allow for setting up the testing credit cards (numbers not listed here)</dd>
+</dl>
+
+Test-case pay-service/purchase-application
+<dl>
+    <dt>Create a new account with no previously purchased items</dt>
+        <dd>The instructions in <tt>pay-service/setup-staging-account</tt> pass without error</dd>
+    <dt>Find the "QR-Code" app in the application scope</dt>
+        <dd>By searching for "QR-Code" an app should be listed and clicking on it show its preview</dd>
+    <dt>Ensure that the QR-Code app has not been previously purchased</dt>
+        <dd>The button in the preview should show the price of the app and not "Open" or "Install"</dd>
+    <dt>Wait 10 minutes for the token to expire</dt>
+        <dd>Take a nice walk on a sunny day</dd>
+    <dt>Select the "Purchase" button for the "QR-Code" application</dt>
+        <dd>The button should depress and a window should appear asking for your Ubuntu One password</dd>
+    <dt>Enter your password and confirm the purchase</dt>
+        <dd>The window should close and the application should begin downloading and install</dd>
+</dl>

=== modified file 'tests/purchase-ual-tests.cpp'
--- tests/purchase-ual-tests.cpp	2014-05-26 14:01:00 +0000
+++ tests/purchase-ual-tests.cpp	2014-06-18 18:46:48 +0000
@@ -33,6 +33,13 @@
 		GDBusConnection * bus = NULL;
 
 		virtual void SetUp() {
+			g_setenv("TEST_CLICK_DB", "click-db", TRUE);
+			g_setenv("TEST_CLICK_USER", "test-user", TRUE);
+
+			gchar * linkfarm = g_build_filename(CMAKE_SOURCE_DIR, "ual-link-farm", NULL);
+			g_setenv("UPSTART_APP_LAUNCH_LINK_FARM", linkfarm, TRUE);
+			g_free(linkfarm);
+
 			service = dbus_test_service_new(NULL);
 
 			mock = dbus_test_dbus_mock_new("com.ubuntu.Upstart");
@@ -107,7 +114,7 @@
 	EXPECT_TRUE(item->run());
 	usleep(20 * 1000);
 
-	dbus_test_dbus_mock_object_emit_signal(mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"), g_variant_new_parsed("('stopped', ['JOB=application-legacy', 'INSTANCE=gedit-'])"), NULL);
+	dbus_test_dbus_mock_object_emit_signal(mock, obj, "EventEmitted", G_VARIANT_TYPE("(sas)"), g_variant_new_parsed("('stopped', ['JOB=application-click', 'INSTANCE=com.canonical.payui_app1_0.1'])"), NULL);
 	usleep(20 * 1000);
 
 	EXPECT_EQ(Purchase::Item::Status::PURCHASED, status);
@@ -128,7 +135,7 @@
 	usleep(20 * 1000);
 
 	GError * error = NULL;
-	g_spawn_command_line_async("gdbus emit --session --object-path / --signal com.canonical.UbuntuAppLaunch.ApplicationFailed gedit crash", &error);
+	g_spawn_command_line_async("gdbus emit --session --object-path / --signal com.canonical.UbuntuAppLaunch.ApplicationFailed com.canonical.payui_app1_0.1 crash", &error);
 	ASSERT_EQ(nullptr, error);
 
 	usleep(100 * 1000);

=== added file 'tests/setup-staging.sh'
--- tests/setup-staging.sh	1970-01-01 00:00:00 +0000
+++ tests/setup-staging.sh	2014-06-18 18:46:48 +0000
@@ -0,0 +1,19 @@
+#!/bin/bash -e
+# This small script sets up the variables needed for acceptance
+# testing of the pay-service and pay related things.
+
+echo "Setting up staging environment variables"
+
+initctl set-env --global SSO_AUTH_BASE_URL=https://login.staging.ubuntu.com
+initctl set-env --global SSO_UONE_BASE_URL=https://staging.one.ubuntu.com
+initctl set-env --global PAY_BASE_URL=https://sc.staging.ubuntu.com/api/2.0/click/
+initctl set-env --global URL_PACKAGE_INFO=https://search.apps.staging.ubuntu.com/api/v1/package/
+initctl set-env --global ACCOUNT_CREDS_URL=https://login.staging.ubuntu.com/api/v2/tokens/oauth
+initctl set-env --global ADD_PAYMENT_URL=https://sc.staging.ubuntu.com/api/2.0/click/paymentmethods/add/
+initctl set-env --global U1_SEARCH_BASE_URL=https://search.apps.staging.ubuntu.com/
+
+echo "Restarting scope registry"
+restart scope-registry
+
+echo "Restarting pay service"
+restart pay-service

=== added file 'tests/token-grabber-null.h'
--- tests/token-grabber-null.h	1970-01-01 00:00:00 +0000
+++ tests/token-grabber-null.h	2014-06-18 18:46:48 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors:
+ *   Ted Gould <[e-mail]>
+ */
+
+#ifndef TOKEN_GRABBER_NULL_HPP__
+#define TOKEN_GRABBER_NULL_HPP__ 1
+
+#include "service/token-grabber.h"
+
+class TokenGrabberNull : public TokenGrabber
+{
+public: 
+	virtual std::string signUrl (std::string url, std::string type)
+	{
+		std::string retval;
+		return retval;
+	}
+};
+
+#endif /* TOKEN_GRABBER_NULL_HPP__ */
+

=== added directory 'tests/ual-link-farm'
=== added file 'tests/ual-link-farm/com.canonical.payui_app1_0.1.desktop'
=== added directory 'tests/verification-curl-endpoints/good'
=== added file 'tests/verification-curl-endpoints/good/device-id.in'
--- tests/verification-curl-endpoints/good/device-id.in	1970-01-01 00:00:00 +0000
+++ tests/verification-curl-endpoints/good/device-id.in	2014-06-18 18:46:48 +0000
@@ -0,0 +1,5 @@
+{
+	/* Not sure of all the detail here, but making it simple to get started */
+	good: "simple",
+    device: "1234"
+}

=== renamed file 'tests/verification-curl-endpoints/good-simple.in' => 'tests/verification-curl-endpoints/good/simple.in'
=== added file 'tests/verification-curl-endpoints/package-name.in'
--- tests/verification-curl-endpoints/package-name.in	1970-01-01 00:00:00 +0000
+++ tests/verification-curl-endpoints/package-name.in	2014-06-18 18:46:48 +0000
@@ -0,0 +1,3 @@
+{
+  "item": "package-name"
+}

=== modified file 'tests/verification-curl-tests.cpp'
--- tests/verification-curl-tests.cpp	2014-05-19 14:47:16 +0000
+++ tests/verification-curl-tests.cpp	2014-06-18 18:46:48 +0000
@@ -19,6 +19,7 @@
 
 #include <gtest/gtest.h>
 #include "service/verification-curl.h"
+#include "token-grabber-null.h"
 
 struct VerificationCurlTests : public ::testing::Test
 {
@@ -26,16 +27,20 @@
 		virtual void SetUp() {
 			endpoint = "file://";
 			endpoint += VERIFICATION_CURL_ENDPOINTS_DIR;
+
+			device = "1234";
 		}
 
 		virtual void TearDown() {
 		}
 
 		std::string endpoint;
+		std::string device;
 };
 
 TEST_F(VerificationCurlTests, InitTest) {
-	auto verify = std::make_shared<Verification::CurlFactory>();
+	auto token = std::make_shared<TokenGrabberNull>();
+	auto verify = std::make_shared<Verification::CurlFactory>(token);
 	EXPECT_NE(nullptr, verify);
 	verify->setEndpoint(endpoint);
 	verify.reset();
@@ -43,7 +48,8 @@
 }
 
 TEST_F(VerificationCurlTests, PurchaseItem) {
-	auto verify = std::make_shared<Verification::CurlFactory>();
+	auto token = std::make_shared<TokenGrabberNull>();
+	auto verify = std::make_shared<Verification::CurlFactory>(token);
 	ASSERT_NE(nullptr, verify);
 	verify->setEndpoint(endpoint);
 
@@ -73,3 +79,46 @@
 
 	EXPECT_EQ(Verification::Item::Status::ERROR, badstatus);
 }
+
+TEST_F(VerificationCurlTests, ClickScope) {
+	auto token = std::make_shared<TokenGrabberNull>();
+	auto verify = std::make_shared<Verification::CurlFactory>(token);
+	ASSERT_NE(nullptr, verify);
+	verify->setEndpoint(endpoint);
+
+	std::string appid("click-scope");
+	std::string itemid("package-name");
+
+	auto item = verify->verifyItem(appid, itemid);
+	ASSERT_NE(nullptr, item);
+
+	Verification::Item::Status status = Verification::Item::Status::ERROR;
+	item->verificationComplete.connect([&status] (Verification::Item::Status in_status) { status = in_status; });
+
+	ASSERT_TRUE(item->run());
+	usleep(20 * 1000);
+
+	EXPECT_EQ(Verification::Item::Status::NOT_PURCHASED, status);
+}
+
+TEST_F(VerificationCurlTests, DeviceId) {
+	auto token = std::make_shared<TokenGrabberNull>();
+	auto verify = std::make_shared<Verification::CurlFactory>(token);
+	ASSERT_NE(nullptr, verify);
+	verify->setEndpoint(endpoint);
+	verify->setDevice(device);
+
+	std::string appid("good");
+	std::string itemid("device-id");
+
+	auto item = verify->verifyItem(appid, itemid);
+	ASSERT_NE(nullptr, item);
+
+	Verification::Item::Status status = Verification::Item::Status::ERROR;
+	item->verificationComplete.connect([&status] (Verification::Item::Status in_status) { status = in_status; });
+
+	ASSERT_TRUE(item->run());
+	usleep(20 * 1000);
+
+	EXPECT_EQ(Verification::Item::Status::NOT_PURCHASED, status);
+}