← Back to branch summary

~michihenning/storage-framework/stand-alone-provider-headers

« back to all changes in this revision

Viewing changes to tests/provider-ProviderInterface/ProviderInterface_test.cpp

  • Committer: Michi Henning
  • Date: 2016-08-23 23:45:34 UTC
  • mfrom: (53.1.4 devel)
  • Revision ID: michi.henning@canonical.com-20160823234534-4owayhnhcp67g39q
Merged devel.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/provider-ProviderInterface/ProviderInterface_test.cpp
21
21
#include <unity/storage/provider/testing/TestServer.h>
22
22
 
23
23
#include "TestProvider.h"
24
 
#include "ProviderClient.h"
25
24
 
26
 
#include <utils/DBusEnvironment.h>
 
25
#include <utils/ProviderFixture.h>
27
26
 
28
27
#include <gtest/gtest.h>
29
28
#include <OnlineAccounts/Account>
55
54
 
56
55
}
57
56
 
58
 
 
59
 
class ProviderInterfaceTest : public ::testing::Test
 
57
class ProviderInterfaceTest : public ProviderFixture
60
58
{
61
 
public:
62
 
    QDBusConnection const& connection()
63
 
    {
64
 
        return dbus_->connection();
65
 
    }
66
 
 
67
 
    void make_provider(unique_ptr<ProviderBase>&& provider)
68
 
    {
69
 
        account_manager_->waitForReady();
70
 
        OnlineAccounts::Account* account = account_manager_->account(
71
 
            2, "oauth2-service");
72
 
        ASSERT_NE(nullptr, account);
73
 
 
74
 
        test_server_.reset(
75
 
            new TestServer(move(provider), account,
76
 
                           *service_connection_, BUS_PATH.toStdString()));
77
 
 
78
 
        client_.reset(new ProviderClient(service_connection_->baseService(),
79
 
                                         BUS_PATH,
80
 
                                         connection()));
81
 
    }
82
 
 
83
 
    void wait_for(QDBusPendingCall const& call) {
84
 
        QDBusPendingCallWatcher watcher(call);
85
 
        QSignalSpy spy(&watcher, &QDBusPendingCallWatcher::finished);
86
 
        ASSERT_TRUE(spy.wait());
87
 
    }
88
 
 
89
59
protected:
90
60
    void SetUp() override
91
61
    {
92
 
        dbus_.reset(new DBusEnvironment);
93
 
        dbus_->start_services();
94
 
        service_connection_.reset(
95
 
            new QDBusConnection(QDBusConnection::connectToBus(
96
 
                dbus_->busAddress(), SERVICE_CONNECTION_NAME)));
97
 
        account_manager_.reset(new OnlineAccounts::Manager(
98
 
                                   "", *service_connection_));
 
62
        client_.reset(new ProviderClient(service_connection_->baseService(), BUS_PATH, connection()));
99
63
    }
100
64
 
101
65
    void TearDown() override
102
66
    {
103
67
        client_.reset();
104
 
        test_server_.reset();
105
 
        service_connection_.reset();
106
 
        QDBusConnection::disconnectFromBus(SERVICE_CONNECTION_NAME);
107
 
        dbus_.reset();
108
68
    }
109
69
 
110
 
    unique_ptr<DBusEnvironment> dbus_;
111
 
    unique_ptr<QDBusConnection> service_connection_;
112
 
    unique_ptr<OnlineAccounts::Manager> account_manager_;
113
 
    unique_ptr<TestServer> test_server_;
114
 
    unique_ptr<ProviderClient> client_;
 
70
    std::unique_ptr<ProviderClient> client_;
115
71
};
116
72
 
117
 
 
118
73
TEST_F(ProviderInterfaceTest, roots)
119
74
{
120
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
75
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
121
76
 
122
77
    auto reply = client_->Roots();
123
78
    wait_for(reply);
133
88
 
134
89
TEST_F(ProviderInterfaceTest, list)
135
90
{
136
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
91
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
137
92
 
138
93
    auto reply = client_->List("root_id", "");
139
94
    wait_for(reply);
171
126
 
172
127
TEST_F(ProviderInterfaceTest, lookup)
173
128
{
174
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
129
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
175
130
 
176
131
    auto reply = client_->Lookup("root_id", "Filename");
177
132
    wait_for(reply);
187
142
 
188
143
TEST_F(ProviderInterfaceTest, metadata)
189
144
{
190
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
145
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
191
146
 
192
147
    auto reply = client_->Metadata("root_id");
193
148
    wait_for(reply);
201
156
 
202
157
TEST_F(ProviderInterfaceTest, create_folder)
203
158
{
204
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
159
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
205
160
 
206
161
    auto reply = client_->CreateFolder("root_id", "New Folder");
207
162
    wait_for(reply);
215
170
 
216
171
TEST_F(ProviderInterfaceTest, create_file)
217
172
{
218
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
173
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
219
174
 
220
175
    const std::string file_contents = "Hello world!";
221
176
    QString upload_id;
263
218
 
264
219
TEST_F(ProviderInterfaceTest, update)
265
220
{
266
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
221
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
267
222
 
268
223
    const std::string file_contents = "Hello world!";
269
224
    QString upload_id;
309
264
 
310
265
TEST_F(ProviderInterfaceTest, upload_short_write)
311
266
{
312
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
267
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
313
268
 
314
269
    QString upload_id;
315
270
    QDBusUnixFileDescriptor socket;
329
284
 
330
285
TEST_F(ProviderInterfaceTest, upload_long_write)
331
286
{
332
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
287
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
333
288
 
334
289
    const std::string file_contents = "Hello world!";
335
290
    QString upload_id;
374
329
 
375
330
TEST_F(ProviderInterfaceTest, cancel_upload)
376
331
{
377
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
332
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
378
333
 
379
334
    QString upload_id;
380
335
    QDBusUnixFileDescriptor socket;
392
347
 
393
348
TEST_F(ProviderInterfaceTest, finish_upload_unknown)
394
349
{
395
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
350
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
396
351
 
397
352
    auto reply = client_->FinishUpload("no-such-upload");
398
353
    wait_for(reply);
399
354
    ASSERT_TRUE(reply.isError());
400
355
    EXPECT_EQ(PROVIDER_ERROR + "UnknownException", reply.error().name());
401
 
    EXPECT_EQ("map::at", reply.error().message());
 
356
    EXPECT_EQ("unknown exception thrown by provider: map::at", reply.error().message());
402
357
}
403
358
 
404
359
TEST_F(ProviderInterfaceTest, download)
405
360
{
406
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
361
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
407
362
 
408
363
    QString download_id;
409
364
    QDBusUnixFileDescriptor socket;
446
401
 
447
402
TEST_F(ProviderInterfaceTest, download_short_read)
448
403
{
449
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
404
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
450
405
 
451
406
    QString download_id;
452
407
    QDBusUnixFileDescriptor socket;
466
421
 
467
422
TEST_F(ProviderInterfaceTest, finish_download_unknown)
468
423
{
469
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
424
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
470
425
 
471
426
    auto reply = client_->FinishDownload("no-such-download");
472
427
    wait_for(reply);
473
428
    ASSERT_TRUE(reply.isError());
474
429
    EXPECT_EQ(PROVIDER_ERROR + "UnknownException", reply.error().name());
475
 
    EXPECT_EQ("map::at", reply.error().message());
 
430
    EXPECT_EQ("unknown exception thrown by provider: map::at", reply.error().message());
476
431
}
477
432
 
478
433
TEST_F(ProviderInterfaceTest, delete_)
479
434
{
480
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
435
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
481
436
 
482
437
    auto reply = client_->Delete("item_id");
483
438
    wait_for(reply);
486
441
 
487
442
TEST_F(ProviderInterfaceTest, move)
488
443
{
489
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
444
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
490
445
 
491
446
    auto reply = client_->Move("child_id", "new_parent_id", "New name");
492
447
    wait_for(reply);
500
455
 
501
456
TEST_F(ProviderInterfaceTest, copy)
502
457
{
503
 
    make_provider(unique_ptr<ProviderBase>(new TestProvider));
 
458
    set_provider(unique_ptr<ProviderBase>(new TestProvider));
504
459
 
505
460
    auto reply = client_->Copy("child_id", "new_parent_id", "New name");
506
461
    wait_for(reply);