Merge lp:~boiko/dialer-app/rtm-fix_call_hangup_and_test_multi_call into lp:dialer-app/rtm-14.09

[Gustavo Pichorim Boiko]

Make sure the correct call is finished when pressing the hangup button on a multi-call scenario.
Also add autopilot tests to avoid this happening in the future.

Make sure the correct call is finished when pressing the hangup button on a multi-call scenario.
Also add autopilot tests to avoid this happening in the future.

[Gustavo Pichorim Boiko (boiko)]

Already reviewed for vivid, approving.

review: Approve

=== modified file 'src/qml/LiveCallPage/LiveCall.qml'
--- src/qml/LiveCallPage/LiveCall.qml	2015-02-16 20:51:04 +0000
+++ src/qml/LiveCallPage/LiveCall.qml	2015-04-16 16:26:21 +0000
@@ -105,7 +105,7 @@
             } else {
                 closeTimer.running = false;
                 statusLabel.text = "";
-                liveCall.call = callManager.foregroundCall;
+                liveCall.call = Qt.binding(callManager.foregroundCall);
             }
         }
 
@@ -464,6 +464,7 @@
 
         MultiCallDisplay {
             id: multiCallArea
+            objectName: "multiCallDisplay"
             calls: callManager.calls
             opacity: 0
             anchors {
@@ -630,7 +631,7 @@
         }
 
         LiveCallKeypadButton {
-            objectName: "pauseStartButton"
+            objectName: "callHoldButton"
             iconSource: {
                 if (callManager.backgroundCall) {
                     return "swap"

=== modified file 'src/qml/LiveCallPage/MultiCallDisplay.qml'
--- src/qml/LiveCallPage/MultiCallDisplay.qml	2015-02-10 18:10:34 +0000
+++ src/qml/LiveCallPage/MultiCallDisplay.qml	2015-04-16 16:26:21 +0000
@@ -40,8 +40,11 @@
 
         Item {
             id: callDelegate
+            objectName: "callDelegate"
             property QtObject callEntry: modelData
             property bool isLast: index == (multiCallRepeater.count - 1)
+            property bool active: !callEntry.held
+            property string phoneNumber: callEntry.phoneNumber
 
             height: units.gu(10) + conferenceArea.height
             anchors {

=== modified file 'tests/autopilot/dialer_app/__init__.py'
--- tests/autopilot/dialer_app/__init__.py	2015-02-11 18:29:21 +0000
+++ tests/autopilot/dialer_app/__init__.py	2015-04-16 16:26:21 +0000
@@ -35,6 +35,7 @@
 
     def _click_button(self, button):
         """Generic way to click a button"""
+        self.visible.wait_for(True)
         button.visible.wait_for(True)
         self.pointing_device.click_object(button)
         return button
@@ -50,11 +51,35 @@
         """Return the hangup button"""
         return self.wait_select_single(objectName='hangupButton')
 
+    def _get_call_hold_button(self):
+        """Return the call holding button"""
+        return self.wait_select_single(objectName='callHoldButton')
+
+    def _get_swap_calls_button(self):
+        """Return the swap calls button"""
+        return self._get_call_hold_button()
+
+    def get_multi_call_display(self):
+        """Return the multi call display panel"""
+        return self.wait_select_single(objectName='multiCallDisplay')
+
+    def get_multi_call_item_for_number(self, number):
+        """Return the multi call display item for the given number"""
+        return self.wait_select_single(objectName='callDelegate',
+                                       phoneNumber=number)
+
     def click_hangup_button(self):
         """Click and return the hangup page"""
-        self.visible.wait_for(True)
         return self._click_button(self._get_hangup_button())
 
+    def click_call_hold_button(self):
+        """Click the call holding button"""
+        return self._click_button(self._get_call_hold_button())
+
+    def click_swap_calls_button(self):
+        """Click the swap calls button"""
+        return self._click_button(self._get_swap_calls_button())
+
 
 class PageWithBottomEdge(MainView):
 

=== modified file 'tests/autopilot/dialer_app/fixture_setup.py'
--- tests/autopilot/dialer_app/fixture_setup.py	2014-08-01 15:25:39 +0000
+++ tests/autopilot/dialer_app/fixture_setup.py	2015-04-16 16:26:21 +0000
@@ -19,6 +19,8 @@
 
 import fixtures
 import subprocess
+import os
+import shutil
 
 
 class TestabilityEnvironment(fixtures.Fixture):
@@ -48,3 +50,84 @@
                 'QT_LOAD_TESTABILITY'
             ]
         )
+
+
+class FillCustomHistory(fixtures.Fixture):
+
+    history_db = "history.sqlite"
+    data_sys = "/usr/lib/python3/dist-packages/dialer_app/data/"
+    data_local = "dialer_app/data/"
+    database_path = '/tmp/' + history_db
+
+    prefilled_history_local = os.path.join(data_local, history_db)
+    prefilled_history_system = os.path.join(data_sys, history_db)
+
+    def setUp(self):
+        super(FillCustomHistory, self).setUp()
+        self.addCleanup(self._clear_test_data)
+        self.addCleanup(self._kill_service_to_respawn)
+        self._clear_test_data()
+        self._prepare_history_data()
+        self._kill_service_to_respawn()
+        self._start_service_with_custom_data()
+
+    def _prepare_history_data(self):
+        if os.path.exists(self.prefilled_history_local):
+            shutil.copy(self.prefilled_history_local, self.database_path)
+        else:
+            shutil.copy(self.prefilled_history_system, self.database_path)
+
+    def _clear_test_data(self):
+        if os.path.exists(self.database_path):
+            os.remove(self.database_path)
+
+    def _kill_service_to_respawn(self):
+        subprocess.call(['pkill', 'history-daemon'])
+
+    def _start_service_with_custom_data(self):
+        os.environ['HISTORY_SQLITE_DBPATH'] = self.database_path
+        with open(os.devnull, 'w') as devnull:
+            subprocess.Popen(['history-daemon'], stderr=devnull)
+
+
+class UseEmptyHistory(FillCustomHistory):
+    database_path = ':memory:'
+
+    def setUp(self):
+        super(UseEmptyHistory, self).setUp()
+
+    def _prepare_history_data(self):
+        # just avoid doing anything
+        self.database_path = ':memory:'
+
+    def _clear_test_data(self):
+        # don't do anything
+        self.database_path = ''
+
+
+class UsePhonesimModem(fixtures.Fixture):
+
+    def setUp(self):
+        super().setUp()
+
+        # configure the cleanups
+        self.addCleanup(self._hangupLeftoverCalls)
+        self.addCleanup(self._restoreModems)
+
+        self._switchToPhonesim()
+
+    def _switchToPhonesim(self):
+        # make sure the modem is running on phonesim
+        subprocess.call(['mc-tool', 'update', 'ofono/ofono/account0',
+                         'string:modem-objpath=/phonesim'])
+        subprocess.call(['mc-tool', 'reconnect', 'ofono/ofono/account0'])
+
+    def _hangupLeftoverCalls(self):
+        # ensure that there are no leftover calls in case of failed tests
+        subprocess.call(["/usr/share/ofono/scripts/hangup-all", "/phonesim"])
+
+    def _restoreModems(self):
+        # set the modem objpath in telepathy-ofono to the real modem
+        subprocess.call(['mc-tool', 'update', 'ofono/ofono/account0',
+                         'string:modem-objpath=/ril_0'])
+        subprocess.call(['mc-tool', 'reconnect', 'ofono/ofono/account0'])

=== modified file 'tests/autopilot/dialer_app/helpers.py'
--- tests/autopilot/dialer_app/helpers.py	2014-06-20 13:26:49 +0000
+++ tests/autopilot/dialer_app/helpers.py	2015-04-16 16:26:21 +0000
@@ -1,8 +1,8 @@
 # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
 #
-# Copyright 2014 Canonical Ltd.
-# Author: Omer Akram <[e-mail]>
-#
+# Copyright 2014-2015 Canonical Ltd.
+# Authors: Omer Akram <[e-mail]>
+#          Gustavo Pichorim Boiko <[e-mail]>
 # 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.
@@ -21,6 +21,9 @@
 import sys
 import time
 import dbus
+import tempfile
+import os
+import shutil
 
 
 def wait_for_incoming_call():
@@ -32,7 +35,7 @@
             ['/usr/share/ofono/scripts/list-calls'],
             stderr=subprocess.PIPE,
             universal_newlines=True)
-        if 'State = incoming' in out:
+        if 'State = incoming' in out or 'State = waiting' in out:
             break
         timeout -= 1
         time.sleep(0.5)
@@ -44,17 +47,38 @@
         subprocess.call(['pkill', '-f', 'notify-osd'])
 
 
-def invoke_incoming_call():
-    """Invoke an incoming call for test purpose."""
-    # magic number 199 will cause a callback from 1234567; dialing 199
-    # itself will fail, so quiesce the error
-    bus = dbus.SystemBus()
-    vcm = dbus.Interface(bus.get_object('org.ofono', '/phonesim'),
-                         'org.ofono.VoiceCallManager')
-    try:
-        vcm.Dial('199', 'default')
-    except dbus.DBusException:
-        pass
+def invoke_incoming_call(caller):
+    """Receive an incoming call from the given caller
+
+    :parameter caller: the phone number calling
+    """
+
+    # prepare and send a Qt GUI script to phonesim, over its private D-BUS
+    # set up by ofono-phonesim-autostart
+    script_dir = tempfile.mkdtemp(prefix="phonesim_script")
+    os.chmod(script_dir, 0o755)
+    with open(os.path.join(script_dir, "call.js"), "w") as f:
+        f.write("""tabCall.gbIncomingCall.leCaller.text = "%s";
+tabCall.gbIncomingCall.pbIncomingCall.click();
+""" % (caller))
+
+    with open("/run/lock/ofono-phonesim-dbus.address") as f:
+        phonesim_bus = f.read().strip()
+    bus = dbus.bus.BusConnection(phonesim_bus)
+    script_proxy = bus.get_object("org.ofono.phonesim", "/")
+    script_proxy.SetPath(script_dir)
+    script_proxy.Run("call.js")
+    shutil.rmtree(script_dir)
+
+
+def accept_incoming_call():
+    """Accept an existing incoming call"""
+    subprocess.check_call(
+        [
+            "dbus-send", "--session", "--print-reply",
+            "--dest=com.canonical.Approver", "/com/canonical/Approver",
+            "com.canonical.TelephonyServiceApprover.AcceptCall"
+        ], stdout=subprocess.PIPE)
 
 
 def get_phonesim():

=== modified file 'tests/autopilot/dialer_app/tests/test_calls.py'
--- tests/autopilot/dialer_app/tests/test_calls.py	2015-02-16 20:51:04 +0000
+++ tests/autopilot/dialer_app/tests/test_calls.py	2015-04-16 16:26:21 +0000
@@ -10,7 +10,6 @@
 
 """Tests for the Dialer App using ofono-phonesim"""
 
-import subprocess
 import os
 import time
 
@@ -20,6 +19,7 @@
 
 from dialer_app.tests import DialerAppTestCase
 from dialer_app import helpers
+from dialer_app import fixture_setup
 
 
 @skipUnless(helpers.is_phonesim_running(),
@@ -30,36 +30,15 @@
     """Tests for simulated phone calls."""
 
     def setUp(self):
-        # provide clean history
-        self.history = os.path.expanduser(
-            "~/.local/share/history-service/history.sqlite")
-        if os.path.exists(self.history):
-            subprocess.call(["pkill", "history-daemon"])
-            os.rename(self.history, self.history + ".orig")
-
-        # make sure the modem is running on phonesim
-        subprocess.call(['mc-tool', 'update', 'ofono/ofono/account0',
-                         'string:modem-objpath=/phonesim'])
-        subprocess.call(['mc-tool', 'reconnect', 'ofono/ofono/account0'])
-
+        empty_history = fixture_setup.UseEmptyHistory()
+        self.useFixture(empty_history)
+        phonesim_modem = fixture_setup.UsePhonesimModem()
+        self.useFixture(phonesim_modem)
         super().setUp()
 
     def tearDown(self):
         super().tearDown()
 
-        # ensure that there are no leftover calls in case of failed tests
-        subprocess.call(["/usr/share/ofono/scripts/hangup-all", "/phonesim"])
-
-        # restore history
-        if os.path.exists(self.history + ".orig"):
-            subprocess.call(["pkill", "history-daemon"])
-            os.rename(self.history + ".orig", self.history)
-
-        # set the modem objpath in telepathy-ofono to the real modem
-        subprocess.call(['mc-tool', 'update', 'ofono/ofono/account0',
-                         'string:modem-objpath=/ril_0'])
-        subprocess.call(['mc-tool', 'reconnect', 'ofono/ofono/account0'])
-
     @property
     def history_list(self):
         # because of the object tree, more than just one item is returned, but
@@ -143,19 +122,14 @@
     def test_incoming(self):
         """Incoming call"""
         number = "1234567"
-        helpers.invoke_incoming_call()
+        helpers.invoke_incoming_call(number)
 
         # wait for incoming call, accept; it would be nicer to fake-click the
         # popup notification, but as this isn't generated by dialer-app it
         # isn't exposed to autopilot
         helpers.wait_for_incoming_call()
         time.sleep(1)  # let's hear the ringing sound for a second :-)
-        subprocess.check_call(
-            [
-                "dbus-send", "--session", "--print-reply",
-                "--dest=com.canonical.Approver", "/com/canonical/Approver",
-                "com.canonical.TelephonyServiceApprover.AcceptCall"
-            ], stdout=subprocess.PIPE)
+        helpers.accept_incoming_call()
 
         # call back is from that number
         self.assertThat(

=== modified file 'tests/autopilot/dialer_app/tests/test_logs.py'
--- tests/autopilot/dialer_app/tests/test_logs.py	2015-02-13 17:54:03 +0000
+++ tests/autopilot/dialer_app/tests/test_logs.py	2015-04-16 16:26:21 +0000
@@ -10,10 +10,6 @@
 
 """Tests for the Dialer App"""
 
-import os
-import shutil
-import subprocess
-
 from autopilot.platform import model
 from autopilot.matchers import Eventually
 from testtools import skipIf
@@ -33,35 +29,19 @@
 class TestCallLogs(DialerAppTestCase):
     """Tests for the call log panel."""
 
-    db_file = 'history.sqlite'
-    local_db_dir = 'dialer_app/data/'
-    system_db_dir = '/usr/lib/python3/dist-packages/dialer_app/data/'
-    temp_db_file = '/tmp/' + db_file
-
     def setUp(self):
-        if os.path.exists('../../src/dialer-app'):
-            database = self.local_db_dir + self.db_file
-        else:
-            database = self.system_db_dir + self.db_file
-
-        if os.path.exists(self.temp_db_file):
-            os.remove(self.temp_db_file)
-
-        shutil.copyfile(database, self.temp_db_file)
-
-        subprocess.call(['pkill', 'history-daemon'])
-        os.environ['HISTORY_SQLITE_DBPATH'] = self.temp_db_file
-        with open(os.devnull, 'w') as devnull:
-            subprocess.Popen(['history-daemon'], stderr=devnull)
-
-        super().setUp()
+        # set the fixtures before launching the app
         testability_environment = fixture_setup.TestabilityEnvironment()
         self.useFixture(testability_environment)
-        self.main_view.dialer_page.reveal_bottom_edge_page()
-        self.addCleanup(subprocess.call, ['pkill', '-f', 'history-daemon'])
+        fill_history = fixture_setup.FillCustomHistory()
+        self.useFixture(fill_history)
         self.fake_url_dispatcher = url_dispatcher_fixtures.FakeURLDispatcher()
         self.useFixture(self.fake_url_dispatcher)
 
+        # now launch the app
+        super().setUp()
+        self.main_view.dialer_page.reveal_bottom_edge_page()
+
     def _get_main_view(self, proxy_object):
         return proxy_object.wait_select_single('QQuickView')
 

=== added file 'tests/autopilot/dialer_app/tests/test_multi_calls.py'
--- tests/autopilot/dialer_app/tests/test_multi_calls.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/dialer_app/tests/test_multi_calls.py	2015-04-16 16:26:21 +0000
@@ -0,0 +1,137 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2015 Canonical
+# Author: Gustavo Pichorim Boiko <[e-mail]>
+#
+# This file is part of dialer-app.
+#
+# dialer-app 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.
+
+"""Multiple calls tests for the Dialer App using ofono-phonesim"""
+
+import time
+
+from autopilot.matchers import Eventually
+from testtools.matchers import Equals
+from testtools import skipUnless
+
+from dialer_app.tests import DialerAppTestCase
+from dialer_app import helpers
+from dialer_app import fixture_setup
+
+
+@skipUnless(helpers.is_phonesim_running(),
+            "this test needs to run under with-ofono-phonesim")
+class TestMultiCalls(DialerAppTestCase):
+    """Tests for simulated phone calls."""
+
+    def setUp(self):
+        empty_history = fixture_setup.UseEmptyHistory()
+        self.useFixture(empty_history)
+        phonesim_modem = fixture_setup.UsePhonesimModem()
+        self.useFixture(phonesim_modem)
+        super().setUp()
+
+    def tearDown(self):
+        super().tearDown()
+
+    @property
+    def history_list(self):
+        # because of the object tree, more than just one item is returned, but
+        # all references point to the same item, so take the first
+        return self.app.select_many(objectName="historyList")[0]
+
+    def get_history_for_number(self, number):
+        # because of the bottom edge tree structure, multiple copies of the
+        # same item are returned, so just use the first one
+        return self.history_list.select_many(
+            "HistoryDelegate", phoneNumber=number)[0]
+
+    def place_calls(self, numbers):
+        for number in numbers:
+            helpers.invoke_incoming_call(number)
+            helpers.wait_for_incoming_call()
+            time.sleep(1)
+            helpers.accept_incoming_call()
+            time.sleep(1)
+
+    def test_multi_call_panel(self):
+        """Make sure the multi call panel is visible when two calls are
+           available"""
+        firstNumber = '11111111'
+        secondNumber = '22222222'
+
+        # place the calls
+        self.place_calls([firstNumber, secondNumber])
+
+        # now ensure that the multi-call panel is visible
+        multi_call = self.main_view.live_call_page.get_multi_call_display()
+        self.assertThat(multi_call.visible, Eventually(Equals(True)))
+
+        # hangup one call
+        self.main_view.live_call_page.click_hangup_button()
+        self.assertThat(multi_call.visible, Eventually(Equals(False)))
+
+        # and the other one
+        self.main_view.live_call_page.click_hangup_button()
+
+    def test_swap_calls(self):
+        """Check that pressing the swap calls button change the call status"""
+        firstNumber = '11111111'
+        secondNumber = '22222222'
+
+        # place the calls
+        self.place_calls([firstNumber, secondNumber])
+
+        live_call = self.main_view.live_call_page
+        firstCallItem = live_call.get_multi_call_item_for_number(firstNumber)
+        secondCallItem = live_call.get_multi_call_item_for_number(secondNumber)
+
+        # check the current status
+        self.assertThat(firstCallItem.active, Eventually(Equals(False)))
+        self.assertThat(secondCallItem.active, Eventually(Equals(True)))
+
+        # now swap the calls
+        live_call.click_swap_calls_button()
+
+        # and make sure the calls changed
+        self.assertThat(firstCallItem.active, Eventually(Equals(True)))
+        self.assertThat(secondCallItem.active, Eventually(Equals(False)))
+
+        # hangup the calls
+        self.main_view.live_call_page.click_hangup_button()
+        time.sleep(1)
+        self.main_view.live_call_page.click_hangup_button()
+
+    def test_swap_and_hangup(self):
+        """Check that after swapping calls and hanging up the correct call
+           stays active"""
+        firstNumber = '11111111'
+        secondNumber = '22222222'
+
+        # place the calls
+        self.place_calls([firstNumber, secondNumber])
+
+        # at this point the calls should be like this:
+        #  - 11111111: held
+        #  - 22222222: active
+        # swap the calls then
+        self.main_view.live_call_page.click_swap_calls_button()
+
+        # - 11111111: active
+        # - 22222222: held
+        self.assertThat(
+            self.main_view.live_call_page.caller,
+            Eventually(Equals(firstNumber)))
+
+        # hangup the active call
+        self.main_view.live_call_page.click_hangup_button()
+
+        # and check that the remaining call is the one that was held
+        self.assertThat(
+            self.main_view.live_call_page.caller,
+            Eventually(Equals(secondNumber)))
+
+        # and hangup the remaining call too
+        self.main_view.live_call_page.click_hangup_button()