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