1 /*
2  * Copyright (c) 2022-2024 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 #ifndef ACCOUNT_IAM_CLIENT_TEST_CALLBACK_H
17 #define ACCOUNT_IAM_CLIENT_TEST_CALLBACK_H
18 
19 #include <vector>
20 #include <memory>
21 #include <gmock/gmock.h>
22 #include "account_iam_client_callback.h"
23 #include "account_iam_info.h"
24 
25 namespace OHOS {
26 namespace AccountTest {
27 class MockIDMCallback final {
28 public:
29     MOCK_METHOD2(OnResult, void(int32_t result, const AccountSA::Attributes &extraInfo));
30     MOCK_METHOD3(OnAcquireInfo, void(int32_t module, uint32_t acquireInfo, const AccountSA::Attributes &extraInfo));
31 };
32 
33 class TestIDMCallback final : public AccountSA::IDMCallback {
34 public:
TestIDMCallback(const std::shared_ptr<MockIDMCallback> & callback)35     TestIDMCallback(const std::shared_ptr<MockIDMCallback> &callback) :callback_(callback) {}
~TestIDMCallback()36     virtual ~TestIDMCallback() {}
OnAcquireInfo(int32_t module,uint32_t acquireInfo,const AccountSA::Attributes & extraInfo)37     void OnAcquireInfo(int32_t module, uint32_t acquireInfo, const AccountSA::Attributes &extraInfo)
38     {
39         callback_->OnAcquireInfo(module, acquireInfo, extraInfo);
40         std::unique_lock<std::mutex> lock(mutex);
41         isReady = true;
42         cv.notify_one();
43         return;
44     }
OnResult(int32_t result,const AccountSA::Attributes & extraInfo)45     void OnResult(int32_t result, const AccountSA::Attributes &extraInfo)
46     {
47         callback_->OnResult(result, extraInfo);
48         std::unique_lock<std::mutex> lock(mutex);
49         isReady = true;
50         cv.notify_one();
51         return;
52     }
53     std::condition_variable cv;
54     bool isReady = false;
55     std::mutex mutex;
56 private:
57     std::shared_ptr<MockIDMCallback> callback_;
58 };
59 
60 class MockGetCredInfoCallback final {
61 public:
62     MOCK_METHOD2(OnCredentialInfo, void(int32_t result, const std::vector<AccountSA::CredentialInfo> &infoList));
63 };
64 
65 class TestGetCredInfoCallback final : public AccountSA::GetCredInfoCallback {
66 public:
TestGetCredInfoCallback(const std::shared_ptr<MockGetCredInfoCallback> & callback)67     TestGetCredInfoCallback(const std::shared_ptr<MockGetCredInfoCallback> &callback) :callback_(callback) {}
~TestGetCredInfoCallback()68     virtual ~TestGetCredInfoCallback() {}
OnCredentialInfo(int32_t result,const std::vector<AccountSA::CredentialInfo> & infoList)69     void OnCredentialInfo(int32_t result, const std::vector<AccountSA::CredentialInfo> &infoList)
70     {
71         callback_->OnCredentialInfo(result, infoList);
72         std::unique_lock<std::mutex> lock(mutex);
73         isReady = true;
74         cv.notify_one();
75         return;
76     }
77     std::condition_variable cv;
78     bool isReady = false;
79     std::mutex mutex;
80 private:
81     std::shared_ptr<MockGetCredInfoCallback> callback_;
82 };
83 
84 class MockGetEnrolledIdCallback final {
85 public:
86     MOCK_METHOD2(OnEnrolledId, void(int32_t result, uint64_t enrolledId));
87 };
88 
89 class TestGetEnrolledIdCallback final : public AccountSA::GetEnrolledIdCallback {
90 public:
TestGetEnrolledIdCallback(const std::shared_ptr<MockGetEnrolledIdCallback> & callback)91     TestGetEnrolledIdCallback(const std::shared_ptr<MockGetEnrolledIdCallback> &callback) :callback_(callback) {}
~TestGetEnrolledIdCallback()92     virtual ~TestGetEnrolledIdCallback() {}
OnEnrolledId(int32_t result,uint64_t enrolledId)93     void OnEnrolledId(int32_t result, uint64_t enrolledId)
94     {
95         callback_->OnEnrolledId(result, enrolledId);
96         std::unique_lock<std::mutex> lock(mutex);
97         isReady = true;
98         cv.notify_one();
99         return;
100     }
101     std::condition_variable cv;
102     bool isReady = false;
103     std::mutex mutex;
104 private:
105     std::shared_ptr<MockGetEnrolledIdCallback> callback_;
106 };
107 
108 class MockGetSetPropCallback final {
109 public:
110     MOCK_METHOD2(OnResult, void(int32_t result, const AccountSA::Attributes &extraInfo));
111 };
112 
113 class TestGetSetPropCallback final : public AccountSA::GetSetPropCallback {
114 public:
TestGetSetPropCallback(const std::shared_ptr<MockGetSetPropCallback> & callback)115     TestGetSetPropCallback(const std::shared_ptr<MockGetSetPropCallback> &callback) :callback_(callback) {}
~TestGetSetPropCallback()116     virtual ~TestGetSetPropCallback() {}
OnResult(int32_t result,const AccountSA::Attributes & extraInfo)117     void OnResult(int32_t result, const AccountSA::Attributes &extraInfo)
118     {
119         callback_->OnResult(result, extraInfo);
120         std::unique_lock<std::mutex> lock(mutex);
121         isReady = true;
122         cv.notify_one();
123         return;
124     }
125     std::condition_variable cv;
126     bool isReady = false;
127     std::mutex mutex;
128 private:
129     std::shared_ptr<MockGetSetPropCallback> callback_;
130 };
131 }  // namespace AccountTest
132 }  // namespace OHOS
133 
134 #endif  // ACCOUNT_IAM_CLIENT_TEST_CALLBACK_H