← Back to branch summary

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

« back to all changes in this revision

Viewing changes to tests/unit/libusermetricsoutput/TestSyncedUserMetricsStore.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/libusermetricsoutput/TestSyncedUserMetricsStore.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 <libusermetricsoutput/SyncedUserMetricsStore.h>
 
20
#include <libusermetricscommon/UserMetricsInterface.h>
 
21
#include <libusermetricscommon/UserDataInterface.h>
 
22
#include <libusermetricscommon/DataSetInterface.h>
 
23
#include <libusermetricscommon/DataSourceInterface.h>
 
24
#include <libusermetricscommon/DBusPaths.h>
 
25
 
 
26
#include <testutils/DBusTest.h>
 
27
#include <testutils/QStringPrinter.h>
 
28
#include <testutils/QVariantPrinter.h>
 
29
#include <testutils/QVariantListPrinter.h>
 
30
 
 
31
#include <QtTest/QSignalSpy>
 
32
 
 
33
#include <gtest/gtest.h>
 
34
 
 
35
using namespace std;
 
36
using namespace UserMetricsCommon;
 
37
using namespace UserMetricsOutput;
 
38
using namespace UserMetricsTestUtils;
 
39
 
 
40
namespace {
 
41
 
 
42
class TestSyncedUserMetricsStore: public DBusTest {
 
43
protected:
 
44
        TestSyncedUserMetricsStore() {
 
45
        }
 
46
 
 
47
        virtual ~TestSyncedUserMetricsStore() {
 
48
        }
 
49
};
 
50
 
 
51
TEST_F(TestSyncedUserMetricsStore, LoadsDataSourcesAtStartup) {
 
52
        com::canonical::UserMetrics userMetricsInterface(DBusPaths::serviceName(),
 
53
                        DBusPaths::userMetrics(), *connection);
 
54
 
 
55
        QDBusObjectPath dataSourcePath1(
 
56
                        userMetricsInterface.createDataSource("data-source-one",
 
57
                                        "format string one %1"));
 
58
        ASSERT_EQ(DBusPaths::dataSource(1), dataSourcePath1.path());
 
59
 
 
60
        QDBusObjectPath dataSourcePath2(
 
61
                        userMetricsInterface.createDataSource("data-source-two",
 
62
                                        "format string two %1"));
 
63
        ASSERT_EQ(DBusPaths::dataSource(2), dataSourcePath2.path());
 
64
 
 
65
        SyncedUserMetricsStore store(*connection);
 
66
 
 
67
        {
 
68
                DataSourcePtr dataSource(store.dataSource("data-source-one"));
 
69
                EXPECT_EQ(QString("format string one %1"), dataSource->formatString());
 
70
        }
 
71
 
 
72
        {
 
73
                DataSourcePtr dataSource(store.dataSource("data-source-two"));
 
74
                EXPECT_EQ(QString("format string two %1"), dataSource->formatString());
 
75
        }
 
76
}
 
77
 
 
78
TEST_F(TestSyncedUserMetricsStore, SyncsNewDataSources) {
 
79
        com::canonical::UserMetrics userMetricsInterface(DBusPaths::serviceName(),
 
80
                        DBusPaths::userMetrics(), *connection);
 
81
 
 
82
        QDBusObjectPath dataSourcePath1(
 
83
                        userMetricsInterface.createDataSource("data-source-one",
 
84
                                        "format string one %1"));
 
85
        ASSERT_EQ(DBusPaths::dataSource(1), dataSourcePath1.path());
 
86
 
 
87
        SyncedUserMetricsStore store(*connection);
 
88
 
 
89
        {
 
90
                DataSourcePtr dataSource(store.dataSource("data-source-one"));
 
91
                ASSERT_FALSE(dataSource.isNull());
 
92
                EXPECT_EQ(QString("format string one %1"), dataSource->formatString());
 
93
        }
 
94
 
 
95
        {
 
96
                DataSourcePtr dataSource(store.dataSource("data-source-two"));
 
97
                ASSERT_TRUE(dataSource.isNull());
 
98
        }
 
99
 
 
100
        QSignalSpy spy(&userMetricsInterface,
 
101
                        SIGNAL(dataSourceAdded(const QString &, const QDBusObjectPath &)));
 
102
 
 
103
        QDBusObjectPath dataSourcePath2(
 
104
                        userMetricsInterface.createDataSource("data-source-two",
 
105
                                        "format string two %1"));
 
106
        ASSERT_EQ(DBusPaths::dataSource(2), dataSourcePath2.path());
 
107
 
 
108
        spy.wait();
 
109
 
 
110
        {
 
111
                DataSourcePtr dataSource(store.dataSource("data-source-one"));
 
112
                ASSERT_FALSE(dataSource.isNull());
 
113
                EXPECT_EQ(QString("format string one %1"), dataSource->formatString());
 
114
        }
 
115
 
 
116
        {
 
117
                DataSourcePtr dataSource(store.dataSource("data-source-two"));
 
118
                ASSERT_FALSE(dataSource.isNull());
 
119
                EXPECT_EQ(QString("format string two %1"), dataSource->formatString());
 
120
        }
 
121
}
 
122
 
 
123
TEST_F(TestSyncedUserMetricsStore, LoadsUserDataAtStartup) {
 
124
        com::canonical::UserMetrics userMetricsInterface(DBusPaths::serviceName(),
 
125
                        DBusPaths::userMetrics(), *connection);
 
126
 
 
127
        QDBusObjectPath userDataPath(
 
128
                        userMetricsInterface.createUserData("username1"));
 
129
        ASSERT_EQ(DBusPaths::userData(1), userDataPath.path());
 
130
 
 
131
        QDBusObjectPath userDataPath2(
 
132
                        userMetricsInterface.createUserData("username2"));
 
133
        ASSERT_EQ(DBusPaths::userData(2), userDataPath2.path());
 
134
 
 
135
        SyncedUserMetricsStore store(*connection);
 
136
 
 
137
        {
 
138
                UserMetricsStore::const_iterator it(store.constFind("username1"));
 
139
                ASSERT_NE(it, store.constEnd());
 
140
                EXPECT_EQ(QString("username1"), it.key());
 
141
        }
 
142
 
 
143
        {
 
144
                UserMetricsStore::const_iterator it(store.constFind("username2"));
 
145
                ASSERT_NE(it, store.constEnd());
 
146
                EXPECT_EQ(QString("username2"), it.key());
 
147
        }
 
148
}
 
149
 
 
150
TEST_F(TestSyncedUserMetricsStore, SyncsNewUserData) {
 
151
        com::canonical::UserMetrics userMetricsInterface(DBusPaths::serviceName(),
 
152
                        DBusPaths::userMetrics(), *connection);
 
153
 
 
154
        QDBusObjectPath userDataPath(
 
155
                        userMetricsInterface.createUserData("username1"));
 
156
        ASSERT_EQ(DBusPaths::userData(1), userDataPath.path());
 
157
 
 
158
        SyncedUserMetricsStore store(*connection);
 
159
 
 
160
        {
 
161
                UserMetricsStore::const_iterator it(store.constFind("username1"));
 
162
                ASSERT_NE(it, store.constEnd());
 
163
                EXPECT_EQ(QString("username1"), it.key());
 
164
        }
 
165
 
 
166
        {
 
167
                UserMetricsStore::const_iterator it(store.constFind("username2"));
 
168
                ASSERT_EQ(it, store.constEnd());
 
169
        }
 
170
 
 
171
        QSignalSpy spy(&userMetricsInterface,
 
172
                        SIGNAL(userDataAdded(const QString &, const QDBusObjectPath &)));
 
173
 
 
174
        QDBusObjectPath userDataPath2(
 
175
                        userMetricsInterface.createUserData("username2"));
 
176
        ASSERT_EQ(DBusPaths::userData(2), userDataPath2.path());
 
177
 
 
178
        spy.wait();
 
179
 
 
180
        {
 
181
                UserMetricsStore::const_iterator it(store.constFind("username1"));
 
182
                ASSERT_NE(it, store.constEnd());
 
183
                EXPECT_EQ(QString("username1"), it.key());
 
184
        }
 
185
 
 
186
        {
 
187
                UserMetricsStore::const_iterator it(store.constFind("username2"));
 
188
                ASSERT_NE(it, store.constEnd());
 
189
                EXPECT_EQ(QString("username2"), it.key());
 
190
        }
 
191
}
 
192
 
 
193
TEST_F(TestSyncedUserMetricsStore, LoadsDataSetsAtStartup) {
 
194
        com::canonical::UserMetrics userMetricsInterface(DBusPaths::serviceName(),
 
195
                        DBusPaths::userMetrics(), *connection);
 
196
 
 
197
        QDBusObjectPath twitterPath(
 
198
                        userMetricsInterface.createDataSource("twitter",
 
199
                                        "twitter format string"));
 
200
        ASSERT_EQ(DBusPaths::dataSource(1), twitterPath.path());
 
201
 
 
202
        QDBusObjectPath userDataPath(
 
203
                        userMetricsInterface.createUserData("username"));
 
204
        ASSERT_EQ(DBusPaths::userData(1), userDataPath.path());
 
205
 
 
206
        com::canonical::usermetrics::UserData userDataInterface(
 
207
                        DBusPaths::serviceName(), DBusPaths::userData(1), *connection);
 
208
        QDBusObjectPath twitterDataPath(userDataInterface.createDataSet("twitter"));
 
209
        ASSERT_EQ(DBusPaths::dataSet(1), twitterDataPath.path());
 
210
 
 
211
        QVariantList data( { 100.0, 50.0, "", -50.0, -100.0 });
 
212
        QVariantList expected( { 100.0, 50.0, QVariant(), -50.0, -100.0 });
 
213
 
 
214
        com::canonical::usermetrics::DataSet dataSetInterface(
 
215
                        DBusPaths::serviceName(), DBusPaths::dataSet(1), *connection);
 
216
        dataSetInterface.update(data);
 
217
 
 
218
        SyncedUserMetricsStore store(*connection);
 
219
 
 
220
        UserMetricsStore::const_iterator userDataIterator(
 
221
                        store.constFind("username"));
 
222
        ASSERT_NE(userDataIterator, store.constEnd());
 
223
        EXPECT_EQ(QString("username"), userDataIterator.key());
 
224
        UserDataPtr userData(*userDataIterator);
 
225
 
 
226
        UserData::const_iterator dataSetIterator(userData->constBegin());
 
227
        ASSERT_NE(dataSetIterator, userData->constEnd());
 
228
        DataSetPtr dataSet(*dataSetIterator);
 
229
        EXPECT_EQ(expected, dataSet->data());
 
230
        EXPECT_EQ(QDate::currentDate(), dataSet->lastUpdated());
 
231
}
 
232
 
 
233
TEST_F(TestSyncedUserMetricsStore, SyncsNewDataSets) {
 
234
        com::canonical::UserMetrics userMetricsInterface(DBusPaths::serviceName(),
 
235
                        DBusPaths::userMetrics(), *connection);
 
236
 
 
237
        QDBusObjectPath twitterPath(
 
238
                        userMetricsInterface.createDataSource("twitter",
 
239
                                        "twitter format string"));
 
240
        ASSERT_EQ(DBusPaths::dataSource(1), twitterPath.path());
 
241
 
 
242
        QDBusObjectPath facebookPath(
 
243
                        userMetricsInterface.createDataSource("facebook",
 
244
                                        "facebook format string"));
 
245
        ASSERT_EQ(DBusPaths::dataSource(2), facebookPath.path());
 
246
 
 
247
        QDBusObjectPath userDataPath(
 
248
                        userMetricsInterface.createUserData("username"));
 
249
        ASSERT_EQ(DBusPaths::userData(1), userDataPath.path());
 
250
 
 
251
        com::canonical::usermetrics::UserData userDataInterface(
 
252
                        DBusPaths::serviceName(), DBusPaths::userData(1), *connection);
 
253
 
 
254
        QDBusObjectPath twitterDataPath(userDataInterface.createDataSet("twitter"));
 
255
        ASSERT_EQ(DBusPaths::dataSet(1), twitterDataPath.path());
 
256
 
 
257
        SyncedUserMetricsStore store(*connection);
 
258
 
 
259
        {
 
260
                UserMetricsStore::const_iterator userDataIterator(
 
261
                                store.constFind("username"));
 
262
                ASSERT_NE(userDataIterator, store.constEnd());
 
263
                EXPECT_EQ(QString("username"), userDataIterator.key());
 
264
                UserDataPtr userData(*userDataIterator);
 
265
 
 
266
                UserData::const_iterator dataSetIterator(userData->constBegin());
 
267
                ASSERT_NE(dataSetIterator, userData->constEnd());
 
268
                EXPECT_EQ(QString("twitter"), dataSetIterator.key());
 
269
 
 
270
                ++dataSetIterator;
 
271
                ASSERT_EQ(dataSetIterator, userData->constEnd());
 
272
        }
 
273
 
 
274
        QSignalSpy spy(&userDataInterface,
 
275
                        SIGNAL(dataSetAdded(const QString &, const QDBusObjectPath &)));
 
276
 
 
277
        QDBusObjectPath facebookDataPath(
 
278
                        userDataInterface.createDataSet("facebook"));
 
279
        ASSERT_EQ(DBusPaths::dataSet(2), facebookDataPath.path());
 
280
 
 
281
        spy.wait();
 
282
 
 
283
        {
 
284
                UserMetricsStore::const_iterator userDataIterator(
 
285
                                store.constFind("username"));
 
286
                ASSERT_NE(userDataIterator, store.constEnd());
 
287
                EXPECT_EQ(QString("username"), userDataIterator.key());
 
288
                UserDataPtr userData(*userDataIterator);
 
289
 
 
290
                UserData::const_iterator dataSetIterator(userData->constBegin());
 
291
 
 
292
                ASSERT_NE(dataSetIterator, userData->constEnd());
 
293
                EXPECT_EQ(QString("facebook"), dataSetIterator.key());
 
294
 
 
295
                ++dataSetIterator;
 
296
                ASSERT_NE(dataSetIterator, userData->constEnd());
 
297
                EXPECT_EQ(QString("twitter"), dataSetIterator.key());
 
298
 
 
299
                ++dataSetIterator;
 
300
                ASSERT_EQ(dataSetIterator, userData->constEnd());
 
301
        }
 
302
}
 
303
 
 
304
} // namespace