← Back to branch summary

~larryprice/libertine-scope/libertine-store-internal-packages

« back to all changes in this revision

Viewing changes to tests/scope/apps/test_query.cpp

Add link to Store in Apps Scope

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/scope/apps/test_query.cpp
25
25
#include <unity/scopes/Category.h>
26
26
#include <vector>
27
27
#include <memory>
28
 
#include <gtest/gtest.h>
29
28
#include <gmock/gmock.h>
 
29
#include <QUrl>
30
30
 
31
31
namespace
32
32
{
95
95
}
96
96
 
97
97
 
 
98
MATCHER_P4(HintPropertiesMatch, title, art, uri, overlay, "")
 
99
{
 
100
  return arg.contains("title") && arg["title"] == unity::scopes::Variant(title) &&
 
101
      arg.contains("art") && arg["art"] == unity::scopes::Variant(art) &&
 
102
      arg.contains("uri") && arg["uri"] == unity::scopes::Variant(uri) &&
 
103
      arg.contains("overlay-color") && arg["overlay-color"] == unity::scopes::Variant(overlay);
 
104
}
 
105
 
 
106
 
98
107
class TestQueryFixture : public ::testing::Test
99
108
{
100
109
public:
106
115
    , category(std::make_shared<FakeCategory>("fake-container", "fake-container", "Application", unity::scopes::CategoryRenderer()))
107
116
    , hidden(new testing::NiceMock<MockHiddenApps>())
108
117
    , blacklist(new testing::NiceMock<MockBlacklist>())
 
118
    , data_dir("/some/fake/path")
109
119
  {
110
120
  }
111
121
 
124
134
    EXPECT_CALL(reply, register_category("fake-container", "fake-container", "Application", testing::_)).WillOnce(testing::Return(category));
125
135
  }
126
136
 
 
137
  void expect_hint_registry(QString const& query = "")
 
138
  {
 
139
    if (query.isEmpty())
 
140
    {
 
141
      EXPECT_CALL(reply, register_category("hint", "Get more apps from the store", "", testing::_)).WillOnce(testing::Return(category));
 
142
    }
 
143
    else
 
144
    {
 
145
      EXPECT_CALL(reply, register_category("hint", QString("Search for '%1' in the store").arg(query).toStdString(), "", testing::_))
 
146
          .WillOnce(testing::Return(category));
 
147
    }
 
148
 
 
149
    auto full_scope = QString("scope://%1?q=%2")
 
150
        .arg(QString::fromStdString(STORE_SCOPE_FULL_NAME))
 
151
        .arg(QString(QUrl::toPercentEncoding(query, QByteArray{}, QByteArray{"."})))
 
152
        .toStdString();
 
153
    EXPECT_CALL(reply, push(testing::Matcher<unity::scopes::CategorisedResult const&>(HintPropertiesMatch("Install X Apps", data_dir+"/store.svg", full_scope, "transparent"))))
 
154
        .WillOnce(testing::Return(true));
 
155
  }
 
156
 
127
157
  void expect_push(std::string title, std::string art, std::string description, std::string appId, bool success = true)
128
158
  {
129
159
    EXPECT_CALL(reply, push(testing::Matcher<unity::scopes::CategorisedResult const&>(ResultPropertiesMatch(title, art, description, appId)))).WillOnce(testing::Return(success));
151
181
  std::shared_ptr<FakeCategory> category;
152
182
  std::shared_ptr<MockHiddenApps> hidden;
153
183
  std::shared_ptr<MockBlacklist> blacklist;
 
184
  std::string data_dir;
154
185
};
155
186
 
156
187
 
160
191
  expect_push_libreoffice();
161
192
  expect_push_linux();
162
193
  expect_push_library();
 
194
  expect_hint_registry();
163
195
 
164
196
  Query query(canned_query, metadata, []() {
165
197
    return FakeLibertine::make_fake(LIBERTINE_OUTPUT_WITH_APPS);
166
 
  }, hidden, blacklist);
 
198
  }, hidden, blacklist, data_dir);
167
199
  query.run(proxy);
168
200
}
169
201
 
172
204
{
173
205
  expect_registry();
174
206
  expect_push_libreoffice();
 
207
  expect_hint_registry("li.*office");
175
208
  canned_query.set_query_string("li.*office");
176
209
 
177
210
  Query query(canned_query, metadata, []() {
178
211
    return FakeLibertine::make_fake(LIBERTINE_OUTPUT_WITH_APPS);
179
 
  }, hidden, blacklist);
 
212
  }, hidden, blacklist, data_dir);
180
213
  query.run(proxy);
181
214
}
182
215
 
188
221
 
189
222
  Query query(canned_query, metadata, []() {
190
223
    return FakeLibertine::make_fake(LIBERTINE_OUTPUT_WITH_APPS);
191
 
  }, hidden, blacklist);
 
224
  }, hidden, blacklist, data_dir);
192
225
  query.run(proxy);
193
226
}
194
227
 
198
231
  expect_registry();
199
232
  expect_push_linux();
200
233
  expect_push_library();
 
234
  expect_hint_registry();
201
235
 
202
236
  EXPECT_CALL(*blacklist, app_is_blacklisted(QString("libreoffice"), "fake-container"))
203
237
      .WillRepeatedly(testing::Return(true));
204
238
 
205
239
  Query query(canned_query, metadata, []() {
206
240
    return FakeLibertine::make_fake(LIBERTINE_OUTPUT_WITH_APPS);
207
 
  }, hidden, blacklist);
 
241
  }, hidden, blacklist, data_dir);
208
242
  query.run(proxy);
209
243
}
210
244
 
214
248
  expect_registry();
215
249
  expect_push_linux();
216
250
  expect_push_libreoffice();
 
251
  expect_hint_registry();
217
252
 
218
253
  EXPECT_CALL(*hidden, app_is_hidden(QString("fake-container/library")))
219
254
              .WillRepeatedly(testing::Return(true));
222
257
 
223
258
  Query query(canned_query, metadata, []() {
224
259
    return FakeLibertine::make_fake(LIBERTINE_OUTPUT_WITH_APPS);
225
 
  }, hidden, blacklist);
 
260
  }, hidden, blacklist, data_dir);
226
261
  query.run(proxy);
227
262
}
228
263
 
241
276
 
242
277
  Query query(canned_query, metadata, []() {
243
278
    return FakeLibertine::make_fake(LIBERTINE_OUTPUT_WITH_APPS);
244
 
  }, hidden, blacklist);
 
279
  }, hidden, blacklist, data_dir);
245
280
  query.run(proxy);
246
281
}
247
282
 
248
283
 
249
 
TEST_F(TestQueryFixture, showsHintWhenAllAppsFiltered)
 
284
TEST_F(TestQueryFixture, showsHintInHiddenDepartmentWhenAllAppsFiltered)
250
285
{
251
286
  expect_registry();
252
287
 
253
288
  EXPECT_CALL(reply, register_category("hint", "", "", testing::_)).WillOnce(testing::Return(category));
254
289
  EXPECT_CALL(reply, push(testing::Matcher<unity::scopes::CategorisedResult const&>(ResultTitleMatch(Query::ALL_RESULTS_FILTERED_HINT)))).WillOnce(testing::Return(true));
255
290
 
256
 
  EXPECT_CALL(*hidden, app_is_hidden(testing::_)).WillRepeatedly(testing::Return(true));
 
291
  EXPECT_CALL(*hidden, app_is_hidden(QString("fake-container/library")))
 
292
              .WillRepeatedly(testing::Return(true));
 
293
  EXPECT_CALL(*hidden, empty())
 
294
      .WillOnce(testing::Return(false));
 
295
 
 
296
  canned_query.set_department_id(HIDDEN_DEPT_ID);
 
297
  canned_query.set_query_string("li.*office");
257
298
 
258
299
  Query query(canned_query, metadata, []() {
259
300
    return FakeLibertine::make_fake(LIBERTINE_OUTPUT_WITH_APPS);
260
 
  }, hidden, blacklist);
 
301
  }, hidden, blacklist, data_dir);
261
302
  query.run(proxy);
262
303
}
263
304
 
264
305
 
265
 
TEST_F(TestQueryFixture, showsHintWhenNoAppsInContainer)
 
306
TEST_F(TestQueryFixture, showsHintInHiddenDepartmentWhenNoApps)
266
307
{
267
308
  expect_registry();
268
309
 
269
310
  EXPECT_CALL(reply, register_category("hint", "", "", testing::_)).WillOnce(testing::Return(category));
270
311
  EXPECT_CALL(reply, push(testing::Matcher<unity::scopes::CategorisedResult const&>(ResultTitleMatch(Query::NO_RESULTS_HINT)))).WillOnce(testing::Return(true));
271
312
 
 
313
  EXPECT_CALL(*hidden, app_is_hidden(QString("fake-container/library")))
 
314
              .WillRepeatedly(testing::Return(true));
 
315
  EXPECT_CALL(*hidden, empty())
 
316
      .WillOnce(testing::Return(false));
 
317
 
 
318
  canned_query.set_department_id(HIDDEN_DEPT_ID);
 
319
 
272
320
  Query query(canned_query, metadata, []() {
273
321
    return FakeLibertine::make_fake("");
274
 
  }, hidden, blacklist);
275
 
  query.run(proxy);
276
 
}
 
322
  }, hidden, blacklist, data_dir);
 
323
   query.run(proxy);
 
324
 }
277
325
} // anonymous namespace