← Back to branch summary

~ci-train-bot/content-hub/content-hub-ubuntu-zesty-2335

« back to all changes in this revision

Viewing changes to tests/acceptance-tests/app_hub_communication_transfer.cpp

  • Committer: Bileto Bot
  • Date: 2017-01-04 16:58:46 UTC
  • mfrom: (300.2.75 content-hub-clipboard)
  • Revision ID: ci-train-bot@canonical.com-20170104165846-uthgk1ap1u4m3q7a
New upstream version to reflect addition of the out of process
peer picker

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/acceptance-tests/app_hub_communication_transfer.cpp
86
86
    using namespace ::testing;
87
87
 
88
88
    test::CrossProcessSync sync;
 
89
 
 
90
    QString default_peer_id{"com.does.not.exist.anywhere.application"};
89
91
    
90
 
    auto parent = [&sync]()
 
92
    auto parent = [&sync, default_peer_id]()
91
93
    {
92
94
        int argc = 0;
93
95
        QCoreApplication app{argc, nullptr};
94
96
 
95
 
        QString default_peer_id{"com.does.not.exist.anywhere.application"};
96
 
 
97
97
        QDBusConnection connection = QDBusConnection::sessionBus();        
98
98
        
99
99
        auto mock = new ::testing::NiceMock<MockedPeerRegistry>{};
100
 
        EXPECT_CALL(*mock, default_source_for_type(_)).
101
 
        Times(AtLeast(1)).
102
 
        WillRepeatedly(Return(cuc::Peer{default_peer_id}));
 
100
        auto mock_app_manager = new MockedAppManager();
 
101
        EXPECT_CALL(*mock_app_manager, is_application_started(_)).
 
102
        Times(AtLeast(1)).
 
103
        WillRepeatedly(Return(true));
 
104
        EXPECT_CALL(*mock_app_manager, invoke_application(_,_)).
 
105
        Times(AtLeast(1)).
 
106
        WillRepeatedly(Return(true));
103
107
        
104
108
        QSharedPointer<cucd::PeerRegistry> registry{mock};
105
 
        auto app_manager = QSharedPointer<cua::ApplicationManager>(new MockedAppManager());
 
109
        auto app_manager = QSharedPointer<cua::ApplicationManager>(mock_app_manager);
106
110
        cucd::Service implementation(connection, registry, app_manager, &app);
107
111
        new ServiceAdaptor(std::addressof(implementation));
108
112
 
119
123
        app.exec();
120
124
    };
121
125
 
122
 
    auto child = [&sync]()
 
126
    auto child = [&sync, default_peer_id]()
123
127
    {
 
128
        sync.wait_for_signal_ready();
124
129
        int argc = 0;
125
130
        QCoreApplication app(argc, nullptr);
126
131
        app.setApplicationName("com.some.test.app");
127
 
 
128
 
        sync.wait_for_signal_ready();
129
132
        
 
133
        auto hub = cuc::Hub::Client::instance();
130
134
        test::TestHarness harness;
131
 
        harness.add_test_case([]()
 
135
        harness.add_test_case([hub, default_peer_id]()
132
136
        {
133
137
            QTemporaryDir store_dir;
134
138
            QVector<cuc::Item> source_items;
156
160
            }
157
161
 
158
162
            /** [Importing pictures] */
159
 
            auto hub = cuc::Hub::Client::instance();
160
 
            auto transfer = hub->create_import_from_peer(
161
 
                hub->default_source_for_type(cuc::Type::Known::pictures()));
 
163
            auto transfer = hub->create_import_from_peer(cuc::Peer{default_peer_id});
162
164
            ASSERT_TRUE(transfer != nullptr);
163
165
            EXPECT_EQ(cuc::Transfer::created, transfer->state());
164
166
            ASSERT_FALSE(hub->has_pending(transfer->destination()));
175
177
            EXPECT_EQ(expected_items, transfer->collect());
176
178
            /** [Importing pictures] */
177
179
 
178
 
            /** Test that the transfer aborts when destination file exists */
179
 
            auto dupe_transfer = hub->create_import_from_peer(
180
 
                hub->default_source_for_type(cuc::Type::Known::pictures()));
181
 
            ASSERT_TRUE(dupe_transfer != nullptr);
182
 
            EXPECT_EQ(cuc::Transfer::created, dupe_transfer->state());
183
 
            EXPECT_TRUE(dupe_transfer->setSelectionType(cuc::Transfer::SelectionType::multiple));
184
 
            ASSERT_EQ(cuc::Transfer::SelectionType::multiple, dupe_transfer->selectionType());
185
 
            dupe_transfer->setStore(new cuc::Store{store_dir.path()});
186
 
            EXPECT_TRUE(dupe_transfer->start());
187
 
            EXPECT_EQ(cuc::Transfer::initiated, dupe_transfer->state());
188
 
            EXPECT_TRUE(dupe_transfer->charge(source_items));
189
 
            EXPECT_EQ(cuc::Transfer::aborted, dupe_transfer->state());
190
 
            /* end dest exists test */
191
 
 
192
180
            /* Test that only a single transfer exists for the same peer */
193
 
            auto single_transfer = hub->create_import_from_peer(
194
 
                hub->default_source_for_type(cuc::Type::Known::pictures()));
 
181
            auto single_transfer = hub->create_import_from_peer(cuc::Peer{default_peer_id});
195
182
            ASSERT_TRUE(single_transfer != nullptr);
196
183
            EXPECT_EQ(cuc::Transfer::created, single_transfer->state());
197
184
            EXPECT_TRUE(single_transfer->start());
198
185
            EXPECT_EQ(cuc::Transfer::initiated, single_transfer->state());
199
186
 
200
 
            auto second_transfer = hub->create_import_from_peer(
201
 
                hub->default_source_for_type(cuc::Type::Known::pictures()));
 
187
            auto second_transfer = hub->create_import_from_peer(cuc::Peer{default_peer_id});
202
188
            ASSERT_TRUE(second_transfer != nullptr);
203
189
            EXPECT_EQ(cuc::Transfer::created, second_transfer->state());
204
190
            /* Now that a second transfer was created, the previous
207
193
            /* end single transfer test */
208
194
 
209
195
            /* Test create_import_from_peer_for_type */
210
 
            auto type_transfer = hub->create_import_from_peer_for_type(
211
 
                hub->default_source_for_type(cuc::Type::Known::pictures()),
212
 
                cuc::Type::Known::pictures());
 
196
            auto type_transfer = hub->create_import_from_peer_for_type(cuc::Peer{default_peer_id}, cuc::Type::Known::pictures());
213
197
            ASSERT_TRUE(type_transfer != nullptr);
214
198
            EXPECT_EQ(cuc::Transfer::created, type_transfer->state());
215
 
            EXPECT_TRUE(transfer->setSelectionType(cuc::Transfer::SelectionType::multiple));
216
 
            ASSERT_EQ(cuc::Transfer::SelectionType::multiple, transfer->selectionType());
 
199
            EXPECT_TRUE(type_transfer->setSelectionType(cuc::Transfer::SelectionType::multiple));
 
200
            ASSERT_EQ(cuc::Transfer::SelectionType::multiple, type_transfer->selectionType());
217
201
            EXPECT_TRUE(type_transfer->start());
218
202
            EXPECT_EQ(cuc::Transfer::initiated, type_transfer->state());
219
203
            ASSERT_EQ(cuc::Type::Known::pictures().id(), type_transfer->contentType());
221
205
            EXPECT_EQ(cuc::Transfer::aborted, type_transfer->state());
222
206
            /* end create_import_from_peer_for_type test */
223
207
 
224
 
            hub->quit();
225
208
        });
226
209
        EXPECT_EQ(0, QTest::qExec(std::addressof(harness)));
 
210
        hub->quit();
227
211
    };
228
212
    
229
213
    EXPECT_EQ(EXIT_SUCCESS, test::fork_and_run(child, parent));