Merge lp:~unity-team/unity-scope-mediascanner/vimeo-youtube-soundcloud-rtm into lp:unity-scope-mediascanner/rtm-14.09

[Paweł Stołowski]

Cherry-picked support for aggregation of results from youtube, vimeo and soundcloud n Music/Videos.

Cherry-picked support for aggregation of results from youtube, vimeo and soundcloud n Music/Videos.

[Marcus Tomlinson (marcustomlinson)]

Looks good to me. Thanks for putting this together

review: Approve

[Xavi Garcia (xavi-garcia-mena)]

Looks good to me, thanks.

review: Approve

=== modified file 'src/musicaggregator/musicaggregator-settings.ini.in'
--- src/musicaggregator/musicaggregator-settings.ini.in	2014-10-07 11:20:33 +0000
+++ src/musicaggregator/musicaggregator-settings.ini.in	2014-11-17 11:41:23 +0000
@@ -12,3 +12,8 @@
 type=boolean
 defaultValue=true
 _displayName=Display results from Grooveshark
+
+[com.ubuntu.scopes.soundcloud_soundcloud]
+type=boolean
+defaultValue=true
+_displayName=Display results from SoundCloud

=== modified file 'src/musicaggregator/musicaggregatorquery.cpp'
--- src/musicaggregator/musicaggregatorquery.cpp	2014-11-17 11:41:22 +0000
+++ src/musicaggregator/musicaggregatorquery.cpp	2014-11-17 11:41:23 +0000
@@ -135,6 +135,48 @@
 }
 )";
 
+static const char SOUNDCLOUD_CATEGORY_DEFINITION[] = R"(
+{
+  "schema-version": 1,
+  "template": {
+    "category-layout": "grid",
+    "card-size": "large",
+    "overlay": true,
+    "card-background": "color:///#000000"
+  },
+  "components": {
+    "title": "title",
+    "art" : {
+      "field": "waveform",
+      "aspect-ratio": 4.0
+    },
+    "subtitle": "username",
+    "mascot": "art",
+    "attributes": {
+      "field": "attributes",
+      "max-count": 3
+    }
+  }
+}
+)";
+
+static const char SOUNDCLOUD_SEARCH_CATEGORY_DEFINITION[] = R"(
+{
+  "schema-version": 1,
+  "template": {
+    "category-layout": "grid",
+    "card-size": "large",
+    "card-layout": "horizontal"
+  },
+  "components": {
+    "title": "title",
+    "mascot":  "art",
+    "subtitle": "address",
+    "attributes": "attributes"
+  }
+}
+)";
+
 static const char SONGKICK_CATEGORY_DEFINITION[] = R"(
 {
   "schema-version": 1,
@@ -168,6 +210,43 @@
 }
 )";
 
+static char YOUTUBE_SURFACING_CATEGORY_DEFINITION[] = R"(
+{
+  "schema-version": 1,
+  "template": {
+    "category-layout": "grid",
+    "card-size": "medium"
+  },
+  "components": {
+    "title": "title",
+    "subtitle": "subtitle",
+    "art":  {
+      "field": "art",
+      "aspect-ratio": 1.5
+    }
+  }
+}
+)";
+
+static char YOUTUBE_SEARCH_CATEGORY_DEFINITION[] = R"(
+{
+  "schema-version": 1,
+  "template": {
+    "category-layout": "grid",
+    "card-size": "medium",
+    "card-layout": "horizontal"
+  },
+  "components": {
+    "title": "title",
+    "subtitle": "subtitle",
+    "art":  {
+      "field": "art",
+      "aspect-ratio": 1.5
+    }
+  }
+}
+)";
+
 const std::string MusicAggregatorQuery::grooveshark_songs_category_id = "cat_0";
 
 MusicAggregatorQuery::MusicAggregatorQuery(CannedQuery const& query, SearchMetadata const& hints,
@@ -175,14 +254,16 @@
         ScopeProxy const& grooveshark_scope,
         ScopeProxy const& soundcloud_scope,
         ScopeProxy const& sevendigital_scope,
-        ScopeProxy const& songkick_scope
+        ScopeProxy const& songkick_scope,
+        ScopeProxy const& youtube_scope
         ) :
     SearchQueryBase(query, hints),
     local_scope(local_scope),
     grooveshark_scope(grooveshark_scope),
     soundcloud_scope(soundcloud_scope),
     sevendigital_scope(sevendigital_scope),
-    songkick_scope(songkick_scope)
+    songkick_scope(songkick_scope),
+    youtube_scope(youtube_scope)
 {
 }
 
@@ -196,11 +277,14 @@
 {
     std::vector<std::shared_ptr<ResultForwarder>> replies;
     std::vector<unity::scopes::ScopeProxy> scopes({local_scope});
+    const std::string department_id = "aggregated:musicaggregator";
 
     const CannedQuery mymusic_query(MusicAggregatorScope::LOCALSCOPE, query().query_string(), "");
     const CannedQuery sevendigital_query(MusicAggregatorScope::SEVENDIGITAL, query().query_string(), "newreleases");
+    const CannedQuery soundcloud_query(MusicAggregatorScope::SOUNDCLOUD, query().query_string(), "");
     const CannedQuery songkick_query(MusicAggregatorScope::SONGKICK, query().query_string(), "");
     const CannedQuery grooveshark_query(MusicAggregatorScope::GROOVESHARKSCOPE, query().query_string(), "");
+    const CannedQuery youtube_query(MusicAggregatorScope::YOUTUBE, query().query_string(), department_id);
 
     const bool empty_search = query().query_string().empty();
 
@@ -212,12 +296,19 @@
     auto sevendigital_cat = empty_search ? parent_reply->register_category("7digital", _("New albums from 7digital"), "",
             sevendigital_query, CategoryRenderer(SEVENDIGITAL_CATEGORY_DEFINITION))
         : parent_reply->register_category("7digital", _("7digital"), "", CategoryRenderer(SEVENDIGITAL_SEARCH_CATEGORY_DEFINITION));
+    auto soundcloud_cat = empty_search ? parent_reply->register_category("soundcloud", _("Popular tracks on SoundCloud"), "",
+            soundcloud_query, CategoryRenderer(SOUNDCLOUD_CATEGORY_DEFINITION))
+        : parent_reply->register_category("soundcloud", _("SoundCloud"), "", CategoryRenderer(SOUNDCLOUD_SEARCH_CATEGORY_DEFINITION));
     auto songkick_cat = empty_search ? parent_reply->register_category("songkick", _("Nearby Events on Songkick"), "",
             songkick_query, CategoryRenderer(SONGKICK_CATEGORY_DEFINITION))
         : parent_reply->register_category("songkick", _("Songkick"), "", CategoryRenderer(SONGKICK_SEARCH_CATEGORY_DEFINITION));
     auto grooveshark_cat = empty_search ? parent_reply->register_category("grooveshark", _("Popular tracks on Grooveshark"), "",
             grooveshark_query, CategoryRenderer(GROOVESHARK_CATEGORY_DEFINITION))
         : parent_reply->register_category("grooveshark", _("Grooveshark"), "", CategoryRenderer(GROOVESHARK_SEARCH_CATEGORY_DEFINITION));
+    auto youtube_cat = empty_search ? parent_reply->register_category("youtube", _("Popular tracks on Youtube"), "",
+                youtube_query, CategoryRenderer(YOUTUBE_SURFACING_CATEGORY_DEFINITION))
+            : parent_reply->register_category("youtube", _("Youtube"), "", youtube_query, CategoryRenderer(YOUTUBE_SEARCH_CATEGORY_DEFINITION));
+
 
     {
         auto local_reply = std::make_shared<ResultForwarder>(parent_reply, [this, mymusic_cat](CategorisedResult& res) -> bool {
@@ -236,6 +327,18 @@
                 });
         replies.push_back(reply);
     }
+    if (soundcloud_scope)
+    {
+        scopes.push_back(soundcloud_scope);
+        auto reply = std::make_shared<OnlineMusicResultForwarder>(parent_reply, [this, soundcloud_cat](CategorisedResult& res) -> bool {
+                if (res.category()->id() == "soundcloud_login_nag") {
+                    return false;
+                }
+                res.set_category(soundcloud_cat);
+                return true;
+            });
+        replies.push_back(reply);
+    }
     if (songkick_scope)
     {
         scopes.push_back(songkick_scope);
@@ -267,6 +370,15 @@
     {
         // TODO when available
     }
+    if (youtube_scope)
+    {
+        scopes.push_back(youtube_scope);
+        auto reply = std::make_shared<OnlineMusicResultForwarder>(parent_reply, [this, youtube_cat](CategorisedResult& res) -> bool {
+                res.set_category(youtube_cat);
+                return !res["musicaggregation"].is_null();
+                });
+        replies.push_back(reply);
+    }
 
     // create and chain result forwarders to enforce proper order of categories
     for (unsigned int i = 1; i < scopes.size(); ++i)
@@ -301,6 +413,13 @@
                 metadata.set_cardinality(3);
             }
         }
+        else if (scopes[i] == soundcloud_scope)
+        {
+            if (empty_search)
+            {
+                metadata.set_cardinality(3);
+            }
+        }
         else if (scopes[i] == songkick_scope)
         {
             if (empty_search)
@@ -308,6 +427,14 @@
                 metadata.set_cardinality(2);
             }
         }
+        else if (scopes[i] == youtube_scope)
+        {
+            if (empty_search)
+            {
+                metadata.set_cardinality(2);
+            }
+            dept = department_id;
+        }
 
         // Don't send location data to scopes that don't need it.
         if (scopes[i] != songkick_scope)

=== modified file 'src/musicaggregator/musicaggregatorquery.h'
--- src/musicaggregator/musicaggregatorquery.h	2014-09-15 07:26:58 +0000
+++ src/musicaggregator/musicaggregatorquery.h	2014-11-17 11:41:23 +0000
@@ -35,7 +35,8 @@
             unity::scopes::ScopeProxy const& grooveshark_scope,
             unity::scopes::ScopeProxy const& soundcloud_scope,
             unity::scopes::ScopeProxy const& sevendigital_scope,
-            unity::scopes::ScopeProxy const& songkick_scope);
+            unity::scopes::ScopeProxy const& songkick_scope,
+            unity::scopes::ScopeProxy const& youtube_scope);
     ~MusicAggregatorQuery();
     virtual void cancelled() override;
 
@@ -47,6 +48,7 @@
     unity::scopes::ScopeProxy soundcloud_scope;
     unity::scopes::ScopeProxy sevendigital_scope;
     unity::scopes::ScopeProxy songkick_scope;
+    unity::scopes::ScopeProxy youtube_scope;
     static const std::string grooveshark_songs_category_id;
 };
 

=== modified file 'src/musicaggregator/musicaggregatorscope.cpp'
--- src/musicaggregator/musicaggregatorscope.cpp	2014-11-17 11:41:22 +0000
+++ src/musicaggregator/musicaggregatorscope.cpp	2014-11-17 11:41:23 +0000
@@ -36,8 +36,9 @@
 #endif
 const std::string MusicAggregatorScope::GROOVESHARKSCOPE = "com.canonical.scopes.grooveshark";
 const std::string MusicAggregatorScope::SEVENDIGITAL = "com.canonical.scopes.sevendigital";
-const std::string MusicAggregatorScope::SOUNDCLOUD = "com.canonical.scopes.soundcloud";
+const std::string MusicAggregatorScope::SOUNDCLOUD = "com.ubuntu.scopes.soundcloud_soundcloud";
 const std::string MusicAggregatorScope::SONGKICK = "com.canonical.scopes.songkick_songkick";
+const std::string MusicAggregatorScope::YOUTUBE = "com.ubuntu.scopes.youtube_youtube";
 
 void MusicAggregatorScope::start(std::string const&) {
     init_gettext(*this);
@@ -53,7 +54,7 @@
     // FIXME: workaround for problem with no remote scopes on first run
     // until network becomes available
     init_scope_proxies();
-    SearchQueryBase::UPtr query(new MusicAggregatorQuery(q, hints, local_scope, grooveshark_scope, soundcloud_scope, sevendigital_scope, songkick_scope));
+    SearchQueryBase::UPtr query(new MusicAggregatorQuery(q, hints, local_scope, grooveshark_scope, soundcloud_scope, sevendigital_scope, songkick_scope, youtube_scope));
     return query;
 }
 
@@ -89,8 +90,9 @@
     const auto config = settings();
     init_scope_proxy(GROOVESHARKSCOPE, grooveshark_scope, config);
     init_scope_proxy(SEVENDIGITAL, sevendigital_scope, config);
-    //init_scope_proxy(SOUNDCLOUD, soundcloud_scope, config);
+    init_scope_proxy(SOUNDCLOUD, soundcloud_scope, config);
     init_scope_proxy(SONGKICK, songkick_scope, config);
+    init_scope_proxy(YOUTUBE, youtube_scope, config);
 }
 
 PreviewQueryBase::UPtr MusicAggregatorScope::preview(Result const& /*result*/, ActionMetadata const& /*hints*/) {

=== modified file 'src/musicaggregator/musicaggregatorscope.h'
--- src/musicaggregator/musicaggregatorscope.h	2014-09-15 07:26:58 +0000
+++ src/musicaggregator/musicaggregatorscope.h	2014-11-17 11:41:23 +0000
@@ -34,6 +34,7 @@
     static const std::string SEVENDIGITAL;
     static const std::string SOUNDCLOUD;
     static const std::string SONGKICK;
+    static const std::string YOUTUBE;
 
     virtual void start(std::string const&) override;
 
@@ -53,6 +54,7 @@
     unity::scopes::ScopeProxy soundcloud_scope;
     unity::scopes::ScopeProxy sevendigital_scope;
     unity::scopes::ScopeProxy songkick_scope;
+    unity::scopes::ScopeProxy youtube_scope;
 };
 
 #endif

=== modified file 'src/videoaggregator/videoaggregator-settings.ini.in'
--- src/videoaggregator/videoaggregator-settings.ini.in	2014-07-31 09:37:39 +0000
+++ src/videoaggregator/videoaggregator-settings.ini.in	2014-11-17 11:41:23 +0000
@@ -2,3 +2,8 @@
 type=boolean
 defaultValue=true
 _displayName=Display results from YouTube
+
+[com.ubuntu.scopes.vimeo_vimeo]
+type=boolean
+defaultValue=true
+_displayName=Display results from Vimeo

=== modified file 'src/videoaggregator/videoaggregatorscope.cpp'
--- src/videoaggregator/videoaggregatorscope.cpp	2014-11-17 11:41:22 +0000
+++ src/videoaggregator/videoaggregatorscope.cpp	2014-11-17 11:41:23 +0000
@@ -35,6 +35,7 @@
     "mediascanner-video",
 #endif
     "com.ubuntu.scopes.youtube_youtube",
+    "com.ubuntu.scopes.vimeo_vimeo",
 };
 
 void VideoAggregatorScope::start(std::string const&) {

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-11-17 11:41:22 +0000
+++ tests/CMakeLists.txt	2014-11-17 11:41:23 +0000
@@ -15,10 +15,26 @@
   test-music-scope.cpp
   ../src/mymusic/music-scope.cpp
 )
+
+add_executable(test-music-aggregator
+  test-music-aggregator.cpp
+  ../src/musicaggregator/musicaggregatorquery.cpp
+  ../src/musicaggregator/onlinemusicresultforwarder.cpp
+  ../src/musicaggregator/musicaggregatorscope.cpp
+)
+
+add_definitions(
+  -DTEST_SCOPE_DIRECTORY="${CMAKE_BINARY_DIR}/src"
+)
+
 target_link_libraries(test-music-scope
   scope-utils ${UNITY_LDFLAGS} ${gtest_libs} ${GIO_DEPS_LDFLAGS})
 add_test(test-music-scope test-music-scope)
 
+target_link_libraries(test-music-aggregator
+  scope-utils ${UNITY_LDFLAGS} ${gtest_libs} ${GIO_DEPS_LDFLAGS})
+add_test(test-music-aggregator test-music-aggregator)
+
 add_executable(test-video-scope
   test-video-scope.cpp
   ../src/myvideos/video-scope.cpp

=== added file 'tests/test-music-aggregator.cpp'
--- tests/test-music-aggregator.cpp	1970-01-01 00:00:00 +0000
+++ tests/test-music-aggregator.cpp	2014-11-17 11:41:23 +0000
@@ -0,0 +1,144 @@
+#include <cerrno>
+#include <cstring>
+#include <memory>
+#include <string>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <unity/scopes/testing/Category.h>
+#include <unity/scopes/testing/MockSearchReply.h>
+#include <unity/scopes/testing/MockScope.h>
+#include <unity/scopes/testing/MockQueryCtrl.h>
+
+
+#include "../src/musicaggregator/musicaggregatorscope.h"
+#include "../src/musicaggregator/musicaggregatorquery.h"
+
+using namespace unity::scopes;
+using ::testing::_;
+using ::testing::Return;
+
+TEST(TestMusicAgregator, TestSurfacingSearch) {
+
+    CannedQuery q("mediascanner-music", "", "");
+    SearchMetadata hints("en_AU", "phone");
+
+    std::shared_ptr<unity::scopes::testing::MockScope> grooveshark_scope(new unity::scopes::testing::MockScope());
+    std::shared_ptr<unity::scopes::testing::MockScope> soundcloud_scope(new unity::scopes::testing::MockScope());
+    std::shared_ptr<unity::scopes::testing::MockScope> sevendigital_scope(new unity::scopes::testing::MockScope());
+    std::shared_ptr<unity::scopes::testing::MockScope> songkick_scope(new unity::scopes::testing::MockScope());
+    std::shared_ptr<unity::scopes::testing::MockScope> youtube_scope(new unity::scopes::testing::MockScope());
+    std::shared_ptr<unity::scopes::testing::MockScope> local_scope(new unity::scopes::testing::MockScope());
+
+    MusicAggregatorQuery query( q, hints, unity::scopes::ScopeProxy(local_scope), unity::scopes::ScopeProxy(grooveshark_scope),
+                                        unity::scopes::ScopeProxy(soundcloud_scope), unity::scopes::ScopeProxy(sevendigital_scope),
+                                        unity::scopes::ScopeProxy(songkick_scope),  unity::scopes::ScopeProxy(youtube_scope) );
+
+
+    unity::scopes::testing::MockSearchReply reply;
+
+    Category::SCPtr mymusic_category = std::make_shared<unity::scopes::testing::Category>(
+        "mymusic", "Tracks", "icon", CategoryRenderer());
+    Category::SCPtr sevendigital_category = std::make_shared<unity::scopes::testing::Category>(
+        "7digital", "Tracks", "icon", CategoryRenderer());
+    Category::SCPtr songkick_category = std::make_shared<unity::scopes::testing::Category>(
+        "songkick", "Tracks", "icon", CategoryRenderer());
+    Category::SCPtr grooveshark_category = std::make_shared<unity::scopes::testing::Category>(
+        "grooveshark", "Tracks", "icon", CategoryRenderer());
+    Category::SCPtr youtube_category = std::make_shared<unity::scopes::testing::Category>(
+        "youtube", "Tracks", "icon", CategoryRenderer());
+    Category::SCPtr soundcloud_category = std::make_shared<unity::scopes::testing::Category>(
+        "soundcloud", "Tracks", "icon", CategoryRenderer());
+
+
+    std::shared_ptr<unity::scopes::testing::MockQueryCtrl> queryctrl(new unity::scopes::testing::MockQueryCtrl());
+
+    EXPECT_CALL(reply, register_category("mymusic", _, _, _,_))
+        .WillOnce(Return(mymusic_category));
+    EXPECT_CALL(reply, register_category("7digital", _, _, _,_))
+        .WillOnce(Return(sevendigital_category));
+    EXPECT_CALL(reply, register_category("songkick", _, _, _,_))
+        .WillOnce(Return(songkick_category));
+    EXPECT_CALL(reply, register_category("grooveshark", _, _, _,_))
+        .WillOnce(Return(grooveshark_category));
+    EXPECT_CALL(reply, register_category("youtube", _, _, _,_))
+        .WillOnce(Return(youtube_category));
+    EXPECT_CALL(reply, register_category("soundcloud", _, _, _,_))
+        .WillOnce(Return(soundcloud_category));
+
+    // check that each scope calls search with the correct parameters...
+    EXPECT_CALL(*sevendigital_scope.get(), search("","newreleases", _, _, _)).WillOnce(Return(queryctrl));
+    EXPECT_CALL(*local_scope.get(), search("","", _, _, _)).WillOnce(Return(queryctrl));
+    EXPECT_CALL(*songkick_scope.get(), search("","", _, _, _)).WillOnce(Return(queryctrl));
+    EXPECT_CALL(*grooveshark_scope.get(), search("","", _, _, _)).WillOnce(Return(queryctrl));
+    EXPECT_CALL(*youtube_scope.get(), search("","aggregated:musicaggregator", _, _, _)).WillOnce(Return(queryctrl));
+    EXPECT_CALL(*soundcloud_scope.get(), search("","", _, _, _)).WillOnce(Return(queryctrl));
+
+    SearchReplyProxy proxy(&reply, [](SearchReply*){});
+    query.run(proxy);
+}
+
+TEST(TestMusicAgregator, TestSpecificSearch) {
+
+    CannedQuery q("mediascanner-music", "test", "");
+    SearchMetadata hints("en_AU", "phone");
+
+    std::shared_ptr<unity::scopes::testing::MockScope> grooveshark_scope(new unity::scopes::testing::MockScope());
+    std::shared_ptr<unity::scopes::testing::MockScope> soundcloud_scope(new unity::scopes::testing::MockScope());
+    std::shared_ptr<unity::scopes::testing::MockScope> sevendigital_scope(new unity::scopes::testing::MockScope());
+    std::shared_ptr<unity::scopes::testing::MockScope> songkick_scope(new unity::scopes::testing::MockScope());
+    std::shared_ptr<unity::scopes::testing::MockScope> youtube_scope(new unity::scopes::testing::MockScope());
+    std::shared_ptr<unity::scopes::testing::MockScope> local_scope(new unity::scopes::testing::MockScope());
+
+    MusicAggregatorQuery query( q, hints, unity::scopes::ScopeProxy(local_scope), unity::scopes::ScopeProxy(grooveshark_scope),
+                                        unity::scopes::ScopeProxy(soundcloud_scope), unity::scopes::ScopeProxy(sevendigital_scope),
+                                        unity::scopes::ScopeProxy(songkick_scope),  unity::scopes::ScopeProxy(youtube_scope) );
+
+
+    unity::scopes::testing::MockSearchReply reply;
+
+    Category::SCPtr mymusic_category = std::make_shared<unity::scopes::testing::Category>(
+        "mymusic", "Tracks", "icon", CategoryRenderer());
+    Category::SCPtr sevendigital_category = std::make_shared<unity::scopes::testing::Category>(
+        "7digital", "Tracks", "icon", CategoryRenderer());
+    Category::SCPtr songkick_category = std::make_shared<unity::scopes::testing::Category>(
+        "songkick", "Tracks", "icon", CategoryRenderer());
+    Category::SCPtr grooveshark_category = std::make_shared<unity::scopes::testing::Category>(
+        "grooveshark", "Tracks", "icon", CategoryRenderer());
+    Category::SCPtr youtube_category = std::make_shared<unity::scopes::testing::Category>(
+        "youtube", "Tracks", "icon", CategoryRenderer());
+    Category::SCPtr soundcloud_category = std::make_shared<unity::scopes::testing::Category>(
+        "soundcloud", "Tracks", "icon", CategoryRenderer());
+
+
+    std::shared_ptr<unity::scopes::testing::MockQueryCtrl> queryctrl(new unity::scopes::testing::MockQueryCtrl());
+
+    EXPECT_CALL(reply, register_category("mymusic", _, _, _))
+        .WillOnce(Return(mymusic_category));
+    EXPECT_CALL(reply, register_category("7digital", _, _,_))
+        .WillOnce(Return(sevendigital_category));
+    EXPECT_CALL(reply, register_category("songkick", _, _,_))
+        .WillOnce(Return(songkick_category));
+    EXPECT_CALL(reply, register_category("grooveshark", _, _,_))
+        .WillOnce(Return(grooveshark_category));
+    EXPECT_CALL(reply, register_category("youtube", _, _, _,_))
+        .WillOnce(Return(youtube_category));
+    EXPECT_CALL(reply, register_category("soundcloud", _, _,_))
+        .WillOnce(Return(soundcloud_category));
+
+    // check that each scope calls search with the correct parameters...
+    EXPECT_CALL(*sevendigital_scope.get(), search("test","", _, _, _)).WillOnce(Return(queryctrl));
+    EXPECT_CALL(*local_scope.get(), search("test","", _, _, _)).WillOnce(Return(queryctrl));
+    EXPECT_CALL(*songkick_scope.get(), search("test","", _, _, _)).WillOnce(Return(queryctrl));
+    EXPECT_CALL(*grooveshark_scope.get(), search("test","", _, _, _)).WillOnce(Return(queryctrl));
+    EXPECT_CALL(*youtube_scope.get(), search("test","aggregated:musicaggregator", _, _, _)).WillOnce(Return(queryctrl));
+    EXPECT_CALL(*soundcloud_scope.get(), search("test","", _, _, _)).WillOnce(Return(queryctrl));
+
+    SearchReplyProxy proxy(&reply, [](SearchReply*){});
+    query.run(proxy);
+}
+
+int main(int argc, char **argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}