1 /*
2 * Copyright (C) 2023 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 "widget_schedule_node_impl.h"
17 #include "widget_context.h"
18
19 #include <future>
20
21 #include "mock_widget_schedule_node_callback.h"
22 #include "mock_context.h"
23 #include "widget_context.h"
24 #include "iam_ptr.h"
25 #include "relative_timer.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace UserIam {
32 namespace UserAuth {
33 namespace {
34 auto &timer = RelativeTimer::GetInstance();
35 }
36 static std::shared_ptr<WidgetScheduleNodeCallback> widgetContext = nullptr;
37
38 class WidgetScheduleNodeImplTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41
42 static void TearDownTestCase();
43
44 void SetUp() override;
45
46 void TearDown() override;
47 };
48
SetUpTestCase()49 void WidgetScheduleNodeImplTest::SetUpTestCase()
50 {
51 uint64_t contextId = 1;
52 ContextFactory::AuthWidgetContextPara para;
53 std::shared_ptr<ContextCallback> callback = Common::MakeShared<MockContextCallback>();
54 widgetContext = Common::MakeShared<WidgetContext>(contextId, para, callback);
55 }
56
TearDownTestCase()57 void WidgetScheduleNodeImplTest::TearDownTestCase()
58 {
59 }
60
SetUp()61 void WidgetScheduleNodeImplTest::SetUp()
62 {
63 }
64
TearDown()65 void WidgetScheduleNodeImplTest::TearDown()
66 {
67 }
68
69 HWTEST_F(WidgetScheduleNodeImplTest, WidgetScheduleNodeImplStartSchedule, TestSize.Level0)
70 {
71 auto schedule = std::make_shared<WidgetScheduleNodeImpl>();
72 ASSERT_NE(schedule, nullptr);
73 schedule->SetCallback(widgetContext);
74 EXPECT_TRUE(schedule->StartSchedule());
75 widgetContext->LaunchWidget();
76 auto handler = ThreadHandler::GetSingleThreadInstance();
__anon133e701a0202() 77 handler->EnsureTask([]() {});
78 }
79
80 HWTEST_F(WidgetScheduleNodeImplTest, WidgetScheduleNodeImplStartAuthList, TestSize.Level0)
81 {
82 auto schedule = std::make_shared<WidgetScheduleNodeImpl>();
83 ASSERT_NE(schedule, nullptr);
84 std::vector<AuthType> authTypeList = {AuthType::ALL, AuthType::PIN, AuthType::FACE, AuthType::FINGERPRINT};
85 schedule->SetCallback(widgetContext);
86 schedule->StartSchedule();
87 EXPECT_TRUE(schedule->StartAuthList(authTypeList, true, AuthIntent::DEFAULT));
88 widgetContext->LaunchWidget();
89 auto handler = ThreadHandler::GetSingleThreadInstance();
__anon133e701a0302() 90 handler->EnsureTask([]() {});
91 }
92
93 HWTEST_F(WidgetScheduleNodeImplTest, WidgetScheduleNodeImplStopAuthList, TestSize.Level0)
94 {
95 auto schedule = std::make_shared<WidgetScheduleNodeImpl>();
96 ASSERT_NE(schedule, nullptr);
97 std::vector<AuthType> authTypeList = {AuthType::ALL, AuthType::PIN, AuthType::FACE, AuthType::FINGERPRINT};
98 schedule->SetCallback(widgetContext);
99 schedule->StartSchedule();
100 schedule->StartAuthList(authTypeList, false, AuthIntent::DEFAULT);
101 EXPECT_TRUE(schedule->StopAuthList(authTypeList));
102 widgetContext->LaunchWidget();
103 auto handler = ThreadHandler::GetSingleThreadInstance();
__anon133e701a0402() 104 handler->EnsureTask([]() {});
105 }
106
107 HWTEST_F(WidgetScheduleNodeImplTest, WidgetScheduleNodeImplSuccessAuth, TestSize.Level0)
108 {
109 auto schedule = std::make_shared<WidgetScheduleNodeImpl>();
110 ASSERT_NE(schedule, nullptr);
111 std::vector<AuthType> authTypeList = {AuthType::ALL, AuthType::PIN, AuthType::FACE, AuthType::FINGERPRINT};
112 schedule->SetCallback(widgetContext);
113 schedule->StartSchedule();
114 schedule->StartAuthList(authTypeList, true, AuthIntent::DEFAULT);
115 EXPECT_TRUE(schedule->SuccessAuth(AuthType::PIN));
116 widgetContext->LaunchWidget();
117 auto handler = ThreadHandler::GetSingleThreadInstance();
__anon133e701a0502() 118 handler->EnsureTask([]() {});
119 }
120
121 HWTEST_F(WidgetScheduleNodeImplTest, WidgetScheduleNodeImplNaviPinAuth, TestSize.Level0)
122 {
123 auto schedule = std::make_shared<WidgetScheduleNodeImpl>();
124 ASSERT_NE(schedule, nullptr);
125 schedule->SetCallback(widgetContext);
126 schedule->StartSchedule();
127 EXPECT_TRUE(schedule->NaviPinAuth());
128 widgetContext->LaunchWidget();
129 auto handler = ThreadHandler::GetSingleThreadInstance();
__anon133e701a0602() 130 handler->EnsureTask([]() {});
131 }
132
133 HWTEST_F(WidgetScheduleNodeImplTest, WidgetScheduleNodeImplWidgetParaInvalid, TestSize.Level0)
134 {
135 auto schedule = std::make_shared<WidgetScheduleNodeImpl>();
136 ASSERT_NE(schedule, nullptr);
137 schedule->SetCallback(widgetContext);
138 schedule->StartSchedule();
139 EXPECT_TRUE(schedule->WidgetParaInvalid());
140 widgetContext->LaunchWidget();
141 auto handler = ThreadHandler::GetSingleThreadInstance();
__anon133e701a0702() 142 handler->EnsureTask([]() {});
143 }
144
145 HWTEST_F(WidgetScheduleNodeImplTest, WidgetScheduleNodeImplStopSchedule, TestSize.Level0)
146 {
147 auto schedule = std::make_shared<WidgetScheduleNodeImpl>();
148 ASSERT_NE(schedule, nullptr);
149 schedule->SetCallback(widgetContext);
150 schedule->StartSchedule();
151 EXPECT_TRUE(schedule->StopSchedule());
152 widgetContext->LaunchWidget();
153 auto handler = ThreadHandler::GetSingleThreadInstance();
__anon133e701a0802() 154 handler->EnsureTask([]() {});
155 }
156
157 HWTEST_F(WidgetScheduleNodeImplTest, WidgetScheduleNodeImplWidgetReload_0001, TestSize.Level0)
158 {
159 auto schedule = std::make_shared<WidgetScheduleNodeImpl>();
160 ASSERT_NE(schedule, nullptr);
161 schedule->SetCallback(widgetContext);
162 schedule->StartSchedule();
163 uint32_t orientation = 1;
164 uint32_t needRotate = 1;
165 uint32_t alreadyLoad = 1;
166 AuthType rotateAuthType = PIN;
167 EXPECT_TRUE(schedule->WidgetReload(orientation, needRotate, alreadyLoad, rotateAuthType));
168 widgetContext->LaunchWidget();
169 auto handler = ThreadHandler::GetSingleThreadInstance();
__anon133e701a0902() 170 handler->EnsureTask([]() {});
171 }
172
173 HWTEST_F(WidgetScheduleNodeImplTest, WidgetScheduleNodeImplWidgetReload_0002, TestSize.Level0)
174 {
175 auto schedule = std::make_shared<WidgetScheduleNodeImpl>();
176 ASSERT_NE(schedule, nullptr);
177 schedule->SetCallback(widgetContext);
178 schedule->StartSchedule();
179 uint32_t orientation = 2;
180 uint32_t needRotate = 1;
181 uint32_t alreadyLoad = 1;
182 AuthType rotateAuthType = FINGERPRINT;
183 EXPECT_TRUE(schedule->WidgetReload(orientation, needRotate, alreadyLoad, rotateAuthType));
184 widgetContext->LaunchWidget();
185 auto handler = ThreadHandler::GetSingleThreadInstance();
__anon133e701a0a02() 186 handler->EnsureTask([]() {});
187 }
188
189 HWTEST_F(WidgetScheduleNodeImplTest, WidgetScheduleNodeImplWidgetReload_0003, TestSize.Level0)
190 {
191 auto schedule = std::make_shared<WidgetScheduleNodeImpl>();
192 ASSERT_NE(schedule, nullptr);
193 schedule->SetCallback(widgetContext);
194 schedule->StartSchedule();
195 uint32_t orientation = 3;
196 uint32_t needRotate = 1;
197 uint32_t alreadyLoad = 1;
198 AuthType rotateAuthType = FACE;
199 EXPECT_TRUE(schedule->WidgetReload(orientation, needRotate, alreadyLoad, rotateAuthType));
200 widgetContext->LaunchWidget();
201 auto handler = ThreadHandler::GetSingleThreadInstance();
__anon133e701a0b02() 202 handler->EnsureTask([]() {});
203 }
204 } // namespace UserAuth
205 } // namespace UserIam
206 } // namespace OHOS
207