Keeper

Merge lp:~xavi-garcia-mena/keeper/tests-with-propertieschanged-signal into lp:keeper/devel

tests-with-propertieschanged-signal
Merge into devel

Proposed by Xavi Garcia on 2016-09-05

Status:	Merged
Merge reported by:	Xavi Garcia
Merged at revision:	not available
Proposed branch:	lp:~xavi-garcia-mena/keeper/tests-with-propertieschanged-signal
Merge into:	lp:keeper/devel
Diff against target:	819 lines (+550/-23) 14 files modified src/service/keeper-task.cpp (+24/-1) src/service/keeper-task.h (+2/-0) src/service/private/keeper-task_p.h (+2/-0) src/service/task-manager.cpp (+30/-16) src/service/task-manager.h (+5/-0) src/util/dbus-utils.cpp (+6/-1) tests/CMakeLists.txt (+1/-0) tests/integration/helpers/CMakeLists.txt (+3/-0) tests/integration/helpers/helpers-test-failure.cpp (+16/-1) tests/integration/helpers/helpers-test.cc (+14/-0) tests/integration/helpers/test-helpers-base.cpp (+360/-3) tests/integration/helpers/test-helpers-base.h (+7/-1) tests/qdbus-stubs/CMakeLists.txt (+53/-0) tests/qdbus-stubs/org.freedesktop.DBus.Properties.xml (+27/-0)
To merge this branch:	bzr merge lp:~xavi-garcia-mena/keeper/tests-with-propertieschanged-signal
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
unity-api-1-bot	continuous-integration		Needs Fixing on 2016-09-06
Charles Kerr (community)		2016-09-05	Approve on 2016-09-06
Review via email: mp+304928@code.launchpad.net

Commit message

Improve integration tests to listen to the PropertiesChanged signal from keeper.User dbus interface.

Description of the change

Improve integration tests to listen to the PropertiesChanged signal from keeper.User dbus interface.

The tests now check that the signals progress is correct. It records all the signals until completion of all tasks and checks that things like "action" state makes sense of "percent-done" is always greater or equal than the previous signal.

It also adds some code modifications to emit the PropertiesChanged signal as now the state lives in the TaskManager class.

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-09-05:

FAILED: Continuous integration, rev:100
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/36/
Executed test runs:
FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/553/console
FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/559/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/36/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Charles Kerr (charlesk) wrote on 2016-09-05:

Clean and straightforward. Overall, looks very good!

Several questions and minor/trivial suggestions inline, one borderline needs-fixing.

review: Needs Information

Revision history for this message

Xavi Garcia (xavi-garcia-mena) wrote on 2016-09-06:

Thanks for the review, Charles. I've added some comments inline.

When fixing the issues you found and suggested I realized that we were not sending a lot of PropertiesChanges signal at the beginning because when I did the TaskManager change I forgot to add them.

To fix this I've created a static method in the KeeperTask class that returns an initial state.

The idea would be to set that initial state for all tasks (which should appear as queued for the user) and then emit the PropertiesSignal to notify the state of all tasks all at once.

I also added a new change to detect when the previous state of a task is equal to the current one. In that case we don't emit the PropertiesChanged signal.

We have a big TODO here, though, and it's about i18n as stated in the code... I've created a Trello card for that.

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-09-06:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-keeper-ci/40/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Charles Kerr (charlesk) wrote on 2016-09-06:

LGTM. Thanks for the changes!

review: Approve

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-09-06:

review: Needs Fixing (continuous-integration)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Unity API Team

Xavi Garcia

 === modified file 'src/service/keeper-task.cpp'
 --- src/service/keeper-task.cpp	2016-08-31 14:40:50 +0000
 +++ src/service/keeper-task.cpp	2016-09-06 13:08:57 +0000
@@ -114,7 +114,7 @@
  void KeeperTaskPrivate::on_helper_percent_done_changed(float /*percent_done*/)
+ {
--    calculate_task_state();
++    calculate_and_notify_state(helper_->state());
+ }
  QVariantMap KeeperTaskPrivate::calculate_task_state()
@@ -149,6 +149,24 @@
      Q_EMIT(q_ptr->task_state_changed(state));
+ }
++QVariantMap KeeperTaskPrivate::get_initial_state(KeeperTask::TaskData const &td)
++{
++    QVariantMap ret;
++
++    auto const uuid = td.metadata.uuid();
++
++    ret.insert(QStringLiteral("action"), td.action);
++
++    // TODO review this when we add the restore tasks.
++    // TODO we maybe have different fields
++    ret.insert(QStringLiteral("display-name"), td.metadata.display_name());
++    ret.insert(QStringLiteral("speed"), 0);
++    ret.insert(QStringLiteral("percent-done"), double(0.0));
++    ret.insert(QStringLiteral("uuid"), uuid);
++
++    return ret;
++}
++
  KeeperTask::KeeperTask(TaskData const & task_data,
                         QSharedPointer<HelperRegistry> const & helper_registry,
                         QSharedPointer<StorageFrameworkClient> const & storage,
@@ -178,3 +196,8 @@
      Q_D(const KeeperTask);
      return d->state();
+ }
++
++QVariantMap KeeperTask::get_initial_state(KeeperTask::TaskData const &td)
++{
++    return KeeperTaskPrivate::get_initial_state(td);
++}
 === modified file 'src/service/keeper-task.h'
 --- src/service/keeper-task.h	2016-08-24 11:04:47 +0000
 +++ src/service/keeper-task.h	2016-09-06 13:08:57 +0000
@@ -59,6 +59,8 @@
      bool start();
      QVariantMap state() const;
++    static QVariantMap get_initial_state(KeeperTask::TaskData const &td);
++
   Q_SIGNALS:
      void task_state_changed(Helper::State state);
      void task_socket_ready(int socket_descriptor);
 === modified file 'src/service/private/keeper-task_p.h'
 --- src/service/private/keeper-task_p.h	2016-08-24 11:04:47 +0000
 +++ src/service/private/keeper-task_p.h	2016-09-06 13:08:57 +0000
@@ -36,6 +36,8 @@
      QVariantMap state() const;
      void ask_for_storage_framework_socket(quint64 n_bytes);
++    static QVariantMap get_initial_state(KeeperTask::TaskData const &td);
++
  protected:
      void set_current_task_action(QString const& action);
      void on_helper_percent_done_changed(float percent_done);
 === modified file 'src/service/task-manager.cpp'
 --- src/service/task-manager.cpp	2016-08-31 14:56:18 +0000
 +++ src/service/task-manager.cpp	2016-09-06 13:08:57 +0000
@@ -79,8 +79,10 @@
              td.type = type;
              td.action = QStringLiteral("queued"); // TODO i18n
--//            update_task_state(td);
++            set_initial_task_state(td);
+         }
++        // notify the initial state once for all tasks
++        notify_state_changed();
          start_next_task();
+     }
@@ -222,20 +224,13 @@
          update_task_state(it.value());
+     }
--    void update_task_state(KeeperTask::KeeperTask::TaskData& td)
--    {
--        state_[td.metadata.uuid()] = task_->state();
--
--#if 0
--        // FIXME: we don't need this to work correctly for the sprint because Marcus is polling in a loop
--        // but we will need this in order for him to stop doing that
--
--        // TODO: compare old and new and decide if it's worth emitting a PropertyChanged signal;
--        // eg don't contribute to dbus noise for minor speed fluctuations
--
--        // TODO: this function is called inside a loop when initializing the state
--        // after start_tasks(), so also ensure we don't have a notify flood here
--
++    void set_initial_task_state(KeeperTask::KeeperTask::TaskData& td)
++    {
++        state_[td.metadata.uuid()] = KeeperTask::get_initial_state(td);
++    }
++
++    void notify_state_changed()
++    {
          DBusUtils::notifyPropertyChanged(
              QDBusConnection::sessionBus(),
              *q_ptr,
@@ -243,7 +238,26 @@
              DBusTypes::KEEPER_USER_INTERFACE,
              QStringList(QStringLiteral("State"))
          );
--#endif
++
++        Q_EMIT(q_ptr->state_changed());
++    }
++
++    void update_task_state(KeeperTask::KeeperTask::TaskData& td)
++    {
++        auto task_state = task_->state();
++
++        // avoid sending repeated states to minimize the use of the bus
++        if (task_state != state_[td.metadata.uuid()] && !task_state.isEmpty())
++        {
++            state_[td.metadata.uuid()] = task_state;
++
++            // FIXME: we don't need this to work correctly for the sprint because Marcus is polling in a loop
++            // but we will need this in order for him to stop doing that
++
++            // TODO: compare old and new and decide if it's worth emitting a PropertyChanged signal;
++            // eg don't contribute to dbus noise for minor speed fluctuations
++            notify_state_changed();
++        }
+     }
      void set_current_task_action(QString const& action)
 === modified file 'src/service/task-manager.h'
 --- src/service/task-manager.h	2016-08-24 11:04:47 +0000
 +++ src/service/task-manager.h	2016-09-06 13:08:57 +0000
@@ -46,6 +46,10 @@
      Q_DISABLE_COPY(TaskManager)
++    Q_PROPERTY(QVariantDictMap State
++               READ get_state
++               NOTIFY state_changed)
++
      void start_tasks(QStringList const & task_uuids);
      QVariantDictMap get_state() const;
@@ -54,6 +58,7 @@
  Q_SIGNALS:
      void socket_ready(int reply);
++    void state_changed();
  private:
      QScopedPointer<TaskManagerPrivate> const d_ptr;
 === modified file 'src/util/dbus-utils.cpp'
 --- src/util/dbus-utils.cpp	2016-05-26 21:33:18 +0000
 +++ src/util/dbus-utils.cpp	2016-09-06 13:08:57 +0000
@@ -65,7 +65,12 @@
          signal << it.key().second;
          // Changed properties (name, value)
          signal << it.value().second;
--        signal << QStringList();
++        QStringList properties_changed;
++        for (auto iter_props = it.value().second.begin(); iter_props != it.value().second.end(); ++iter_props)
++        {
++            properties_changed << iter_props.key();
++        }
++        signal << properties_changed;
          // Connection
          it.value().first.send(signal);
+     }
 === modified file 'tests/CMakeLists.txt'
 --- tests/CMakeLists.txt	2016-08-31 14:40:50 +0000
 +++ tests/CMakeLists.txt	2016-09-06 13:08:57 +0000
@@ -99,6 +99,7 @@
  add_subdirectory(utils)
  add_subdirectory(fakes)
  add_subdirectory(integration)
++add_subdirectory(qdbus-stubs)
  set(
    COVERAGE_TEST_TARGETS
 === modified file 'tests/integration/helpers/CMakeLists.txt'
 --- tests/integration/helpers/CMakeLists.txt	2016-08-30 12:50:46 +0000
 +++ tests/integration/helpers/CMakeLists.txt	2016-09-06 13:08:57 +0000
@@ -23,6 +23,7 @@
    ${UAL_INCLUDE_DIRS}
    ${PROP-CPP_INCLUDE_DIRS}
    ${HELPERS_TEST_DEPS_INCLUDE_DIRS}
++  "${CMAKE_BINARY_DIR}/tests/qdbus-stubs"
+ )
  set(
@@ -48,6 +49,7 @@
    ${HELPERS_TEST}
    ${HELPERS_TEST_DEPS_LDFLAGS}
    ${INTEGRATION_TEST_LIBRARIES}
++  qdbus-stubs-tests
    Qt5::Core
    Qt5::DBus
    Qt5::Test
@@ -113,6 +115,7 @@
    ${HELPERS_TEST_FAILURE}
    ${HELPERS_TEST_DEPS_LDFLAGS}
    ${INTEGRATION_TEST_LIBRARIES}
++  qdbus-stubs-tests
    Qt5::Core
    Qt5::DBus
    Qt5::Test
 === modified file 'tests/integration/helpers/helpers-test-failure.cpp'
 --- tests/integration/helpers/helpers-test-failure.cpp	2016-09-01 12:55:19 +0000
 +++ tests/integration/helpers/helpers-test-failure.cpp	2016-09-06 13:08:57 +0000
@@ -67,11 +67,26 @@
      QFile helper_mark(SIMPLE_HELPER_MARK_FILE_PATH);
      qDebug() << "Helper mark exists before calling StartBackup..." << helper_mark.exists();
++    QSharedPointer<DBusPropertiesInterface> properties_interface(new DBusPropertiesInterface(
++                                                            DBusTypes::KEEPER_SERVICE,
++                                                            DBusTypes::KEEPER_USER_PATH,
++                                                            dbus_test_runner.sessionConnection()
++                                                        ) );
++
++    ASSERT_TRUE(properties_interface->isValid()) << qPrintable(QDBusConnection::sessionBus().lastError().message());
++
++    QSignalSpy spy(properties_interface.data(),&DBusPropertiesInterface::PropertiesChanged);
++
      // Now we know the music folder uuid, let's start the backup for it.
      QDBusReply<void> backup_reply = user_iface->call("StartBackup", QStringList{user_folder_uuid});
      ASSERT_TRUE(backup_reply.isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
--    // wait until all the tasks have the action state "failed"
++    // waits until all tasks are complete, recording PropertiesChanged signals
++    // and checks all the recorded values
++    EXPECT_TRUE(capture_and_check_state_until_all_tasks_complete(spy, {user_folder_uuid}, "failed"));
++
++    // wait until all the tasks have the action state "complete"
++    // this one uses pooling so it should just call Get once
      EXPECT_TRUE(wait_for_all_tasks_have_action_state({user_folder_uuid}, "failed", user_iface));
      // check that the content of the file is the expected
 === modified file 'tests/integration/helpers/helpers-test.cc'
 --- tests/integration/helpers/helpers-test.cc	2016-09-01 12:55:19 +0000
 +++ tests/integration/helpers/helpers-test.cc	2016-09-06 13:08:57 +0000
@@ -104,12 +104,26 @@
      ASSERT_FALSE(user_folder_uuid_2.isEmpty());
      qDebug() << "User folder 2 UUID is:" << user_folder_uuid_2;
++    QSharedPointer<DBusPropertiesInterface> properties_interface(new DBusPropertiesInterface(
++                                                            DBusTypes::KEEPER_SERVICE,
++                                                            DBusTypes::KEEPER_USER_PATH,
++                                                            dbus_test_runner.sessionConnection()
++                                                        ) );
++
++    ASSERT_TRUE(properties_interface->isValid()) << qPrintable(QDBusConnection::sessionBus().lastError().message());
++
++    QSignalSpy spy(properties_interface.data(),&DBusPropertiesInterface::PropertiesChanged);
      // Now we know the music folder uuid, let's start the backup for it.
      QDBusReply<void> backup_reply = user_iface->call("StartBackup", QStringList{user_folder_uuid, user_folder_uuid_2});
      ASSERT_TRUE(backup_reply.isValid()) << qPrintable(dbus_test_runner.sessionConnection().lastError().message());
++    // waits until all tasks are complete, recording PropertiesChanged signals
++    // and checks all the recorded values
++    EXPECT_TRUE(capture_and_check_state_until_all_tasks_complete(spy, {user_folder_uuid, user_folder_uuid_2}, "complete"));
++
      // wait until all the tasks have the action state "complete"
++    // this one uses pooling so it should just call Get once
      EXPECT_TRUE(wait_for_all_tasks_have_action_state({user_folder_uuid, user_folder_uuid_2}, "complete", user_iface));
      // check that the content of the file is the expected
 === modified file 'tests/integration/helpers/test-helpers-base.cpp'
 --- tests/integration/helpers/test-helpers-base.cpp	2016-08-31 14:48:23 +0000
 +++ tests/integration/helpers/test-helpers-base.cpp	2016-09-06 13:08:57 +0000
@@ -26,6 +26,242 @@
  using namespace QtDBusTest;
  using namespace QtDBusMock;
++///
++/// State helpers
++//
++
++bool qvariant_to_map(QVariant const& variant, QVariantMap& map)
++{
++    if (variant.type() == QMetaType::QVariantMap)
++    {
++        map = variant.toMap();
++        return true;
++    }
++    qWarning() << Q_FUNC_INFO << ": Could not convert variant to QVariantMap. Variant received has type " << variant.typeName();
++
++    return false;
++}
++
++bool qdbus_argument_to_variant_dict_map(QVariant const& variant, QVariantDictMap& map)
++{
++    if (variant.canConvert<QDBusArgument>())
++    {
++        QDBusArgument value(variant.value<QDBusArgument>());
++        if (value.currentType() == QDBusArgument::MapType)
++        {
++            value >> map;
++            return true;
++        }
++        else
++        {
++            qWarning() << Q_FUNC_INFO << ": Could not convert variant to QVariantDictMap. Variant received has type " << value.currentType();
++        }
++    }
++    else
++    {
++        qWarning() << Q_FUNC_INFO << ": Could not convert variant to QDBusArgument.";
++    }
++    return false;
++}
++
++bool get_property_qvariant_dict_map(QString const & property, QVariant const &variant, QVariantDictMap & map)
++{
++    QVariantMap properties_map;
++    if (!qvariant_to_map(variant, properties_map))
++    {
++        qWarning() << Q_FUNC_INFO << ": Error converting variant in PropertiesChanged signal to QVariantMap";
++        return false;
++    }
++
++    auto iter = properties_map.find(property);
++    if (iter == properties_map.end())
++    {
++        qWarning() << Q_FUNC_INFO << ": Property [" << property << "] was not found in PropertiesChanged";
++        return false;
++    }
++
++    if(!qdbus_argument_to_variant_dict_map((*iter), map))
++    {
++        qWarning() << Q_FUNC_INFO << ": Error converting property [" << property << "] to QVariantDictMap";
++        return false;
++    }
++
++    return true;
++}
++
++bool all_tasks_has_state(QMap<QString, QString> const & tasks_state, QString const & state)
++{
++    for (auto iter = tasks_state.begin(); iter != tasks_state.end(); ++iter )
++    {
++        if ((*iter) != state)
++        {
++            return false;
++        }
++    }
++    return true;
++}
++
++bool get_task_property(QString const &property, QVariantMap const &values, QVariant &value)
++{
++    auto iter = values.find(property);
++    if (iter == values.end())
++    {
++        qWarning() << Q_FUNC_INFO << ": Property [" << property << "] was not found.";
++        return false;
++    }
++    value = (*iter);
++    return true;
++}
++
++bool analyze_task_percentage_values(QString const & uuid, QList<QVariantMap> const & recorded_values)
++{
++    double previous_percentage = -1.0;
++    for (auto iter = recorded_values.begin(); iter != recorded_values.end(); ++iter)
++    {
++        QVariant percentage;
++        if (!get_task_property("percent-done", (*iter), percentage))
++        {
++            qWarning() << Q_FUNC_INFO << ": Percentage was not found for task: " << uuid;
++            return false;
++        }
++        bool ok_double;
++        auto percentage_double = percentage.toDouble(&ok_double);
++        if (!ok_double)
++        {
++            qWarning() << Q_FUNC_INFO << ": Error converting percent-done to double for uuid: " << uuid << ". State: " << (*iter);
++            return false;
++        }
++        if (percentage_double < previous_percentage)
++        {
++            qWarning() << Q_FUNC_INFO << ": Eror, current percentage is less than previous: current=" << percentage_double << ", previous=" << previous_percentage;
++            return false;
++        }
++        previous_percentage = percentage_double;
++    }
++    return true;
++}
++
++bool check_valid_action_state_step(QString const &previous, QString const &current)
++{
++    if (current == "queued")
++    {
++        return previous == "none" || previous == "queued";
++    }
++    else if (current == "saving")
++    {
++        return previous == "saving" || previous == "queued";
++    }
++    else if (current == "finishing")
++    {
++        return previous == "finishing" || previous == "saving";
++    }
++    else if (current == "complete")
++    {
++        // we may pass from "saving" to "complete" if we don't have enough time
++        // to emit the "finishing" state change
++        return previous == "complete" || previous == "finishing" || previous == "saving";
++    }
++    else if (current == "failed")
++    {
++        // we can get to failed from any state except complete
++        return previous != "complete";
++    }
++    else
++    {
++        // for possible new states, please add your code here
++        qWarning() << "Unhandled state: " << current;
++        return false;
++    }
++}
++
++bool analyze_task_action_values(QString const & uuid, QList<QVariantMap> const & recorded_values)
++{
++    QString previous_action = "none";
++    for (auto iter = recorded_values.begin(); iter != recorded_values.end(); ++iter)
++    {
++        QVariant action;
++        if (!get_task_property("action", (*iter), action))
++        {
++            qWarning() << Q_FUNC_INFO << ": Action was not found for task: " << uuid;
++            return false;
++        }
++        auto current_action = action.toString();
++
++        if (!check_valid_action_state_step(previous_action, action.toString()))
++        {
++            qWarning() << Q_FUNC_INFO << ": Bad action state step: previous state=" << previous_action << ", current=" << action.toString();
++            return false;
++        }
++        previous_action = action.toString();
++    }
++    return true;
++}
++
++bool analyze_task_display_name_values(QString const & uuid, QList<QVariantMap> const & recorded_values)
++{
++    QString previous_name;
++    // check that the display name never changes between recorded states
++    for (auto iter = recorded_values.begin(); iter != recorded_values.end(); ++iter)
++    {
++        QVariant name;
++        if (!get_task_property("display-name", (*iter), name))
++        {
++            qWarning() << Q_FUNC_INFO << ": display-name was not found for task: " << uuid;
++            return false;
++        }
++        auto current_name = name.toString();
++
++        if (previous_name.isEmpty())
++        {
++            previous_name = name.toString();
++        }
++        else if(name.toString() != previous_name)
++        {
++            qWarning() << Q_FUNC_INFO << "ERROR: display-name for uuid: " << uuid << " changed from " << previous_name << " to " << name.toString();
++            return false;
++        }
++    }
++    return true;
++}
++
++bool analyze_tasks_values(QMap<QString, QList<QVariantMap>> const &uuids_state)
++{
++    for (auto iter = uuids_state.begin(); iter != uuids_state.end(); ++iter)
++    {
++        if(!analyze_task_display_name_values(iter.key(), (*iter)))
++            return false;
++        if(!analyze_task_action_values(iter.key(), (*iter)))
++            return false;
++        if(!analyze_task_percentage_values(iter.key(), (*iter)))
++            return false;
++    }
++    return true;
++}
++
++bool verify_signal_interface_and_invalidated_properties(QVariant const &interface,
++                                                        QVariant const &invalidated_properties,
++                                                        QString const & expected_interface,
++                                                        QString const & expected_property)
++{
++    auto props_list = invalidated_properties.toStringList();
++    if (!props_list.contains(expected_property))
++    {
++        qWarning() << Q_FUNC_INFO << "ERROR: PropertiesChanged signal did not include the property: " << expected_property << " as the ones invalidated";
++        return false;
++    }
++
++    if (interface.toString() != expected_interface)
++    {
++        qWarning() << Q_FUNC_INFO << "ERROR: Interface: [" << interface.toString() << "] is not valid. Expecting: [" << expected_interface << "]";
++        return false;
++    }
++    return true;
++}
++
++///
++///
++///
++
  TestHelpersBase::TestHelpersBase()
      :dbus_mock(dbus_test_runner)
+ {
@@ -63,7 +299,13 @@
          throw;
+     }
--    system("dbus-send --session --dest=org.freedesktop.DBus --type=method_call --print-reply /org/freedesktop/DBus org.freedesktop.DBus.ListNames");
++#if 0
++    // Enable this to get extra dbus information.
++    if (!start_dbus_monitor())
++    {
++        throw std::logic_error("Error starting dbus-monitor process.");
++    }
++#endif
+ }
  void TestHelpersBase::SetUp()
@@ -243,12 +485,12 @@
          : -1;
+ }
--bool TestHelpersBase::wait_for_all_tasks_have_action_state(QStringList const & uuids, QString const & action_state, QSharedPointer<DBusInterfaceKeeperUser> const & keeper_user_iface, int max_timeout)
++bool TestHelpersBase::wait_for_all_tasks_have_action_state(QStringList const & uuids, QString const & action_state, QSharedPointer<DBusInterfaceKeeperUser> const & keeper_user_iface, int max_timeout_msec)
+ {
      QElapsedTimer timer;
      timer.start();
      bool finished = false;
--    while (!timer.hasExpired(max_timeout) && !finished)
++    while (!timer.hasExpired(max_timeout_msec) && !finished)
+     {
          auto state = keeper_user_iface->state();
          auto all_helpers_finished = true;
@@ -278,6 +520,98 @@
      return (*iter_props).toString() == action_state;
+ }
++bool TestHelpersBase::capture_and_check_state_until_all_tasks_complete(QSignalSpy & spy, QStringList const & uuids, QString const & action_state, int max_timeout_msec)
++{
++    QMap<QString, QList<QVariantMap>> uuids_state;
++    QMap<QString, QString> uuids_current_state;
++
++    // initialize the current state map to wait for all expected uuids
++    for (auto const& uuid : uuids)
++    {
++        uuids_current_state[uuid] = "none";
++        uuids_state[uuid] = QList<QVariantMap>();
++    }
++
++    QElapsedTimer timer;
++    timer.start();
++    bool finished = false;
++    while (!timer.hasExpired(max_timeout_msec) && !finished)
++    {
++        spy.wait();
++
++        qDebug() << "PropertiesChanged SIGNALS RECEIVED:  " << spy.count();
++        while (spy.count())
++        {
++            auto arguments = spy.takeFirst();
++
++            if (arguments.size() != 3)
++            {
++                qWarning() << "Bad number of arguments in PropertiesChanged signal";
++                return false;
++            }
++
++            // verify interface and invalidated_properties arguments
++            if(!verify_signal_interface_and_invalidated_properties(arguments.at(0), arguments.at(2), DBusTypes::KEEPER_USER_INTERFACE, "State"))
++            {
++                return false;
++            }
++            QVariantDictMap keeper_state;
++            if (!get_property_qvariant_dict_map("State", arguments.at(1), keeper_state))
++            {
++                return false;
++            }
++            for (auto iter = keeper_state.begin(); iter != keeper_state.end(); ++iter )
++            {
++                // check for unexpected uuids
++                if (!uuids.contains(iter.key()))
++                {
++                    qWarning() << "State contains unexpected uuid: " << iter.key();
++                    return false;
++                }
++
++                QVariantMap task_state;
++                if (!qvariant_to_map((*iter), task_state))
++                {
++                    qWarning() << "Error converting second argument in PropertiesChanged signal to QVariantMap for uuid: " << iter.key();
++                    return false;
++                }
++                qDebug() << "State for uuid: " << iter.key() << " : " << task_state;
++
++                QVariant action;
++                if (get_task_property("action", task_state, action))
++                {
++                    if (action.type() != QVariant::String)
++                    {
++                        qWarning() << "Property [action] is not a string";
++                        return false;
++                    }
++                    // store the current action state
++                    uuids_current_state[iter.key()] = action.toString();
++
++                    bool store = true;
++                    if (action.toString() == action_state)
++                    {
++                        // check if it worths storing this new event
++                        store = uuids_state[iter.key()].last() != task_state;
++                    }
++                    if (store)
++                    {
++                        // store the current state for later inspection
++                        uuids_state[iter.key()].push_back(task_state);
++                    }
++                }
++            }
++        }
++        finished = all_tasks_has_state(uuids_current_state, action_state);
++        if (finished)
++        {
++            qDebug() << "ALL TASKS FINISHED =========================================";
++        }
++    }
++    // check for the recorded values
++    return analyze_tasks_values(uuids_state);
++}
++
  QString TestHelpersBase::get_uuid_for_xdg_folder_path(QString const &path, QVariantDictMap const & choices) const
+ {
      for(auto iter = choices.begin(); iter != choices.end(); ++iter)
@@ -296,3 +630,26 @@
      return QString();
+ }
++
++bool TestHelpersBase::start_dbus_monitor()
++{
++    if (!dbus_monitor_process)
++    {
++        dbus_monitor_process.reset(new QProcess());
++
++        dbus_monitor_process->setProcessChannelMode(QProcess::ForwardedChannels);
++
++        dbus_monitor_process->start("dbus-monitor", QStringList() << "--session");
++        if (!dbus_monitor_process->waitForStarted())
++        {
++            qWarning() << "Error, starting dbus-monitor: " << dbus_monitor_process->errorString();
++            return false;
++        }
++    }
++    else
++    {
++        qWarning() << "Error, dbus-monitor should be called one time per test.";
++        return false;
++    }
++    return true;
++}
 === modified file 'tests/integration/helpers/test-helpers-base.h'
 --- tests/integration/helpers/test-helpers-base.h	2016-08-30 12:50:46 +0000
 +++ tests/integration/helpers/test-helpers-base.h	2016-09-06 13:08:57 +0000
@@ -22,6 +22,7 @@
  #include <helper/backup-helper.h>
  #include <qdbus-stubs/dbus-types.h>
++#include "DBusPropertiesInterface.h"
  #include "qdbus-stubs/keeper_user_interface.h"
  #include "tests/fakes/fake-backup-helper.h"
@@ -73,6 +74,7 @@
      QtDBusMock::DBusMock dbus_mock;
      QSharedPointer<QtDBusTest::QProcessDBusService> keeper_service;
      QSharedPointer<QtDBusTest::QProcessDBusService> upstart_service;
++    QScopedPointer<QProcess> dbus_monitor_process;
  protected:
      void start_tasks();
@@ -93,11 +95,15 @@
      QString get_last_storage_framework_file();
--    bool wait_for_all_tasks_have_action_state(QStringList const & uuids, QString const & action_state, QSharedPointer<DBusInterfaceKeeperUser> const & keeper_user_iface, int max_timeout = 15000);
++    bool wait_for_all_tasks_have_action_state(QStringList const & uuids, QString const & action_state, QSharedPointer<DBusInterfaceKeeperUser> const & keeper_user_iface, int max_timeout_msec = 15000);
      bool check_task_has_action_state(QVariantDictMap const & state, QString const & uuid, QString const & action_state);
++    bool capture_and_check_state_until_all_tasks_complete(QSignalSpy & spy, QStringList const & uuids, QString const & action_state, int max_timeout_msec = 15000);
++
      QString get_uuid_for_xdg_folder_path(QString const &path, QVariantDictMap const & choices) const;
++
++    bool start_dbus_monitor();
  };
  #define EXPECT_ENV(expected, envvars, key) EXPECT_EQ(expected, get_env(envvars, key)) << "for key " << key
 === added directory 'tests/qdbus-stubs'
 === added file 'tests/qdbus-stubs/CMakeLists.txt'
 --- tests/qdbus-stubs/CMakeLists.txt	1970-01-01 00:00:00 +0000
 +++ tests/qdbus-stubs/CMakeLists.txt	2016-09-06 13:08:57 +0000
@@ -0,0 +1,53 @@
++# Copyright © 2015 Canonical Ltd.
++#
++# This program is free software: you can redistribute it and/or modify it
++# under the terms of the GNU Lesser General Public License version 3,
++# as published by the Free Software Foundation.
++#
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++# GNU Lesser General Public License for more details.
++#
++# You should have received a copy of the GNU Lesser General Public License
++# along with this program.  If not, see <http://www.gnu.org/licenses/>.
++#
++# Authors:
++#     Xavi Garcia <marcus.tomlinson@canonical.com>
++
++# disable compilier warnings in machine-generated code
++add_compile_options(-w)
++
++# XML
++
++set(
++  properties_xml
++  "org.freedesktop.DBus.Properties.xml"
++)
++
++set_source_files_properties(
++  "${properties_xml}"
++  PROPERTIES
++  NO_NAMESPACE YES
++  CLASSNAME DBusPropertiesInterface
++)
++
++qt5_add_dbus_interface(
++  interface_files
++  ${properties_xml}
++  DBusPropertiesInterface
++)
++
++#
++#
++
++set(
++  STUBS_LIB
++  qdbus-stubs-tests
++)
++
++add_library(
++  ${STUBS_LIB}
++  STATIC
++  ${interface_files}
++)
 === added file 'tests/qdbus-stubs/org.freedesktop.DBus.Properties.xml'
 --- tests/qdbus-stubs/org.freedesktop.DBus.Properties.xml	1970-01-01 00:00:00 +0000
 +++ tests/qdbus-stubs/org.freedesktop.DBus.Properties.xml	2016-09-06 13:08:57 +0000
@@ -0,0 +1,27 @@
++<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
++                      "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
++<node>
++  <interface name="org.freedesktop.DBus.Properties">
++    <method name="Get">
++      <arg type="s" name="interface_name" direction="in"/>
++      <arg type="s" name="property_name" direction="in"/>
++      <arg type="v" name="value" direction="out"/>
++    </method>
++    <method name="GetAll">
++      <arg type="s" name="interface_name" direction="in"/>
++      <arg type="a{sv}" name="properties" direction="out"/>
++      <annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantMap"/>
++    </method>
++    <method name="Set">
++      <arg type="s" name="interface_name" direction="in"/>
++      <arg type="s" name="property_name" direction="in"/>
++      <arg type="v" name="value" direction="in"/>
++    </method>
++    <signal name="PropertiesChanged">
++      <arg type="s" name="interface_name"/>
++      <arg type="a{sv}" name="changed_properties"/>
++      <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QVariantMap"/>
++      <arg type="as" name="invalidated_properties"/>
++    </signal>
++  </interface>
++</node>