← Back to branch summary

~jonas-drange/ubuntu-system-settings/filepicker

« back to all changes in this revision

Viewing changes to tests/plugins/system-update/tst_imagemanager.cpp

  • Committer: Jonas G. Drange
  • Date: 2016-10-14 13:59:02 UTC
  • mfrom: (1673.1.55 ubuntu-system-settings)
  • Revision ID: jonas.drange@canonical.com-20161014135902-9xufvqt524iaurit
sync trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/plugins/system-update/tst_imagemanager.cpp
 
1
/*
 
2
 * This file is part of system-settings
 
3
 *
 
4
 * Copyright (C) 2016 Canonical Ltd.
 
5
 *
 
6
 * This program is free software: you can redistribute it and/or modify it
 
7
 * under the terms of the GNU General Public License version 3, as published
 
8
 * by the Free Software Foundation.
 
9
 *
 
10
 * This program is distributed in the hope that it will be useful, but
 
11
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 
12
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
 
13
 * PURPOSE.  See the GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License along
 
16
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 
17
 */
 
18
 
 
19
#include "updatedb.h"
 
20
#include "systemimage.h"
 
21
#include "image/imagemanager_impl.h"
 
22
 
 
23
#include "system-image-dbus/fakesystemimagedbus.h"
 
24
 
 
25
#include <libqtdbusmock/MethodCall.h>
 
26
 
 
27
#include <QSignalSpy>
 
28
#include <QTest>
 
29
#include <QVariantMap>
 
30
 
 
31
using namespace UpdatePlugin;
 
32
 
 
33
Q_DECLARE_METATYPE(Update::State)
 
34
 
 
35
class TstImageManager : public QObject
 
36
{
 
37
    Q_OBJECT
 
38
private slots:
 
39
    void init()
 
40
    {
 
41
        m_model = new UpdateModel(":memory:");
 
42
 
 
43
        QVariantMap parameters;
 
44
        parameters["build_number"] = 1;
 
45
        parameters["target_build_number"] = 2;
 
46
        m_siMock = new FakeSystemImageDbus(parameters);
 
47
        m_dbus = new QDBusConnection(m_siMock->dbus());
 
48
        m_systemImage = new QSystemImage(*m_dbus);
 
49
        m_mock = new QDBusInterface(SI_SERVICE,
 
50
                                    SI_MAIN_OBJECT,
 
51
                                    "org.freedesktop.DBus.Mock",
 
52
                                    *m_dbus);
 
53
 
 
54
        m_instance = new Image::ManagerImpl(m_systemImage, m_model);
 
55
 
 
56
        m_methodSpy = new QSignalSpy(
 
57
            m_mock, SIGNAL(MethodCalled(const QString &, const QVariantList &))
 
58
        );
 
59
 
 
60
        connect(this, SIGNAL(mockCheckingForUpdatesChanged()),
 
61
                m_instance, SLOT(handleCheckingForUpdatesChanged()));
 
62
        connect(this,
 
63
            SIGNAL(mockUpdateAvailableStatus(const bool, const bool, const QString&,
 
64
                                             const int&, const QString&,
 
65
                                             const QString&)),
 
66
            m_instance,
 
67
            SLOT(handleUpdateAvailableStatus(const bool, const bool, const QString&,
 
68
                                             const int&, const QString&,
 
69
                                             const QString&))
 
70
        );
 
71
        connect(this, SIGNAL(mockDownloadStarted()),
 
72
                m_instance, SLOT(handleDownloadStarted()));
 
73
        connect(this, SIGNAL(mockUpdateProgress(const int&, const double&)),
 
74
                m_instance, SLOT(handleUpdateProgress(const int&, const double&)));
 
75
        connect(this, SIGNAL(mockUpdatePaused(const int&)),
 
76
                m_instance, SLOT(handleUpdatePaused(const int&)));
 
77
        connect(this, SIGNAL(mockUpdateDownloaded()),
 
78
                m_instance, SLOT(handleUpdateDownloaded()));
 
79
        connect(this, SIGNAL(mockUpdateFailed(const int&, const QString&)),
 
80
                m_instance, SLOT(handleUpdateFailed(const int&, const QString&)));
 
81
        connect(this, SIGNAL(mockCurrentBuildNumberChanged()),
 
82
                m_instance, SLOT(handleCurrentBuildNumberChanged()));
 
83
        connect(this, SIGNAL(mockRebooting(const bool)),
 
84
                m_instance, SLOT(handleRebooting(const bool)));
 
85
        connect(this, SIGNAL(mockUpdateProcessing()),
 
86
                m_instance, SLOT(handleUpdateProcessing()));
 
87
        connect(this, SIGNAL(mockUpdateProcessFailed(const QString&)),
 
88
                m_instance, SLOT(handleUpdateProcessFailed(const QString&)));
 
89
 
 
90
    }
 
91
    void cleanup()
 
92
    {
 
93
        QSignalSpy destroyedSpy(m_instance, SIGNAL(destroyed(QObject*)));
 
94
        m_instance->deleteLater();
 
95
        QTRY_COMPARE(destroyedSpy.count(), 1);
 
96
        delete m_model;
 
97
        delete m_mock;
 
98
        delete m_systemImage;
 
99
        delete m_dbus;
 
100
        delete m_siMock;
 
101
    }
 
102
    void testCheck()
 
103
    {
 
104
        m_instance->check();
 
105
        QVERIFY(m_methodSpy->wait());
 
106
        QDBusReply<QList<MethodCall>> reply = m_mock->call("GetMethodCalls", "CheckForUpdate");
 
107
        QVERIFY2(reply.isValid(), "Method was not called correctly.");
 
108
        QCOMPARE(reply.value().size(), 1); // Called once.
 
109
    }
 
110
    void testCancel()
 
111
    {
 
112
        m_instance->cancel();
 
113
        QVERIFY(m_methodSpy->wait());
 
114
        QDBusReply<QList<MethodCall>> reply = m_mock->call("GetMethodCalls", "CancelUpdate");
 
115
        QVERIFY2(reply.isValid(), "Method was not called correctly.");
 
116
        QCOMPARE(reply.value().size(), 1); // Called once.
 
117
    }
 
118
    void testUpdateAvailableStatus_data()
 
119
    {
 
120
        QTest::addColumn<bool>("isAvailable");
 
121
        QTest::addColumn<bool>("downloading");
 
122
        QTest::addColumn<QString>("availableVersion");
 
123
        QTest::addColumn<QString>("errorReason");
 
124
        QTest::addColumn<int>("downloadMode");
 
125
        QTest::addColumn<Update::State>("targetState");
 
126
 
 
127
        QTest::newRow("update") << true << false << "50" << "" << 0 << Update::State::StateAvailable;
 
128
        QTest::newRow("no update") << false << false << "50" << "" << 0 << Update::State::StateAvailable;
 
129
        QTest::newRow("downloading") << true << true << "50" << "" << 0 << Update::State::StateDownloading;
 
130
        QTest::newRow("paused") << true << false << "50" << "paused" << 0 << Update::State::StateDownloadPaused;
 
131
        QTest::newRow("(auto) downloading") << true << true << "50" << "" << 1 << Update::State::StateDownloadingAutomatically;
 
132
        QTest::newRow("(auto) paused") << true << false << "50" << "paused" << 1 << Update::State::StateAutomaticDownloadPaused;
 
133
    }
 
134
    void testUpdateAvailableStatus()
 
135
    {
 
136
        QFETCH(bool, isAvailable);
 
137
        QFETCH(bool, downloading);
 
138
        QFETCH(QString, availableVersion);
 
139
        QFETCH(QString, errorReason);
 
140
        QFETCH(int, downloadMode);
 
141
        QFETCH(Update::State, targetState);
 
142
 
 
143
        // Decides whether or not a download is automatic.
 
144
        m_systemImage->setDownloadMode(downloadMode);
 
145
 
 
146
        Q_EMIT mockUpdateAvailableStatus(isAvailable, downloading,
 
147
                                         availableVersion, 0, "", errorReason);
 
148
 
 
149
        QSharedPointer<Update> u = m_model->fetch(Image::ManagerImpl::ubuntuId, 50);
 
150
        if (isAvailable) {
 
151
            QVERIFY(!u.isNull());
 
152
        }
 
153
 
 
154
        if (downloading) {
 
155
            QCOMPARE(u->identifier(), Image::ManagerImpl::ubuntuId);
 
156
            QCOMPARE(u->state(), targetState);
 
157
        }
 
158
    }
 
159
    void testDownloadStarted()
 
160
    {
 
161
        m_model->setImageUpdate(Image::ManagerImpl::ubuntuId, 2, 0);
 
162
        Q_EMIT mockDownloadStarted();
 
163
        QSharedPointer<Update> u = m_model->fetch(Image::ManagerImpl::ubuntuId, 2);
 
164
        QCOMPARE(u->state(), Update::State::StateDownloading);
 
165
    }
 
166
    void testUpdateProgress()
 
167
    {
 
168
        m_model->setImageUpdate(Image::ManagerImpl::ubuntuId, 2, 0);
 
169
        Q_EMIT mockUpdateProgress(50, 0);
 
170
        QSharedPointer<Update> u = m_model->fetch(Image::ManagerImpl::ubuntuId, 2);
 
171
        QCOMPARE(u->state(), Update::State::StateDownloading);
 
172
        QCOMPARE(u->progress(), 50);
 
173
    }
 
174
    void testUpdatePaused()
 
175
    {
 
176
        m_model->setImageUpdate(Image::ManagerImpl::ubuntuId, 2, 0);
 
177
        Q_EMIT mockUpdatePaused(50);
 
178
        QSharedPointer<Update> u = m_model->fetch(Image::ManagerImpl::ubuntuId, 2);
 
179
        QCOMPARE(u->state(), Update::State::StateDownloadPaused);
 
180
        QCOMPARE(u->progress(), 50);
 
181
    }
 
182
    void testUpdateDownloaded()
 
183
    {
 
184
        m_model->setImageUpdate(Image::ManagerImpl::ubuntuId, 2, 0);
 
185
        Q_EMIT mockUpdateDownloaded();
 
186
        QSharedPointer<Update> u = m_model->fetch(Image::ManagerImpl::ubuntuId, 2);
 
187
        QCOMPARE(u->state(), Update::State::StateDownloaded);
 
188
    }
 
189
    void testUpdateFailed()
 
190
    {
 
191
        m_model->setImageUpdate(Image::ManagerImpl::ubuntuId, 2, 0);
 
192
        Q_EMIT mockUpdateFailed(1, "failure");
 
193
        QSharedPointer<Update> u = m_model->fetch(Image::ManagerImpl::ubuntuId, 2);
 
194
        QCOMPARE(u->error(), QString("failure"));
 
195
    }
 
196
    void testCurrentBuildNumberChanged()
 
197
    {
 
198
        /* Makes sure any updates that has the current build number are marked
 
199
        as installed. */
 
200
        m_model->setImageUpdate(Image::ManagerImpl::ubuntuId, 1, 0);
 
201
        Q_EMIT mockCurrentBuildNumberChanged();
 
202
        QSharedPointer<Update> u = m_model->fetch(Image::ManagerImpl::ubuntuId, 1);
 
203
        QVERIFY(u->installed());
 
204
    }
 
205
    void testRebooting_data()
 
206
    {
 
207
        /* status: A boolean indicating whether the device has initiated a reboot
 
208
        sequence or not. */
 
209
        QTest::addColumn<bool>("status");
 
210
        QTest::newRow("initiated") << true;
 
211
        QTest::newRow("not initiated") << false;
 
212
    }
 
213
    void testRebooting()
 
214
    {
 
215
        QFETCH(bool, status);
 
216
        m_model->setImageUpdate(Image::ManagerImpl::ubuntuId, 2, 0);
 
217
        Q_EMIT mockRebooting(status);
 
218
        QSharedPointer<Update> u = m_model->fetch(Image::ManagerImpl::ubuntuId, 2);
 
219
        if (status) {
 
220
            QCOMPARE(u->state(), Update::State::StateInstalling);
 
221
        } else {
 
222
            QCOMPARE(u->state(), Update::State::StateFailed);
 
223
        }
 
224
    }
 
225
    void testUpdateProcessing()
 
226
    {
 
227
        m_model->setImageUpdate(Image::ManagerImpl::ubuntuId, 2, 0);
 
228
        Q_EMIT mockUpdateProcessing();
 
229
        QSharedPointer<Update> u = m_model->fetch(Image::ManagerImpl::ubuntuId, 2);
 
230
        QCOMPARE(u->state(), Update::State::StateInstalling);
 
231
    }
 
232
    void testUpdateProcessFailed()
 
233
    {
 
234
        m_model->setImageUpdate(Image::ManagerImpl::ubuntuId, 2, 0);
 
235
        Q_EMIT mockUpdateProcessFailed("failure");
 
236
        QSharedPointer<Update> u = m_model->fetch(Image::ManagerImpl::ubuntuId, 2);
 
237
        QCOMPARE(u->state(), Update::State::StateFailed);
 
238
        QCOMPARE(u->error(), QString("failure"));
 
239
    }
 
240
Q_SIGNALS:
 
241
    void mockUpdateAvailableStatus(const bool isAvailable,
 
242
                                   const bool downloading,
 
243
                                   const QString &availableVersion,
 
244
                                   const int &updateSize,
 
245
                                   const QString &lastUpdateDate,
 
246
                                   const QString &errorReason);
 
247
    void mockDownloadStarted();
 
248
    void mockUpdateProgress(const int &percentage, const double &eta);
 
249
    void mockUpdatePaused(const int &percentage);
 
250
    void mockUpdateDownloaded();
 
251
    void mockUpdateFailed(const int &consecutiveFailureCount, const QString &lastReason);
 
252
    void mockCurrentBuildNumberChanged();
 
253
    void mockRebooting(const bool status);
 
254
    void mockUpdateProcessing();
 
255
    void mockUpdateProcessFailed(const QString &reason);
 
256
    void mockCheckingForUpdatesChanged();
 
257
 
 
258
private:
 
259
    QSignalSpy *m_methodSpy;
 
260
    FakeSystemImageDbus *m_siMock = nullptr;
 
261
    QDBusConnection *m_dbus = nullptr;
 
262
    QSystemImage *m_systemImage = nullptr;
 
263
    QDBusInterface *m_mock = nullptr;
 
264
    Image::Manager *m_instance = nullptr;
 
265
    UpdateModel *m_model = nullptr;
 
266
};
 
267
 
 
268
QTEST_GUILESS_MAIN(TstImageManager)
 
269
#include "tst_imagemanager.moc"