Merge lp:~marcustomlinson/unity-scopes-api/online_accounts_tests into lp:unity-scopes-api/devel

[Marcus Tomlinson]

Added tests for OnlineAccountClient

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:276
http://jenkins.qa.ubuntu.com/job/unity-scopes-api-ci/472/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-utopic-amd64-ci/99
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-utopic-armhf-ci/99
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-utopic-armhf-ci/99/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-utopic-i386-ci/99

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-api-ci/472/rebuild

review: Approve (continuous-integration)

[Paweł Stołowski (stolowski)]

LGTM.

review: Approve

[lp:~marcustomlinson/unity-scopes-api/online_accounts_tests]

278. By Marcus Tomlinson on 2014-10-08

Merged fix_ui_policy

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:278
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~marcustomlinson/unity-scopes-api/online_accounts_tests/+merge/237571/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/unity-scopes-api-devel-ci/1204/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-devel-utopic-amd64-ci/762
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-devel-utopic-armhf-ci/757/console
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-devel-utopic-armhf-ci/757/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-devel-utopic-i386-ci/756

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-api-devel-ci/1204/rebuild

review: Needs Fixing (continuous-integration)

[Marcus Tomlinson (marcustomlinson)]

Set a commit message and hit rebuild.

[Paweł Stołowski (stolowski)]

+1

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:278
http://jenkins.qa.ubuntu.com/job/unity-scopes-api-devel-ci/1205/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-devel-utopic-amd64-ci/763
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-devel-utopic-armhf-ci/758
        deb: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-devel-utopic-armhf-ci/758/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-scopes-api-devel-utopic-i386-ci/757

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scopes-api-devel-ci/1205/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'debian/control'
--- debian/control	2014-09-23 08:33:51 +0000
+++ debian/control	2014-10-08 11:04:26 +0000
@@ -26,6 +26,8 @@
                libjsoncpp-dev,
                libaccounts-glib-dev,
                libsignon-glib-dev,
+               dbus-test-runner,
+               libdbustest1-dev,
                valgrind,
 Standards-Version: 3.9.5
 XS-Testsuite: autopkgtest
@@ -81,4 +83,4 @@
 Multi-Arch: foreign
 Depends: ${misc:Depends},
 Description: Documentation for Unity scopes API
- Library to integrate scopes with the Unity shell (documentation)
\ No newline at end of file
+ Library to integrate scopes with the Unity shell (documentation)

=== modified file 'include/unity/scopes/OnlineAccountClient.h'
--- include/unity/scopes/OnlineAccountClient.h	2014-10-08 11:04:26 +0000
+++ include/unity/scopes/OnlineAccountClient.h	2014-10-08 11:04:26 +0000
@@ -37,6 +37,11 @@
 class OnlineAccountClientImpl;
 }
 
+namespace testing
+{
+class OnlineAccountClientTest;
+}
+
 /**
 \brief A simple interface for integrating online accounts access and monitoring into scopes.
 
@@ -159,6 +164,8 @@
 
 private:
     std::unique_ptr<internal::OnlineAccountClientImpl> p;
+
+    friend class testing::OnlineAccountClientTest;
 };
 
 } // namespace scopes

=== modified file 'include/unity/scopes/internal/OnlineAccountClientImpl.h'
--- include/unity/scopes/internal/OnlineAccountClientImpl.h	2014-10-08 11:04:26 +0000
+++ include/unity/scopes/internal/OnlineAccountClientImpl.h	2014-10-08 11:04:26 +0000
@@ -89,6 +89,7 @@
     std::shared_ptr<AgManager> manager();
     std::string service_name();
     OnlineAccountClient::MainLoopSelect main_loop_select();
+    std::shared_ptr<GMainContext> main_loop_context();
 
     void callback(AccountInfo const* info, std::string const& error = "");
 

=== modified file 'src/scopes/internal/OnlineAccountClientImpl.cpp'
--- src/scopes/internal/OnlineAccountClientImpl.cpp	2014-10-08 11:04:26 +0000
+++ src/scopes/internal/OnlineAccountClientImpl.cpp	2014-10-08 11:04:26 +0000
@@ -193,7 +193,7 @@
         if (error)
         {
             // Send notification that the authorization session failed
-            info->account_client->callback(info, error->message);
+            info->account_client->callback(info, error->message);  // LCOV_EXCL_LINE
             return;
         }
 
@@ -205,7 +205,7 @@
         {
             g_variant_builder_add(&builder, "{sv}",
                                   SIGNON_SESSION_DATA_UI_POLICY,
-                                  g_variant_new_int32(SIGNON_POLICY_DEFAULT));
+                                  g_variant_new_int32(SIGNON_POLICY_DEFAULT));  // LCOV_EXCL_LINE
         }
         else
         {
@@ -243,7 +243,7 @@
     if (!account)
     {
         // The account was not found
-        return;
+        return;  // LCOV_EXCL_LINE
     }
     // Find the service we're concerned with
     std::shared_ptr<GList> services(ag_account_list_services(account.get()), ag_service_list_free);
@@ -320,6 +320,7 @@
         }
         if (!main_loop_is_running_)
         {
+            // LCOV_EXCL_START
             if (main_loop_)
             {
                 // Quit the main loop, causing the thread to exit
@@ -337,6 +338,7 @@
             {
                 throw unity::ResourceException("OnlineAccountClientImpl(): main_loop_thread failed to start.");
             }
+            // LCOV_EXCL_STOP
         }
     }
     else
@@ -351,6 +353,7 @@
         std::lock_guard<std::mutex> lock(mutex_);
         if (thread_exception_)
         {
+            // LCOV_EXCL_START
             try
             {
                 std::rethrow_exception(thread_exception_);
@@ -363,6 +366,7 @@
             {
                 std::cerr << "~OnlineAccountClientImpl(): main_loop_thread threw an unknown exception" << std::endl;
             }
+            // LCOV_EXCL_STOP
         }
     }
 
@@ -394,7 +398,7 @@
     std::lock_guard<std::mutex> lock(mutex_);
     if (thread_exception_)
     {
-        std::rethrow_exception(thread_exception_);
+        std::rethrow_exception(thread_exception_);  // LCOV_EXCL_LINE
     }
 
     std::lock_guard<std::mutex> callback_lock(callback_mutex_);
@@ -406,7 +410,7 @@
     std::unique_lock<std::mutex> lock(mutex_);
     if (thread_exception_)
     {
-        std::rethrow_exception(thread_exception_);
+        std::rethrow_exception(thread_exception_);  // LCOV_EXCL_LINE
     }
 
     std::shared_ptr<GList> enabled_accounts(ag_manager_list(manager_.get()), ag_manager_list_free);
@@ -431,7 +435,7 @@
     std::lock_guard<std::mutex> lock(mutex_);
     if (thread_exception_)
     {
-        std::rethrow_exception(thread_exception_);
+        std::rethrow_exception(thread_exception_);  // LCOV_EXCL_LINE
     }
 
     // Return all service statuses
@@ -577,6 +581,11 @@
     return main_loop_select_;
 }
 
+std::shared_ptr<GMainContext> OnlineAccountClientImpl::main_loop_context()
+{
+    return main_loop_context_;
+}
+
 void OnlineAccountClientImpl::callback(AccountInfo const* info, std::string const& error)
 {
     std::lock_guard<std::mutex> lock(callback_mutex_);
@@ -642,6 +651,7 @@
         main_loop_.reset(g_main_loop_new(main_loop_context_.get(), true), g_main_loop_unref);
         g_main_loop_run(main_loop_.get());
     }
+    // LCOV_EXCL_START
     catch (std::exception const& e)
     {
         std::cerr << "OnlineAccountClientImpl::main_loop_thread(): Thread aborted: " << e.what() << std::endl;
@@ -654,6 +664,7 @@
         std::lock_guard<std::mutex> lock(mutex_);
         thread_exception_ = std::current_exception();
     }
+    // LCOV_EXCL_STOP
 }
 
 void OnlineAccountClientImpl::auth_callback(std::string const& details_json)

=== modified file 'test/gtest/scopes/OnlineAccountClient/CMakeLists.txt'
--- test/gtest/scopes/OnlineAccountClient/CMakeLists.txt	2014-09-10 08:45:38 +0000
+++ test/gtest/scopes/OnlineAccountClient/CMakeLists.txt	2014-10-08 11:04:26 +0000
@@ -1,4 +1,12 @@
 add_executable(OnlineAccountClient_test OnlineAccountClient_test.cpp)
+
+pkg_check_modules(DBUSTEST REQUIRED dbustest-1)
+include_directories(${DBUSTEST_INCLUDE_DIRS})
+target_link_libraries(OnlineAccountClient_test ${DBUSTEST_LDFLAGS})
+
+add_definitions(-DTEST_DATA_DIR="${CMAKE_CURRENT_SOURCE_DIR}/data")
+add_definitions(-DTEST_DB_DIR="${CMAKE_CURRENT_BINARY_DIR}")
+
 target_link_libraries(OnlineAccountClient_test ${TESTLIBS})
 
 add_test(OnlineAccountClient OnlineAccountClient_test)

=== modified file 'test/gtest/scopes/OnlineAccountClient/OnlineAccountClient_test.cpp'
--- test/gtest/scopes/OnlineAccountClient/OnlineAccountClient_test.cpp	2014-10-08 11:04:26 +0000
+++ test/gtest/scopes/OnlineAccountClient/OnlineAccountClient_test.cpp	2014-10-08 11:04:26 +0000
@@ -16,17 +16,552 @@
  * Authored by: Marcus Tomlinson <[e-mail]>
  */
 
+#include <unity/scopes/OnlineAccountClient.h>
+#include <unity/scopes/internal/OnlineAccountClientImpl.h>
+
+#include <unity/scopes/CategorisedResult.h>
+#include <unity/scopes/CategoryRenderer.h>
+#include <unity/scopes/internal/CategoryRegistry.h>
+#include <unity/scopes/PreviewWidget.h>
+#include <unity/scopes/Variant.h>
+
+#include <boost/filesystem/operations.hpp>
+#include <condition_variable>
+#include <functional>
 #include <gtest/gtest.h>
-#include <unity/scopes/OnlineAccountClient.h>
-
+#include <libaccounts-glib/accounts-glib.h>
+#include <libdbustest/dbus-test.h>
 #include <thread>
 
+using namespace unity;
 using namespace unity::scopes;
-
-TEST(OnlineAccountClient, basic)
-{
-    setenv("XDG_RUNTIME_DIR", "/tmp", true);
-
-    OnlineAccountClient oa_client("com.ubuntu.scopes.youtube_youtube", "sharing", "google");
-    auto service_statuses = oa_client.get_service_statuses();
+using namespace unity::scopes::testing;
+using namespace unity::scopes::internal;
+
+namespace unity
+{
+namespace scopes
+{
+namespace testing
+{
+
+class OnlineAccountClientTest : public ::testing::Test
+{
+public:
+    OnlineAccountClientTest(OnlineAccountClient::MainLoopSelect main_loop_select = OnlineAccountClient::CreateInternalMainLoop)
+    {
+        boost::filesystem::remove(TEST_DB_DIR "/accounts.db");
+
+        setenv("XDG_RUNTIME_DIR", "/tmp", true);
+        setenv("ACCOUNTS", TEST_DB_DIR, false);
+        setenv("AG_SERVICES", TEST_DATA_DIR, false);
+        setenv("AG_SERVICE_TYPES", TEST_DATA_DIR, false);
+        setenv("AG_PROVIDERS", TEST_DATA_DIR, false);
+
+        oa_client_.reset(new OnlineAccountClient("TestService", "sharing", "TestProvider", main_loop_select));
+
+        manager_ = oa_client_->p->manager();
+        main_loop_context_ = oa_client_->p->main_loop_context();
+    }
+
+    ~OnlineAccountClientTest()
+    {
+        account_ = nullptr;
+        manager_ = nullptr;
+        oa_client_ = nullptr;
+    }
+
+    std::shared_ptr<OnlineAccountClient> oa_client()
+    {
+        return oa_client_;
+    }
+
+    void create_account()
+    {
+        run_in_main_loop_(std::bind(&OnlineAccountClientTest::create_account_, this));
+    }
+
+    void delete_account()
+    {
+        run_in_main_loop_(std::bind(&OnlineAccountClientTest::delete_account_, this));
+    }
+
+    void enable_service()
+    {
+        run_in_main_loop_(std::bind(&OnlineAccountClientTest::enable_service_, this));
+    }
+
+    void disable_service()
+    {
+        run_in_main_loop_(std::bind(&OnlineAccountClientTest::disable_service_, this));
+    }
+
+    void disable_account()
+    {
+        run_in_main_loop_(std::bind(&OnlineAccountClientTest::disable_account_, this));
+    }
+
+    void enable_account()
+    {
+        run_in_main_loop_(std::bind(&OnlineAccountClientTest::enable_account_, this));
+    }
+
+    void service_update_enabled(OnlineAccountClient::ServiceStatus const& status)
+    {
+        EXPECT_EQ(1, status.account_id);
+        EXPECT_EQ(true, status.service_enabled);
+        EXPECT_EQ(false, status.service_authenticated);
+        EXPECT_EQ("69842936499-sdflkbhslufhgrjamwlicefhb.apps.test.com", status.client_id);
+        EXPECT_EQ("lj3i8iorep0w03994jwjef0j", status.client_secret);
+        EXPECT_EQ("", status.access_token);
+        EXPECT_EQ("", status.token_secret);
+        EXPECT_NE("", status.error);
+
+        std::lock_guard<std::mutex> lock(mutex_);
+        got_update_ = true;
+        cond_.notify_all();
+    }
+
+    void service_update_disabled(OnlineAccountClient::ServiceStatus const& status)
+    {
+        EXPECT_EQ(1, status.account_id);
+        EXPECT_EQ(false, status.service_enabled);
+        EXPECT_EQ(false, status.service_authenticated);
+        EXPECT_EQ("69842936499-sdflkbhslufhgrjamwlicefhb.apps.test.com", status.client_id);
+        EXPECT_EQ("lj3i8iorep0w03994jwjef0j", status.client_secret);
+        EXPECT_EQ("", status.access_token);
+        EXPECT_EQ("", status.token_secret);
+        EXPECT_EQ("", status.error);
+
+        std::lock_guard<std::mutex> lock(mutex_);
+        got_update_ = true;
+        cond_.notify_all();
+    }
+
+    void service_update_none(OnlineAccountClient::ServiceStatus const& status)
+    {
+        EXPECT_EQ(1, status.account_id);
+        EXPECT_EQ(false, status.service_enabled);
+        EXPECT_EQ(false, status.service_authenticated);
+        EXPECT_EQ("", status.client_id);
+        EXPECT_EQ("", status.client_secret);
+        EXPECT_EQ("", status.access_token);
+        EXPECT_EQ("", status.token_secret);
+        EXPECT_EQ("", status.error);
+
+        std::lock_guard<std::mutex> lock(mutex_);
+        got_update_ = true;
+        cond_.notify_all();
+    }
+
+    void service_update_auth(OnlineAccountClient::ServiceStatus const& status)
+    {
+        EXPECT_EQ(1, status.account_id);
+        EXPECT_EQ(true, status.service_enabled);
+        EXPECT_EQ(true, status.service_authenticated);
+        EXPECT_EQ("isuertbiseruy87srkuthksvu", status.client_id);
+        EXPECT_EQ("rytwekfgiodng523dr4", status.client_secret);
+        EXPECT_EQ("sfhgbfgutgi9ugwirheg74", status.access_token);
+        EXPECT_EQ("qwpeurylsfdg83", status.token_secret);
+        EXPECT_EQ("not really an error, but just to test", status.error);
+
+        std::lock_guard<std::mutex> lock(mutex_);
+        got_update_ = true;
+        cond_.notify_all();
+    }
+
+    bool wait_for_service_update()
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        EXPECT_TRUE(cond_.wait_for(lock, std::chrono::seconds(1), [this]{ return got_update_; })) << "service update callback not triggered";
+        bool result = got_update_;
+        got_update_ = false;
+        return result;
+    }
+
+    void invoke_callback(std::shared_ptr<OnlineAccountClient> oa_client, AccountInfo const* info, std::string const& error)
+    {
+        oa_client->p->callback(info, error);
+    }
+
+    static void safe_g_error_free_(GError* e)
+    {
+        if (e)
+        {
+            g_error_free(e);
+        }
+    }
+
+    static void safe_g_variant_free_(GVariant* v)
+    {
+        if (v)
+        {
+            g_variant_unref(v);
+        }
+    }
+
+private:
+    std::shared_ptr<OnlineAccountClient> oa_client_;
+    std::shared_ptr<AgManager> manager_;
+    std::shared_ptr<AgAccount> account_;
+    std::shared_ptr<GMainContext> main_loop_context_;
+
+    bool got_update_;
+    std::mutex mutex_;
+    std::condition_variable cond_;
+
+private:
+    void run_in_main_loop_(std::function<void()> func)
+    {
+        auto func_task = [](void* user_data)
+        {
+            auto cb_data = reinterpret_cast<std::pair<std::function<void()>*, GMainLoop*>*>(user_data);
+            auto func = cb_data->first;
+            auto event_loop = cb_data->second;
+
+            (*func)();
+
+            while (!g_main_loop_is_running(event_loop));
+            g_main_loop_quit(event_loop);
+
+            return G_SOURCE_REMOVE;
+        };
+
+        std::shared_ptr<GMainLoop> event_loop;
+        if (main_loop_context_)
+        {
+            event_loop.reset(g_main_loop_new(main_loop_context_.get(), false), g_main_loop_unref);
+            auto cb_data = std::make_pair(&func, event_loop.get());
+            g_main_context_invoke(main_loop_context_.get(), func_task, &cb_data);
+        }
+        else
+        {
+            event_loop.reset(g_main_loop_new(nullptr, false), g_main_loop_unref);
+            auto cb_data = std::make_pair(&func, event_loop.get());
+            g_idle_add(func_task, &cb_data);
+        }
+        g_main_loop_run(event_loop.get());
+    }
+
+    void create_account_()
+    {
+        account_.reset(ag_manager_create_account(manager_.get(), "TestProvider"), g_object_unref);
+        ag_account_select_service(account_.get(), nullptr);
+        ag_account_set_enabled(account_.get(), true);
+
+        GError* error = nullptr;
+        bool stored = ag_account_store_blocking(account_.get(), &error);
+        std::shared_ptr<GError> error_cleanup(error, safe_g_error_free_);
+
+        EXPECT_TRUE(stored);
+        EXPECT_EQ(nullptr, error);
+    }
+
+    void delete_account_()
+    {
+        ag_account_delete(account_.get());
+
+        GError* error = nullptr;
+        bool stored = ag_account_store_blocking(account_.get(), &error);
+        std::shared_ptr<GError> error_cleanup(error, safe_g_error_free_);
+
+        account_ = nullptr;
+
+        EXPECT_TRUE(stored);
+        EXPECT_EQ(nullptr, error);
+    }
+
+    void enable_service_()
+    {
+        auto service = ag_manager_get_service(manager_.get(), "TestService");
+        ag_account_select_service(account_.get(), service);
+        ag_account_set_enabled(account_.get(), true);
+
+        GError* error = nullptr;
+        bool stored = ag_account_store_blocking(account_.get(), &error);
+        std::shared_ptr<GError> error_cleanup(error, safe_g_error_free_);
+
+        EXPECT_TRUE(stored);
+        EXPECT_EQ(nullptr, error);
+    }
+
+    void disable_service_()
+    {
+        auto service = ag_manager_get_service(manager_.get(), "TestService");
+        ag_account_select_service(account_.get(), service);
+        ag_account_set_enabled(account_.get(), false);
+
+        GError* error = nullptr;
+        bool stored = ag_account_store_blocking(account_.get(), &error);
+        std::shared_ptr<GError> error_cleanup(error, safe_g_error_free_);
+
+        EXPECT_TRUE(stored);
+        EXPECT_EQ(nullptr, error);
+    }
+
+    void disable_account_()
+    {
+        ag_account_set_enabled(account_.get(), false);
+
+        GError* error = nullptr;
+        bool stored = ag_account_store_blocking(account_.get(), &error);
+        std::shared_ptr<GError> error_cleanup(error, safe_g_error_free_);
+
+        EXPECT_TRUE(stored);
+        EXPECT_EQ(nullptr, error);
+    }
+
+    void enable_account_()
+    {
+        ag_account_set_enabled(account_.get(), true);
+
+        GError* error = nullptr;
+        bool stored = ag_account_store_blocking(account_.get(), &error);
+        std::shared_ptr<GError> error_cleanup(error, safe_g_error_free_);
+
+        EXPECT_TRUE(stored);
+        EXPECT_EQ(nullptr, error);
+    }
+};
+
+class OnlineAccountClientTestNoMainLoop : public OnlineAccountClientTest
+{
+public:
+    OnlineAccountClientTestNoMainLoop()
+        : OnlineAccountClientTest(OnlineAccountClient::RunInExternalMainLoop) {}
+};
+
+} // namespace testing
+} // namespace scopes
+} // namespace unity
+
+TEST_F(OnlineAccountClientTest, register_account_login_result)
+{
+    OnlineAccountClient oa_client("test_service_name", "test_service_type", "test_provider");
+
+    CategoryRegistry reg;
+    auto cat = reg.register_category("1", "title", "icon", nullptr, CategoryRenderer());
+    CategorisedResult result(cat);
+
+    oa_client.register_account_login_item(result, CannedQuery("test"), OnlineAccountClient::InvalidateResults, OnlineAccountClient::DoNothing);
+
+    EXPECT_TRUE(result.contains("online_account_details"));
+
+    VariantMap details = result.value("online_account_details").get_dict();
+
+    EXPECT_NE(details.end(), details.find("service_name"));
+    EXPECT_NE(details.end(), details.find("service_type"));
+    EXPECT_NE(details.end(), details.find("provider_name"));
+    EXPECT_NE(details.end(), details.find("login_passed_action"));
+    EXPECT_NE(details.end(), details.find("login_failed_action"));
+
+    EXPECT_EQ("test_service_name", details.at("service_name").get_string());
+    EXPECT_EQ("test_service_type", details.at("service_type").get_string());
+    EXPECT_EQ("test_provider", details.at("provider_name").get_string());
+    EXPECT_EQ(OnlineAccountClient::InvalidateResults, static_cast<OnlineAccountClient::PostLoginAction>(details.at("login_passed_action").get_int()));
+    EXPECT_EQ(OnlineAccountClient::DoNothing, static_cast<OnlineAccountClient::PostLoginAction>(details.at("login_failed_action").get_int()));
+}
+
+TEST_F(OnlineAccountClientTest, register_account_login_widget)
+{
+    OnlineAccountClient oa_client("test_service_name", "test_service_type", "test_provider");
+
+    PreviewWidget widget("i1", "image");
+
+    oa_client.register_account_login_item(widget, OnlineAccountClient::ContinueActivation, OnlineAccountClient::DoNothing);
+
+    VariantMap values = widget.attribute_values();
+
+    EXPECT_NE(values.end(), values.find("online_account_details"));
+
+    VariantMap details = values.at("online_account_details").get_dict();
+
+    EXPECT_NE(details.end(), details.find("service_name"));
+    EXPECT_NE(details.end(), details.find("service_type"));
+    EXPECT_NE(details.end(), details.find("provider_name"));
+    EXPECT_NE(details.end(), details.find("login_passed_action"));
+    EXPECT_NE(details.end(), details.find("login_failed_action"));
+
+    EXPECT_EQ("test_service_name", details.at("service_name").get_string());
+    EXPECT_EQ("test_service_type", details.at("service_type").get_string());
+    EXPECT_EQ("test_provider", details.at("provider_name").get_string());
+    EXPECT_EQ(OnlineAccountClient::ContinueActivation, static_cast<OnlineAccountClient::PostLoginAction>(details.at("login_passed_action").get_int()));
+    EXPECT_EQ(OnlineAccountClient::DoNothing, static_cast<OnlineAccountClient::PostLoginAction>(details.at("login_failed_action").get_int()));
+}
+
+TEST_F(OnlineAccountClientTest, refresh_services_main_loop)
+{
+    auto statuses = oa_client()->get_service_statuses();
+    EXPECT_EQ(0, statuses.size());
+
+    create_account();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_EQ(1, statuses.size());
+    EXPECT_FALSE(statuses[0].service_enabled);
+
+    enable_service();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_TRUE(statuses[0].service_enabled);
+
+    disable_service();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_FALSE(statuses[0].service_enabled);
+
+    enable_service();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_TRUE(statuses[0].service_enabled);
+
+    disable_account();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_FALSE(statuses[0].service_enabled);
+
+    enable_account();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_TRUE(statuses[0].service_enabled);
+
+    delete_account();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_EQ(0, statuses.size());
+}
+
+TEST_F(OnlineAccountClientTest, service_update_callback)
+{
+    auto statuses = oa_client()->get_service_statuses();
+    EXPECT_EQ(0, statuses.size());
+
+    oa_client()->set_service_update_callback(std::bind(&OnlineAccountClientTest::service_update_none, this, std::placeholders::_1));
+    create_account();
+    wait_for_service_update();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_EQ(1, statuses.size());
+
+    oa_client()->set_service_update_callback(std::bind(&OnlineAccountClientTest::service_update_enabled, this, std::placeholders::_1));
+    enable_service();
+    wait_for_service_update();
+
+    oa_client()->set_service_update_callback(std::bind(&OnlineAccountClientTest::service_update_disabled, this, std::placeholders::_1));
+    disable_service();
+    wait_for_service_update();
+
+    oa_client()->set_service_update_callback(std::bind(&OnlineAccountClientTest::service_update_enabled, this, std::placeholders::_1));
+    enable_service();
+    wait_for_service_update();
+
+    oa_client()->set_service_update_callback(std::bind(&OnlineAccountClientTest::service_update_disabled, this, std::placeholders::_1));
+    disable_account();
+    wait_for_service_update();
+
+    oa_client()->set_service_update_callback(std::bind(&OnlineAccountClientTest::service_update_enabled, this, std::placeholders::_1));
+    enable_account();
+    wait_for_service_update();
+
+    oa_client()->set_service_update_callback(std::bind(&OnlineAccountClientTest::service_update_disabled, this, std::placeholders::_1));
+    delete_account();
+    wait_for_service_update();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_EQ(0, statuses.size());
+}
+
+TEST_F(OnlineAccountClientTestNoMainLoop, refresh_services_no_main_loop)
+{
+    auto statuses = oa_client()->get_service_statuses();
+    EXPECT_EQ(0, statuses.size());
+
+    create_account();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_EQ(1, statuses.size());
+    EXPECT_FALSE(statuses[0].service_enabled);
+
+    enable_service();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_TRUE(statuses[0].service_enabled);
+
+    disable_service();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_FALSE(statuses[0].service_enabled);
+
+    enable_service();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_TRUE(statuses[0].service_enabled);
+
+    disable_account();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_FALSE(statuses[0].service_enabled);
+
+    enable_account();
+    oa_client()->refresh_service_statuses();
+
+    statuses = oa_client()->get_service_statuses();
+    EXPECT_TRUE(statuses[0].service_enabled);
+}
+
+TEST_F(OnlineAccountClientTestNoMainLoop, pub_sub_authentication)
+{
+    std::shared_ptr<OnlineAccountClient> shell_oa_client;
+    shell_oa_client.reset(new OnlineAccountClient("TestService", "sharing", "TestProvider", OnlineAccountClient::RunInExternalUiMainLoop));
+
+    std::shared_ptr<OnlineAccountClient> scope_oa_client;
+    scope_oa_client.reset(new OnlineAccountClient("TestService", "sharing", "TestProvider", OnlineAccountClient::RunInExternalMainLoop));
+
+    create_account();
+    scope_oa_client->refresh_service_statuses();
+
+    std::shared_ptr<AccountInfo> info(new AccountInfo);
+    info->account_id = 1;
+    info->service_enabled = true;
+    {
+        GVariantDict dict;
+        g_variant_dict_init(&dict, nullptr);
+        g_variant_dict_insert(&dict, "ConsumerKey", "s", "isuertbiseruy87srkuthksvu");
+        g_variant_dict_insert(&dict, "ConsumerSecret", "s", "rytwekfgiodng523dr4");
+        info->auth_params.reset(g_variant_ref_sink(g_variant_dict_end(&dict)), safe_g_variant_free_);
+    }
+    {
+        GVariantDict dict;
+        g_variant_dict_init(&dict, nullptr);
+        g_variant_dict_insert(&dict, "AccessToken", "s", "sfhgbfgutgi9ugwirheg74");
+        g_variant_dict_insert(&dict, "TokenSecret", "s", "qwpeurylsfdg83");
+        info->session_data.reset(g_variant_ref_sink(g_variant_dict_end(&dict)), safe_g_variant_free_);
+    }
+
+    // Invoke callback on shell_oa_client which should invoke a callback on scope_oa_client via pub/sub
+    scope_oa_client->set_service_update_callback(std::bind(&OnlineAccountClientTest::service_update_auth, this, std::placeholders::_1));
+    invoke_callback(shell_oa_client, info.get(), "not really an error, but just to test");
+    wait_for_service_update();
+}
+
+int main(int argc, char **argv)
+{
+    std::shared_ptr<DbusTestService> dbus_test_service;
+    dbus_test_service.reset(dbus_test_service_new(nullptr), g_object_unref);
+    dbus_test_service_run(dbus_test_service.get());
+
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
 }

=== added directory 'test/gtest/scopes/OnlineAccountClient/data'
=== added file 'test/gtest/scopes/OnlineAccountClient/data/TestService.service'
--- test/gtest/scopes/OnlineAccountClient/data/TestService.service	1970-01-01 00:00:00 +0000
+++ test/gtest/scopes/OnlineAccountClient/data/TestService.service	2014-10-08 11:04:26 +0000
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<service id="TestService">
+  <type>sharing</type>
+  <name>Test Service</name>
+  <provider>TestProvider</provider>
+  <template>
+    <group name="auth">
+      <setting name="method">oauth2</setting>
+      <setting name="mechanism">web_server</setting>
+      <group name="oauth2">
+        <group name="web_server">
+          <setting name="Host">accounts.test.com</setting>
+          
+          <setting name="AuthPath">o/oauth2/auth?access_type=offline</setting>
+          <setting name="TokenPath">o/oauth2/token</setting>
+          <setting name="RedirectUri">https://wiki.ubuntu.com/</setting>
+          <setting name="ResponseType">code</setting>
+          <setting type="as" name="Scope">['https://www.test.com/auth/test.readonly']</setting>
+          <setting name="ClientId">69842936499-sdflkbhslufhgrjamwlicefhb.apps.test.com</setting>
+          <setting name="ClientSecret">lj3i8iorep0w03994jwjef0j</setting>
+          <setting type="as" name="AllowedSchemes">['https','http']</setting>
+        </group>
+      </group>
+    </group>
+  </template>
+</service>

=== modified file 'valgrind-suppress'
--- valgrind-suppress	2014-09-25 09:43:35 +0000
+++ valgrind-suppress	2014-10-08 11:04:26 +0000
@@ -212,3 +212,24 @@
    Memcheck:Cond
    fun:ag_auth_data_unref
 }
+
+{
+   malloc[Memcheck:Leak]
+   Memcheck:Leak
+   fun:malloc
+   fun:g_malloc
+   fun:g_slice_alloc
+   fun:g_slice_alloc0
+   ...
+   fun:ag_manager_get_service
+   ...
+   fun:ag_manager_list_services_by_type
+   fun:ag_account_list_services
+}
+
+{
+   operator new(unsigned long)[Memcheck:Leak]
+   Memcheck:Leak
+   fun:_Znwm
+   fun:_ZNSs4_Rep9_S_createEmmRKSaIcE
+}