← Back to branch summary

~stolowski/thumbnailer/more-debug

« back to all changes in this revision

Viewing changes to tests/dbus/dbus_test.cpp

  • Committer: CI Train Bot
  • Author(s): Michi Henning
  • Date: 2016-01-07 04:36:36 UTC
  • mfrom: (129.1.22 landing-12.15)
  • Revision ID: ci-train-bot@canonical.com-20160107043636-xbao3rktj4uf3u0f
Merge changes from devel to trunk for landing.
Approved by: Michi Henning, PS Jenkins bot

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/dbus/dbus_test.cpp
17
17
 *              Michi Henning <michi.henning@canonical.com>
18
18
 */
19
19
 
 
20
#include <internal/env_vars.h>
20
21
#include <internal/image.h>
21
22
#include <internal/raii.h>
22
23
#include "utils/artserver.h"
23
24
#include "utils/dbusserver.h"
 
25
#include "utils/env_var_guard.h"
24
26
 
25
27
#include <boost/algorithm/string/predicate.hpp>
26
28
#include <gtest/gtest.h>
72
74
        tempdir.reset(new QTemporaryDir(TESTBINDIR "/dbus-test.XXXXXX"));
73
75
        setenv("XDG_CACHE_HOME", (tempdir->path() + "/cache").toUtf8().data(), true);
74
76
 
75
 
        // set 3 seconds as max idle time
76
 
        setenv("THUMBNAILER_MAX_IDLE", "1000", true);
 
77
        setenv(MAX_IDLE, "1000", true);
 
78
        setenv(LOG_LEVEL, "2", true);  // For coverage
77
79
 
78
80
        dbus_.reset(new DBusServer());
79
81
    }
88
90
        dbus_.reset();
89
91
        art_server_.reset();
90
92
 
91
 
        unsetenv("THUMBNAILER_MAX_IDLE");
 
93
        unsetenv(MAX_IDLE);
92
94
        unsetenv("XDG_CACHE_HOME");
93
95
        tempdir.reset();
94
96
    }
100
102
 
101
103
TEST_F(DBusTest, get_album_art)
102
104
{
103
 
    QDBusReply<QDBusUnixFileDescriptor> reply =
 
105
    QDBusReply<QByteArray> reply =
104
106
        dbus_->thumbnailer_->GetAlbumArt("metallica", "load", QSize(24, 24));
105
107
    assert_no_error(reply);
106
 
    Image image(reply.value().fileDescriptor());
 
108
    Image image(reply.value());
107
109
    EXPECT_EQ(24, image.width());
108
110
    EXPECT_EQ(24, image.width());
109
111
}
113
115
    // We do this twice, so we get a cache hit on the second try.
114
116
    for (int i = 0; i < 2; ++i)
115
117
    {
116
 
        QDBusReply<QDBusUnixFileDescriptor> reply =
 
118
        QDBusReply<QByteArray> reply =
117
119
            dbus_->thumbnailer_->GetArtistArt("metallica", "load", QSize(24, 24));
118
120
        assert_no_error(reply);
119
 
        Image image(reply.value().fileDescriptor());
 
121
        Image image(reply.value());
120
122
        EXPECT_EQ(24, image.width());
121
123
        EXPECT_EQ(24, image.width());
122
124
    }
125
127
TEST_F(DBusTest, thumbnail_image)
126
128
{
127
129
    const char* filename = TESTDATADIR "/testimage.jpg";
128
 
    QDBusReply<QDBusUnixFileDescriptor> reply =
 
130
    QDBusReply<QByteArray> reply =
129
131
        dbus_->thumbnailer_->GetThumbnail(filename, QSize(256, 256));
130
132
    assert_no_error(reply);
131
133
 
132
 
    Image image(reply.value().fileDescriptor());
 
134
    Image image(reply.value());
133
135
    EXPECT_EQ(256, image.width());
134
136
    EXPECT_EQ(160, image.height());
135
137
}
140
142
    for (int i = 0; i < 2; ++i)
141
143
    {
142
144
        const char* filename = TESTDATADIR "/testsong.ogg";
143
 
        QDBusReply<QDBusUnixFileDescriptor> reply =
 
145
        QDBusReply<QByteArray> reply =
144
146
            dbus_->thumbnailer_->GetThumbnail(filename, QSize(256, 256));
145
147
        assert_no_error(reply);
146
148
 
147
 
        Image image(reply.value().fileDescriptor());
 
149
        Image image(reply.value());
148
150
        EXPECT_EQ(200, image.width());
149
151
        EXPECT_EQ(200, image.height());
150
152
    }
156
158
    for (int i = 0; i < 2; ++i)
157
159
    {
158
160
        const char* filename = TESTDATADIR "/testvideo.ogg";
159
 
        QDBusReply<QDBusUnixFileDescriptor> reply =
 
161
        QDBusReply<QByteArray> reply =
160
162
            dbus_->thumbnailer_->GetThumbnail(filename, QSize(256, 256));
161
163
        assert_no_error(reply);
162
164
 
163
 
        Image image(reply.value().fileDescriptor());
 
165
        Image image(reply.value());
164
166
        EXPECT_EQ(256, image.width());
165
167
        EXPECT_EQ(144, image.height());
166
168
    }
169
171
TEST_F(DBusTest, thumbnail_no_such_file)
170
172
{
171
173
    const char* no_such_file = TESTDATADIR "/no-such-file.jpg";
172
 
    QDBusReply<QDBusUnixFileDescriptor> reply =
 
174
    QDBusReply<QByteArray> reply =
173
175
        dbus_->thumbnailer_->GetThumbnail(no_such_file, QSize(256, 256));
174
176
    EXPECT_FALSE(reply.isValid());
175
177
    auto message = reply.error().message().toStdString();
178
180
 
179
181
TEST_F(DBusTest, server_error)
180
182
{
181
 
    QDBusReply<QDBusUnixFileDescriptor> reply =
182
 
        dbus_->thumbnailer_->GetArtistArt("error", "500", QSize(256, 256));
183
 
    EXPECT_FALSE(reply.isValid());
184
 
    auto message = reply.error().message().toStdString();
185
 
    // TODO: That's a seriously poor error message.
186
 
    EXPECT_TRUE(boost::contains(message, "fetch() failed")) << message;
 
183
    {
 
184
        QDBusReply<QDBusUnixFileDescriptor> reply =
 
185
            dbus_->thumbnailer_->GetArtistArt("error", "500", QSize(256, 256));
 
186
        EXPECT_FALSE(reply.isValid());
 
187
        auto message = reply.error().message().toStdString();
 
188
        EXPECT_EQ("Handler::createFinished(): could not get thumbnail for artist: error/500 (256,256): TEMPORARY ERROR",
 
189
                  message) << message;
 
190
    }
 
191
 
 
192
    // Again, so we cover the network retry limit case.
 
193
    {
 
194
        QDBusReply<QDBusUnixFileDescriptor> reply =
 
195
            dbus_->thumbnailer_->GetArtistArt("error", "500", QSize(256, 256));
 
196
        EXPECT_FALSE(reply.isValid());
 
197
        auto message = reply.error().message().toStdString();
 
198
        EXPECT_EQ("Handler::checkFinished(): no artwork for artist: error/500 (256,256): TEMPORARY ERROR",
 
199
                  message) << message;
 
200
    }
187
201
}
188
202
 
189
203
TEST_F(DBusTest, duplicate_requests)
218
232
    // rate limited, but it does exercise the code paths as shown by
219
233
    // the coverage report.
220
234
    int const N_REQUESTS = 10;
221
 
    QDBusPendingReply<QDBusUnixFileDescriptor> replies[N_REQUESTS];
 
235
    QDBusPendingReply<QByteArray> replies[N_REQUESTS];
222
236
 
223
237
    for (int i = 0; i < N_REQUESTS; i++)
224
238
    {
245
259
                        static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished));
246
260
 
247
261
    // start a query
248
 
    QDBusReply<QDBusUnixFileDescriptor> reply =
 
262
    QDBusReply<QByteArray> reply =
249
263
        dbus_->thumbnailer_->GetThumbnail(filename, QSize(256, 256));
250
264
    assert_no_error(reply);
251
265
 
260
274
 
261
275
TEST_F(DBusTest, service_exits_if_run_twice)
262
276
{
 
277
    if (!SLOW_TESTS)
 
278
    {
 
279
        return;
 
280
    }
 
281
 
263
282
    // Try to start a second copy of the thumbnailer service
264
283
    QProcess process;
265
284
    process.setStandardInputFile(QProcess::nullDevice());
291
310
 
292
311
TEST(DBusTestBadIdle, env_variable_bad_value)
293
312
{
 
313
    if (!SLOW_TESTS)
 
314
    {
 
315
        return;
 
316
    }
 
317
 
294
318
    QTemporaryDir tempdir(TESTBINDIR "/dbus-test.XXXXXX");
295
319
    setenv("XDG_CACHE_HOME", (tempdir.path() + "/cache").toUtf8().data(), true);
296
320
 
297
 
    setenv("THUMBNAILER_MAX_IDLE", "bad_value", true);
 
321
    EnvVarGuard ev_guard(MAX_IDLE, "bad_value");
298
322
    try
299
323
    {
300
324
        unique_ptr<DBusServer> dbus(new DBusServer());
305
329
        string err = e.what();
306
330
        EXPECT_TRUE(err.find("failed to appear on bus"));
307
331
    }
308
 
    unsetenv("THUMBNAILER_MAX_IDLE");
309
332
}
310
333
 
311
334
TEST(DBusTestBadIdle, env_variable_out_of_range)
312
335
{
 
336
    if (!SLOW_TESTS)
 
337
    {
 
338
        return;
 
339
    }
 
340
 
313
341
    QTemporaryDir tempdir(TESTBINDIR "/dbus-test.XXXXXX");
314
342
    setenv("XDG_CACHE_HOME", (tempdir.path() + "/cache").toUtf8().data(), true);
315
343
 
316
 
    setenv("THUMBNAILER_MAX_IDLE", "999", true);
 
344
    EnvVarGuard ev_guard(MAX_IDLE, "999");
317
345
    try
318
346
    {
319
347
        unique_ptr<DBusServer> dbus(new DBusServer());
324
352
        string err = e.what();
325
353
        EXPECT_TRUE(err.find("failed to appear on bus"));
326
354
    }
327
 
    unsetenv("THUMBNAILER_MAX_IDLE");
328
355
}
329
356
 
330
357
TEST(DBusTestBadIdle, default_timeout)
332
359
    QTemporaryDir tempdir(TESTBINDIR "/dbus-test.XXXXXX");
333
360
    setenv("XDG_CACHE_HOME", (tempdir.path() + "/cache").toUtf8().data(), true);
334
361
 
335
 
    unsetenv("THUMBNAILER_MAX_IDLE");
 
362
    EnvVarGuard ev_guard(MAX_IDLE, nullptr);
336
363
    unique_ptr<DBusServer> dbus(new DBusServer());  // For coverage with default timeout.
337
364
}
338
365
 
437
464
 
438
465
    // Get a remote image from the cache, so the stats change.
439
466
    {
440
 
        QDBusReply<QDBusUnixFileDescriptor> reply =
 
467
        QDBusReply<QByteArray> reply =
441
468
            dbus_->thumbnailer_->GetAlbumArt("metallica", "load", QSize(24, 24));
442
469
        assert_no_error(reply);
443
 
        Image image(reply.value().fileDescriptor());
 
470
        Image image(reply.value());
444
471
        EXPECT_EQ(24, image.width());
445
472
        EXPECT_EQ(24, image.width());
446
473
    }
501
528
 
502
529
    // Get the same image again, so we get a hit.
503
530
    {
504
 
        QDBusReply<QDBusUnixFileDescriptor> reply =
 
531
        QDBusReply<QByteArray> reply =
505
532
            dbus_->thumbnailer_->GetAlbumArt("metallica", "load", QSize(24, 24));
506
533
        assert_no_error(reply);
507
 
        Image image(reply.value().fileDescriptor());
 
534
        Image image(reply.value());
508
535
        EXPECT_EQ(24, image.width());
509
536
        EXPECT_EQ(24, image.width());
510
537
    }
534
561
 
535
562
    // Get a non-existent remote image from the cache, so the failure stats change.
536
563
    {
537
 
        QDBusReply<QDBusUnixFileDescriptor> reply =
 
564
        QDBusReply<QByteArray> reply =
538
565
            dbus_->thumbnailer_->GetAlbumArt(
539
566
                "no_such_artist", "no_such_album", QSize(24, 24));
540
567
    }
551
578
 
552
579
    // Get the same non-existent remote image again, so we get a hit.
553
580
    {
554
 
        QDBusReply<QDBusUnixFileDescriptor> reply =
 
581
        QDBusReply<QByteArray> reply =
555
582
            dbus_->thumbnailer_->GetAlbumArt(
556
583
                "no_such_artist", "no_such_album", QSize(24, 24));
557
584
    }
589
616
 
590
617
    setenv("GSETTINGS_BACKEND", "memory", true);
591
618
    setenv("GSETTINGS_SCHEMA_DIR", GSETTINGS_SCHEMA_DIR, true);
592
 
    setenv("TN_UTILDIR", TESTBINDIR "/../src/vs-thumb", true);
 
619
    setenv(UTIL_DIR, TESTBINDIR "/../src/vs-thumb", true);
593
620
    ::testing::InitGoogleTest(&argc, argv);
594
621
    return RUN_ALL_TESTS();
595
622
}