Merge lp:~larryprice/libertine-scope/libertine-store-create-container into lp:~larryprice/libertine-scope/libertine-store-search

[Larry Price]

Warn user on data usage before container creation.

Warn user on data usage before container creation.

If the "palatine" container does not exist, present user with a special icon for creating the container. This takes the user to a special preview with a short warning message and the option to create the container.

I ended up changing some namespacing things here as I started running into collisions.

Unmerged revisions

113. By Larry Price on 2016-10-05

further specify namespace for store scope

112. By Larry Price on 2016-10-05

Tests for new code

111. By Larry Price on 2016-10-05

Fix old tests

110. By Larry Price on 2016-10-05

Progress bar on create

109. By Larry Price on 2016-10-05

Special preview pane for creating the palatine container

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-09-23 14:36:02 +0000
+++ CMakeLists.txt	2016-10-05 19:26:10 +0000
@@ -65,8 +65,10 @@
 # Important project paths
 if (CLICK_MODE)
   set(SCOPE_INSTALL_DIR "/libertine-scope")
+  set(STORE_INSTALL_DIR "/libertine-store")
 else()
   set(SCOPE_INSTALL_DIR ${CMAKE_INSTALL_FULL_LIBDIR}/unity-scopes/libertine-scope/)
+  set(STORE_INSTALL_DIR ${CMAKE_INSTALL_FULL_LIBDIR}/unity-scopes/libertine-store/)
 endif(CLICK_MODE)
 
 set(SCOPE_NAME "libertine-scope")
 
=== modified file 'data/CMakeLists.txt'
--- data/CMakeLists.txt	2016-08-30 21:11:50 +0000
+++ data/CMakeLists.txt	2016-10-05 19:26:10 +0000
@@ -1,5 +1,6 @@
 # Copy data files into apps scope dir for dev
 file(COPY store.svg blacklist DESTINATION ${CMAKE_BINARY_DIR}/scope/apps/)
+file(COPY store.svg DESTINATION ${CMAKE_BINARY_DIR}/scope/store/)
 
 install(FILES apps.png apps.svg
         DESTINATION ${APPS_DATA_DIR})
@@ -7,5 +8,8 @@
 install(FILES blacklist store.svg
         DESTINATION ${SCOPE_INSTALL_DIR})
 
+install(FILES store.svg
+        DESTINATION ${STORE_INSTALL_DIR})
+
 install(FILES com.canonical.libertine.ContainerManager.service
         DESTINATION ${CMAKE_INSTALL_DATADIR}/dbus-1/services)
 
=== modified file 'lib/libertine-scope/CMakeLists.txt'
--- lib/libertine-scope/CMakeLists.txt	2016-08-24 16:21:47 +0000
+++ lib/libertine-scope/CMakeLists.txt	2016-10-05 19:26:10 +0000
@@ -5,6 +5,7 @@
   preview.cpp
   service_manager.cpp
   package.cpp
+  container.cpp
   action.cpp
 )
 
 
=== modified file 'lib/libertine-scope/action.h'
--- lib/libertine-scope/action.h	2016-09-20 20:09:51 +0000
+++ lib/libertine-scope/action.h	2016-10-05 19:26:10 +0000
@@ -38,7 +38,7 @@
 
   virtual unity::scopes::ActivationResponse activate() override;
 
-private:
+protected:
   std::string action_id_;
   std::shared_ptr<ServiceManager> service_;
 };
 
=== added file 'lib/libertine-scope/container.cpp'
--- lib/libertine-scope/container.cpp	1970-01-01 00:00:00 +0000
+++ lib/libertine-scope/container.cpp	2016-10-05 19:26:10 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2016 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/>.
+ */
+#include "libertine-scope/container.h"
+
+
+namespace
+{
+libertine::scope::Container::ContainerStatus string_to_status(QString const& status)
+{
+  if (status == "ready")
+  {
+    return libertine::scope::Container::ContainerStatus::ready;
+  }
+  else if (status == "installing")
+  {
+    return libertine::scope::Container::ContainerStatus::installing;
+  }
+  else if (status == "removing")
+  {
+    return libertine::scope::Container::ContainerStatus::removing;
+  }
+
+  return libertine::scope::Container::ContainerStatus::none;
+}
+}
+
+
+libertine::scope::Container libertine::scope::Container::
+from_map(QVariantMap const& pkgMap)
+{
+  Container container;
+  container.id = pkgMap["id"].toString().toStdString();
+  container.progress = pkgMap["progress_id"].toString().toStdString();
+  container.status = string_to_status(pkgMap["status"].toString());
+
+  return container;
+}
 
=== added file 'lib/libertine-scope/container.h'
--- lib/libertine-scope/container.h	1970-01-01 00:00:00 +0000
+++ lib/libertine-scope/container.h	2016-10-05 19:26:10 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2016 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/>.
+ */
+#pragma once
+
+#include <QVariant>
+
+
+namespace libertine
+{
+namespace scope
+{
+
+
+class Container
+{
+public:
+  explicit Container() = default;
+  virtual ~Container() = default;
+
+  static Container from_map(QVariantMap const&);
+
+  enum class ContainerStatus {ready, installing, removing, none};
+
+  std::string id;
+  ContainerStatus status;
+  std::string progress;
+};
+
+
+} // Store
+} // Libertine
 
=== modified file 'lib/libertine-scope/preview.cpp'
--- lib/libertine-scope/preview.cpp	2016-09-23 14:19:44 +0000
+++ lib/libertine-scope/preview.cpp	2016-10-05 19:26:10 +0000
@@ -18,8 +18,8 @@
 
 #include "libertine-scope/i18n.h"
 #include "libertine-scope/service_manager.h"
-#include <future>
 #include <QDebug>
+#include <thread>
 #include <unity/UnityExceptions.h>
 #include <unity/scopes/ColumnLayout.h>
 #include <unity/scopes/PreviewReply.h>
@@ -164,7 +164,7 @@
   if (app.status == "installing" || app.status == "removing") {
     thread_.reset(new std::thread([=](){
       std::this_thread::sleep_for(update_progress_after);
-      service_->update_progress(QString::fromStdString(app.id));
+      service_->update_progress(QString::fromStdString(app.progress));
     }));
   }
 }
 
=== modified file 'lib/libertine-scope/service_manager.cpp'
--- lib/libertine-scope/service_manager.cpp	2016-09-20 17:56:18 +0000
+++ lib/libertine-scope/service_manager.cpp	2016-10-05 19:26:10 +0000
@@ -26,6 +26,9 @@
 constexpr auto INSTALL_METHOD = "install";
 constexpr auto REMOVE_METHOD = "remove";
 constexpr auto UPDATE_PROGRESS_METHOD = "update_progress";
+constexpr auto CONTAINER_INFO_METHOD = "container_info";
+constexpr auto CONTAINER_PROGRESS_METHOD = "container_progress";
+constexpr auto CREATE_METHOD = "create_container";
 constexpr auto LIBERTINE_SERVICE_DESTINATION = "com.canonical.libertine.ContainerManager";
 constexpr auto LIBERTINE_SERVICE_INTERFACE = "com.canonical.libertine.ContainerManager";
 constexpr auto LIBERTINE_SERVICE_OBJECT = "/Manager";
@@ -39,6 +42,20 @@
 }
 
 
+QList<libertine::scope::Package> libertine::scope::ServiceManager::
+search_cache(const QString &query) const
+{
+  return Package::from_map(call<QList<QVariantMap > >(SEARCH_CACHE_METHOD, QVariant(query)));
+}
+
+
+libertine::scope::Package libertine::scope::ServiceManager::
+app_info(const QString &app_id) const
+{
+  return Package::from_map(call<QVariantMap >(APP_INFO_METHOD, QVariant(app_id)));
+}
+
+
 void libertine::scope::ServiceManager::
 install(QString const& package_name) const
 {
@@ -53,10 +70,10 @@
 }
 
 
-libertine::scope::Package libertine::scope::ServiceManager::
-app_info(const QString &app_id) const
+void libertine::scope::ServiceManager::
+create(QString const& container_id) const
 {
-  return Package::from_map(call<QVariantMap >(APP_INFO_METHOD, QVariant(app_id)));
+  call<qlonglong>(CREATE_METHOD, QVariant(container_id));
 }
 
 
@@ -67,10 +84,10 @@
 }
 
 
-QList<libertine::scope::Package> libertine::scope::ServiceManager::
-search_cache(const QString &query) const
+libertine::scope::Container libertine::scope::ServiceManager::
+container_info(const QString &container_id) const
 {
-  return Package::from_map(call<QList<QVariantMap > >(SEARCH_CACHE_METHOD, QVariant(query)));
+  return Container::from_map(call<QVariantMap >(CONTAINER_INFO_METHOD, QVariant(container_id)));
 }
 
 
 
=== modified file 'lib/libertine-scope/service_manager.h'
--- lib/libertine-scope/service_manager.h	2016-09-20 17:56:18 +0000
+++ lib/libertine-scope/service_manager.h	2016-10-05 19:26:10 +0000
@@ -16,6 +16,7 @@
 #pragma once
 
 #include "libertine-scope/package.h"
+#include "libertine-scope/container.h"
 
 #include <QString>
 #include <QVariant>
@@ -38,6 +39,8 @@
   virtual void install(QString const& package_name) const;
   virtual void remove(QString const& package_name) const;
   virtual void update_progress(QString const& package_name) const;
+  virtual Container container_info(QString const& container_id) const;
+  virtual void create(QString const& container_id) const;
 
 private:
   bool valid() const;
 
=== modified file 'scope/apps/action.cpp'
--- scope/apps/action.cpp	2016-09-20 20:09:51 +0000
+++ scope/apps/action.cpp	2016-10-05 19:26:10 +0000
@@ -46,7 +46,6 @@
        std::shared_ptr<HiddenApps> const&                       hidden,
        unity::scopes::FilterState const&                        filter_state)
   : libertine::scope::Action(result, metadata, action_id, service)
-  , action_id_(action_id)
   , hidden_(hidden)
   , filter_state_(filter_state)
 {
 
=== modified file 'scope/apps/action.h'
--- scope/apps/action.h	2016-09-20 20:09:51 +0000
+++ scope/apps/action.h	2016-10-05 19:26:10 +0000
@@ -43,7 +43,6 @@
   virtual unity::scopes::ActivationResponse activate() override;
 
 private:
-  std::string action_id_;
   std::string cache_dir_;
   std::shared_ptr<HiddenApps> hidden_;
   unity::scopes::FilterState filter_state_;
 
=== added file 'scope/store/action.cpp'
--- scope/store/action.cpp	1970-01-01 00:00:00 +0000
+++ scope/store/action.cpp	2016-10-05 19:26:10 +0000
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2016 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/>.
+ */
+
+#include "scope/store/action.h"
+#include <libertine-scope/service_manager.h>
+#include <unity/scopes/CannedQuery.h>
+#include <QString>
+
+
+libertine::scope::store::Action::
+Action(unity::scopes::Result const&                        result,
+       unity::scopes::ActionMetadata const&                     metadata,
+       std::string const&                                       action_id,
+       std::shared_ptr<libertine::scope::ServiceManager> const& service)
+  : ::libertine::scope::Action(result, metadata, action_id, service)
+{
+}
+
+
+unity::scopes::ActivationResponse libertine::scope::store::Action::
+activate()
+{
+  if (action_id_ == "create")
+  {
+    service_->create("palatine");
+    return unity::scopes::ActivationResponse(unity::scopes::ActivationResponse::Status::ShowPreview);
+  }
+
+  return ::libertine::scope::Action::activate();
+}
 
=== added file 'scope/store/action.h'
--- scope/store/action.h	1970-01-01 00:00:00 +0000
+++ scope/store/action.h	2016-10-05 19:26:10 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2016 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/>.
+ */
+#pragma once
+
+
+#include <libertine-scope/action.h>
+#include <unity/scopes/ActionMetadata.h>
+#include <unity/scopes/ActivationResponse.h>
+#include <unity/scopes/Result.h>
+
+
+namespace libertine
+{
+namespace scope
+{
+namespace store
+{
+class Action : public ::libertine::scope::Action
+{
+public:
+  explicit
+  Action(unity::scopes::Result const&                             result,
+         unity::scopes::ActionMetadata const&                     metadata,
+         std::string const&                                       action_id,
+         std::shared_ptr<libertine::scope::ServiceManager> const& service);
+
+  virtual
+  ~Action() = default;
+
+  virtual
+  unity::scopes::ActivationResponse activate() override;
+};
+} // namespace store
+} // namespace scope
+} // namespace libertine
 
=== added file 'scope/store/create_preview.cpp'
--- scope/store/create_preview.cpp	1970-01-01 00:00:00 +0000
+++ scope/store/create_preview.cpp	2016-10-05 19:26:10 +0000
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2016 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/>.
+ */
+#include "scope/store/create_preview.h"
+
+#include "libertine-scope/i18n.h"
+#include "libertine-scope/service_manager.h"
+#include <thread>
+#include <unity/scopes/PreviewReply.h>
+#include <unity/scopes/PreviewWidget.h>
+#include <unity/scopes/VariantBuilder.h>
+
+
+namespace
+{
+static unity::scopes::PreviewWidget
+warning()
+{
+  unity::scopes::PreviewWidget warning("warning", "text");
+  warning.add_attribute_value("title", unity::scopes::Variant(_("Initializing this scope may consume up to 500MB of data and could take several minutes.")));
+  return warning;
+}
+}
+
+
+std::chrono::milliseconds libertine::scope::store::CreatePreview::
+update_progress_after = std::chrono::milliseconds(500);
+
+
+libertine::scope::store::CreatePreview::
+CreatePreview(unity::scopes::Result const&           result,
+              unity::scopes::ActionMetadata const&   metadata,
+              std::shared_ptr<ServiceManager> const& service)
+: PreviewQueryBase(result, metadata)
+, service_(service)
+, thread_()
+{
+}
+
+
+libertine::scope::store::CreatePreview::
+~CreatePreview()
+{
+    if (thread_ != nullptr)
+    {
+      thread_->join();
+    }
+}
+
+
+void libertine::scope::store::CreatePreview::
+cancelled()
+{
+}
+
+
+void libertine::scope::store::CreatePreview::
+run(unity::scopes::PreviewReplyProxy const& reply)
+{
+  auto info = service_->container_info("palatine");
+
+  unity::scopes::PreviewWidgetList widgets;
+
+  if (info.status == Container::ContainerStatus::none)
+  {
+    widgets.push_back(warning());
+    unity::scopes::VariantBuilder builder;
+    builder.add_tuple(
+        {
+            {"id", unity::scopes::Variant("create")},
+            {"label", unity::scopes::Variant(_("Start"))},
+        });
+    unity::scopes::PreviewWidget start("actions", "actions");
+    start.add_attribute_value("actions", builder.end());
+    widgets.push_back(start);
+  }
+  else if (info.status != Container::ContainerStatus::ready)
+  {
+    widgets.push_back(warning());
+    unity::scopes::PreviewWidget progress("actions", "progress");
+    unity::scopes::VariantMap tuple;
+    tuple["dbus-name"] = "com.canonical.libertine.ContainerManager";
+    tuple["dbus-object"] = std::string("/Progress/") + info.progress;
+    progress.add_attribute_value("source", unity::scopes::Variant(tuple));
+    widgets.push_back(progress);
+
+    // update the progress bar asynchronously
+    thread_.reset(new std::thread([=](){
+      std::this_thread::sleep_for(update_progress_after);
+      service_->update_progress(QString::fromStdString(info.progress));
+    }));
+  }
+  else
+  {
+    unity::scopes::PreviewWidget info("info", "text");
+    info.add_attribute_value("title", unity::scopes::Variant(_("Scope is ready.")));
+    widgets.push_back(info);
+  }
+
+  reply->push(widgets);
+}
 
=== added file 'scope/store/create_preview.h'
--- scope/store/create_preview.h	1970-01-01 00:00:00 +0000
+++ scope/store/create_preview.h	2016-10-05 19:26:10 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2016 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/>.
+ */
+#pragma once
+
+#include <chrono>
+#include <unity/scopes/PreviewQueryBase.h>
+
+
+namespace std
+{
+class thread;
+}
+
+
+namespace libertine
+{
+namespace scope
+{
+class ServiceManager;
+
+namespace store
+{
+
+class CreatePreview
+: public unity::scopes::PreviewQueryBase
+{
+public:
+  explicit
+  CreatePreview(unity::scopes::Result const&           result,
+          unity::scopes::ActionMetadata const&   metadata,
+          std::shared_ptr<ServiceManager> const& service);
+
+  virtual
+  ~CreatePreview();
+
+  virtual void
+  cancelled() override;
+
+  virtual void
+  run(unity::scopes::PreviewReplyProxy const& reply) override;
+
+  static
+  std::chrono::milliseconds update_progress_after;
+
+private:
+  std::shared_ptr<ServiceManager> service_;
+  std::unique_ptr<std::thread> thread_;
+};
+
+} // namespace store
+} // namespace scope
+} // namespace libertine
 
=== modified file 'scope/store/entry_point.cpp'
--- scope/store/entry_point.cpp	2016-08-24 19:18:32 +0000
+++ scope/store/entry_point.cpp	2016-10-05 19:26:10 +0000
@@ -29,7 +29,7 @@
 EXPORT unity::scopes::ScopeBase*
 UNITY_SCOPE_CREATE_FUNCTION()
 {
-  return new libertine::scope::Scope();
+  return new libertine::scope::store::Scope();
 }
 
 
 
=== modified file 'scope/store/query.cpp'
--- scope/store/query.cpp	2016-09-15 18:55:23 +0000
+++ scope/store/query.cpp	2016-10-05 19:26:10 +0000
@@ -65,33 +65,56 @@
 )";
 
 
+static const auto CATEGORY_CREATE = R"(
+    {
+      "schema-version": 1,
+      "template": {
+        "category-layout": "grid",
+        "overlay": true,
+        "card-background": "color:///#E95420"
+      },
+      "components": {
+        "title": "title",
+        "art": {
+          "aspect-ratio": 0.55,
+          "field": "art"
+        },
+        "overlay-color": "overlay-color"
+      }
+    }
+)";
+
+
 static auto const SINGLE_RESULT_FOUND = _("%1 result found");
 static auto const MULTIPLE_RESULTS_FOUND = _("%1 results found");
 static QString const APPID_URI_FORMAT = "appid://palatine/%1/0.0";
 }
 
 
-std::string const libertine::scope::Query::USE_SEARCH_HINT = _("Use the searchbar to find software.");
-std::string const libertine::scope::Query::NO_SEARCH_RESULTS_HINT = _("No results found.");
-
-
-libertine::scope::Query::
-Query(usc::CannedQuery                 const&    query,
-      usc::SearchMetadata              const& metadata,
-      std::shared_ptr<ServiceManager>  const& service)
+std::string const libertine::scope::store::Query::USE_SEARCH_HINT = _("Use the searchbar to find software.");
+std::string const libertine::scope::store::Query::NO_SEARCH_RESULTS_HINT = _("No results found.");
+std::string const libertine::scope::store::Query::CREATE_CATEGORY_TITLE = _("Get started");
+
+
+libertine::scope::store::Query::
+Query(usc::CannedQuery const&                query,
+      usc::SearchMetadata const&             metadata,
+      std::shared_ptr<ServiceManager> const& service,
+      std::string const &                    data_directory)
   : usc::SearchQueryBase(query, metadata)
   , service_(service)
+  , data_directory_(data_directory)
 {
 }
 
 
-void libertine::scope::Query::
+void libertine::scope::store::Query::
 cancelled()
 {
 }
 
 
-void libertine::scope::Query::
+void libertine::scope::store::Query::
 show_hint(usc::SearchReplyProxy const& reply,
           std::string const&           reason) const
 {
@@ -103,7 +126,21 @@
 }
 
 
-void libertine::scope::Query::
+void libertine::scope::store::Query::
+add_create_category(usc::SearchReplyProxy const& reply) const
+{
+  auto cat = reply->register_category("create", "", "", usc::CategoryRenderer(CATEGORY_CREATE));
+  usc::CategorisedResult res(cat);
+  res.set_title(CREATE_CATEGORY_TITLE);
+  res.set_art(data_directory_ + "/store.svg");
+  res.set_uri("libertine-store://create");
+  res["overlay-color"] = "transparent";
+  res["show_create_preview"] = true;
+  reply->push(res);
+}
+
+
+void libertine::scope::store::Query::
 run_search(usc::SearchReplyProxy const& reply) const
 {
   auto results = service_->search_cache(QString::fromStdString(query().query_string()));
@@ -136,9 +173,16 @@
 }
 
 
-void libertine::scope::Query::
+void libertine::scope::store::Query::
 run(usc::SearchReplyProxy const& reply)
 {
+  auto info = service_->container_info("palatine");
+  if (info.status != Container::ContainerStatus::ready)
+  {
+    add_create_category(reply);
+    return;
+  }
+
   if (!query().query_string().empty())
   {
     run_search(reply);
 
=== modified file 'scope/store/query.h'
--- scope/store/query.h	2016-08-24 19:18:32 +0000
+++ scope/store/query.h	2016-10-05 19:26:10 +0000
@@ -13,23 +13,22 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef LIBERTINE_STORE_QUERY_H_
-#define LIBERTINE_STORE_QUERY_H_
-
+#pragma once
 
 #include <unity/scopes/ReplyProxyFwd.h>
 #include <unity/scopes/SearchQueryBase.h>
-
-class QStringList;
+#include <QString>
 
 
 namespace libertine
 {
 namespace scope
 {
-
 class ServiceManager;
 
+namespace store
+{
+
 /**
  * Engine to run a specific store query.
  */
@@ -37,10 +36,12 @@
     : public unity::scopes::SearchQueryBase
 {
 public:
-  explicit Query(unity::scopes::CannedQuery      const&    query,
-                 unity::scopes::SearchMetadata   const& metadata,
-                 std::shared_ptr<ServiceManager> const& service);
+  explicit Query(unity::scopes::CannedQuery const&      query,
+                 unity::scopes::SearchMetadata const&   metadata,
+                 std::shared_ptr<ServiceManager> const& service,
+                 std::string const&                     data_directory = "");
 
+  virtual
   ~Query() = default;
 
   virtual void
@@ -51,6 +52,7 @@
 
   static std::string const USE_SEARCH_HINT;
   static std::string const NO_SEARCH_RESULTS_HINT;
+  static std::string const CREATE_CATEGORY_TITLE;
 
 private:
   void
@@ -58,13 +60,13 @@
             std::string const&                     reason) const;
   void
   run_search(unity::scopes::SearchReplyProxy const& reply) const;
+  void
+  add_create_category(unity::scopes::SearchReplyProxy const& reply) const;
 
   std::shared_ptr<ServiceManager> service_;
+  const std::string data_directory_;
 };
 
+} // namespace store
 } // namespace scope
 } // namespace libertine
-
-#endif // LIBERTINE_STORE_QUERY_H_
-
-
 
=== modified file 'scope/store/scope.cpp'
--- scope/store/scope.cpp	2016-09-20 17:56:18 +0000
+++ scope/store/scope.cpp	2016-10-05 19:26:10 +0000
@@ -19,6 +19,8 @@
  */
 #include "scope/store/scope.h"
 
+#include "scope/store/action.h"
+#include "scope/store/create_preview.h"
 #include "scope/store/query.h"
 #include <libertine-scope/action.h>
 #include <libertine-scope/i18n.h>
@@ -29,13 +31,13 @@
 namespace usc = unity::scopes;
 
 
-libertine::scope::Scope::
+libertine::scope::store::Scope::
 Scope()
   : service_(std::make_shared<ServiceManager>())
 { }
 
 
-void libertine::scope::Scope::
+void libertine::scope::store::Scope::
 start(std::string const&)
 {
   setlocale(LC_ALL, "");
@@ -45,23 +47,28 @@
 }
 
 
-usc::SearchQueryBase::UPtr libertine::scope::Scope::
+usc::SearchQueryBase::UPtr libertine::scope::store::Scope::
 search(usc::CannedQuery const&    query,
        usc::SearchMetadata const& metadata)
 {
-  return usc::SearchQueryBase::UPtr(new Query(query, metadata, service_));
+  return usc::SearchQueryBase::UPtr(new Query(query, metadata, service_, scope_directory()));
 }
 
 
-usc::PreviewQueryBase::UPtr libertine::scope::Scope::
+usc::PreviewQueryBase::UPtr libertine::scope::store::Scope::
 preview(usc::Result const&         result,
         usc::ActionMetadata const& metadata)
 {
+  if (result.contains("show_create_preview") && result["show_create_preview"].get_bool())
+  {
+    return usc::PreviewQueryBase::UPtr(new CreatePreview(result, metadata, service_));
+  }
+
   return usc::PreviewQueryBase::UPtr(new Preview(result, metadata, service_));
 }
 
 
-usc::ActivationQueryBase::UPtr libertine::scope::Scope::
+usc::ActivationQueryBase::UPtr libertine::scope::store::Scope::
 perform_action(usc::Result const&         result,
                usc::ActionMetadata const& metadata,
                std::string const&         /* widget_id */,
@@ -72,4 +79,3 @@
                                                    action_id,
                                                    service_));
 }
-
 
=== modified file 'scope/store/scope.h'
--- scope/store/scope.h	2016-09-20 17:56:18 +0000
+++ scope/store/scope.h	2016-10-05 19:26:10 +0000
@@ -17,8 +17,7 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef LIBERTINE_STORE_SCOPE_H_
-#define LIBERTINE_STORE_SCOPE_H_
+#pragma once
 
 #include <unity/scopes/ScopeBase.h>
 
@@ -26,10 +25,10 @@
 {
 namespace scope
 {
-
 class ServiceManager;
 
-
+namespace store
+{
 class Scope
 : public unity::scopes::ScopeBase
 {
@@ -70,8 +69,6 @@
   std::shared_ptr<ServiceManager> service_;
 };
 
-
+} // namespace store
 } // namespace scope
 } // namespace libertine
-
-#endif /* LIBERTINE_STORE_SCOPE_H_ */
 
=== modified file 'service/libertine_service/container.py'
--- service/libertine_service/container.py	2016-08-22 15:28:57 +0000
+++ service/libertine_service/container.py	2016-10-05 19:26:10 +0000
@@ -56,12 +56,22 @@
         task = tasks.RemoveTask(package_name, container_id, self.libertine_config, progress, self.lock, self.log)
         return task.start()
 
-    def status(self, package_name, container_id):
-        self.log.debug("Checking status of package '%s'" % package_name)
+    def status(self, container, package=''):
+        self.log.debug("Checking status of '%s':'%s'" % (container, package))
         self.libertine_config.refresh_database()
-        if not self._container_exists(container_id):
+        if not self._container_exists(container):
             return ''
-        return self.libertine_config.get_package_install_status(container_id, package_name) or ''
+        if package == '':
+            return self.libertine_config._get_value_by_key(container, 'installStatus')
+        return self.libertine_config.get_package_install_status(container, package) or ''
+
+    def create(self, container_id, progress):
+        self.log.debug("Create container with ID '%s'" % container_id)
+        self.libertine_config.refresh_database()
+        if self._container_exists(container_id):
+            return -1
+        task = tasks.CreateTask(container_id, self.libertine_config, progress, self.lock, self.log)
+        return task.start()
 
     def _container_exists(self, container_id):
         self.log.debug("Checking if container '%s' exists" % container_id)
 
=== modified file 'service/libertine_service/dbus.py'
--- service/libertine_service/dbus.py	2016-09-20 18:30:26 +0000
+++ service/libertine_service/dbus.py	2016-10-05 19:26:10 +0000
@@ -62,7 +62,6 @@
 
 
 class Service(dbus.service.Object):
-
     def __init__(self, config):
         log.debug("creating service")
         DBusGMainLoop(set_as_default=True)
@@ -117,16 +116,37 @@
         log.debug("app_info('{}') called".format(app_id))
         app = self.cache.app_info(app_id)
         if 'package' in app:
-            app['status'] = self.container.status(app['package'], CONTAINER_ID)
+            app['status'] = self.container.status(package=app['package'], container=CONTAINER_ID)
             if app['id'] in self.progress:
                 app['progress_id'] = self.progress[app['id']].id
 
         return app
 
-    @dbus.service.signal(LIBERTINE_STORE_INTERFACE,
-                         signature='su')
-    def updating(self, target, percent):
-        log.debug("emit updating('{}', {})".format(target, percent))
+    @dbus.service.method(LIBERTINE_STORE_INTERFACE,
+                         in_signature='s',
+                         out_signature='a{sv}')
+    def container_info(self, container_id):
+        log.debug("container_info('{}')".format(container_id))
+        info = {"status": self.container.status(container=container_id)}
+        if info['status'] != '':
+            info['id'] = container_id
+            cid = '_%s' % container_id
+            if cid in self.progress:
+                info['progress_id'] = self.progress[cid].id
+
+        return info
+
+    @dbus.service.method(LIBERTINE_STORE_INTERFACE,
+                         in_signature='s',
+                         out_signature='x')
+    def create_container(self, container_id):
+        log.debug("create_container('{}')".format(container_id))
+        container_progress = Progress(self.connection)
+        self.progress["_%s" % container_id] = container_progress
+        retval = self.container.create(container_id, container_progress)
+        if retval <= 0:
+            container_progress.finished('')
+        return retval
 
     # Packaging
 
@@ -155,11 +175,12 @@
     @dbus.service.method(LIBERTINE_STORE_INTERFACE,
                          in_signature='s',
                          out_signature='b')
-    def update_progress(self, app_id):
-        log.debug("update_progress('%s')" % app_id)
+    def update_progress(self, progress_id):
+        log.debug("update_progress('%s')" % progress_id)
         self.cleanup_progress()
-        if app_id in self.progress:
-            self.progress[app_id].emit_progress()
+        progress = [v for k, v in self.progress.items() if v.id == progress_id]
+        if len(progress) == 1:
+            progress[0].emit_progress()
             return True
         return False
 
 
=== modified file 'service/libertine_service/tasks.py'
--- service/libertine_service/tasks.py	2016-09-16 21:35:57 +0000
+++ service/libertine_service/tasks.py	2016-10-05 19:26:10 +0000
@@ -12,13 +12,23 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from subprocess import Popen, PIPE
+import shlex
+from subprocess import Popen, DEVNULL
 from threading import Thread
 from abc import ABCMeta, abstractmethod
 from libertine import LibertineContainer, HostInfo, utils
 from dbus import UInt64
 
 
+def refresh_libertine_store_scope():
+    scopes_object_path = "/com/canonical/unity/scopes"
+    invalidate_signal = "com.canonical.unity.scopes.InvalidateResults"
+    libertine_scope_id = "libertine-scope.ubuntu_libertine-store"
+    gdbus_cmd = ("gdbus emit --session --object-path %s --signal %s %s" %
+                 (scopes_object_path, invalidate_signal, libertine_scope_id))
+    Popen(shlex.split(gdbus_cmd), stdout=DEVNULL, stderr=DEVNULL)
+
+
 class LibertineTask(metaclass=ABCMeta):
     """
     Abstract class for performing long-running, synchronous operations on a
@@ -120,24 +130,29 @@
             self.log.debug("Package '%s' already exists, skipping install" % self.package)
             return False
 
-
-class CreateTask(LibertineTask):
-    def __init__(self, container_id, config, lock, log):
-        super().__init__(lock, log)
-        self.container = container_id
-        self.config = config
+import time
+class CreateTask(ProgressTask):
+    def __init__(self, container_id, config, progress, lock, log):
+        super().__init__("", container_id, config, progress, lock, log)
 
     def _run(self):
         self.log.debug("Creating container '%s'" % self.container)
+        self._progress()
+
         container = LibertineContainer(self.container, self.config)
         if not container.create_libertine_container(password=''):
             self.log.debug("Creating container '%s' failed" % self.container)
             self.config.delete_container(self.container)
             return
+        self._progress()
+
         self.config.update_container_install_status(self.container, "ready")
+        self.progress.finished(self.container)
+        refresh_libertine_store_scope()
 
     def _before(self):
         self.log.debug("CreateTask::_before")
+        self._progress()
         if self.config.container_exists(self.container):
             return False
 
@@ -146,4 +161,5 @@
         self.config.add_new_container(self.container, 'User Applications', info.select_container_type_by_kernel(),
                                       info.get_host_distro_release())
         self.config.update_container_install_status(self.container, 'installing')
+        self._progress()
         return True
 
=== modified file 'tests/lib/libertine-scope/CMakeLists.txt'
--- tests/lib/libertine-scope/CMakeLists.txt	2016-08-24 16:21:47 +0000
+++ tests/lib/libertine-scope/CMakeLists.txt	2016-10-05 19:26:10 +0000
@@ -19,6 +19,7 @@
   add_test(${test_name} ${test_name}_exe)
 endfunction(create_test)
 
+create_test(test_action)
+create_test(test_container)
+create_test(test_package)
 create_test(test_preview)
-create_test(test_package)
-create_test(test_action)
 
=== modified file 'tests/lib/libertine-scope/mock_service_manager.h'
--- tests/lib/libertine-scope/mock_service_manager.h	2016-09-20 17:56:18 +0000
+++ tests/lib/libertine-scope/mock_service_manager.h	2016-10-05 19:26:10 +0000
@@ -40,6 +40,8 @@
   MOCK_CONST_METHOD1(update_progress, void(QString const&));
   MOCK_CONST_METHOD1(install, void(QString const&));
   MOCK_CONST_METHOD1(remove, void(QString const&));
+  MOCK_CONST_METHOD1(container_info, Container(QString const&));
+  MOCK_CONST_METHOD1(create, void(QString const&));
 };
 
 
 
=== modified file 'tests/lib/libertine-scope/test_action.cpp'
--- tests/lib/libertine-scope/test_action.cpp	2016-08-25 12:59:32 +0000
+++ tests/lib/libertine-scope/test_action.cpp	2016-10-05 19:26:10 +0000
@@ -23,7 +23,7 @@
 
 namespace
 {
-TEST(StoreActionTest, CallsInstallOnServiceManager)
+TEST(ActionTest, CallsInstallOnServiceManager)
 {
   unity::scopes::testing::Result result;
   result["id"] = "vim-common";
@@ -39,7 +39,7 @@
 }
 
 
-TEST(StoreActionTest, CallsRemoveOnServiceManager)
+TEST(ActionTest, CallsRemoveOnServiceManager)
 {
   unity::scopes::testing::Result result;
   result["id"] = "gedit";
@@ -55,7 +55,7 @@
 }
 
 
-TEST(StoreActionTest, OpenAllowsDefaultHandlerToRun)
+TEST(ActionTest, OpenAllowsDefaultHandlerToRun)
 {
   unity::scopes::testing::Result result;
   result["id"] = "gedit";
 
=== added file 'tests/lib/libertine-scope/test_container.cpp'
--- tests/lib/libertine-scope/test_container.cpp	1970-01-01 00:00:00 +0000
+++ tests/lib/libertine-scope/test_container.cpp	2016-10-05 19:26:10 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2016 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/>.
+ */
+#include "libertine-scope/container.h"
+
+#include <gmock/gmock.h>
+
+
+namespace
+{
+using namespace libertine::scope;
+
+
+TEST(PackageTest, FromMapCreatesPackage)
+{
+  QVariantMap attributes;
+  attributes["id"] = "foobar";
+  attributes["status"] = "ready";
+  attributes["progress_id"] = "1234321";
+
+  auto container = Container::from_map(attributes);
+  EXPECT_EQ("foobar", container.id);
+  EXPECT_EQ(Container::ContainerStatus::ready, container.status);
+  EXPECT_EQ("1234321", container.progress);
+}
+
+
+TEST(PackageTest, FromMapConvertsStatusStrings)
+{
+  QVariantMap attributes;
+
+  attributes["status"] = "ready";
+  EXPECT_EQ(Container::ContainerStatus::ready, Container::from_map(attributes).status);
+  attributes["status"] = "installing";
+  EXPECT_EQ(Container::ContainerStatus::installing, Container::from_map(attributes).status);
+  attributes["status"] = "removing";
+  EXPECT_EQ(Container::ContainerStatus::removing, Container::from_map(attributes).status);
+  attributes["status"] = "";
+  EXPECT_EQ(Container::ContainerStatus::none, Container::from_map(attributes).status);
+}
+}
 
=== modified file 'tests/lib/libertine-scope/test_preview.cpp'
--- tests/lib/libertine-scope/test_preview.cpp	2016-09-20 17:56:18 +0000
+++ tests/lib/libertine-scope/test_preview.cpp	2016-10-05 19:26:10 +0000
@@ -249,7 +249,7 @@
   package.status = "removing";
   package.progress = "something";
   usePackage(package);
-  EXPECT_CALL(*service, update_progress(QString::fromStdString(package.id)));
+  EXPECT_CALL(*service, update_progress(QString::fromStdString(package.progress)));
 
   std::unique_ptr<Preview> preview(new Preview(result, metadata, service));
   preview->run(proxy);
@@ -273,7 +273,7 @@
   package.status = "installing";
   package.progress = "foobar";
   usePackage(package);
-  EXPECT_CALL(*service, update_progress(QString::fromStdString(package.id)));
+  EXPECT_CALL(*service, update_progress(QString::fromStdString(package.progress)));
 
   std::unique_ptr<Preview> preview(new Preview(result, metadata, service));
   preview->run(proxy);
 
=== modified file 'tests/scope/store/CMakeLists.txt'
--- tests/scope/store/CMakeLists.txt	2016-08-24 16:21:47 +0000
+++ tests/scope/store/CMakeLists.txt	2016-10-05 19:26:10 +0000
@@ -20,4 +20,6 @@
   add_test(${full_test_name} ${full_test_name}_exe)
 endfunction(create_test)
 
+create_test(test_action)
+create_test(test_create_preview)
 create_test(test_query)
 
=== added file 'tests/scope/store/test_action.cpp'
--- tests/scope/store/test_action.cpp	1970-01-01 00:00:00 +0000
+++ tests/scope/store/test_action.cpp	2016-10-05 19:26:10 +0000
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2016 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/>.
+ */
+#include "scope/store/action.h"
+
+#include <gmock/gmock.h>
+#include <tests/lib/libertine-scope/mock_service_manager.h>
+#include <unity/scopes/ActionMetadata.h>
+#include <unity/scopes/testing/Result.h>
+
+
+namespace
+{
+TEST(ActionTest, OpenAllowsDefaultHandlerToRun)
+{
+  unity::scopes::testing::Result result;
+  result.set_uri("app://this/is/my/app");
+  unity::scopes::ActionMetadata metadata("en_US", "phone");
+  auto service = std::make_shared<testing::NiceMock<libertine::scope::MockServiceManager> >();
+
+  libertine::scope::store::Action action(result, metadata, "open", service);
+
+  auto response = action.activate();
+  EXPECT_EQ(unity::scopes::ActivationResponse::Status::NotHandled, response.status());
+}
+
+
+TEST(ActionTest, CallsCreateOnServiceManager)
+{
+  unity::scopes::testing::Result result;
+  unity::scopes::ActionMetadata metadata("en_US", "phone");
+  auto service = std::make_shared<testing::NiceMock<libertine::scope::MockServiceManager> >();
+
+  libertine::scope::store::Action action(result, metadata, "create", service);
+
+  EXPECT_CALL(*service, create(QString("palatine")));
+
+  auto response = action.activate();
+  EXPECT_EQ(unity::scopes::ActivationResponse::Status::ShowPreview, response.status());
+}
+
+
+TEST(ActionTest, CallsInstallOnServiceManager)
+{
+  unity::scopes::testing::Result result;
+  result["id"] = "vim-common";
+  unity::scopes::ActionMetadata metadata("en_US", "phone");
+  auto service = std::make_shared<testing::NiceMock<libertine::scope::MockServiceManager> >();
+
+  libertine::scope::store::Action action(result, metadata, "install", service);
+
+  EXPECT_CALL(*service, install(QString("vim-common")));
+
+  auto response = action.activate();
+  EXPECT_EQ(unity::scopes::ActivationResponse::Status::ShowPreview, response.status());
+}
+
+
+TEST(ActionTest, CallsRemoveOnServiceManager)
+{
+  unity::scopes::testing::Result result;
+  result["id"] = "gedit";
+  unity::scopes::ActionMetadata metadata("en_US", "phone");
+  auto service = std::make_shared<testing::NiceMock<libertine::scope::MockServiceManager> >();
+
+  libertine::scope::store::Action action(result, metadata, "remove", service);
+
+  EXPECT_CALL(*service, remove(QString("gedit")));
+
+  auto response = action.activate();
+  EXPECT_EQ(unity::scopes::ActivationResponse::Status::ShowPreview, response.status());
+}
+}
 
=== added file 'tests/scope/store/test_create_preview.cpp'
--- tests/scope/store/test_create_preview.cpp	1970-01-01 00:00:00 +0000
+++ tests/scope/store/test_create_preview.cpp	2016-10-05 19:26:10 +0000
@@ -0,0 +1,137 @@
+/*
+ * Copyright 2016 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/>.
+ */
+#include "scope/store/create_preview.h"
+
+#include <gtest/gtest.h>
+#include <memory>
+#include <unity/scopes/Variant.h>
+#include <unity/scopes/ActionMetadata.h>
+#include <unity/scopes/testing/Result.h>
+#include <unity/scopes/testing/MockPreviewReply.h>
+#include <unity/scopes/PreviewWidget.h>
+#include <tests/lib/libertine-scope/mock_service_manager.h>
+
+
+namespace
+{
+using namespace libertine::scope::store;
+
+
+class CreatePreviewTest : public testing::Test
+{
+protected:
+  CreatePreviewTest()
+    : testing::Test()
+    , result()
+    , metadata("en_US", "phone")
+    , list(new unity::scopes::PreviewWidgetList())
+    , reply()
+    , proxy(&reply, [](unity::scopes::PreviewReply*) {})
+    , service(new testing::NiceMock<libertine::scope::MockServiceManager>())
+  {
+  }
+
+  virtual void
+  SetUp()
+  {
+    EXPECT_CALL(reply, push(testing::_)).WillOnce(testing::SaveArg<0>(list.get()));
+    CreatePreview::update_progress_after = std::chrono::milliseconds(0);
+  }
+
+  unity::scopes::testing::Result result;
+  unity::scopes::ActionMetadata metadata;
+  std::unique_ptr<unity::scopes::PreviewWidgetList> list;
+  testing::NiceMock<unity::scopes::testing::MockPreviewReply> reply;
+  unity::scopes::PreviewReplyProxy proxy;
+  std::shared_ptr<testing::NiceMock<libertine::scope::MockServiceManager> > service;
+};
+
+
+TEST_F(CreatePreviewTest, ShowsCreateWarningWithInstallButton)
+{
+  ::libertine::scope::Container c;
+  c.status = ::libertine::scope::Container::ContainerStatus::none;
+  EXPECT_CALL(*service, container_info(QString("palatine"))).WillOnce(testing::Return(c));
+
+  CreatePreview preview(result, metadata, service);
+  preview.run(proxy);
+
+  ASSERT_NE(nullptr, list);
+  ASSERT_EQ(2, list->size());
+
+  auto description = list->front();
+  EXPECT_EQ("warning", description.id());
+  EXPECT_EQ("text", description.widget_type());
+  EXPECT_EQ("Initializing this scope may consume up to 500MB of data and could take several minutes.", description.attribute_values()["title"].get_string());
+  list->pop_front();
+
+  auto buttons = list->front();
+  EXPECT_EQ("actions", buttons.id());
+  EXPECT_EQ("actions", buttons.widget_type());
+  auto buttons_actions = buttons.attribute_values()["actions"].get_array();
+  ASSERT_EQ(1, buttons_actions.size());
+  EXPECT_EQ("create", buttons_actions[0].get_dict()["id"].get_string());
+  EXPECT_EQ("Start", buttons_actions[0].get_dict()["label"].get_string());
+}
+
+
+TEST_F(CreatePreviewTest, ShowsCreateWarningWithProgressBar)
+{
+  ::libertine::scope::Container c;
+  c.status = ::libertine::scope::Container::ContainerStatus::installing;
+  c.progress = "12321";
+  EXPECT_CALL(*service, container_info(QString("palatine"))).WillOnce(testing::Return(c));
+  EXPECT_CALL(*service, update_progress(QString::fromStdString(c.progress)));
+
+  CreatePreview preview(result, metadata, service);
+  preview.run(proxy);
+
+  ASSERT_NE(nullptr, list);
+  ASSERT_EQ(2, list->size());
+
+  auto description = list->front();
+  EXPECT_EQ("warning", description.id());
+  EXPECT_EQ("text", description.widget_type());
+  EXPECT_EQ("Initializing this scope may consume up to 500MB of data and could take several minutes.", description.attribute_values()["title"].get_string());
+
+  list->pop_front();
+  auto buttons = list->front();
+  EXPECT_EQ("actions", buttons.id());
+  EXPECT_EQ("progress", buttons.widget_type());
+  auto source = buttons.attribute_values()["source"].get_dict();
+  EXPECT_EQ("com.canonical.libertine.ContainerManager", source["dbus-name"].get_string());
+  EXPECT_EQ(std::string("/Progress/") + c.progress, source["dbus-object"].get_string());
+}
+
+
+TEST_F(CreatePreviewTest, ShowsScopeReadyMessage)
+{
+  ::libertine::scope::Container c;
+  c.status = ::libertine::scope::Container::ContainerStatus::ready;
+  EXPECT_CALL(*service, container_info(QString("palatine"))).WillOnce(testing::Return(c));
+
+  CreatePreview preview(result, metadata, service);
+  preview.run(proxy);
+
+  ASSERT_NE(nullptr, list);
+  ASSERT_EQ(1, list->size());
+
+  auto description = list->front();
+  EXPECT_EQ("info", description.id());
+  EXPECT_EQ("text", description.widget_type());
+  EXPECT_EQ("Scope is ready.", description.attribute_values()["title"].get_string());
+}
+}
 
=== modified file 'tests/scope/store/test_query.cpp'
--- tests/scope/store/test_query.cpp	2016-08-26 14:22:41 +0000
+++ tests/scope/store/test_query.cpp	2016-10-05 19:26:10 +0000
@@ -28,7 +28,7 @@
 
 namespace
 {
-using namespace libertine::scope;
+using namespace libertine::scope::store;
 
 
 class FakeCategory : public unity::scopes::Category
@@ -56,6 +56,13 @@
 }
 
 
+MATCHER(ResultCreateMatch, "")
+{
+  return arg.contains("title") && arg["title"] == unity::scopes::Variant(Query::CREATE_CATEGORY_TITLE) &&
+      arg.contains("show_create_preview") && arg["show_create_preview"].get_bool();
+}
+
+
 class TestStoreQuery : public ::testing::Test
 {
 protected:
@@ -65,13 +72,13 @@
     , reply_()
     , proxy_(&reply_, [](unity::scopes::SearchReply*) {})
     , category_(std::make_shared<FakeCategory>("fake-container", "fake-container", "Application", unity::scopes::CategoryRenderer()))
-    , service_(new testing::NiceMock<MockServiceManager>())
+    , service_(new testing::NiceMock<::libertine::scope::MockServiceManager>())
   {
   }
 
-  Package create_package(std::string const& name, std::string const& summary, std::string const& id)
+  ::libertine::scope::Package create_package(std::string const& name, std::string const& summary, std::string const& id)
   {
-    Package package;
+    ::libertine::scope::Package package;
     package.name = name;
     package.summary = summary;
     package.id = id;
@@ -84,17 +91,25 @@
     EXPECT_CALL(reply_, push(testing::Matcher<unity::scopes::CategorisedResult const&>(ResultPackageMatch(title, subtitle, id)))).WillOnce(testing::Return(result));
   }
 
+  void set_container_ready(::libertine::scope::Container::ContainerStatus status = ::libertine::scope::Container::ContainerStatus::ready)
+  {
+    ::libertine::scope::Container info;
+    info.status = status;
+    EXPECT_CALL(*service_, container_info(QString("palatine"))).WillOnce(testing::Return(info));
+  }
+
   unity::scopes::SearchMetadata metadata_;
   unity::scopes::CannedQuery canned_query_;
   testing::NiceMock<unity::scopes::testing::MockSearchReply> reply_;
   unity::scopes::SearchReplyProxy proxy_;
   std::shared_ptr<FakeCategory> category_;
-  std::shared_ptr<testing::NiceMock<MockServiceManager>> service_;
+  std::shared_ptr<testing::NiceMock<::libertine::scope::MockServiceManager>> service_;
 };
 
 
 TEST_F(TestStoreQuery, ShowsSearchHintOnEmptyQuery)
 {
+  set_container_ready();
   EXPECT_CALL(reply_, register_category("hint", "", "", testing::_)).WillOnce(testing::Return(category_));
   EXPECT_CALL(reply_, push(testing::Matcher<unity::scopes::CategorisedResult const&>(ResultTitleMatch(Query::USE_SEARCH_HINT)))).WillOnce(testing::Return(true));
 
@@ -105,9 +120,10 @@
 
 TEST_F(TestStoreQuery, ShowsNoResultsHintOnQueryWithNoResults)
 {
+  set_container_ready();
   EXPECT_CALL(reply_, register_category("hint", "", "", testing::_)).WillOnce(testing::Return(category_));
   EXPECT_CALL(reply_, push(testing::Matcher<unity::scopes::CategorisedResult const&>(ResultTitleMatch(Query::NO_SEARCH_RESULTS_HINT)))).WillOnce(testing::Return(true));
-  EXPECT_CALL(*service_, search_cache(testing::_)).WillOnce(testing::Return(QList<Package>{}));
+  EXPECT_CALL(*service_, search_cache(testing::_)).WillOnce(testing::Return(QList<::libertine::scope::Package>{}));
   canned_query_.set_query_string("foobar");
 
   Query q(canned_query_, metadata_, service_);
@@ -117,12 +133,13 @@
 
 TEST_F(TestStoreQuery, ShowSingleSearchResult)
 {
+  set_container_ready();
   EXPECT_CALL(reply_, register_category("aptcache", "1 result found", "Application", testing::_)).WillOnce(testing::Return(category_));
 
   auto package = create_package("vim", "Writin' stuff", "vim.desktop");
   expect_push("vim", "Writin' stuff", "vim.desktop");
 
-  EXPECT_CALL(*service_, search_cache(testing::_)).WillOnce(testing::Return(QList<Package>{package}));
+  EXPECT_CALL(*service_, search_cache(testing::_)).WillOnce(testing::Return(QList<::libertine::scope::Package>{package}));
   canned_query_.set_query_string("vim");
 
   Query q(canned_query_, metadata_, service_);
@@ -132,6 +149,7 @@
 
 TEST_F(TestStoreQuery, ShowMultipleSearchResults)
 {
+  set_container_ready();
   EXPECT_CALL(reply_, register_category("aptcache", "3 results found", "Application", testing::_)).WillOnce(testing::Return(category_));
 
   auto vim = create_package("vim", "Writin' stuff", "vim.desktop");
@@ -142,7 +160,7 @@
   expect_push("gedit", "Writin' gui stuff", "gedit.desktop");
   expect_push("ed", "Writin' simple stuff", "ed.desktop");
 
-  EXPECT_CALL(*service_, search_cache(testing::_)).WillOnce(testing::Return(QList<Package>{vim, gedit, ed}));
+  EXPECT_CALL(*service_, search_cache(testing::_)).WillOnce(testing::Return(QList<::libertine::scope::Package>{vim, gedit, ed}));
   canned_query_.set_query_string("vim");
 
   Query q(canned_query_, metadata_, service_);
@@ -152,6 +170,7 @@
 
 TEST_F(TestStoreQuery, FailureToPushEndsQueryPrematurely)
 {
+  set_container_ready();
   EXPECT_CALL(reply_, register_category("aptcache", "3 results found", "Application", testing::_)).WillOnce(testing::Return(category_));
 
   auto vim = create_package("vim", "Writin' stuff", "vim.desktop");
@@ -161,10 +180,21 @@
   expect_push("vim", "Writin' stuff", "vim.desktop");
   expect_push("gedit", "Writin' gui stuff", "gedit.desktop", false);
 
-  EXPECT_CALL(*service_, search_cache(testing::_)).WillOnce(testing::Return(QList<Package>{vim, gedit, ed}));
+  EXPECT_CALL(*service_, search_cache(testing::_)).WillOnce(testing::Return(QList<::libertine::scope::Package>{vim, gedit, ed}));
   canned_query_.set_query_string("vim");
 
   Query q(canned_query_, metadata_, service_);
   q.run(proxy_);
 }
+
+
+TEST_F(TestStoreQuery, ShowsCreateCategoryWhenContainerDoesNotExist)
+{
+  set_container_ready(::libertine::scope::Container::ContainerStatus::none);
+  EXPECT_CALL(reply_, register_category("create", "", "", testing::_)).WillOnce(testing::Return(category_));
+  EXPECT_CALL(reply_, push(testing::Matcher<unity::scopes::CategorisedResult const&>(ResultCreateMatch()))).WillOnce(testing::Return(true));
+
+  Query q(canned_query_, metadata_, service_);
+  q.run(proxy_);
+}
 }