← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libusermetrics/trusty-proposed

« back to all changes in this revision

Viewing changes to tests/unit/usermetricsservice/TestUserMetricsService.cpp

  • Committer: Package Import Robot
  • Author(s): Ubuntu daily release, Pete Woods, Ubuntu daily release
  • Date: 2013-07-02 02:02:52 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20130702020252-53yuhnlabsq1cq8x
Tags: 1.0.1+13.10.20130702-0ubuntu1
[ Pete Woods ]
* Implement most of storage service and wire up input API.
* Wire up the output API to the storage service.

[ Ubuntu daily release ]
* Automatic snapshot from revision 80

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit/usermetricsservice/TestUserMetricsService.cpp
 
1
/*
 
2
 * Copyright (C) 2013 Canonical, Ltd.
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or modify
 
5
 * it under the terms of the GNU General Public License as published by
 
6
 * the Free Software Foundation; version 3.
 
7
 *
 
8
 * This program is distributed in the hope that it will be useful,
 
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
 * GNU General Public License for more details.
 
12
 *
 
13
 * You should have received a copy of the GNU General Public License
 
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
15
 *
 
16
 * Author: Pete Woods <pete.woods@canonical.com>
 
17
 */
 
18
 
 
19
#include <usermetricsservice/DBusUserMetrics.h>
 
20
#include <usermetricsservice/DBusDataSource.h>
 
21
#include <usermetricsservice/DBusUserData.h>
 
22
#include <usermetricsservice/DBusDataSet.h>
 
23
#include <libusermetricscommon/DateFactory.h>
 
24
 
 
25
#include <testutils/DBusTest.h>
 
26
#include <testutils/QStringPrinter.h>
 
27
#include <testutils/QVariantListPrinter.h>
 
28
 
 
29
#include <QDjango.h>
 
30
 
 
31
#include <QSqlDatabase>
 
32
#include <QtCore/QVariantList>
 
33
 
 
34
#include <gtest/gtest.h>
 
35
#include <gmock/gmock.h>
 
36
 
 
37
using namespace std;
 
38
using namespace testing;
 
39
using namespace UserMetricsCommon;
 
40
using namespace UserMetricsService;
 
41
using namespace UserMetricsTestUtils;
 
42
 
 
43
namespace {
 
44
 
 
45
class MockDateFactory: public DateFactory {
 
46
public:
 
47
        MOCK_CONST_METHOD0(currentDate, QDate());
 
48
};
 
49
 
 
50
class TestUserMetricsService: public DBusTest {
 
51
protected:
 
52
        TestUserMetricsService() :
 
53
                        db(
 
54
                                        QSqlDatabase::addDatabase("QSQLITE",
 
55
                                                        "test-user-metrics-service")), dateFactory(
 
56
                                        new NiceMock<MockDateFactory>()) {
 
57
                db.setDatabaseName(":memory:");
 
58
                if (!db.open()) {
 
59
                        throw logic_error("couldn't open database");
 
60
                }
 
61
 
 
62
                ON_CALL(*dateFactory, currentDate()).WillByDefault(
 
63
                                Return(QDate(2001, 01, 07)));
 
64
 
 
65
//              QDjango::setDebugEnabled(true);
 
66
                QDjango::setDatabase(db);
 
67
        }
 
68
 
 
69
        virtual ~TestUserMetricsService() {
 
70
                QDjango::dropTables();
 
71
                db.close();
 
72
                QSqlDatabase::removeDatabase("test-user-metrics-service");
 
73
        }
 
74
 
 
75
        QSqlDatabase db;
 
76
 
 
77
        QSharedPointer<MockDateFactory> dateFactory;
 
78
};
 
79
 
 
80
TEST_F(TestUserMetricsService, PersistsDataSourcesBetweenRestart) {
 
81
        {
 
82
                DBusUserMetrics userMetrics(*connection, dateFactory);
 
83
 
 
84
                EXPECT_TRUE(userMetrics.dataSources().empty());
 
85
 
 
86
                EXPECT_EQ(QString("/com/canonical/UserMetrics/DataSource/1"),
 
87
                                userMetrics.createDataSource("facebook", "%1 messages received").path());
 
88
 
 
89
                DBusDataSourcePtr facebook(userMetrics.dataSource("facebook"));
 
90
                EXPECT_EQ(QString("facebook"), facebook->name());
 
91
                EXPECT_EQ(QString("%1 messages received"), facebook->formatString());
 
92
 
 
93
                QList<QDBusObjectPath> dataSources(userMetrics.dataSources());
 
94
                EXPECT_EQ(1, dataSources.size());
 
95
                EXPECT_EQ(QString("/com/canonical/UserMetrics/DataSource/1"),
 
96
                                dataSources.first().path());
 
97
        }
 
98
 
 
99
        {
 
100
                DBusUserMetrics userMetrics(*connection, dateFactory);
 
101
 
 
102
                QList<QDBusObjectPath> dataSources(userMetrics.dataSources());
 
103
                EXPECT_EQ(1, dataSources.size());
 
104
                EXPECT_EQ(QString("/com/canonical/UserMetrics/DataSource/1"),
 
105
                                dataSources.first().path());
 
106
 
 
107
                DBusDataSourcePtr facebook(userMetrics.dataSource("facebook"));
 
108
                EXPECT_EQ(QString("facebook"), facebook->name());
 
109
                EXPECT_EQ(QString("%1 messages received"), facebook->formatString());
 
110
        }
 
111
}
 
112
 
 
113
TEST_F(TestUserMetricsService, UpdatesFormatString) {
 
114
        {
 
115
                DBusUserMetrics userMetrics(*connection, dateFactory);
 
116
 
 
117
                userMetrics.createDataSource("twitter", "%1 tweets received");
 
118
 
 
119
                DBusDataSourcePtr twitter(userMetrics.dataSource("twitter"));
 
120
                EXPECT_EQ(QString("%1 tweets received"), twitter->formatString());
 
121
 
 
122
                twitter->setFormatString("%1 new format string");
 
123
                EXPECT_EQ(QString("%1 new format string"), twitter->formatString());
 
124
        }
 
125
 
 
126
        {
 
127
                DBusUserMetrics userMetrics(*connection, dateFactory);
 
128
 
 
129
                DBusDataSourcePtr twitter(userMetrics.dataSource("twitter"));
 
130
                EXPECT_EQ(QString("%1 new format string"), twitter->formatString());
 
131
        }
 
132
}
 
133
 
 
134
TEST_F(TestUserMetricsService, PersistsUserDataBetweenRestart) {
 
135
        {
 
136
                DBusUserMetrics userMetrics(*connection, dateFactory);
 
137
 
 
138
                EXPECT_TRUE(userMetrics.dataSources().empty());
 
139
 
 
140
                EXPECT_EQ(QString("/com/canonical/UserMetrics/UserData/1"),
 
141
                                userMetrics.createUserData("alice").path());
 
142
 
 
143
                DBusUserDataPtr alice(userMetrics.userData("alice"));
 
144
                EXPECT_EQ(QString("alice"), alice->username());
 
145
 
 
146
                QList<QDBusObjectPath> userData(userMetrics.userDatas());
 
147
                EXPECT_EQ(1, userData.size());
 
148
                EXPECT_EQ(QString("/com/canonical/UserMetrics/UserData/1"),
 
149
                                userData.first().path());
 
150
        }
 
151
 
 
152
        {
 
153
                DBusUserMetrics userMetrics(*connection, dateFactory);
 
154
 
 
155
                QList<QDBusObjectPath> userData(userMetrics.userDatas());
 
156
                EXPECT_EQ(1, userData.size());
 
157
                EXPECT_EQ(QString("/com/canonical/UserMetrics/UserData/1"),
 
158
                                userData.first().path());
 
159
 
 
160
                DBusUserDataPtr alice(userMetrics.userData("alice"));
 
161
                EXPECT_EQ(QString("alice"), alice->username());
 
162
        }
 
163
}
 
164
 
 
165
TEST_F(TestUserMetricsService, PersistsDataSetsBetweenRestart) {
 
166
        QVariantList data( { 100.0, 50.0, 0.0, -50.0, -100.0 });
 
167
 
 
168
        {
 
169
                DBusUserMetrics userMetrics(*connection, dateFactory);
 
170
 
 
171
                userMetrics.createDataSource("twitter", "%1 tweets received");
 
172
                userMetrics.createUserData("alice");
 
173
 
 
174
                DBusUserDataPtr alice(userMetrics.userData("alice"));
 
175
 
 
176
                EXPECT_TRUE(alice->dataSets().empty());
 
177
 
 
178
                // should re-use the same data set
 
179
                EXPECT_EQ(QString("/com/canonical/UserMetrics/DataSet/1"),
 
180
                                alice->createDataSet("twitter").path());;
 
181
                EXPECT_EQ(QString("/com/canonical/UserMetrics/DataSet/1"),
 
182
                                alice->createDataSet("twitter").path());;
 
183
 
 
184
                DBusDataSetPtr twitter(alice->dataSet("twitter"));
 
185
                EXPECT_EQ(1, twitter->id());
 
186
 
 
187
                QList<QDBusObjectPath> dataSets(alice->dataSets());
 
188
                EXPECT_EQ(1, dataSets.size());
 
189
                EXPECT_EQ(QString("/com/canonical/UserMetrics/DataSet/1"),
 
190
                                dataSets.first().path());
 
191
 
 
192
                twitter->update(data);
 
193
        }
 
194
 
 
195
        {
 
196
                DBusUserMetrics userMetrics(*connection, dateFactory);
 
197
 
 
198
                DBusUserDataPtr alice(userMetrics.userData("alice"));
 
199
                EXPECT_EQ(QString("alice"), alice->username());
 
200
 
 
201
                QList<QDBusObjectPath> dataSets(alice->dataSets());
 
202
                EXPECT_EQ(1, dataSets.size());
 
203
                EXPECT_EQ(QString("/com/canonical/UserMetrics/DataSet/1"),
 
204
                                dataSets.first().path());
 
205
 
 
206
                DBusDataSetPtr twitter(alice->dataSet("twitter"));
 
207
                EXPECT_EQ(1, twitter->id());
 
208
 
 
209
                EXPECT_EQ(data, twitter->data());
 
210
        }
 
211
}
 
212
 
 
213
TEST_F(TestUserMetricsService, CreateDataSetsWithUnknownSourceFailsGracefully) {
 
214
        DBusUserMetrics userMetrics(*connection, dateFactory);
 
215
 
 
216
        userMetrics.createUserData("bob");
 
217
        DBusUserDataPtr bob(userMetrics.userData("bob"));
 
218
 
 
219
        EXPECT_EQ(QString(), bob->createDataSet("twitter").path());
 
220
}
 
221
 
 
222
TEST_F(TestUserMetricsService, UpdateData) {
 
223
        EXPECT_CALL(*dateFactory, currentDate()).Times(2).WillOnce(
 
224
                        Return(QDate(2001, 01, 5))).WillOnce(Return(QDate(2001, 01, 8)));
 
225
 
 
226
        DBusUserMetrics userMetrics(*connection, dateFactory);
 
227
        userMetrics.createDataSource("twitter", "foo");
 
228
 
 
229
        userMetrics.createUserData("bob");
 
230
        DBusUserDataPtr bob(userMetrics.userData("bob"));
 
231
 
 
232
        bob->createDataSet("twitter");
 
233
        DBusDataSetPtr twitter(bob->dataSet("twitter"));
 
234
 
 
235
        QVariantList first( { 5.0, 4.0, 3.0, 2.0, 1.0 });
 
236
        QVariantList second( { 10.0, 9.0, 8.0, 7.0, 6.0 });
 
237
        QVariantList expected( { 10.0, 9.0, 8.0, 7.0, 6.0, 3.0, 2.0, 1.0 });
 
238
 
 
239
        // first update happens on the 5th of the month
 
240
        twitter->update(first);
 
241
        EXPECT_EQ(first, twitter->data());
 
242
        EXPECT_EQ(QDate(2001, 01, 5), twitter->lastUpdatedDate());
 
243
 
 
244
        // second update happens on the 8th of the month
 
245
        // -> 3 new data points and 2 overwritten
 
246
        twitter->update(second);
 
247
        EXPECT_EQ(expected, twitter->data());
 
248
        EXPECT_EQ(QDate(2001, 01, 8), twitter->lastUpdatedDate());
 
249
}
 
250
 
 
251
TEST_F(TestUserMetricsService, UpdateDataWithGap) {
 
252
        EXPECT_CALL(*dateFactory, currentDate()).Times(2).WillOnce(
 
253
                        Return(QDate(2001, 01, 5))).WillOnce(Return(QDate(2001, 01, 15)));
 
254
 
 
255
        DBusUserMetrics userMetrics(*connection, dateFactory);
 
256
        userMetrics.createDataSource("twitter", "foo");
 
257
 
 
258
        userMetrics.createUserData("bob");
 
259
        DBusUserDataPtr bob(userMetrics.userData("bob"));
 
260
 
 
261
        bob->createDataSet("twitter");
 
262
        DBusDataSetPtr twitter(bob->dataSet("twitter"));
 
263
 
 
264
        QVariantList first( { 5.0, 4.0, 3.0, 2.0, 1.0 });
 
265
        QVariantList second( { 10.0, 9.0, 8.0, 7.0, 6.0 });
 
266
        QVariantList expected;
 
267
        expected.append(second);
 
268
        for (int i(0); i < 5; ++i) {
 
269
                expected.append(QVariant(""));
 
270
        }
 
271
        expected.append(first);
 
272
 
 
273
        // first update happens on the 5th of the month
 
274
        twitter->update(first);
 
275
        EXPECT_EQ(first, twitter->data());
 
276
        EXPECT_EQ(QDate(2001, 01, 5), twitter->lastUpdatedDate());
 
277
 
 
278
        // second update happens on the 15th of the month
 
279
        // -> 5 new data points, 5 nulls, and none overwritten
 
280
        twitter->update(second);
 
281
        EXPECT_EQ(expected, twitter->data());
 
282
        EXPECT_EQ(QDate(2001, 01, 15), twitter->lastUpdatedDate());
 
283
}
 
284
 
 
285
TEST_F(TestUserMetricsService, UpdateDataTotallyOverwrite) {
 
286
        EXPECT_CALL(*dateFactory, currentDate()).Times(2).WillOnce(
 
287
                        Return(QDate(2001, 01, 5))).WillOnce(Return(QDate(2001, 01, 7)));
 
288
 
 
289
        DBusUserMetrics userMetrics(*connection, dateFactory);
 
290
        userMetrics.createDataSource("twitter", "foo");
 
291
 
 
292
        userMetrics.createUserData("bob");
 
293
        DBusUserDataPtr bob(userMetrics.userData("bob"));
 
294
 
 
295
        bob->createDataSet("twitter");
 
296
        DBusDataSetPtr twitter(bob->dataSet("twitter"));
 
297
 
 
298
        QVariantList first( { 3.0, 2.0, 1.0 });
 
299
        QVariantList second( { 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0 });
 
300
        QVariantList &expected(second);
 
301
 
 
302
        // first update happens on the 5th of the month
 
303
        twitter->update(first);
 
304
        EXPECT_EQ(first, twitter->data());
 
305
        EXPECT_EQ(QDate(2001, 01, 5), twitter->lastUpdatedDate());
 
306
 
 
307
        // second update happens on the 7th of the month
 
308
        // -> 2 new data points, 3 overwrites, and 2 new appends
 
309
        twitter->update(second);
 
310
        EXPECT_EQ(expected, twitter->data());
 
311
        EXPECT_EQ(QDate(2001, 01, 7), twitter->lastUpdatedDate());
 
312
}
 
313
 
 
314
} // namespace