1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "device_matrix.h"
16
17 #include "block_data.h"
18 #include "device_manager_adapter.h"
19 #include "eventcenter/event_center.h"
20 #include "feature/feature_system.h"
21 #include "gtest/gtest.h"
22 #include "ipc_skeleton.h"
23 #include "matrix_event.h"
24 #include "metadata/meta_data_manager.h"
25 #include "metadata/store_meta_data_local.h"
26 #include "mock/db_store_mock.h"
27 #include "types.h"
28 using namespace testing::ext;
29 using namespace OHOS::DistributedData;
30 using namespace OHOS::DistributedKv;
31 using namespace OHOS;
32 using DMAdapter = DeviceManagerAdapter;
33 using namespace DistributedDB;
34 class DeviceMatrixTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40 protected:
41 struct Result {
42 uint16_t mask_ = MatrixMetaData::DEFAULT_MASK;
43 std::string deviceId_;
ResultDeviceMatrixTest::Result44 Result() {};
45 };
46 static constexpr const char *TEST_DEVICE = "14a0a92a428005db27c40bad46bf145fede38ec37effe0347cd990fcb031f320";
47 static constexpr const char *TEST_BUNDLE = "matrix_test";
48 static constexpr const char *TEST_STORE = "matrix_store";
49 static constexpr const char *TEST_USER = "0";
50 void InitRemoteMatrixMeta();
51 void InitMetaData();
52
53 static BlockData<Result> isFinished_;
54 static std::shared_ptr<DBStoreMock> dbStoreMock_;
55 static uint32_t selfToken_;
56 StoreMetaData metaData_;
57 StoreMetaDataLocal localMeta_;
58 };
59 BlockData<DeviceMatrixTest::Result> DeviceMatrixTest::isFinished_(1, Result());
60 std::shared_ptr<DBStoreMock> DeviceMatrixTest::dbStoreMock_ = std::make_shared<DBStoreMock>();
61 uint32_t DeviceMatrixTest::selfToken_ = 0;
SetUpTestCase(void)62 void DeviceMatrixTest::SetUpTestCase(void)
63 {
64 MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr, [](const auto &, auto) {
65 DeviceMatrix::GetInstance().OnChanged(DeviceMatrix::META_STORE_MASK);
66 });
67 selfToken_ = IPCSkeleton::GetCallingTokenID();
68 FeatureSystem::GetInstance().GetCreator("kv_store")();
69 DeviceMatrix::GetInstance().Initialize(selfToken_, "service_meta");
70 EventCenter::GetInstance().Subscribe(DeviceMatrix::MATRIX_ONLINE, [](const Event &event) {
71 auto &evt = static_cast<const MatrixEvent &>(event);
72 auto mask = evt.GetMask();
73 auto deviceId = evt.GetDeviceId();
74 if ((mask & DeviceMatrix::META_STORE_MASK) != 0) {
75 auto onComplete = [deviceId](const std::map<std::string, DBStatus> &) {
76 DeviceMatrix::GetInstance().OnExchanged(deviceId, DeviceMatrix::META_STORE_MASK);
77 };
78 dbStoreMock_->Sync({ deviceId }, SYNC_MODE_PUSH_PULL, onComplete, false);
79 }
80 #ifdef TEST_ON_DEVICE
81 auto finEvent = std::make_unique<MatrixEvent>(DeviceMatrix::MATRIX_META_FINISHED, deviceId, mask);
82 EventCenter::GetInstance().PostEvent(std::move(finEvent));
83 #endif
84 });
85
86 EventCenter::GetInstance().Subscribe(DeviceMatrix::MATRIX_META_FINISHED, [](const Event &event) {
87 auto &evt = static_cast<const MatrixEvent &>(event);
88 Result result;
89 result.deviceId_ = evt.GetDeviceId();
90 result.mask_ = evt.GetMask();
91 isFinished_.SetValue(result);
92 });
93
94 mkdir("/data/service/el1/public/database/matrix_test", (S_IRWXU | S_IRWXG | S_IRWXO));
95 mkdir("/data/service/el1/public/database/matrix_test/kvdb", (S_IRWXU | S_IRWXG | S_IRWXO));
96 }
97
TearDownTestCase(void)98 void DeviceMatrixTest::TearDownTestCase(void)
99 {
100 EventCenter::GetInstance().Unsubscribe(DeviceMatrix::MATRIX_ONLINE);
101 EventCenter::GetInstance().Unsubscribe(DeviceMatrix::MATRIX_META_FINISHED);
102 EventCenter::GetInstance().Unsubscribe(DeviceMatrix::MATRIX_BROADCAST);
103 }
104
SetUp()105 void DeviceMatrixTest::SetUp()
106 {
107 isFinished_.Clear(Result());
108 DeviceMatrix::GetInstance().Clear();
109 InitMetaData();
110 InitRemoteMatrixMeta();
111 }
112
TearDown()113 void DeviceMatrixTest::TearDown()
114 {
115 (void)remove("/data/service/el1/public/database/matrix_test/kvdb");
116 (void)remove("/data/service/el1/public/database/matrix_test");
117 }
118
InitRemoteMatrixMeta()119 void DeviceMatrixTest::InitRemoteMatrixMeta()
120 {
121 MatrixMetaData metaData;
122 metaData.version = 1;
123 metaData.mask = 0x3;
124 metaData.deviceId = TEST_DEVICE;
125 metaData.maskInfo = { "distributed_device_profile_service" };
126 MetaDataManager::GetInstance().DelMeta(metaData.GetKey());
127 MetaDataManager::GetInstance().SaveMeta(metaData.GetKey(), metaData);
128 }
129
InitMetaData()130 void DeviceMatrixTest::InitMetaData()
131 {
132 metaData_.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
133 metaData_.appId = TEST_BUNDLE;
134 metaData_.bundleName = TEST_BUNDLE;
135 metaData_.user = TEST_USER;
136 metaData_.area = EL1;
137 metaData_.tokenId = IPCSkeleton::GetCallingTokenID();
138 metaData_.instanceId = 0;
139 metaData_.isAutoSync = true;
140 metaData_.storeType = true;
141 metaData_.storeId = TEST_STORE;
142 PolicyValue value;
143 value.type = PolicyType::IMMEDIATE_SYNC_ON_ONLINE;
144 localMeta_.policies = { std::move(value) };
145 }
146
147 /**
148 * @tc.name: FirstOnline
149 * @tc.desc: the first online time;
150 * @tc.type: FUNC
151 * @tc.require:
152 * @tc.author: blue sky
153 */
154 HWTEST_F(DeviceMatrixTest, FirstOnline, TestSize.Level0)
155 {
156 DeviceMatrix::GetInstance().Online(TEST_DEVICE);
157 auto result = isFinished_.GetValue();
158 ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
159 ASSERT_EQ(result.mask_, 0x3);
160 }
161
162 /**
163 * @tc.name: OnlineAgainNoData
164 * @tc.desc: the second online with no data change;
165 * @tc.type: FUNC
166 * @tc.require:
167 * @tc.author: blue sky
168 */
169 HWTEST_F(DeviceMatrixTest, OnlineAgainNoData, TestSize.Level0)
170 {
171 DeviceMatrix::GetInstance().Online(TEST_DEVICE);
172 auto result = isFinished_.GetValue();
173 ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
174 ASSERT_EQ(result.mask_, 0x3);
175 isFinished_.Clear(Result());
176 DeviceMatrix::GetInstance().Offline(TEST_DEVICE);
177 DeviceMatrix::GetInstance().Online(TEST_DEVICE);
178 result = isFinished_.GetValue();
179 ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
180 ASSERT_EQ(result.mask_, 0x2);
181 }
182
183 /**
184 * @tc.name: OnlineAgainWithData
185 * @tc.desc: the second online with sync data change;
186 * @tc.type: FUNC
187 * @tc.require:
188 * @tc.author: blue sky
189 */
190 HWTEST_F(DeviceMatrixTest, OnlineAgainWithData, TestSize.Level0)
191 {
192 DeviceMatrix::GetInstance().Online(TEST_DEVICE);
193 auto result = isFinished_.GetValue();
194 ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
195 ASSERT_EQ(result.mask_, 0x3);
196 isFinished_.Clear(Result());
197 DeviceMatrix::GetInstance().Offline(TEST_DEVICE);
198 MetaDataManager::GetInstance().SaveMeta(metaData_.GetKey(), metaData_);
199 DeviceMatrix::GetInstance().Online(TEST_DEVICE);
200 result = isFinished_.GetValue();
201 ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
202 ASSERT_EQ(result.mask_, 0x3);
203 }
204
205 /**
206 * @tc.name: OnlineAgainWithLocal
207 * @tc.desc: the second online with local data change;
208 * @tc.type: FUNC
209 * @tc.require:
210 * @tc.author: blue sky
211 */
212 HWTEST_F(DeviceMatrixTest, OnlineAgainWithLocal, TestSize.Level0)
213 {
214 DeviceMatrix::GetInstance().Online(TEST_DEVICE);
215 auto result = isFinished_.GetValue();
216 ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
217 ASSERT_EQ(result.mask_, 0x3);
218 isFinished_.Clear(Result());
219 DeviceMatrix::GetInstance().Offline(TEST_DEVICE);
220 MetaDataManager::GetInstance().SaveMeta(metaData_.GetKeyLocal(), localMeta_, true);
221 DeviceMatrix::GetInstance().Online(TEST_DEVICE);
222 result = isFinished_.GetValue();
223 ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
224 ASSERT_EQ(result.mask_, 0x2);
225 }
226
227 /**
228 * @tc.name: GetMetaStoreCode
229 * @tc.desc: get the meta data store mask code;
230 * @tc.type: FUNC
231 * @tc.require:
232 * @tc.author: blue sky
233 */
234 HWTEST_F(DeviceMatrixTest, GetMetaStoreCode, TestSize.Level0)
235 {
236 StoreMetaData meta;
237 meta.bundleName = "distributeddata";
238 meta.tokenId = selfToken_;
239 meta.storeId = "service_meta";
240 auto code = DeviceMatrix::GetInstance().GetCode(meta);
241 ASSERT_EQ(code, DeviceMatrix::META_STORE_MASK);
242 }
243
244 /**
245 * @tc.name: GetDPCode
246 * @tc.desc: get the device profile store mask code;
247 * @tc.type: FUNC
248 * @tc.require:
249 * @tc.author: blue sky
250 */
251 HWTEST_F(DeviceMatrixTest, GetDPCode, TestSize.Level0)
252 {
253 StoreMetaData meta = metaData_;
254 meta.appId = "distributed_device_profile_service";
255 meta.bundleName = "distributed_device_profile_service";
256 auto code = DeviceMatrix::GetInstance().GetCode(meta);
257 ASSERT_EQ(code, 0x2);
258 }
259
260 /**
261 * @tc.name: GetOtherStoreCode
262 * @tc.desc: get the other store mask code;
263 * @tc.type: FUNC
264 * @tc.require:
265 * @tc.author: blue sky
266 */
267 HWTEST_F(DeviceMatrixTest, GetOtherStoreCode, TestSize.Level0)
268 {
269 StoreMetaData meta = metaData_;
270 auto code = DeviceMatrix::GetInstance().GetCode(meta);
271 ASSERT_EQ(code, 0);
272 }
273
274 /**
275 * @tc.name: BroadcastMeta
276 * @tc.desc: broadcast the meta store change;
277 * @tc.type: FUNC
278 * @tc.require:
279 * @tc.author: blue sky
280 */
281 HWTEST_F(DeviceMatrixTest, BroadcastMeta, TestSize.Level0)
282 {
283 auto mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, DeviceMatrix::META_STORE_MASK);
284 ASSERT_EQ(mask, DeviceMatrix::META_STORE_MASK);
285 }
286
287 /**
288 * @tc.name: BroadcastDP
289 * @tc.desc: broadcast the device profile store change;
290 * @tc.type: FUNC
291 * @tc.require:
292 * @tc.author: blue sky
293 */
294 HWTEST_F(DeviceMatrixTest, BroadcastDP, TestSize.Level0)
295 {
296 StoreMetaData meta = metaData_;
297 meta.appId = "distributed_device_profile_service";
298 meta.bundleName = "distributed_device_profile_service";
299 auto code = DeviceMatrix::GetInstance().GetCode(meta);
300 auto mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, code);
301 ASSERT_EQ(mask, 0x2);
302 }
303
304 /**
305 * @tc.name: BroadcastOthers
306 * @tc.desc: broadcast the device profile store change;
307 * @tc.type: FUNC
308 * @tc.require:
309 * @tc.author: blue sky
310 */
311 HWTEST_F(DeviceMatrixTest, BroadcastOthers, TestSize.Level0)
312 {
313 StoreMetaData meta = metaData_;
314 auto code = DeviceMatrix::GetInstance().GetCode(meta);
315 auto mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, code);
316 ASSERT_EQ(mask, 0);
317 }
318
319 /**
320 * @tc.name: BroadcastAll
321 * @tc.desc: broadcast the all store change;
322 * @tc.type: FUNC
323 * @tc.require:
324 * @tc.author: blue sky
325 */
326 HWTEST_F(DeviceMatrixTest, BroadcastAll, TestSize.Level0)
327 {
328 auto mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, DeviceMatrix::META_STORE_MASK);
329 ASSERT_EQ(mask, DeviceMatrix::META_STORE_MASK);
330 StoreMetaData meta = metaData_;
331 meta.appId = "distributed_device_profile_service";
332 meta.bundleName = "distributed_device_profile_service";
333 auto code = DeviceMatrix::GetInstance().GetCode(meta);
334 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, code);
335 ASSERT_EQ(mask, 0x3);
336 DeviceMatrix::GetInstance().OnExchanged(TEST_DEVICE, DeviceMatrix::META_STORE_MASK);
337 DeviceMatrix::GetInstance().OnExchanged(TEST_DEVICE, 0x2);
338
339 meta = metaData_;
340 code = DeviceMatrix::GetInstance().GetCode(meta);
341 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, code);
342 ASSERT_EQ(mask, 0);
343
344 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, 0xFFFF);
345 ASSERT_EQ(mask, 0x3);
346 }
347
348 /**
349 * @tc.name: UpdateMatrixMeta
350 * @tc.desc: update the remote matrix meta the all store change;
351 * @tc.type: FUNC
352 * @tc.require:
353 * @tc.author: blue sky
354 */
355 HWTEST_F(DeviceMatrixTest, UpdateMatrixMeta, TestSize.Level0)
356 {
357 MatrixMetaData metaData;
358 metaData.version = 2;
359 metaData.mask = 0x7;
360 metaData.deviceId = TEST_DEVICE;
361 metaData.maskInfo = { TEST_BUNDLE, "distributed_device_profile_service" };
362 MetaDataManager::GetInstance().Subscribe(MatrixMetaData::GetPrefix({ TEST_DEVICE }),
__anon2992dbf20502(const std::string &, const std::string &value, int32_t flag) 363 [](const std::string &, const std::string &value, int32_t flag) {
364 if (flag != MetaDataManager::INSERT && flag != MetaDataManager::UPDATE) {
365 return true;
366 }
367 MatrixMetaData meta;
368 MatrixMetaData::Unmarshall(value, meta);
369 Result result;
370 result.deviceId_ = meta.deviceId;
371 isFinished_.SetValue(result);
372 return true;
373 });
374 MetaDataManager::GetInstance().DelMeta(metaData.GetKey());
375 MetaDataManager::GetInstance().SaveMeta(metaData.GetKey(), metaData);
376
377 auto result = isFinished_.GetValue();
378 ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
379
380 auto mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, 0x2);
381 ASSERT_EQ(mask, 0);
382 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, DeviceMatrix::META_STORE_MASK);
383 ASSERT_EQ(mask, DeviceMatrix::META_STORE_MASK);
384 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, 0x4);
385 ASSERT_EQ(mask, 0x3);
386 DeviceMatrix::GetInstance().OnExchanged(TEST_DEVICE, DeviceMatrix::META_STORE_MASK);
387 DeviceMatrix::GetInstance().OnExchanged(TEST_DEVICE, 0x2);
388 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, 0xFFFF);
389 ASSERT_EQ(mask, 0x3);
390 MetaDataManager::GetInstance().Unsubscribe(MatrixMetaData::GetPrefix({ TEST_DEVICE }));
391 }