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 <gtest/gtest.h>
17 #include <string>
18 #include <system_ability_definition.h>
19 #include <vector>
20
21 #include "application_manager_proxy.h"
22 #include "edm_sys_manager_mock.h"
23 #include "enterprise_device_mgr_stub_mock.h"
24 #include "utils.h"
25
26 using namespace testing::ext;
27 using namespace testing;
28
29 namespace OHOS {
30 namespace EDM {
31 namespace TEST {
32 const std::string ADMIN_PACKAGENAME = "com.edm.test.demo";
33 class ApplicationManagerProxyTest : public testing::Test {
34 protected:
35 void SetUp() override;
36
37 void TearDown() override;
38
39 static void TearDownTestSuite(void);
40 std::shared_ptr<ApplicationManagerProxy> applicationManagerProxy_ = nullptr;
41 std::shared_ptr<EdmSysManager> edmSysManager_ = nullptr;
42 sptr<EnterpriseDeviceMgrStubMock> object_ = nullptr;
43 };
44
SetUp()45 void ApplicationManagerProxyTest::SetUp()
46 {
47 applicationManagerProxy_ = ApplicationManagerProxy::GetApplicationManagerProxy();
48 edmSysManager_ = std::make_shared<EdmSysManager>();
49 object_ = new (std::nothrow) EnterpriseDeviceMgrStubMock();
50 edmSysManager_->RegisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID, object_);
51 Utils::SetEdmServiceEnable();
52 }
53
TearDown()54 void ApplicationManagerProxyTest::TearDown()
55 {
56 applicationManagerProxy_.reset();
57 edmSysManager_->UnregisterSystemAbilityOfRemoteObject(ENTERPRISE_DEVICE_MANAGER_SA_ID);
58 object_ = nullptr;
59 Utils::SetEdmServiceDisable();
60 }
61
TearDownTestSuite()62 void ApplicationManagerProxyTest::TearDownTestSuite()
63 {
64 ASSERT_FALSE(Utils::GetEdmServiceState());
65 std::cout << "EdmServiceState : " << Utils::GetEdmServiceState() << std::endl;
66 }
67
68 /**
69 * @tc.name: TestAddDisallowedRunningBundlesSuc
70 * @tc.desc: Test AddDisallowedRunningBundles success func.
71 * @tc.type: FUNC
72 */
73 HWTEST_F(ApplicationManagerProxyTest, AddDisallowedRunningBundlesSuc, TestSize.Level1)
74 {
75 OHOS::AppExecFwk::ElementName admin;
76 std::vector<std::string> bundles = {ADMIN_PACKAGENAME};
77 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
78 .Times(1)
79 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
80 ErrCode ret = applicationManagerProxy_->AddDisallowedRunningBundles(admin, bundles, DEFAULT_USER_ID);
81 ASSERT_TRUE(ret == ERR_OK);
82 }
83
84 /**
85 * @tc.name: TestAddDisallowedRunningBundlesFail
86 * @tc.desc: Test AddDisallowedRunningBundles without enable edm service func.
87 * @tc.type: FUNC
88 */
89 HWTEST_F(ApplicationManagerProxyTest, AddDisallowedRunningBundles, TestSize.Level1)
90 {
91 Utils::SetEdmServiceDisable();
92 OHOS::AppExecFwk::ElementName admin;
93 std::vector<std::string> bundles = {ADMIN_PACKAGENAME};
94 ErrCode ret = applicationManagerProxy_->AddDisallowedRunningBundles(admin, bundles, DEFAULT_USER_ID);
95 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
96 }
97
98 /**
99 * @tc.name: TestRemoveDisallowedRunningBundlesSuc
100 * @tc.desc: Test RemoveDisallowedRunningBundles success func.
101 * @tc.type: FUNC
102 */
103 HWTEST_F(ApplicationManagerProxyTest, RemoveDisallowedRunningBundlesSuc, TestSize.Level1)
104 {
105 OHOS::AppExecFwk::ElementName admin;
106 std::vector<std::string> bundles = {ADMIN_PACKAGENAME};
107 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
108 .Times(1)
109 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
110 ErrCode ret = applicationManagerProxy_->RemoveDisallowedRunningBundles(admin, bundles, DEFAULT_USER_ID);
111 ASSERT_TRUE(ret == ERR_OK);
112 }
113
114 /**
115 * @tc.name: TestRemoveDisallowedRunningBundlesFail
116 * @tc.desc: Test RemoveDisallowedRunningBundles without enable edm service func.
117 * @tc.type: FUNC
118 */
119 HWTEST_F(ApplicationManagerProxyTest, RemoveDisallowedRunningBundlesFail, TestSize.Level1)
120 {
121 Utils::SetEdmServiceDisable();
122 OHOS::AppExecFwk::ElementName admin;
123 std::vector<std::string> bundles = {ADMIN_PACKAGENAME};
124 ErrCode ret = applicationManagerProxy_->RemoveDisallowedRunningBundles(admin, bundles, DEFAULT_USER_ID);
125 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
126 }
127
128 /**
129 * @tc.name: TestGetDisallowedRunningBundlesSuc
130 * @tc.desc: Test GetDisallowedRunningBundles success func.
131 * @tc.type: FUNC
132 */
133 HWTEST_F(ApplicationManagerProxyTest, GetDisallowedRunningBundlesSuc, TestSize.Level1)
134 {
135 OHOS::AppExecFwk::ElementName admin;
136 std::vector<std::string> bundles = {ADMIN_PACKAGENAME};
137 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
138 .Times(1)
139 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeArrayStringSendRequestGetPolicy));
140 ErrCode ret = applicationManagerProxy_->GetDisallowedRunningBundles(admin, DEFAULT_USER_ID, bundles);
141 ASSERT_TRUE(ret == ERR_OK);
142 ASSERT_TRUE(bundles.size() == 1);
143 ASSERT_TRUE(bundles[0] == RETURN_STRING);
144 }
145
146 /**
147 * @tc.name: TestGetDisallowedRunningBundlesFail
148 * @tc.desc: Test GetDisallowedRunningBundles without enable edm service func.
149 * @tc.type: FUNC
150 */
151 HWTEST_F(ApplicationManagerProxyTest, GetDisallowedRunningBundlesFail, TestSize.Level1)
152 {
153 Utils::SetEdmServiceDisable();
154 OHOS::AppExecFwk::ElementName admin;
155 std::vector<std::string> bundles = {ADMIN_PACKAGENAME};
156 ErrCode ret = applicationManagerProxy_->GetDisallowedRunningBundles(admin, DEFAULT_USER_ID, bundles);
157 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
158 }
159
160 /**
161 * @tc.name: TestAddAutoStartAppsFail
162 * @tc.desc: Test AddAutoStartApps without enable edm service func.
163 * @tc.type: FUNC
164 */
165 HWTEST_F(ApplicationManagerProxyTest, TestAddAutoStartAppsFail, TestSize.Level1)
166 {
167 Utils::SetEdmServiceDisable();
168 OHOS::AppExecFwk::ElementName admin;
169 std::vector<OHOS::AppExecFwk::ElementName> apps;
170 ErrCode ret = applicationManagerProxy_->AddAutoStartApps(admin, apps);
171 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
172 }
173
174 /**
175 * @tc.name: TestAddAutoStartAppsSuc
176 * @tc.desc: Test AddAutoStartApps success func.
177 * @tc.type: FUNC
178 */
179 HWTEST_F(ApplicationManagerProxyTest, AddAutoStartAppsSuc, TestSize.Level1)
180 {
181 OHOS::AppExecFwk::ElementName admin;
182 std::vector<OHOS::AppExecFwk::ElementName> apps;
183 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
184 .Times(1)
185 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
186 ErrCode ret = applicationManagerProxy_->AddAutoStartApps(admin, apps);
187 ASSERT_TRUE(ret == ERR_OK);
188 }
189
190 /**
191 * @tc.name: TestRemoveAutoStartAppsFail
192 * @tc.desc: Test RemoveAutoStartApps without enable edm service func.
193 * @tc.type: FUNC
194 */
195 HWTEST_F(ApplicationManagerProxyTest, TestRemoveAutoStartAppsFail, TestSize.Level1)
196 {
197 Utils::SetEdmServiceDisable();
198 OHOS::AppExecFwk::ElementName admin;
199 std::vector<OHOS::AppExecFwk::ElementName> apps;
200 ErrCode ret = applicationManagerProxy_->RemoveAutoStartApps(admin, apps);
201 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
202 }
203
204 /**
205 * @tc.name: TestRemoveAutoStartAppsSuc
206 * @tc.desc: Test RemoveAutoStartApps success func.
207 * @tc.type: FUNC
208 */
209 HWTEST_F(ApplicationManagerProxyTest, TestRemoveAutoStartAppsSuc, TestSize.Level1)
210 {
211 OHOS::AppExecFwk::ElementName admin;
212 std::vector<OHOS::AppExecFwk::ElementName> apps;
213 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
214 .Times(1)
215 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeSendRequestSetPolicy));
216 ErrCode ret = applicationManagerProxy_->RemoveAutoStartApps(admin, apps);
217 ASSERT_TRUE(ret == ERR_OK);
218 }
219
220 /**
221 * @tc.name: TestGetAutoStartAppsSuc
222 * @tc.desc: Test GetAutoStartApps success func.
223 * @tc.type: FUNC
224 */
225 HWTEST_F(ApplicationManagerProxyTest, TestGetAutoStartAppsSuc, TestSize.Level1)
226 {
227 OHOS::AppExecFwk::ElementName admin;
228 std::vector<OHOS::AppExecFwk::ElementName> apps;
229 EXPECT_CALL(*object_, SendRequest(_, _, _, _))
230 .Times(1)
231 .WillOnce(Invoke(object_.GetRefPtr(), &EnterpriseDeviceMgrStubMock::InvokeArrayElementSendRequestGetPolicy));
232 ErrCode ret = applicationManagerProxy_->GetAutoStartApps(admin, apps);
233 ASSERT_TRUE(ret == ERR_OK);
234 ASSERT_TRUE(apps.size() == 1);
235 }
236
237 /**
238 * @tc.name: TestGetAutoStartAppsFail
239 * @tc.desc: Test GetAutoStartApps without enable edm service func.
240 * @tc.type: FUNC
241 */
242 HWTEST_F(ApplicationManagerProxyTest, TestGetAutoStartAppsFail, TestSize.Level1)
243 {
244 Utils::SetEdmServiceDisable();
245 OHOS::AppExecFwk::ElementName admin;
246 std::vector<OHOS::AppExecFwk::ElementName> apps;
247 ErrCode ret = applicationManagerProxy_->GetAutoStartApps(admin, apps);
248 ASSERT_TRUE(ret == EdmReturnErrCode::ADMIN_INACTIVE);
249 }
250 } // namespace TEST
251 } // namespace EDM
252 } // namespace OHOS
253