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