Merge lp:~azzar1/unity/category-expension into lp:~unity-team/unity/libunity-7.0-breakage

[Andrea Azzarone]

Fix category expansion.

== Problem ==
Category header expansion is misbehaving.

== Notes ==
Bug 1174485 is hard to reproduce with a fast internet connection, btw all the tests pass. There could be not handled corner cases but should be ok for the moment.

== Tests ==
Unit tests added.

[PS Jenkins bot (ps-jenkins)]

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

http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-ci/72/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-raring-amd64-ci/72/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-team-unity-libunity-7.0-breakage-ci/72/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3136
http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-ci/73/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-raring-amd64-ci/73/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-team-unity-libunity-7.0-breakage-ci/73/rebuild

review: Needs Fixing (continuous-integration)

[Nick Dedekind (nick-dedekind)]

LGTM.
Tests run successfully. Tested UI behaviour.

There are many errors output by DeeSequenceModel when running the ScopeView tests, but it doesn't seem to affect the tests. Would be nice to get rid of these.

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Autolanding.
More details in the following jenkins job:
http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-autolanding/63/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-team-unity-libunity-7.0-breakage-raring-amd64-autolanding/63/console

review: Needs Fixing (continuous-integration)

[Michal Hruby (mhr3)]

Superseded by https://code.launchpad.net/~unity-team/unity/category-expansion/+merge/162744

=== modified file 'UnityCore/Scope.cpp'
--- UnityCore/Scope.cpp	2013-03-27 19:45:52 +0000
+++ UnityCore/Scope.cpp	2013-05-02 18:31:27 +0000
@@ -66,7 +66,6 @@
 Scope::Impl::~Impl()
 {
   for_each(property_connections.begin(), property_connections.end(), [](ConnectionPtr const& con) { con->disconnect(); });
-  property_connections.clear();
 }
 
 void Scope::Impl::Init()
@@ -93,10 +92,6 @@
     property_connections.push_back(utils::ConnectProperties(owner_->query_pattern, proxy_->query_pattern));
     property_connections.push_back(utils::ConnectProperties(owner_->shortcut, proxy_->shortcut));
     property_connections.push_back(utils::ConnectProperties(owner_->visible, proxy_->visible));
-
-    property_connections.push_back(utils::ConnectProperties(owner_->results, proxy_->results));
-    property_connections.push_back(utils::ConnectProperties(owner_->filters, proxy_->filters));
-    property_connections.push_back(utils::ConnectProperties(owner_->categories, proxy_->categories));
   }
 }
 

=== modified file 'dash/PlacesGroup.h'
--- dash/PlacesGroup.h	2013-05-02 18:31:27 +0000
+++ dash/PlacesGroup.h	2013-05-02 18:31:27 +0000
@@ -76,8 +76,8 @@
 
   void SetCounts(unsigned n_total_items);
 
-  void SetExpanded(bool is_expanded);
-  bool GetExpanded() const;
+  virtual void SetExpanded(bool is_expanded);
+  virtual bool GetExpanded() const;
 
   void PushExpanded();
   void PopExpanded();

=== modified file 'dash/ScopeView.cpp'
--- dash/ScopeView.cpp	2013-05-02 18:31:27 +0000
+++ dash/ScopeView.cpp	2013-05-02 18:31:27 +0000
@@ -303,6 +303,8 @@
   if (!categories)
     return;
 
+  QueueCategoryCountsCheck();
+
   category_added_connection = categories->category_added.connect(sigc::mem_fun(this, &ScopeView::OnCategoryAdded));
   category_changed_connection = categories->category_changed.connect(sigc::mem_fun(this, &ScopeView::OnCategoryChanged));
   category_removed_connection = categories->category_removed.connect(sigc::mem_fun(this, &ScopeView::OnCategoryRemoved));
@@ -714,7 +716,7 @@
 
 void ScopeView::CheckNoResults(glib::HintsMap const& hints)
 {
-  gint count = scope_->results()->count();
+  gint count = scope_->results() ? scope_->results()->count() : 0;
 
   if (count == 0 && !no_results_active_ && !search_string_.empty())
   {
@@ -774,38 +776,34 @@
 
   PushResultFocus("count check");
 
-  for (auto iter = category_order_.begin(); iter != category_order_.end(); ++iter)
+  for (auto category_index : category_order_)
   {
-    unsigned int category_index = *iter;
     if (category_views_.size() <= category_index)
      continue;
 
-    PlacesGroup::Ptr group = category_views_[category_index];
+    PlacesGroup::Ptr const& group = category_views_[category_index];
 
     group->SetCounts(counts_[group]);
     group->SetVisible(counts_[group] > 0);
 
     if (counts_[group] > 0)
     {
-      number_of_displayed_categories++;
+      ++number_of_displayed_categories;
       new_expanded_group = group;
     }
   }
 
-  if (new_expanded_group && get_search_string().empty())
-  {
-    // only expand the category if we have only one with results.
-    if (number_of_displayed_categories <= 2)
-      new_expanded_group->SetExpanded(true);
-    if (last_expanded_group_ && last_expanded_group_ != new_expanded_group)
-      last_expanded_group_->SetExpanded(false);
-  }
-  else if (last_expanded_group_)
-  {
-    last_expanded_group_->SetExpanded(false);
+  if (last_expanded_group_ and last_expanded_group_ != new_expanded_group) {
+    last_expanded_group_->PopExpanded();
+    last_expanded_group_ = nullptr;
   }
 
-  last_expanded_group_ = new_expanded_group;
+  if (new_expanded_group and number_of_displayed_categories <= 2)
+  {
+    new_expanded_group->PushExpanded();
+    new_expanded_group->SetExpanded(true);
+    last_expanded_group_ = new_expanded_group;
+  }
 
   PopResultFocus("count check");
 }
@@ -823,6 +821,10 @@
 
 bool ScopeView::PerformSearch(std::string const& search_query, SearchCallback const& callback)
 {
+  if (search_string_ != search_query)
+    for (auto const& group : category_views_)
+      group->SetExpanded(false);
+
   search_string_ = search_query;
   if (scope_)
   {

=== added file 'tests/MockResults.h'
--- tests/MockResults.h	1970-01-01 00:00:00 +0000
+++ tests/MockResults.h	2013-05-02 18:31:27 +0000
@@ -0,0 +1,62 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 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 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/>.
+ *
+ * Authored by: Andrea Azzarone <[e-mail]>
+ */
+
+#ifndef UNITY_MOCK_RESULTS_H
+#define UNITY_MOCK_RESULTS_H
+
+#include "UnityCore/Results.h"
+
+namespace unity {
+namespace dash {
+
+struct MockResults : public Results
+{
+  MockResults(unsigned int count)
+    : Results(LOCAL)
+    , model_(dee_sequence_model_new())
+  {
+    dee_model_set_schema(model_, "s", "s", "u", "u", "s", "s", "s", "s", "a{sv}", nullptr);
+    AddResults(count);
+
+    SetModel(model_);
+  }
+
+  void AddResults(unsigned count)
+  {
+    GVariantBuilder b;
+    g_variant_builder_init(&b, G_VARIANT_TYPE("a{sv}"));
+    GVariant *hints = g_variant_builder_end(&b);
+
+    for(unsigned i = 0; i < count; ++i)
+    {
+      dee_model_append(model_, "uri", "icon_hint", 
+                       0, 0, "mimetype", 
+                       "title", "comment", "dnd_uri", hints);
+    }
+
+    g_variant_unref(hints);
+  }
+
+  glib::Object<DeeModel> model_;
+};
+
+}
+}
+
+#endif
\ No newline at end of file

=== modified file 'tests/test_mock_scope.h'
--- tests/test_mock_scope.h	2013-03-15 10:54:33 +0000
+++ tests/test_mock_scope.h	2013-05-02 18:31:27 +0000
@@ -29,6 +29,8 @@
 
 #include <unity-protocol.h>
 
+#include "MockResults.h"
+
 namespace unity
 {
 namespace dash
@@ -44,8 +46,9 @@
 class MockScopeProxy : public ScopeProxyInterface
 {
 public:
-  MockScopeProxy(std::string const& _name, std::string const& _icon_hint)
-  : connected_(true)
+  MockScopeProxy(std::string const& _name, std::string const& _icon_hint, unsigned count_results)
+    : connected_(true)
+    , results_(std::make_shared<MockResults>(count_results))
   {
     connected.SetGetterFunction([this] () { return connected_; });
     name.SetGetterFunction([_name] () { return _name; });
@@ -96,12 +99,13 @@
 
   virtual Results::Ptr GetResultsForCategory(unsigned category) const
   {
-    return Results::Ptr();
+    return results_;
   }
 
 protected:
   glib::SourceManager source_manager;
   bool connected_;
+  MockResults::Ptr results_;
 };
 
 class MockScopeData : public ScopeData
@@ -124,12 +128,13 @@
 
   MockScope(ScopeData::Ptr const& scope_data,
             std::string const& name = "",
-            std::string const& icon_hint = "")
+            std::string const& icon_hint = "",
+            unsigned result_count = 0)
   : Scope(scope_data)
   {
-    proxy_func = [name, icon_hint]()
+    proxy_func = [name, icon_hint, result_count]()
     {
-      return ScopeProxyInterface::Ptr(new MockScopeProxy(name, icon_hint));
+      return ScopeProxyInterface::Ptr(new MockScopeProxy(name, icon_hint, result_count));
     };
     
     Init();

=== modified file 'tests/test_scope_bar.cpp'
--- tests/test_scope_bar.cpp	2013-02-21 10:47:14 +0000
+++ tests/test_scope_bar.cpp	2013-05-02 18:31:27 +0000
@@ -25,9 +25,6 @@
 #include "unity-shared/UnitySettings.h"
 #include "test_mock_scope.h"
 
-using namespace unity;
-using namespace unity::dash;
-
 namespace unity
 {
 namespace dash

=== modified file 'tests/test_scope_proxy.cpp'
--- tests/test_scope_proxy.cpp	2013-03-15 10:54:33 +0000
+++ tests/test_scope_proxy.cpp	2013-05-02 18:31:27 +0000
@@ -30,8 +30,6 @@
 #include "RadioOptionFilter.h"
 
 using namespace std;
-using namespace unity;
-using namespace unity::dash;
 
 namespace unity
 {

=== modified file 'tests/test_scopeview.cpp'
--- tests/test_scopeview.cpp	2013-03-13 11:18:48 +0000
+++ tests/test_scopeview.cpp	2013-05-02 18:31:27 +0000
@@ -26,35 +26,40 @@
 #include <UnityCore/Category.h>
 
 #include "MockCategories.h"
-
-using namespace unity;
-using namespace unity::dash;
+#include "test_mock_scope.h"
+#include "test_utils.h"
 
 namespace unity
 {
 namespace dash
 {
 
-class TestScopeView : public ::testing::Test
+struct TestScopeView : public ::testing::Test
 {
-public:
-
-  class FakePlacesGroup : public PlacesGroup
+  struct FakePlacesGroup : public PlacesGroup
   {
-  public:
-    FakePlacesGroup():PlacesGroup(dash::Style::Instance()) {}
+    FakePlacesGroup()
+      : PlacesGroup(dash::Style::Instance())
+      , is_expanded_(false)
+    {}
+
+    bool GetExpanded() const override { return is_expanded_; }
+    void SetExpanded(bool is_expanded) override { is_expanded_ = is_expanded; expanded.emit(this); }
 
     using PlacesGroup::_using_filters_background;
+    bool is_expanded_;
   };
 
-  class FakeScopeView : public ScopeView
+  struct FakeScopeView : public ScopeView
   {
-  public:
-    FakeScopeView():ScopeView(Scope::Ptr(), nullptr) {}
-
-    using ScopeView::OnCategoryAdded;
-
-    virtual PlacesGroup::Ptr CreatePlacesGroup(Category const& category)
+    FakeScopeView(MockScope::Ptr const& scope)
+      : ScopeView(scope, nullptr)
+    {}
+
+    using ScopeView::OnResultAdded;
+    using ScopeView::search_string_;
+
+    PlacesGroup::Ptr CreatePlacesGroup(Category const& category) override
     {
       FakePlacesGroup* group = new FakePlacesGroup();
       fake_groups_.push_back(group);
@@ -65,39 +70,234 @@
   };
 
   TestScopeView()
-    : scope_view_(new FakeScopeView())
-    , categories_(5)
-  {
-  }
+    : scope_data_(std::make_shared<MockScopeData>(""))
+    , scope_(std::make_shared<MockScope>(scope_data_, "", "", 10))
+    , scope_view_(new FakeScopeView(scope_))
+  {}
 
   unity::Settings settings;
   dash::Style style;
+  MockScopeData::Ptr scope_data_;
+  MockScope::Ptr scope_;
   std::unique_ptr<FakeScopeView> scope_view_;
-  MockCategories categories_;
 };
 
 TEST_F(TestScopeView, TestCategoryInsert)
 {
-  scope_view_->OnCategoryAdded(categories_.RowAtIndex(0));
-  scope_view_->OnCategoryAdded(categories_.RowAtIndex(1));
+  MockCategories::Ptr categories = std::make_shared<MockCategories>(2);
+  scope_->categories.changed.emit(categories);
 
   EXPECT_EQ(scope_view_->GetOrderedCategoryViews().size(), 2);
 }
 
 TEST_F(TestScopeView, TestFilterExpansion)
 {
-  scope_view_->OnCategoryAdded(categories_.RowAtIndex(0));
-  scope_view_->OnCategoryAdded(categories_.RowAtIndex(1));
-  scope_view_->OnCategoryAdded(categories_.RowAtIndex(2));
-  scope_view_->OnCategoryAdded(categories_.RowAtIndex(3));
+  MockCategories::Ptr categories = std::make_shared<MockCategories>(4);
+  scope_->categories.changed.emit(categories);
 
   EXPECT_EQ(scope_view_->fake_groups_.size(), 4);
 
   scope_view_->filters_expanded = true;
-  for (unsigned i = 0; i < scope_view_->fake_groups_.size(); i++)
-  {
+  for (unsigned i = 0; i < scope_view_->fake_groups_.size(); ++i)
     EXPECT_EQ(scope_view_->fake_groups_[i]->_using_filters_background, true);
-  }
+}
+
+TEST_F(TestScopeView, TestCategoryExpansion_OneCategory_EmptySearchString)
+{
+  MockCategories::Ptr categories = std::make_shared<MockCategories>(1);
+  scope_view_->search_string_ = "";
+
+  scope_->categories.changed.emit(categories);
+  Utils::WaitForTimeoutMSec(500);
+
+  EXPECT_EQ(scope_view_->fake_groups_.size(), 1);
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[0]->GetExpanded(); });
+}
+
+TEST_F(TestScopeView, TestCategoryExpansion_OneCategory_FilledSearchString)
+{
+  MockCategories::Ptr categories = std::make_shared<MockCategories>(1);
+  scope_view_->search_string_ = "Ubuntu";
+
+  scope_->categories.changed.emit(categories);
+  Utils::WaitForTimeoutMSec(500);
+
+  EXPECT_EQ(scope_view_->fake_groups_.size(), 1);
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[0]->GetExpanded(); });
+}
+
+TEST_F(TestScopeView, TestCategoryExpansion_TwoCategory_EmptySearchString)
+{
+  MockCategories::Ptr categories = std::make_shared<MockCategories>(2);
+  scope_view_->search_string_ = "";
+
+  scope_->categories.changed.emit(categories);
+  Utils::WaitForTimeoutMSec(500);
+
+  EXPECT_EQ(scope_view_->fake_groups_.size(), 2);
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[1]->GetExpanded(); });
+}
+
+TEST_F(TestScopeView, TestCategoryExpansion_TwoCategory_FilledSearchString)
+{
+  MockCategories::Ptr categories = std::make_shared<MockCategories>(2);
+  scope_view_->search_string_ = "Ubuntu";
+
+  scope_->categories.changed.emit(categories);
+  Utils::WaitForTimeoutMSec(500);
+
+  EXPECT_EQ(scope_view_->fake_groups_.size(), 2);
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[1]->GetExpanded(); });
+}
+
+TEST_F(TestScopeView, TestCategoryExpansion_ThreeCategory_EmptySearchString)
+{
+  MockCategories::Ptr categories = std::make_shared<MockCategories>(3);
+  scope_view_->search_string_ = "";
+
+  scope_->categories.changed.emit(categories);
+  Utils::WaitForTimeoutMSec(500);
+
+  EXPECT_EQ(scope_view_->fake_groups_.size(), 3);
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[1]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[2]->GetExpanded(); });
+}
+
+TEST_F(TestScopeView, TestCategoryExpansion_ThreeCategory_FilledSearchString)
+{
+  MockCategories::Ptr categories = std::make_shared<MockCategories>(3);
+  scope_view_->search_string_ = "Ubuntu";
+
+  scope_->categories.changed.emit(categories);
+  Utils::WaitForTimeoutMSec(500);
+
+  EXPECT_EQ(scope_view_->fake_groups_.size(), 3);
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[1]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[2]->GetExpanded(); });
+}
+
+TEST_F(TestScopeView, TestCategoryExpansion_TwoCategory_OnResultAdded_EmptySearchString)
+{
+  MockCategories::Ptr categories = std::make_shared<MockCategories>(2);
+
+  scope_->categories.changed.emit(categories);
+  Utils::WaitForTimeoutMSec(500);
+
+  EXPECT_EQ(scope_view_->fake_groups_.size(), 2);
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[1]->GetExpanded(); });
+
+  /* XXX: we should emit the signal not call the callback */
+  MockResults added_results(2);
+
+  scope_view_->fake_groups_[0]->SetExpanded(true);
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[1]->GetExpanded(); });
+
+  scope_view_->OnResultAdded(added_results.RowAtIndex(0));
+  Utils::WaitForTimeoutMSec(500);
+
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[1]->GetExpanded(); });
+}
+
+TEST_F(TestScopeView, TestCategoryExpansion_TwoCategory_OnResultAdded_FilledSearchString)
+{
+  MockCategories::Ptr categories = std::make_shared<MockCategories>(2);
+  scope_view_->search_string_ = "Ubuntu";
+
+  scope_->categories.changed.emit(categories);
+  Utils::WaitForTimeoutMSec(500);
+
+  EXPECT_EQ(scope_view_->fake_groups_.size(), 2);
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[1]->GetExpanded(); });
+
+  /* XXX: we should emit the signal not call the callback */
+  MockResults added_results(2);
+
+  scope_view_->fake_groups_[0]->SetExpanded(true);
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[1]->GetExpanded(); });
+
+  scope_view_->OnResultAdded(added_results.RowAtIndex(0));
+  Utils::WaitForTimeoutMSec(500);
+
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[1]->GetExpanded(); });
+}
+
+TEST_F(TestScopeView, TestCategoryExpansion_ThreeCategory_OnResultAdded_EmptySearchString)
+{
+  MockCategories::Ptr categories = std::make_shared<MockCategories>(3);
+
+  scope_->categories.changed.emit(categories);
+  Utils::WaitForTimeoutMSec(500);
+
+  EXPECT_EQ(scope_view_->fake_groups_.size(), 3);
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[1]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[2]->GetExpanded(); });
+
+  /* XXX: we should emit the signal not call the callback */
+  MockResults added_results(2);
+  scope_view_->OnResultAdded(added_results.RowAtIndex(0));
+  Utils::WaitForTimeoutMSec(500);
+
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[1]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[2]->GetExpanded(); });
+
+  scope_view_->fake_groups_[0]->SetExpanded(true);
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[1]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[2]->GetExpanded(); });
+
+  scope_view_->OnResultAdded(added_results.RowAtIndex(1));
+  Utils::WaitForTimeoutMSec(500);
+
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[1]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[2]->GetExpanded(); });
+}
+
+TEST_F(TestScopeView, TestCategoryExpansion_ThreeCategory_OnResultAdded_FilledSearchString)
+{
+  MockCategories::Ptr categories = std::make_shared<MockCategories>(3);
+  scope_view_->search_string_ = "Ubuntu";
+
+  scope_->categories.changed.emit(categories);
+  Utils::WaitForTimeoutMSec(500);
+
+  EXPECT_EQ(scope_view_->fake_groups_.size(), 3);
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[1]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[2]->GetExpanded(); });
+
+  /* XXX: we should emit the signal not call the callback */
+  MockResults added_results(2);
+  scope_view_->OnResultAdded(added_results.RowAtIndex(0));
+  Utils::WaitForTimeoutMSec(500);
+
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[1]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[2]->GetExpanded(); });
+
+  scope_view_->fake_groups_[0]->SetExpanded(true);
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[1]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[2]->GetExpanded(); });
+
+  scope_view_->OnResultAdded(added_results.RowAtIndex(1));
+  Utils::WaitForTimeoutMSec(500);
+
+  Utils::WaitUntil([this] () { return scope_view_->fake_groups_[0]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[1]->GetExpanded(); });
+  Utils::WaitUntil([this] () { return not scope_view_->fake_groups_[2]->GetExpanded(); });
 }
 
 }