1 /*
2 * Copyright (c) 2021-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
16 #include <filesystem>
17 #include <gtest/gtest.h>
18 #include <gmock/gmock.h>
19 #include <thread>
20 #include "account_log_wrapper.h"
21 #include "datetime_ex.h"
22 #define private public
23 #include "iinner_os_account_manager.h"
24 #include "os_account.h"
25 #include "os_account_manager_service.h"
26 #undef private
27 #include "accesstoken_kit.h"
28 #include "account_iam_client.h"
29 #include "account_log_wrapper.h"
30 #include "account_iam_callback.h"
31 #include "account_iam_mgr_proxy.h"
32 #include "account_iam_callback_stub.h"
33 #include "account_iam_callback_service.h"
34 #include "account_iam_client_test_callback.h"
35 #include "ipc_skeleton.h"
36 #include "iam_common_defines.h"
37 #include "os_account_subscriber.h"
38 #include "os_account_subscribe_manager.h"
39 #include "singleton.h"
40 #include "test_common.h"
41 #include "token_setproc.h"
42
43
44 using namespace testing;
45 using namespace testing::ext;
46 using namespace OHOS::AccountSA;
47 using namespace OHOS::Security::AccessToken;
48 using namespace OHOS::UserIam::UserAuth;
49 using namespace OHOS::AccountSA::Constants;
50 #ifdef HAS_PIN_AUTH_PART
51 using namespace OHOS::UserIam::PinAuth;
52 #endif
53
54 namespace OHOS {
55 namespace AccountTest {
56 namespace {
57 std::mutex g_mtx;
58 std::mutex h_mtx;
59 const int32_t WAIT_TIME = 20;
60 } // namespace
61
62 class OsAccountManagerServiceSubscribeModuleTest : public testing::Test {
63 public:
64 static void SetUpTestCase(void);
65 static void TearDownTestCase(void);
66 void SetUp(void) override;
67 void TearDown(void) override;
68 std::shared_ptr<OsAccountManagerService> osAccountManagerService_ = std::make_shared<OsAccountManagerService>();
69 };
70
SetUpTestCase(void)71 void OsAccountManagerServiceSubscribeModuleTest::SetUpTestCase(void)
72 {
73 #ifdef ACCOUNT_TEST
74 AccountFileOperator osAccountFileOperator;
75 osAccountFileOperator.DeleteDirOrFile(USER_INFO_BASE);
76 GTEST_LOG_(INFO) << "delete account test path " << USER_INFO_BASE;
77 #endif // ACCOUNT_TEST
78 IInnerOsAccountManager::GetInstance().Init();
79 IInnerOsAccountManager::GetInstance().ActivateDefaultOsAccount();
80 }
81
TearDownTestCase(void)82 void OsAccountManagerServiceSubscribeModuleTest::TearDownTestCase(void)
83 {
84 GTEST_LOG_(INFO) << "TearDownTestCase exit!";
85 #ifdef ACCOUNT_TEST
86 AccountFileOperator osAccountFileOperator;
87 osAccountFileOperator.DeleteDirOrFile(USER_INFO_BASE);
88 GTEST_LOG_(INFO) << "delete account test path " << USER_INFO_BASE;
89 #endif // ACCOUNT_TEST
90 }
91
SetUp(void)92 void OsAccountManagerServiceSubscribeModuleTest::SetUp(void) __attribute__((no_sanitize("cfi")))
93 {
94 testing::UnitTest *test = testing::UnitTest::GetInstance();
95 ASSERT_NE(test, nullptr);
96 const testing::TestInfo *testinfo = test->current_test_info();
97 ASSERT_NE(testinfo, nullptr);
98 string testCaseName = string(testinfo->name());
99 ACCOUNT_LOGI("[SetUp] %{public}s start", testCaseName.c_str());
100 }
101
TearDown(void)102 void OsAccountManagerServiceSubscribeModuleTest::TearDown(void)
103 {}
104
105 class OsAccountSubscriberTest : public OsAccountSubscriber {
106 public:
OsAccountSubscriberTest(const OsAccountSubscribeInfo & subscribeInfo)107 explicit OsAccountSubscriberTest(const OsAccountSubscribeInfo &subscribeInfo)
108 : OsAccountSubscriber(subscribeInfo), id_(0)
109 {
110 ACCOUNT_LOGI("enter");
111 }
112
~OsAccountSubscriberTest()113 ~OsAccountSubscriberTest()
114 {}
115
OnAccountsChanged(const int & id)116 virtual void OnAccountsChanged(const int &id)
117 {
118 ACCOUNT_LOGI("enter");
119
120 g_mtx.unlock();
121 EXPECT_EQ(id, id_);
122 GTEST_LOG_(INFO) << id;
123 GTEST_LOG_(INFO) << id_;
124 }
125 int id_;
126 };
127 class MockOsAccountSubscriber final {
128 public:
129 MOCK_METHOD1(OnAccountsChanged, void(const int &id));
130 };
131
132 class TestOsAccountSubscriber final : public OsAccountSubscriber {
133 public:
TestOsAccountSubscriber(const std::shared_ptr<MockOsAccountSubscriber> & ptr,const OsAccountSubscribeInfo & subscribeInfo)134 explicit TestOsAccountSubscriber(
135 const std::shared_ptr<MockOsAccountSubscriber> &ptr, const OsAccountSubscribeInfo &subscribeInfo)
136 : OsAccountSubscriber(subscribeInfo), ptr_(ptr)
137 {}
OnAccountsChanged(const int & id)138 void OnAccountsChanged(const int &id)
139 {
140 ptr_->OnAccountsChanged(id);
141 std::unique_lock<std::mutex> lock(mutex);
142 isReady = true;
143 cv.notify_one();
144 return;
145 }
~TestOsAccountSubscriber()146 virtual ~TestOsAccountSubscriber()
147 {}
148 std::condition_variable cv;
149 bool isReady = false;
150 std::mutex mutex;
151 private:
152 std::shared_ptr<MockOsAccountSubscriber> ptr_;
153 };
154
155 class TestAuthCallBack : public OHOS::AccountSA::IDMCallback {
156 public:
TestAuthCallBack()157 explicit TestAuthCallBack()
158 {}
159 virtual ~TestAuthCallBack()=default;
OnResult(int32_t result,const Attributes & extraInfo)160 void OnResult(int32_t result, const Attributes &extraInfo) override
161 {
162 g_mtx.unlock();
163 }
OnAcquireInfo(int32_t module,uint32_t acquireInfo,const Attributes & extraInfo)164 void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) override
165 {}
166 };
167
168 class TestAddCredCallBack : public OHOS::AccountSA::IDMCallback {
169 public:
TestAddCredCallBack()170 explicit TestAddCredCallBack()
171 {}
172 virtual ~TestAddCredCallBack() = default;
OnResult(int32_t result,const Attributes & extraInfo)173 void OnResult(int32_t result, const Attributes &extraInfo) override
174 {
175 g_mtx.unlock();
176 }
OnAcquireInfo(int32_t module,uint32_t acquireInfo,const Attributes & extraInfo)177 void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const Attributes &extraInfo) override
178 {}
179 };
180
181 /**
182 * @tc.name: OsAccountManagerServiceSubscribeModuleTest_0001
183 * @tc.desc: Subscribe os accounts activate
184 * @tc.type: FUNC
185 * @tc.require: SR000GGVFH
186 */
187 HWTEST_F(OsAccountManagerServiceSubscribeModuleTest, OsAccountManagerServiceSubscribeModuleTest_0001, TestSize.Level1)
188 {
189 ACCOUNT_LOGI("OsAccountManagerServiceSubscribeModuleTest_0001");
190 OsAccountSubscribeInfo osAccountSubscribeInfo;
191 osAccountSubscribeInfo.SetOsAccountSubscribeType(OS_ACCOUNT_SUBSCRIBE_TYPE::ACTIVED);
192 osAccountSubscribeInfo.SetName("subscribeActive");
193
194 // make a subscriber
195 auto subscriberTestPtr = std::make_shared<OsAccountSubscriberTest>(osAccountSubscribeInfo);
196
197 // make an event listener
198 sptr<IRemoteObject> osAccountEventListener = nullptr;
199
200 OsAccountInfo osAccountInfo;
201 ErrCode result = OsAccount::GetInstance().CreateOsAccount(
202 "OsAccountManagerServiceSubscribeModuleTest_0001", OsAccountType::GUEST, osAccountInfo);
203 EXPECT_EQ(result, ERR_OK);
204 subscriberTestPtr->id_ = osAccountInfo.GetLocalId();
205 // subscribe os account
206 result = OsAccount::GetInstance().SubscribeOsAccount(subscriberTestPtr);
207 EXPECT_EQ(result, ERR_OK);
208 // lock the mutex
209 g_mtx.lock();
210 EXPECT_EQ(result, ERR_OK);
211 result = OsAccount::GetInstance().ActivateOsAccount(osAccountInfo.GetLocalId());
212 EXPECT_EQ(result, ERR_OK);
213 struct tm startTime = {0};
214 EXPECT_EQ(GetSystemCurrentTime(&startTime), true);
215 struct tm doingTime = {0};
216 while (!g_mtx.try_lock()) {
217 EXPECT_EQ(GetSystemCurrentTime(&doingTime), true);
218 int64_t seconds = GetSecondsBetween(startTime, doingTime);
219 if (seconds >= 5) {
220 break;
221 }
222 }
223 g_mtx.unlock();
224 result = OsAccount::GetInstance().UnsubscribeOsAccount(subscriberTestPtr);
225 EXPECT_EQ(result, ERR_OK);
226 // unlock the mutex
227 result = OsAccount::GetInstance().RemoveOsAccount(osAccountInfo.GetLocalId());
228 EXPECT_EQ(result, ERR_OK);
229 }
230
231 /**
232 * @tc.name: OsAccountManagerServiceSubscribeModuleTest_0002
233 * @tc.desc: Subscribe os accounts unlock with no password
234 * @tc.type: FUNC
235 * @tc.require: issueI7WX2P
236 */
237 HWTEST_F(OsAccountManagerServiceSubscribeModuleTest, OsAccountManagerServiceSubscribeModuleTest_0002, TestSize.Level1)
238 {
239 ACCOUNT_LOGI("OsAccountManagerServiceSubscribeModuleTest_0002");
240 OsAccountSubscribeInfo osAccountSubscribeInfo;
241 osAccountSubscribeInfo.SetOsAccountSubscribeType(OS_ACCOUNT_SUBSCRIBE_TYPE::UNLOCKED);
242 osAccountSubscribeInfo.SetName("subscribeUnlock");
243 // make a subscriber
244 auto subscriberMockPtr = std::make_shared<MockOsAccountSubscriber>();
245 auto subscriberTestPtr = std::make_shared<TestOsAccountSubscriber>(subscriberMockPtr, osAccountSubscribeInfo);
246 // create a osAccount
247 OsAccountInfo osAccountInfo;
248 ErrCode result = OsAccount::GetInstance().CreateOsAccount(
249 "OsAccountManagerServiceSubscribeModuleTest_0002", OsAccountType::GUEST, osAccountInfo);
250 const int id = osAccountInfo.GetLocalId();
251 EXPECT_CALL(*subscriberMockPtr, OnAccountsChanged(id)).Times(Exactly(1));
252 //subscribe
253 result = OsAccount::GetInstance().SubscribeOsAccount(subscriberTestPtr);
254 EXPECT_EQ(result, ERR_OK);
255 //unlock
256 result = OsAccount::GetInstance().ActivateOsAccount(id);
257 std::unique_lock<std::mutex> lock(subscriberTestPtr->mutex);
258 subscriberTestPtr->cv.wait_for(
__anon14445bf00202() 259 lock, std::chrono::seconds(WAIT_TIME), [lockCallback = subscriberTestPtr]() { return lockCallback->isReady; });
260 EXPECT_EQ(result, ERR_OK);
261 OsAccount::GetInstance().UnsubscribeOsAccount(subscriberTestPtr);
262 EXPECT_EQ(result, ERR_OK);
263 result = OsAccount::GetInstance().RemoveOsAccount(id);
264 EXPECT_EQ(result, ERR_OK);
265 }
266 }
267 }
268