1 /*
2 * Copyright (c) 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 <gtest/gtest.h>
17 #define private public
18 #define protected public
19 #include "extension_config.h"
20 #undef private
21 #undef protected
22
23 using namespace testing;
24 using namespace testing::ext;
25 using json = nlohmann::json;
26
27 namespace {
28 constexpr const char* EXTENSION_CONFIG_NAME = "extension_config_name";
29 constexpr const char* EXTENSION_TYPE_NAME = "extension_type_name";
30 constexpr const char* EXTENSION_AUTO_DISCONNECT_TIME = "auto_disconnect_time";
31
32 constexpr const char* EXTENSION_THIRD_PARTY_APP_BLOCKED_FLAG_NAME = "third_party_app_blocked_flag";
33 constexpr const char* EXTENSION_SERVICE_BLOCKED_LIST_NAME = "service_blocked_list";
34 constexpr const char* EXTENSION_SERVICE_STARTUP_ENABLE_FLAG = "service_startup_enable_flag";
35 constexpr const char* EXTENSION_NETWORK_ENABLE_FLAG = "network_access_enable_flag";
36 constexpr const char* EXTENSION_SA_ENABLE_FLAG = "sa_access_enable_flag";
37 }
38 namespace OHOS {
39 namespace AbilityRuntime {
40 class AbilityExtensionConfigTest : public testing::Test {
41 public:
42 static void SetUpTestCase();
43 static void TearDownTestCase();
44 void SetUp() override;
45 void TearDown() override;
46 public:
47 static std::shared_ptr<AAFwk::ExtensionConfig> extensionConfig_;
48 };
49
50 std::shared_ptr<AAFwk::ExtensionConfig> AbilityExtensionConfigTest::extensionConfig_ =
51 DelayedSingleton<AAFwk::ExtensionConfig>::GetInstance();
52
SetUpTestCase(void)53 void AbilityExtensionConfigTest::SetUpTestCase(void)
54 {}
55
TearDownTestCase(void)56 void AbilityExtensionConfigTest::TearDownTestCase(void)
57 {}
58
SetUp()59 void AbilityExtensionConfigTest::SetUp()
60 {}
61
TearDown()62 void AbilityExtensionConfigTest::TearDown()
63 {}
64
65 /*
66 * @tc.number : GetExtensionConfigPath_001
67 * @tc.name : AbilityExtensionConfigTest
68 * @tc.desc : Test Function GetExtensionConfigPath
69 */
70 HWTEST_F(AbilityExtensionConfigTest, GetExtensionConfigPath_001, TestSize.Level1)
71 {
72 extensionConfig_->GetExtensionConfigPath();
73 extensionConfig_->LoadExtensionConfiguration();
74 std::string extensionTypeName = EXTENSION_TYPE_NAME;
75 extensionConfig_->GetExtensionAutoDisconnectTime(extensionTypeName);
76 auto result = extensionConfig_->IsExtensionStartThirdPartyAppEnable(extensionTypeName);
77 EXPECT_EQ(result, true);
78 }
79
80 /*
81 * @tc.number : LoadExtensionServiceBlockedList_001
82 * @tc.name : AbilityExtensionConfigTest
83 * @tc.desc : Test Function LoadExtensionServiceBlockedList
84 */
85 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionServiceBlockedList_001, TestSize.Level1)
86 {
87 json jsOnFile;
88 extensionConfig_->LoadExtensionServiceBlockedList(jsOnFile, "aa");
89 jsOnFile[EXTENSION_SERVICE_STARTUP_ENABLE_FLAG] = false;
90 extensionConfig_->LoadExtensionServiceBlockedList(jsOnFile, "aa");
91 jsOnFile[EXTENSION_SERVICE_STARTUP_ENABLE_FLAG] = true;
92 extensionConfig_->LoadExtensionServiceBlockedList(jsOnFile, "aa");
93 jsOnFile[EXTENSION_SERVICE_BLOCKED_LIST_NAME] = {"aa", "bb"};
94 extensionConfig_->LoadExtensionServiceBlockedList(jsOnFile, "aa");
95 EXPECT_TRUE(extensionConfig_ != nullptr);
96 }
97
98 /*
99 * @tc.number : LoadExtensionThirdPartyAppBlockedList_001
100 * @tc.name : AbilityExtensionConfigTest
101 * @tc.desc : Test Function LoadExtensionThirdPartyAppBlockedList
102 */
103 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionThirdPartyAppBlockedList_001, TestSize.Level1)
104 {
105 json jsOnFile;
106 std::string extensionTypeName = "aa";
107 extensionConfig_->LoadExtensionThirdPartyAppBlockedList(jsOnFile, extensionTypeName);
108 jsOnFile[EXTENSION_THIRD_PARTY_APP_BLOCKED_FLAG_NAME] = false;
109 extensionConfig_->LoadExtensionThirdPartyAppBlockedList(jsOnFile, extensionTypeName);
110 jsOnFile[EXTENSION_THIRD_PARTY_APP_BLOCKED_FLAG_NAME] = true;
111 extensionConfig_->LoadExtensionThirdPartyAppBlockedList(jsOnFile, extensionTypeName);
112 EXPECT_TRUE(extensionConfig_ != nullptr);
113 }
114
115 /*
116 * @tc.number : LoadExtensionAutoDisconnectTime_001
117 * @tc.name : AbilityExtensionConfigTest
118 * @tc.desc : Test Function LoadExtensionAutoDisconnectTime
119 */
120 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionAutoDisconnectTime_001, TestSize.Level1)
121 {
122 json jsOnFile;
123 std::string extensionTypeName = "aa";
124 extensionConfig_->LoadExtensionAutoDisconnectTime(jsOnFile, extensionTypeName);
125 jsOnFile[EXTENSION_AUTO_DISCONNECT_TIME] = 100;
126 extensionConfig_->LoadExtensionAutoDisconnectTime(jsOnFile, extensionTypeName);
127 EXPECT_TRUE(extensionConfig_ != nullptr);
128 }
129
130 /*
131 * @tc.number : LoadExtensionConfig_001
132 * @tc.name : AbilityExtensionConfigTest
133 * @tc.desc : Test Function LoadExtensionConfig
134 */
135 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionConfig_001, TestSize.Level1)
136 {
137 json jsOnFile;
138 json jsOnItem;
139 json jsOnItem2;
140 extensionConfig_->LoadExtensionConfig(jsOnFile);
141 jsOnItem[EXTENSION_TYPE_NAME] = "aa";
142 jsOnItem2[EXTENSION_TYPE_NAME] = "bb";
143 jsOnFile[EXTENSION_CONFIG_NAME] = {jsOnItem, jsOnItem2, "cc"};
144 extensionConfig_->LoadExtensionConfig(jsOnFile);
145 EXPECT_TRUE(extensionConfig_ != nullptr);
146 }
147
148 /*
149 * @tc.number : CheckServiceExtensionUriValid_001
150 * @tc.name : AbilityExtensionConfigTest
151 * @tc.desc : Test Function CheckServiceExtensionUriValid
152 */
153 HWTEST_F(AbilityExtensionConfigTest, CheckServiceExtensionUriValid_001, TestSize.Level1)
154 {
155 auto result = extensionConfig_->CheckServiceExtensionUriValid("http://aaa/bb/");
156 EXPECT_EQ(result, false);
157 result = extensionConfig_->CheckServiceExtensionUriValid("http://aaa/bb/cc/");
158 EXPECT_EQ(result, false);
159 result = extensionConfig_->CheckServiceExtensionUriValid("http://aaa//cc/");
160 EXPECT_EQ(result, false);
161 result = extensionConfig_->CheckServiceExtensionUriValid("/bundleName/moduleName/abilityName");
162 EXPECT_EQ(result, true);
163 result = extensionConfig_->CheckServiceExtensionUriValid("deviceName/bundleName/moduleName/abilityName");
164 EXPECT_EQ(result, true);
165 AppExecFwk::ElementName targetElementName;
166 EXPECT_EQ(targetElementName.ParseURI("deviceName/bundleName/moduleName/abilityName"), true);
167 EXPECT_EQ(targetElementName.GetBundleName(), "bundleName");
168 EXPECT_EQ(targetElementName.GetModuleName(), "moduleName");
169 EXPECT_EQ(targetElementName.GetAbilityName(), "abilityName");
170 }
171
172 /*
173 * @tc.number : IsExtensionStartServiceEnable_001
174 * @tc.name : AbilityExtensionConfigTest
175 * @tc.desc : Test Function IsExtensionStartServiceEnable
176 */
177 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnable_001, TestSize.Level1)
178 {
179 auto extType = "form";
180 ASSERT_NE(extensionConfig_, nullptr);
181 extensionConfig_->configMap_.clear();
182 extensionConfig_->configMap_[extType].serviceEnableFlag = false;
183 bool enable = extensionConfig_->IsExtensionStartServiceEnable(extType, "form");
184 EXPECT_EQ(enable, false);
185 }
186
187 /*
188 * @tc.number : IsExtensionStartServiceEnable_002
189 * @tc.name : AbilityExtensionConfigTest
190 * @tc.desc : Test Function IsExtensionStartServiceEnable
191 */
192 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnable_002, TestSize.Level1)
193 {
194 auto extType = "form";
195 ASSERT_NE(extensionConfig_, nullptr);
196 extensionConfig_->configMap_.clear();
197 extensionConfig_->configMap_[extType].serviceEnableFlag = true;
198 bool enable = extensionConfig_->IsExtensionStartServiceEnable(extType, "bbb");
199 EXPECT_EQ(enable, true);
200 }
201
202 /*
203 * @tc.number : IsExtensionStartServiceEnable_003
204 * @tc.name : AbilityExtensionConfigTest
205 * @tc.desc : Test Function IsExtensionStartServiceEnable
206 */
207 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnable_003, TestSize.Level1)
208 {
209 json jsOnFile;
210 auto extType = "form";
211 jsOnFile[EXTENSION_SERVICE_STARTUP_ENABLE_FLAG] = true;
212 jsOnFile[EXTENSION_SERVICE_BLOCKED_LIST_NAME] = {"aa", "bb", "/bundle/module/ability"};
213 extensionConfig_->LoadExtensionServiceBlockedList(jsOnFile, extType);
214 // uri not valid
215 bool enable = extensionConfig_->IsExtensionStartServiceEnable(extType, "bb");
216 EXPECT_EQ(enable, true);
217 }
218
219 /*
220 * @tc.number : IsExtensionStartServiceEnable_004
221 * @tc.name : AbilityExtensionConfigTest
222 * @tc.desc : Test Function IsExtensionStartServiceEnable
223 */
224 HWTEST_F(AbilityExtensionConfigTest, IsExtensionStartServiceEnable_004, TestSize.Level1)
225 {
226 json jsOnFile;
227 auto extType = "form";
228 jsOnFile[EXTENSION_SERVICE_STARTUP_ENABLE_FLAG] = true;
229 jsOnFile[EXTENSION_SERVICE_BLOCKED_LIST_NAME] = {"aa", "bb", "/bundle/module/ability"};
230 extensionConfig_->LoadExtensionServiceBlockedList(jsOnFile, extType);
231 // uri is valid
232 bool enable = extensionConfig_->IsExtensionStartServiceEnable(extType, "/bundle/module/ability");
233 EXPECT_EQ(enable, false);
234 }
235
236 /*
237 * @tc.number : ReadFileInfoJson_001
238 * @tc.name : AbilityExtensionConfigTest
239 * @tc.desc : Test Function ReadFileInfoJson
240 */
241 HWTEST_F(AbilityExtensionConfigTest, ReadFileInfoJson_001, TestSize.Level1)
242 {
243 nlohmann::json jsOne;
244 auto result = extensionConfig_->ReadFileInfoJson("d://dddd", jsOne);
245 EXPECT_EQ(result, false);
246 }
247
248 /*
249 * @tc.number : LoadExtensionNetworkEnable_001
250 * @tc.name : AbilityExtensionConfigTest
251 * @tc.desc : Test Function LoadExtensionNetworkEnable
252 */
253 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionNetworkEnable_001, TestSize.Level1)
254 {
255 json jsOnFile;
256 jsOnFile[EXTENSION_NETWORK_ENABLE_FLAG] = false;
257 ASSERT_NE(extensionConfig_, nullptr);
258 extensionConfig_->configMap_.clear();
259 extensionConfig_->LoadExtensionNetworkEnable(jsOnFile, "form");
260 EXPECT_FALSE(extensionConfig_->configMap_["form"].networkEnableFlag);
261 }
262
263 /*
264 * @tc.number : LoadExtensionSAEnable_001
265 * @tc.name : AbilityExtensionConfigTest
266 * @tc.desc : Test Function LoadExtensionSAEnable
267 */
268 HWTEST_F(AbilityExtensionConfigTest, LoadExtensionSAEnable_001, TestSize.Level1)
269 {
270 json jsOnFile;
271 jsOnFile[EXTENSION_SA_ENABLE_FLAG] = false;
272 auto extType = "form";
273 ASSERT_NE(extensionConfig_, nullptr);
274 extensionConfig_->configMap_.clear();
275 extensionConfig_->LoadExtensionSAEnable(jsOnFile, extType);
276 EXPECT_FALSE(extensionConfig_->configMap_[extType].saEnableFlag);
277 }
278
279 /*
280 * @tc.number : IsExtensionNetworkEnable_001
281 * @tc.name : AbilityExtensionConfigTest
282 * @tc.desc : Test Function IsExtensionNetworkEnable
283 */
284 HWTEST_F(AbilityExtensionConfigTest, IsExtensionNetworkEnable_001, TestSize.Level1)
285 {
286 auto extType = "form";
287 ASSERT_NE(extensionConfig_, nullptr);
288 extensionConfig_->configMap_.clear();
289 extensionConfig_->configMap_[extType].networkEnableFlag = false;
290 bool enable = extensionConfig_->IsExtensionNetworkEnable(extType);
291 EXPECT_FALSE(enable);
292 }
293
294 /*
295 * @tc.number : IsExtensionSAEnable_001
296 * @tc.name : AbilityExtensionConfigTest
297 * @tc.desc : Test Function IsExtensionSAEnable
298 */
299 HWTEST_F(AbilityExtensionConfigTest, IsExtensionSAEnable_001, TestSize.Level1)
300 {
301 auto extType = "form";
302 ASSERT_NE(extensionConfig_, nullptr);
303 extensionConfig_->configMap_.clear();
304 extensionConfig_->configMap_[extType].saEnableFlag = false;
305 bool enable = extensionConfig_->IsExtensionSAEnable(extType);
306 EXPECT_FALSE(enable);
307 }
308 }
309 }
310