Merge lp:~boiko/telephony-service/prevent_automatic_answering_calls into lp:telephony-service/rtm-15.04

[Gustavo Pichorim Boiko]

Prevent telephony-service from auto-accepting calls in the case of an approver failure.

Prevent telephony-service from auto-accepting calls in the case of an approver failure.

== Checklist ==
Are there any related MPs required for this MP to build/function as expected? Please list.
No

Is your branch in sync with latest trunk (e.g. bzr pull lp:trunk -> no changes)
Yes

Did you perform an exploratory manual test run of your code change and any related functionality on device or emulator?
Yes

Did you successfully run all tests found in your component's Test Plan (https://wiki.ubuntu.com/Process/Merges/TestPlan/<package-name>) on device or emulator?
Yes

If you changed the UI, was the change specified/approved by design?
N/A

If you changed UI labels, did you update the pot file?
N/A

If you changed the packaging (debian), did you add a core-dev as a reviewer to this MP?
N/A

[lp:~boiko/telephony-service/prevent_automatic_answering_calls]

1103. By Gustavo Pichorim Boiko on 2015-07-03

Disable approver test on arm64.

1104. By Gustavo Pichorim Boiko on 2015-07-03

Another try at disabling the tests.

[Tiago Salem Herrmann (tiagosh)]

Looks good.

--Checklist--
Did you perform an exploratory manual test run of the code change and any related functionality on device or emulator?
Yes

Did CI run pass? If not, please explain why.
CI is not configured for the targeted branch.

Have you checked that submitter has accurately filled out the submitter checklist and has taken no shortcut?
Yes

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2015-05-21 18:02:42 +0000
+++ .bzrignore	2015-07-03 18:36:10 +0000
@@ -47,6 +47,7 @@
 
 tests/*/*Test
 tests/common/dbus-test-wrapper.sh
+tests/common/NotificationsMock
 tests/common/MockConnectionInterface.*
 tests/common/mock/mockconnectionadaptor.*
 tests/common/mock/telepathy-mock

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-06-10 21:05:50 +0000
+++ CMakeLists.txt	2015-07-03 18:36:10 +0000
@@ -12,6 +12,9 @@
 # Instruct CMake to run moc automatically when needed.
 set(CMAKE_AUTOMOC ON)
 
+# just to make debug easier, print the system processor
+message(STATUS "System processor: ${CMAKE_SYSTEM_PROCESSOR}")
+
 # Check if should build using ubuntu platform api
 check_include_file_cxx("ubuntu/application/init.h" USE_UBUNTU_PLATFORM_API)
 

=== modified file 'approver/approver.cpp'
--- approver/approver.cpp	2015-07-03 18:36:10 +0000
+++ approver/approver.cpp	2015-07-03 18:36:10 +0000
@@ -334,8 +334,8 @@
         request->setFilter(QContactPhoneNumber::match(contact->id()));
 
         // lambda function to update the notification
-        QObject::connect(request, &QContactAbstractRequest::stateChanged, [this, request, dispatchOp, channel]() {
-            if (!request || request->state() != QContactAbstractRequest::FinishedState) {
+        QObject::connect(request, &QContactAbstractRequest::stateChanged, [this, request, dispatchOp, channel](QContactAbstractRequest::State state) {
+            if (!request || state != QContactAbstractRequest::FinishedState) {
                 return;
             }
 
@@ -349,7 +349,6 @@
                 // Also notify greeter via AccountsService
                 GreeterContacts::emitContact(contact);
             }
-
             showSnapDecision(dispatchOp, channel, contact);
         });
 
@@ -368,6 +367,8 @@
 {
     closeSnapDecision();
 
+    acceptCallChannels(dispatchOp);
+
     // forward the channel to the handler
     dispatchOp->handleWith(TELEPHONY_SERVICE_HANDLER);
 
@@ -386,6 +387,8 @@
         CallManager::instance()->foregroundCall()->endCall();
     }
 
+    acceptCallChannels(dispatchOp);
+
     // forward the channel to the handler
     dispatchOp->handleWith(TELEPHONY_SERVICE_HANDLER);
 
@@ -554,6 +557,17 @@
     return true;
 }
 
+void Approver::acceptCallChannels(const Tp::ChannelDispatchOperationPtr dispatchOp)
+{
+    // accept all channels
+    Q_FOREACH(Tp::ChannelPtr channel, dispatchOp->channels()) {
+        Tp::CallChannelPtr callChannel = Tp::CallChannelPtr::dynamicCast(channel);
+        if (callChannel) {
+            callChannel->accept();
+        }
+    }
+}
+
 Tp::ChannelDispatchOperationPtr Approver::dispatchOperationForIncomingCall()
 {
     Tp::ChannelDispatchOperationPtr callDispatchOp;

=== modified file 'approver/approver.h'
--- approver/approver.h	2015-01-20 12:46:29 +0000
+++ approver/approver.h	2015-07-03 18:36:10 +0000
@@ -56,6 +56,7 @@
     bool showSnapDecision(const Tp::ChannelDispatchOperationPtr dispatchOperation,
                           const Tp::ChannelPtr channel,
                           const QContact &contact = QContact());
+    void acceptCallChannels(const Tp::ChannelDispatchOperationPtr dispatchOp);
     bool handleMediaKey(bool doubleClick);
 
 protected:

=== modified file 'cmake/modules/GenerateTest.cmake'
--- cmake/modules/GenerateTest.cmake	2015-07-03 18:36:10 +0000
+++ cmake/modules/GenerateTest.cmake	2015-07-03 18:36:10 +0000
@@ -77,7 +77,8 @@
                                     HISTORY_SQLITE_DBPATH=:memory:
                                     MC_ACCOUNT_DIR=${TMPDIR}
                                     MC_MANAGER_DIR=${TMPDIR}
-                                    MC_CLIENTS_DIR=${TMPDIR})
+                                    MC_CLIENTS_DIR=${TMPDIR}
+                                    TELEPHONY_SERVICE_TEST=1)
             endif ()
 
             set(TEST_COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${TESTNAME} ${PLATFORM} -p -o -p -,txt -p -o -p ${CMAKE_BINARY_DIR}/test_${TESTNAME}.xml,xunitxml)
@@ -105,7 +106,7 @@
 
 function(generate_telepathy_test TESTNAME)
     set(options "")
-    set(oneValueArgs "")
+    set(oneValueArgs WAIT_FOR)
     set(multiValueArgs TASKS LIBRARIES QT5_MODULES)
     cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
 
@@ -126,10 +127,13 @@
     if (NOT DEFINED ARG_QT5_MODULES)
         set(ARG_QT5_MODULES Core DBus Test Qml)
     endif (NOT DEFINED ARG_QT5_MODULES)
+    if (NOT DEFINED ARG_WAIT_FOR)
+        set(ARG_WAIT_FOR org.freedesktop.Telepathy.Client.TelephonyServiceHandler)
+    endif (NOT DEFINED ARG_WAIT_FOR)
     generate_test(${TESTNAME} ${ARGN}
                   TASKS ${TASKS}
                   LIBRARIES ${ARG_LIBRARIES} 
                   QT5_MODULES ${ARG_QT5_MODULES} 
                   USE_DBUS USE_UI 
-                  WAIT_FOR org.freedesktop.Telepathy.Client.TelephonyServiceHandler)
+                  WAIT_FOR ${ARG_WAIT_FOR})
 endfunction(generate_telepathy_test)

=== modified file 'handler/callhandler.cpp'
--- handler/callhandler.cpp	2015-03-04 18:02:13 +0000
+++ handler/callhandler.cpp	2015-07-03 18:36:10 +0000
@@ -264,8 +264,6 @@
 
 void CallHandler::onCallChannelAvailable(Tp::CallChannelPtr channel)
 {
-    channel->accept();
-
     QDBusInterface callChannelIface(channel->busName(), channel->objectPath(), DBUS_PROPERTIES_IFACE);
     QDBusMessage reply = callChannelIface.call("GetAll", CANONICAL_TELEPHONY_AUDIOOUTPUTS_IFACE);
     QVariantList args = reply.arguments();

=== modified file 'handler/handler.cpp'
--- handler/handler.cpp	2015-06-10 21:05:50 +0000
+++ handler/handler.cpp	2015-07-03 18:36:10 +0000
@@ -21,6 +21,7 @@
  */
 
 #include "handler.h"
+#include "accountentry.h"
 #include "protocolmanager.h"
 #include "telepathyhelper.h"
 
@@ -60,6 +61,7 @@
 
 
     Q_FOREACH(const Tp::ChannelPtr channel, channels) {
+        mContexts[channel.data()] = context;
         Tp::TextChannelPtr textChannel = Tp::TextChannelPtr::dynamicCast(channel);
         if (textChannel) {
             Tp::PendingReady *pr = textChannel->becomeReady(Tp::Features()
@@ -89,7 +91,6 @@
         }
 
     }
-    context->setFinished();
 }
 
 Tp::ChannelClassSpecList Handler::channelFilters()
@@ -121,6 +122,10 @@
     }
 
     mReadyRequests.remove(pr);
+    Tp::MethodInvocationContextPtr<> context = mContexts.take(textChannel.data());
+    if (context) {
+        context->setFinished();
+    }
 
     Q_EMIT textChannelAvailable(textChannel);
 }
@@ -134,15 +139,37 @@
         return;
     }
 
-    Tp::ChannelPtr channel = mReadyRequests[pr];
+    Tp::ChannelPtr channel = mReadyRequests.take(pr);
     Tp::CallChannelPtr callChannel = Tp::CallChannelPtr::dynamicCast(channel);
+    Tp::MethodInvocationContextPtr<> context = mContexts.take(channel.data());
 
     if(!callChannel) {
+        if (context) {
+            context->setFinishedWithError(TP_QT_ERROR_CONFUSED, "Channel was not a call channel");
+        }
         qCritical() << "The saved channel is not a Tp::CallChannel";
         return;
     }
 
-    mReadyRequests.remove(pr);
+    // if the call is neither Accepted nor Active, it means it got dispatched directly to the handler without passing
+    // through any approver. For phone calls, this would mean calls getting auto-accepted which is not desirable
+    // so we return an error here
+    bool incoming = false;
+    AccountEntry *accountEntry = TelepathyHelper::instance()->accountForConnection(callChannel->connection());
+    if (accountEntry) {
+        incoming = callChannel->initiatorContact() != accountEntry->account()->connection()->selfContact();
+    }
+    if (incoming && callChannel->callState() != Tp::CallStateAccepted && callChannel->callState() != Tp::CallStateActive) {
+        qWarning() << "Available channel was not approved by telephony-service-approver, ignoring it.";
+        if (context) {
+            context->setFinishedWithError(TP_QT_ERROR_NOT_CAPABLE, "Only channels approved and accepted by telephony-service-approver are supported");
+        }
+        return;
+    }
+
+    if (context) {
+        context->setFinished();
+    }
 
     Q_EMIT callChannelAvailable(callChannel);
 }

=== modified file 'handler/handler.h'
--- handler/handler.h	2013-07-18 17:02:10 +0000
+++ handler/handler.h	2015-07-03 18:36:10 +0000
@@ -56,6 +56,7 @@
 
 private:
     QMap<Tp::PendingReady*, Tp::ChannelPtr> mReadyRequests;
+    QMap<Tp::Channel*, Tp::MethodInvocationContextPtr<> > mContexts;
 };
 
 #endif // HANDLER_H

=== modified file 'libtelephonyservice/applicationutils.cpp'
--- libtelephonyservice/applicationutils.cpp	2015-05-21 18:02:42 +0000
+++ libtelephonyservice/applicationutils.cpp	2015-07-03 18:36:10 +0000
@@ -60,13 +60,15 @@
 bool ApplicationUtils::openUrl(const QUrl &url)
 {
 #ifdef USE_UBUNTU_PLATFORM_API
-    UAUrlDispatcherSession* session = ua_url_dispatcher_session();
-    if (!session)
-        return false;
-
-    ua_url_dispatcher_session_open(session, url.toEncoded().constData(), NULL, NULL);
-
-    free(session);
+    if (qgetenv("TELEPHONY_SERVICE_TEST").isEmpty()) {
+        UAUrlDispatcherSession* session = ua_url_dispatcher_session();
+        if (!session)
+            return false;
+
+        ua_url_dispatcher_session_open(session, url.toEncoded().constData(), NULL, NULL);
+
+        free(session);
+    }
 #endif
     return true;
 }

=== modified file 'libtelephonyservice/telepathyhelper.cpp'
--- libtelephonyservice/telepathyhelper.cpp	2015-06-11 16:48:18 +0000
+++ libtelephonyservice/telepathyhelper.cpp	2015-07-03 18:36:10 +0000
@@ -466,6 +466,7 @@
     }
 
     if (mAccounts.count() == 0) {
+        mFirstTime = false;
         Q_EMIT setupReady();
         return;
     }

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-05-21 18:02:42 +0000
+++ tests/CMakeLists.txt	2015-07-03 18:36:10 +0000
@@ -1,6 +1,7 @@
 include (GenerateTest)
 
 add_subdirectory(common)
+add_subdirectory(approver)
 add_subdirectory(handler)
 add_subdirectory(indicator)
 add_subdirectory(libtelephonyservice)

=== added directory 'tests/approver'
=== added file 'tests/approver/ApproverTest.cpp'
--- tests/approver/ApproverTest.cpp	1970-01-01 00:00:00 +0000
+++ tests/approver/ApproverTest.cpp	2015-07-03 18:36:10 +0000
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2013-2015 Canonical, Ltd.
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * telephony-service 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 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/>.
+ */
+
+#include <QtCore/QObject>
+#include <QtTest/QtTest>
+#include "telepathytest.h"
+#include "approvercontroller.h"
+#include "mockcontroller.h"
+#include "accountentry.h"
+#include "accountentryfactory.h"
+#include "telepathyhelper.h"
+
+class ApproverTest : public TelepathyTest
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void initTestCase();
+    void init();
+    void cleanup();
+    void testSnapDecisionTimeout();
+    void testAcceptCall();
+
+private:
+    void waitForCallActive(const QString &callerId);
+    MockController *mMockController;
+    Tp::AccountPtr mTpAccount;
+};
+
+void ApproverTest::initTestCase()
+{
+    initialize();
+
+    QSignalSpy setupReadySpy(TelepathyHelper::instance(), SIGNAL(setupReady()));
+    TRY_COMPARE(setupReadySpy.count(), 1);
+}
+
+void ApproverTest::init()
+{
+    mTpAccount = addAccount("mock", "mock", "the account");
+
+    // and create the mock controller
+    mMockController = new MockController("mock", this);
+}
+
+void ApproverTest::cleanup()
+{
+    doCleanup();
+    mMockController->deleteLater();
+}
+
+void ApproverTest::testSnapDecisionTimeout()
+{
+    QString callerId("12345");
+    QVariantMap properties;
+    properties["Caller"] = callerId;
+    properties["State"] = "incoming";
+
+    QDBusInterface notificationsMock("org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications");
+    QSignalSpy notificationSpy(&notificationsMock, SIGNAL(MockNotificationReceived(QString, uint, QString, QString, QString, QStringList, QVariantMap, int)));
+    mMockController->placeCall(properties);
+    TRY_COMPARE(notificationSpy.count(), 1);
+    QVariantMap hints = notificationSpy.first()[6].toMap();
+    QVERIFY(hints.contains("x-canonical-snap-decisions-timeout"));
+    QCOMPARE(hints["x-canonical-snap-decisions-timeout"].toInt(), -1);
+}
+
+void ApproverTest::testAcceptCall()
+{
+    QString callerId("7654321");
+
+    QVariantMap properties;
+    properties["Caller"] = callerId;
+    properties["State"] = "incoming";
+
+    QDBusInterface notificationsMock("org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications");
+    QSignalSpy notificationSpy(&notificationsMock, SIGNAL(MockNotificationReceived(QString, uint, QString, QString, QString, QStringList, QVariantMap, int)));
+    QString objectPath = mMockController->placeCall(properties);
+    TRY_COMPARE(notificationSpy.count(), 1);
+
+    // at this point we are already sure the approver has the call, as the notification was placed
+    QSignalSpy callStateSpy(mMockController, SIGNAL(CallStateChanged(QString,QString,QString)));
+    ApproverController::instance()->acceptCall();
+    TRY_COMPARE(callStateSpy.count(), 1);
+    QCOMPARE(callStateSpy.first()[0].toString(), callerId);
+    QCOMPARE(callStateSpy.first()[1].toString(), objectPath);
+    QCOMPARE(callStateSpy.first()[2].toString(), QString("accepted"));
+    mMockController->HangupCall(callerId);
+}
+
+QTEST_MAIN(ApproverTest)
+#include "ApproverTest.moc"

=== added file 'tests/approver/CMakeLists.txt'
--- tests/approver/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/approver/CMakeLists.txt	2015-07-03 18:36:10 +0000
@@ -0,0 +1,16 @@
+include_directories(
+    ${CMAKE_CURRENT_BINARY_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/../common
+    ${CMAKE_SOURCE_DIR}
+    ${CMAKE_SOURCE_DIR}/libtelephonyservice
+    ${CMAKE_BINARY_DIR}/tests/common
+    ${TP_QT5_INCLUDE_DIRS}
+    ${GSETTINGS_QT_INCLUDE_DIRS}
+    )
+
+if (NOT ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "aarch64"))
+    generate_telepathy_test(ApproverTest
+                            SOURCES ApproverTest.cpp approvercontroller.cpp
+                            TASKS --task ${CMAKE_BINARY_DIR}/approver/telephony-service-approver --task-name telephony-service-approver --wait-for com.canonical.TelephonyServiceHandler --ignore-return
+                            WAIT_FOR org.freedesktop.Telepathy.Client.TelephonyServiceApprover)
+endif()

=== added file 'tests/approver/approvercontroller.cpp'
--- tests/approver/approvercontroller.cpp	1970-01-01 00:00:00 +0000
+++ tests/approver/approvercontroller.cpp	2015-07-03 18:36:10 +0000
@@ -0,0 +1,49 @@
+/**
+ * Copyright (C) 2013-2015 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:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ */
+
+#include <QStringList>
+#include "approvercontroller.h"
+#include <QDBusReply>
+#include <QDebug>
+
+#define APPROVER_SERVICE "com.canonical.Approver"
+#define APPROVER_OBJECT "/com/canonical/Approver"
+#define APPROVER_INTERFACE "com.canonical.TelephonyServiceApprover"
+
+ApproverController *ApproverController::instance()
+{
+    static ApproverController *self = new ApproverController();
+    return self;
+}
+
+ApproverController::ApproverController(QObject *parent) :
+    QObject(parent),
+    mApproverInterface(APPROVER_SERVICE, APPROVER_OBJECT, APPROVER_INTERFACE)
+{
+}
+
+void ApproverController::acceptCall()
+{
+    mApproverInterface.call("AcceptCall");
+}
+
+void ApproverController::hangUpAndAcceptCall()
+{
+    mApproverInterface.call("HangUpAndAcceptCall");
+}

=== added file 'tests/approver/approvercontroller.h'
--- tests/approver/approvercontroller.h	1970-01-01 00:00:00 +0000
+++ tests/approver/approvercontroller.h	2015-07-03 18:36:10 +0000
@@ -0,0 +1,41 @@
+/**
+ * Copyright (C) 2013-2015 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:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ */
+
+#ifndef APPROVERCONTROLLER_H
+#define APPROVERCONTROLLER_H
+
+#include <QObject>
+#include <QDBusInterface>
+
+class ApproverController : public QObject
+{
+    Q_OBJECT
+public:
+    static ApproverController *instance();
+
+public Q_SLOTS:
+    void acceptCall();
+    void hangUpAndAcceptCall();
+
+private:
+    explicit ApproverController(QObject *parent = 0);
+    QDBusInterface mApproverInterface;
+};
+
+#endif // ApproverController_H

=== modified file 'tests/common/NotificationsMock.cpp'
--- tests/common/NotificationsMock.cpp	2015-07-03 18:36:10 +0000
+++ tests/common/NotificationsMock.cpp	2015-07-03 18:36:10 +0000
@@ -32,8 +32,9 @@
     Q_CLASSINFO("D-Bus Interface", NOTIFICATIONS_DBUS_SERVICE_NAME)
 
 public:
-    Q_SCRIPTABLE void Notify(QString app_name, uint replaces_id, QString app_icon, QString summary, QString body, QStringList actions, QVariantMap hints, int expire_timeout);
+    Q_SCRIPTABLE uint Notify(QString app_name, uint replaces_id, QString app_icon, QString summary, QString body, QStringList actions, QVariantMap hints, int expire_timeout);
     Q_SCRIPTABLE void CloseNotification(uint id);
+    Q_SCRIPTABLE QString GetServerInformation(QString& vendor, QString& version, QString& spec_version);
 
     // Mock specific method
     Q_SCRIPTABLE void MockInvokeAction(uint id, QString action_key);
@@ -46,9 +47,11 @@
     Q_SCRIPTABLE void MockNotificationReceived(QString app_name, uint replaces_id, QString app_icon, QString summary, QString body, QStringList actions, QVariantMap hints, int expire_timeout);
 };
 
-void NotificationsMock::Notify(QString app_name, uint replaces_id, QString app_icon, QString summary, QString body, QStringList actions, QVariantMap hints, int expire_timeout)
+uint NotificationsMock::Notify(QString app_name, uint replaces_id, QString app_icon, QString summary, QString body, QStringList actions, QVariantMap hints, int expire_timeout)
 {
     Q_EMIT MockNotificationReceived(app_name, replaces_id, app_icon, summary, body, actions, hints, expire_timeout);
+    static uint id = 1;
+    return (replaces_id != 0 ? replaces_id : id++);
 }
 
 void NotificationsMock::MockInvokeAction(uint id, QString action_key)
@@ -62,6 +65,11 @@
     Q_EMIT NotificationClosed(id, 3); // 3 is closed by a CloseNotification() call
 }
 
+QString NotificationsMock::GetServerInformation(QString &vendor, QString &version, QString &spec_version)
+{
+    return QString();
+}
+
 int main(int argc, char **argv)
 {
     QCoreApplication a(argc, argv);

=== modified file 'tests/common/mock/callchannel.cpp'
--- tests/common/mock/callchannel.cpp	2015-03-23 19:59:50 +0000
+++ tests/common/mock/callchannel.cpp	2015-07-03 18:36:10 +0000
@@ -68,7 +68,15 @@
 
 void MockCallChannel::onAccept(Tp::DBusError*)
 {
-    setCallState("active");
+    setCallState("accepted");
+    QTimer *timer = new QTimer(this);
+    timer->setSingleShot(true);
+    timer->setInterval(100);
+    connect(timer, &QTimer::timeout, [this, timer]() {
+        setCallState("active");
+        timer->deleteLater();
+    });
+    timer->start();
 }
 
 void MockCallChannel::init()
@@ -195,6 +203,8 @@
         }
         mCallChannel->setCallState(Tp::CallStateEnded, 0, reason, stateDetails);
         mBaseChannel->close();
+    } else if (state == "accepted") {
+        mCallChannel->setCallState(Tp::CallStateAccepted, 0, reason, stateDetails);
     } else if (state == "active") {
         qDebug() << "active";
         mHoldIface->setHoldState(Tp::LocalHoldStateUnheld, Tp::LocalHoldStateReasonNone);

=== modified file 'tests/handler/HandlerTest.cpp'
--- tests/handler/HandlerTest.cpp	2015-05-07 16:44:43 +0000
+++ tests/handler/HandlerTest.cpp	2015-07-03 18:36:10 +0000
@@ -41,8 +41,11 @@
     void testConferenceCall();
     void testSendMessage();
     void testActiveCallIndicator();
+    void testNotApprovedChannels();
 
 private:
+    void registerApprover();
+    void unregisterApprover();
     void waitForCallActive(const QString &callerId);
     Approver *mApprover;
     MockController *mMockController;
@@ -56,11 +59,7 @@
     QSignalSpy setupReadySpy(TelepathyHelper::instance(), SIGNAL(setupReady()));
     TRY_COMPARE(setupReadySpy.count(), 1);
 
-    // register the approver
-    mApprover = new Approver(this);
-    TelepathyHelper::instance()->registerClient(mApprover, "TelephonyTestApprover");
-    // Tp-qt does not set registered status to approvers
-    TRY_VERIFY(QDBusConnection::sessionBus().interface()->isServiceRegistered(TELEPHONY_SERVICE_APPROVER));
+    registerApprover();
 }
 
 void HandlerTest::init()
@@ -163,6 +162,8 @@
     TRY_COMPARE(approverCallSpy.count(), 1);
     mApprover->acceptCall();
 
+    waitForCallActive(callerId);
+
     // wait until the call properties are changed
     TRY_VERIFY(handlerCallPropertiesSpy.count() > 0);
     QString objectPath = handlerCallPropertiesSpy.last()[0].toString();
@@ -302,21 +303,63 @@
     QVERIFY(!HandlerController::instance()->callIndicatorVisible());
 }
 
+void HandlerTest::testNotApprovedChannels()
+{
+    QVariantMap properties;
+    properties["Caller"] = "123456";
+    properties["State"] = "incoming";
+
+    QSignalSpy approverCallSpy(mApprover, SIGNAL(newCall()));
+
+    QSignalSpy callStateSpy(mMockController, SIGNAL(CallStateChanged(QString,QString,QString)));
+    QString objectPath = mMockController->placeCall(properties);
+    QVERIFY(!objectPath.isEmpty());
+
+    // wait for the channel to hit the approver
+    TRY_COMPARE(approverCallSpy.count(), 1);
+
+    // accept the call but do not call callChannel->accept() on the channel
+    mApprover->acceptCall(false);
+
+    // wait for a few seconds
+    QTest::qWait(3000);
+
+    // no state changes should happen, as the channel was not accepted
+    QVERIFY(callStateSpy.isEmpty());
+}
+
+void HandlerTest::registerApprover()
+{
+    // register the approver
+    mApprover = new Approver();
+    QVERIFY(TelepathyHelper::instance()->registerClient(mApprover, "TelephonyTestApprover"));
+    // Tp-qt does not set registered status to approvers
+    TRY_VERIFY(QDBusConnection::sessionBus().interface()->isServiceRegistered(TELEPHONY_SERVICE_APPROVER));
+}
+
+void HandlerTest::unregisterApprover()
+{
+    QVERIFY(TelepathyHelper::instance()->unregisterClient(mApprover));
+    mApprover->deleteLater();
+    mApprover = NULL;
+    TRY_VERIFY(!QDBusConnection::sessionBus().interface()->isServiceRegistered(TELEPHONY_SERVICE_APPROVER));
+}
+
 void HandlerTest::waitForCallActive(const QString &callerId)
 {
-    // wait until the call state is "accepted"
     QSignalSpy callStateSpy(mMockController, SIGNAL(CallStateChanged(QString,QString,QString)));
     QString state;
     QString objectPath;
     QString caller;
     int tries = 0;
-    while (state != "active" && caller != callerId && tries < 5) {
+    while ((state != "active" || caller != callerId) && tries < 5) {
         TRY_COMPARE(callStateSpy.count(), 1);
         caller = callStateSpy.first()[0].toString();
         objectPath = callStateSpy.first()[1].toString();
         state = callStateSpy.first()[2].toString();
         callStateSpy.clear();
         tries++;
+        qDebug() << "Waiting for call active, try " << tries << " failed.";
     }
 
     QCOMPARE(caller, callerId);

=== modified file 'tests/handler/approver.cpp'
--- tests/handler/approver.cpp	2015-03-23 19:59:50 +0000
+++ tests/handler/approver.cpp	2015-07-03 18:36:10 +0000
@@ -107,11 +107,17 @@
     }
 }
 
-void Approver::acceptCall()
+void Approver::acceptCall(bool callAcceptOnChannel)
 {
     Q_FOREACH (Tp::ChannelDispatchOperationPtr dispatchOperation, mDispatchOps) {
         QList<Tp::ChannelPtr> channels = dispatchOperation->channels();
         Q_FOREACH (Tp::ChannelPtr channel, channels) {
+            if (callAcceptOnChannel) {
+                Tp::CallChannelPtr callChannel = Tp::CallChannelPtr::dynamicCast(channel);
+                if (callChannel) {
+                    callChannel->accept();
+                }
+            }
             if (dispatchOperation->possibleHandlers().contains(TELEPHONY_SERVICE_HANDLER)) {
                 dispatchOperation->handleWith(TELEPHONY_SERVICE_HANDLER);
                 mDispatchOps.removeAll(dispatchOperation);

=== modified file 'tests/handler/approver.h'
--- tests/handler/approver.h	2014-01-07 19:53:45 +0000
+++ tests/handler/approver.h	2015-07-03 18:36:10 +0000
@@ -44,7 +44,7 @@
     void newCall();
 
 public Q_SLOTS:
-    void acceptCall();
+    void acceptCall(bool callAcceptOnChannel = true);
     void rejectCall();
 
 private Q_SLOTS:

=== modified file 'tests/handler/handlercontroller.cpp'
--- tests/handler/handlercontroller.cpp	2014-06-17 17:46:07 +0000
+++ tests/handler/handlercontroller.cpp	2015-07-03 18:36:10 +0000
@@ -99,6 +99,12 @@
     mHandlerInterface.call("SendDTMF", objectPath, key);
 }
 
+bool HandlerController::hasCalls()
+{
+    QDBusReply<bool> reply = mHandlerInterface.call("HasCalls");
+    return reply.isValid() && reply.value();
+}
+
 void HandlerController::createConferenceCall(const QStringList &objectPaths)
 {
     mHandlerInterface.call("CreateConferenceCall", objectPaths);

=== modified file 'tests/handler/handlercontroller.h'
--- tests/handler/handlercontroller.h	2014-06-17 17:46:07 +0000
+++ tests/handler/handlercontroller.h	2015-07-03 18:36:10 +0000
@@ -40,6 +40,7 @@
     void setMuted(const QString &objectPath, bool muted);
     void setSpeakerMode(const QString &objectPath, bool enabled);
     void sendDTMF(const QString &objectPath, const QString &key);
+    bool hasCalls();
 
     // conference call methods
     void createConferenceCall(const QStringList &objectPaths);

=== modified file 'tests/libtelephonyservice/CallEntryTest.cpp'
--- tests/libtelephonyservice/CallEntryTest.cpp	2015-05-08 21:57:06 +0000
+++ tests/libtelephonyservice/CallEntryTest.cpp	2015-07-03 18:36:10 +0000
@@ -122,7 +122,12 @@
 
 void CallEntryTest::onCallChannelAvailable(const Tp::CallChannelPtr &channel)
 {
-    mCallChannel = channel;
+    channel->accept();
+    connect(channel->becomeReady(Tp::Features() << Tp::CallChannel::FeatureCore
+                                                << Tp::CallChannel::FeatureCallState),
+            &Tp::PendingOperation::finished, [this, channel] {
+        mCallChannel = channel;
+    });
 }
 
 QTEST_MAIN(CallEntryTest)