Merge lp:~mardy/online-accounts-api/mock-template into lp:online-accounts-api

[Alberto Mardegan]

Create python-dbusmock template

And a couple of tests to ensure it's working properly.

Create python-dbusmock template

And a couple of tests to ensure it's working properly.

Unmerged revisions

38. By Alberto Mardegan on 2015-03-11

Update library name

37. By Alberto Mardegan on 2015-03-11

Merge from qt branch

36. By Alberto Mardegan on 2015-03-10

Remove disabled tests, fix execution

35. By Alberto Mardegan on 2015-03-10

WIP

=== added file 'src/daemon/online_accounts.py'
--- src/daemon/online_accounts.py	1970-01-01 00:00:00 +0000
+++ src/daemon/online_accounts.py	2015-03-11 07:42:13 +0000
@@ -0,0 +1,128 @@
+'''online-accounts mock template
+
+This creates the expected methods and properties of the main
+com.ubuntu.OnlineAccounts.Manager object. By default, all actions are rejected.  You
+can call AllowUnknown() and SetAllowed() on the mock D-BUS interface to control
+which actions are allowed.
+'''
+
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation; either version 3 of the License, or (at your option) any
+# later version.  See http://www.gnu.org/copyleft/lgpl.html for the full text
+# of the license.
+
+__author__ = 'Alberto Mardegan'
+__email__ = '[e-mail]'
+__copyright__ = '(c) 2015 Canonical Ltd.'
+__license__ = 'LGPL 3+'
+
+import dbus
+
+from dbusmock import MOCK_IFACE
+
+BUS_NAME = 'com.ubuntu.OnlineAccounts.Manager'
+MAIN_OBJ = '/com/ubuntu/OnlineAccounts/Manager'
+MAIN_IFACE = 'com.ubuntu.OnlineAccounts.Manager'
+SYSTEM_BUS = False
+
+ERROR_PREFIX = 'com.ubuntu.OnlineAccounts.Error.'
+ERROR_NO_ACCOUNT = ERROR_PREFIX + 'NoAccount'
+ERROR_CANCELED = ERROR_PREFIX + 'UserCanceled'
+ERROR_PERMISSION_DENIED = ERROR_PREFIX + 'PermissionDenied'
+ERROR_INTERACTION_REQUIRED = ERROR_PREFIX + 'InteractionRequired'
+
+CHANGE_TYPE_ENABLED = 0
+CHANGE_TYPE_DISABLED = 1
+CHANGE_TYPE_UPDATED = 2
+
+def load(mock, parameters):
+    mock.AddMethod(MAIN_IFACE,
+                   'GetAccounts',
+                   'a{sv}',
+                   'a(ua{sv})',
+                   '''ret = self.accounts.items()''')
+
+    mock.AddMethod(MAIN_IFACE,
+                   'RequestAccess',
+                   'sa{sv}',
+                   '(ua{sv})a{sv}',
+                   'ret = self.request_access(args[0], args[1])')
+
+    mock.AddMethod(MAIN_IFACE,
+                   'Authenticate',
+                   'usbba{sv}',
+                   'a{sv}',
+                   'ret = self.authenticate(args[0], args[1], args[2], args[3], args[4])')
+
+    mock.accounts = {}
+    mock.authentication_reply = {}
+    mock.authentication_error = None
+    mock.last_account_id = 0
+    mock.new_account_details = {}
+
+    def request_access(self, service_id, params):
+        if len(self.new_account_details) == 0:
+            raise dbus.exceptions.DBusException('Permission denied',
+                                                name=ERROR_PERMISSION_DENIED)
+        self.AddAccount(self.new_account_details)
+        authentication_reply = self.authenticate(self.last_account_id, service_id,
+                                                 True, False, params)
+        return ((self.last_account_id, self.new_account_details), authentication_reply)
+
+    setattr(mock.__class__, "request_access", request_access)
+
+    def authenticate(self, account_id, service_id, interactive, invalidate, params):
+        if account_id not in self.accounts:
+            raise dbus.exceptions.DBusException('No account with id %s' % (account_id,),
+                                                name=ERROR_NO_ACCOUNT)
+        if self.authentication_error:
+            raise dbus.exceptions.DBusException('Authentication error',
+                                                name=self.authentication_error)
+        return self.authentication_reply
+
+    setattr(mock.__class__, "authenticate", authenticate)
+
[e-mail](MOCK_IFACE, in_signature='a{sv}', out_signature='u')
+def AddAccount(self, account_details):
+    '''Add a new account to the DB
+
+    Returns the ID of the new account
+    '''
+    self.last_account_id += 1
+    self.accounts[self.last_account_id] = account_details
+    service = account_details.get('serviceId', '')
+    signal_data = account_details.copy()
+    signal_data['changeType'] = CHANGE_TYPE_ENABLED
+    self.EmitSignal(MAIN_IFACE, 'AccountChanged', 's(ua{sv})',
+                    [service, (self.last_account_id, signal_data)])
+    return self.last_account_id
+
+
[e-mail](MOCK_IFACE, in_signature='u', out_signature='')
+def RemoveAccount(self, account_id):
+    '''Remove an existing account'''
+
+    account_details = self.accounts[account_id]
+    service = account_details.get('serviceId', '')
+    signal_data = account_details.copy()
+    signal_data['changeType'] = CHANGE_TYPE_DISABLED
+    self.EmitSignal(MAIN_IFACE, 'AccountChanged', 's(ua{sv})',
+                    [service, (account_id, signal_data)])
+    del self.accounts[account_id]
+
+
[e-mail](MOCK_IFACE, in_signature='a{sv}', out_signature='')
+def SetRequestAccessReply(self, account_details):
+    '''Prepares the reply for the next RequestAccess call'''
+
+    self.new_account_details = account_details
+
+
[e-mail](MOCK_IFACE, in_signature='sa{sv}', out_signature='')
+def SetAuthenticationReply(self, authentication_reply, error_name):
+    '''Prepares the reply for the next Authenticate call'''
+
+    self.authentication_reply = authentication_reply
+    self.authentication_error = error_name
+

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-03-11 07:42:13 +0000
+++ tests/CMakeLists.txt	2015-03-11 07:42:13 +0000
@@ -6,5 +6,6 @@
   ${TEST_INCLUDE_DIRS}
 )
 
+add_subdirectory(daemon/mock_template)
 add_subdirectory(lib/OnlineAccounts)
 add_subdirectory(unit)

=== added directory 'tests/daemon'
=== added directory 'tests/daemon/mock_template'
=== added file 'tests/daemon/mock_template/CMakeLists.txt'
--- tests/daemon/mock_template/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/daemon/mock_template/CMakeLists.txt	2015-03-11 07:42:13 +0000
@@ -0,0 +1,28 @@
+set(TEST mock_template)
+set(SOURCES
+    mock_template.cpp
+)
+
+pkg_check_modules(QTDBUSMOCK REQUIRED libqtdbusmock-1)
+pkg_check_modules(QTDBUSTEST REQUIRED libqtdbustest-1)
+
+add_executable(${TEST} ${SOURCES})
+include_directories(
+    ${CMAKE_CURRENT_BINARY_DIR}
+    ${OnlineAccountsQt_SOURCE_DIR}/..
+    ${QTDBUSMOCK_INCLUDE_DIRS}
+    ${QTDBUSTEST_INCLUDE_DIRS}
+)
+add_definitions(
+    -DMOCK_TEMPLATE="${OnlineAccountsDaemon_SOURCE_DIR}/online_accounts.py"
+)
+
+target_link_libraries(${TEST}
+    OnlineAccountsQt
+    ${QTDBUSMOCK_LIBRARIES}
+    ${QTDBUSTEST_LIBRARIES}
+)
+
+qt5_use_modules(${TEST} Core Test)
+add_test(${TEST} ${CMAKE_CURRENT_BINARY_DIR}/${TEST} -xunitxml -o ${TEST}.xml)
+add_dependencies(check ${TEST})

=== added file 'tests/daemon/mock_template/mock_template.cpp'
--- tests/daemon/mock_template/mock_template.cpp	1970-01-01 00:00:00 +0000
+++ tests/daemon/mock_template/mock_template.cpp	2015-03-11 07:42:13 +0000
@@ -0,0 +1,157 @@
+/*
+ * This file is part of libOnlineAccounts
+ *
+ * Copyright (C) 2015 Canonical Ltd.
+ *
+ * Contact: Alberto Mardegan <[e-mail]>
+ *
+ * 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "OnlineAccounts/Account"
+#include "OnlineAccounts/Manager"
+#include "OnlineAccounts/OAuth1Data"
+#include "OnlineAccounts/OAuth2Data"
+#include "OnlineAccounts/PasswordData"
+#include "OnlineAccounts/dbus_constants.h"
+#include <QDBusConnection>
+#include <QObject>
+#include <QSignalSpy>
+#include <QTest>
+#include <libqtdbusmock/DBusMock.h>
+
+struct AccountDetails
+{
+    AccountDetails() {}
+    AccountDetails(const QString &name, const QString &service,
+                   const QVariantMap &settings = QVariantMap()) {
+        map[ONLINE_ACCOUNTS_INFO_KEY_DISPLAY_NAME] = name;
+        map[ONLINE_ACCOUNTS_INFO_KEY_SERVICE_ID] = service;
+        QMapIterator<QString, QVariant> it(settings);
+        while (it.hasNext()) {
+            it.next();
+            map[ONLINE_ACCOUNTS_INFO_KEY_SETTINGS + it.key()] = it.value();
+        }
+    }
+
+    QVariantMap map;
+};
+
+class MockTemplateTests: public QObject
+{
+    Q_OBJECT
+
+public:
+    MockTemplateTests();
+
+    OrgFreedesktopDBusMockInterface &mocked() {
+        return m_mock.mockInterface(ONLINE_ACCOUNTS_MANAGER_SERVICE_NAME,
+                                    ONLINE_ACCOUNTS_MANAGER_PATH,
+                                    ONLINE_ACCOUNTS_MANAGER_INTERFACE,
+                                    QDBusConnection::SessionBus);
+    }
+
+    uint addAccount(const AccountDetails &details);
+    void setRequestAccessReply(const AccountDetails &details);
+    void setAuthenticationReply(const QVariantMap &reply,
+                                const QString &errorName = QString());
+
+private Q_SLOTS:
+    void testManagerAvailableAccounts();
+    void testManagerRequestAccess();
+
+private:
+    QtDBusTest::DBusTestRunner m_dbus;
+    QtDBusMock::DBusMock m_mock;
+};
+
+MockTemplateTests::MockTemplateTests():
+    QObject(),
+    m_mock(m_dbus)
+{
+    m_mock.registerCustomMock(ONLINE_ACCOUNTS_MANAGER_SERVICE_NAME,
+                              ONLINE_ACCOUNTS_MANAGER_PATH,
+                              ONLINE_ACCOUNTS_MANAGER_INTERFACE,
+                              QDBusConnection::SessionBus);
+    m_dbus.startServices();
+    mocked().AddTemplate(MOCK_TEMPLATE, QVariantMap());
+}
+
+uint MockTemplateTests::addAccount(const AccountDetails &details)
+{
+    QDBusReply<uint> reply = mocked().call("AddAccount", details.map);
+    return reply.isValid() ? reply.value() : 0;
+}
+
+void MockTemplateTests::setRequestAccessReply(const AccountDetails &details)
+{
+    mocked().call("SetRequestAccessReply", details.map);
+}
+
+void MockTemplateTests::setAuthenticationReply(const QVariantMap &reply,
+                                               const QString &errorName)
+{
+    mocked().call("SetAuthenticationReply", reply, errorName);
+}
+
+void MockTemplateTests::testManagerAvailableAccounts()
+{
+    OnlineAccounts::Manager manager("my-app");
+    QSignalSpy accountAvailable(&manager,
+                                SIGNAL(accountAvailable(OnlineAccounts::Account*)));
+
+    manager.waitForReady();
+    QVERIFY(manager.availableAccounts().isEmpty());
+
+    uint accountId = addAccount(AccountDetails("cold account", "cool service"));
+    QVERIFY(accountId != 0);
+
+    if (accountAvailable.count() == 0) {
+        accountAvailable.wait();
+    }
+    QCOMPARE(accountAvailable.count(), 1);
+
+    QList<OnlineAccounts::Account *> accounts = manager.availableAccounts();
+    QCOMPARE(accounts.count(), 1);
+
+    OnlineAccounts::Account *account = accounts.first();
+    QCOMPARE(uint(account->id()), accountId);
+    QCOMPARE(account->displayName(), QString("cold account"));
+    QCOMPARE(account->serviceId(), QString("cool service"));
+}
+
+void MockTemplateTests::testManagerRequestAccess()
+{
+    OnlineAccounts::Manager manager("my-app");
+    manager.waitForReady();
+
+    setRequestAccessReply(AccountDetails("Tom", "photos"));
+    QVariantMap replyData;
+    replyData[ONLINE_ACCOUNTS_AUTH_KEY_ACCESS_TOKEN] = QByteArray("go-on");
+    setAuthenticationReply(replyData);
+
+    OnlineAccounts::OAuth2Data oauth;
+    oauth.setClientId("happy app");
+    OnlineAccounts::PendingCall call = manager.requestAccess("my-service",
+                                                             oauth);
+    OnlineAccounts::RequestAccessReply accessReply(call);
+    OnlineAccounts::Account *account = accessReply.account();
+    QVERIFY(account);
+    QCOMPARE(account->displayName(), QString("Tom"));
+
+    OnlineAccounts::OAuth2Reply oauthReply(call);
+    QCOMPARE(oauthReply.accessToken(), QByteArray("go-on"));
+}
+
+QTEST_MAIN(MockTemplateTests)
+#include "mock_template.moc"