1 /*
2  * Copyright (c) 2022-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 <vector>
19 #define private public
20 #define protected public
21 #include "iplugin.h"
22 #undef protected
23 #undef private
24 #include "func_code.h"
25 #include "iplugin_mock.h"
26 
27 using namespace testing::ext;
28 using namespace testing;
29 
30 namespace OHOS {
31 namespace EDM {
32 namespace TEST {
33 class IPluginTest : public testing::Test {
34 protected:
35     void SetUp() override {}
36 
37     void TearDown() override {}
38 };
39 
40 /**
41  * @tc.name: TestIsGlobalPolicy
42  * @tc.desc: Test IsGlobalPolicy func.
43  * @tc.type: FUNC
44  */
HWTEST_F(IPluginTest, TestIsGlobalPolicy, TestSize.Level1)45 HWTEST_F(IPluginTest, TestIsGlobalPolicy, TestSize.Level1)
46 {
47     IPluginMock iplugin1;
48     EXPECT_TRUE(iplugin1.IsGlobalPolicy());
49     iplugin1.MockSetPolicyName("test");
50     std::string mergeJsonData;
51     ErrCode err = iplugin1.MergePolicyData("com.edm.test.demo", mergeJsonData);
52     EXPECT_TRUE(err == ERR_OK);
53     MessageParcel reply;
54     err = iplugin1.WritePolicyToParcel("name:test", reply);
55     EXPECT_TRUE(err == ERR_OK);
56 }
57 
58 /**
59  * @tc.name: TestPolicyPermissionConfig
60  * @tc.desc: Test PolicyPermissionConfig struct.
61  * @tc.type: FUNC
62  */
HWTEST_F(IPluginTest, TestPolicyPermissionConfig, TestSize.Level1)63 HWTEST_F(IPluginTest, TestPolicyPermissionConfig, TestSize.Level1)
64 {
65     IPlugin::PolicyPermissionConfig config1 = IPlugin::PolicyPermissionConfig();
66     EXPECT_TRUE(config1.permissionType == IPlugin::PermissionType::UNKNOWN);
67     EXPECT_TRUE(config1.apiType == IPlugin::ApiType::UNKNOWN);
68 
69     IPlugin::PolicyPermissionConfig config2 = IPlugin::PolicyPermissionConfig("test_permission",
70         IPlugin::PermissionType::SUPER_DEVICE_ADMIN, IPlugin::ApiType::PUBLIC);
71     EXPECT_TRUE(config2.permission == "test_permission");
72     EXPECT_TRUE(config2.permissionType == IPlugin::PermissionType::SUPER_DEVICE_ADMIN);
73     EXPECT_TRUE(config2.apiType == IPlugin::ApiType::PUBLIC);
74 
75     std::map<std::string, std::string> perms;
76     perms.insert(std::make_pair("tag1", "permission1"));
77     perms.insert(std::make_pair("tag2", "permission2"));
78     IPlugin::PolicyPermissionConfig config3 = IPlugin::PolicyPermissionConfig(perms,
79         IPlugin::PermissionType::NORMAL_DEVICE_ADMIN, IPlugin::ApiType::SYSTEM);
80     EXPECT_TRUE(config3.tagPermissions.size() == 2);
81     EXPECT_TRUE(config3.permissionType == IPlugin::PermissionType::NORMAL_DEVICE_ADMIN);
82     EXPECT_TRUE(config3.apiType == IPlugin::ApiType::SYSTEM);
83 }
84 
85 /**
86  * @tc.name: TestGetApiType
87  * @tc.desc: Test GetApiType func.
88  * @tc.type: FUNC
89  */
HWTEST_F(IPluginTest, TestGetApiType, TestSize.Level1)90 HWTEST_F(IPluginTest, TestGetApiType, TestSize.Level1)
91 {
92     FuncOperateType operaType = FuncOperateType::GET;
93     IPluginMock::ApiType ret;
94 
95     std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap1;
96     IPluginMock::PolicyPermissionConfig permissionConfig1;
97     std::unique_ptr<IPlugin> iplugin1 = std::make_unique<IPluginMock>();
98     permissionMap1[operaType] = permissionConfig1;
99     iplugin1->permissionMap_ = permissionMap1;
100     iplugin1->permissionConfig_ = permissionConfig1;
101     ret = iplugin1->GetApiType(operaType);
102     EXPECT_TRUE(ret == IPluginMock::ApiType::UNKNOWN);
103 
104     std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap2;
105     IPluginMock::PolicyPermissionConfig permissionConfig2;
106     std::unique_ptr<IPlugin> iplugin2 = std::make_unique<IPluginMock>();
107     iplugin2->permissionMap_ = permissionMap2;
108     permissionConfig2.apiType = IPluginMock::ApiType::PUBLIC;
109     iplugin2->permissionConfig_ = permissionConfig2;
110     ret = iplugin2->GetApiType(operaType);
111     EXPECT_TRUE(ret == IPluginMock::ApiType::PUBLIC);
112 
113     std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap3;
114     IPluginMock::PolicyPermissionConfig permissionConfig3;
115     std::unique_ptr<IPlugin> iplugin3 = std::make_unique<IPluginMock>();
116     permissionConfig3.apiType = IPluginMock::ApiType::PUBLIC;
117     permissionMap3[operaType] = permissionConfig3;
118     iplugin3->permissionMap_ = permissionMap3;
119     ret = iplugin3->GetApiType(operaType);
120     EXPECT_TRUE(ret == IPluginMock::ApiType::PUBLIC);
121 
122     std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap4;
123     IPluginMock::PolicyPermissionConfig permissionConfig4;
124     std::unique_ptr<IPlugin> iplugin4 = std::make_unique<IPluginMock>();
125     permissionConfig4.apiType = IPluginMock::ApiType::UNKNOWN;
126     permissionMap4[operaType] = permissionConfig4;
127     iplugin4->permissionConfig_ = permissionConfig4;
128     ret = iplugin4->GetApiType(operaType);
129     EXPECT_TRUE(ret == IPluginMock::ApiType::UNKNOWN);
130 }
131 
132 /**
133  * @tc.name: TestGetPermissionWhenIfEstablished
134  * @tc.desc: Test GetPermission func when The If Condition is Met.
135  * @tc.type: FUNC
136  */
HWTEST_F(IPluginTest, TestGetPermissionWhenIfEstablished, TestSize.Level1)137 HWTEST_F(IPluginTest, TestGetPermissionWhenIfEstablished, TestSize.Level1)
138 {
139     FuncOperateType operaType = FuncOperateType::GET;
140     std::string permissionTag = "permissionTag";
141     std::map<FuncOperateType, IPluginMock::PolicyPermissionConfig> permissionMap;
142     IPluginMock::PolicyPermissionConfig permissionConfig;
143     std::unique_ptr<IPlugin> iplugin = std::make_unique<IPluginMock>();
144 
145     permissionMap[operaType] = permissionConfig;
146     iplugin->permissionMap_ = permissionMap;
147     iplugin->permissionConfig_ = permissionConfig;
148     std::string ret = iplugin->GetPermission(operaType, permissionTag);
149     std::string checkRet = NONE_PERMISSION_MATCH;
150     EXPECT_TRUE(ret == checkRet);
151 }
152 
153 /**
154  * @tc.name: TestSetExtensionPlugin
155  * @tc.desc: Test SetExtensionPlugin func.
156  * @tc.type: FUNC
157  */
HWTEST_F(IPluginTest, TestSetExtensionPlugin, TestSize.Level1)158 HWTEST_F(IPluginTest, TestSetExtensionPlugin, TestSize.Level1)
159 {
160     std::shared_ptr<IPlugin> extensionPlugin = std::make_shared<IPluginMock>();
161     std::unique_ptr<IPlugin> iplugin = std::make_unique<IPluginMock>();
162     iplugin->SetExtensionPlugin(extensionPlugin);
163     EXPECT_TRUE(extensionPlugin == iplugin->GetExtensionPlugin());
164 }
165 
166 /**
167  * @tc.name: TestSetExecuteStrategy
168  * @tc.desc: Test SetExecuteStrategy func.
169  * @tc.type: FUNC
170  */
HWTEST_F(IPluginTest, TestSetExecuteStrategy, TestSize.Level1)171 HWTEST_F(IPluginTest, TestSetExecuteStrategy, TestSize.Level1)
172 {
173     std::shared_ptr<IPluginExecuteStrategy> strategy = std::make_shared<IPluginExecuteStrategy>();
174     std::unique_ptr<IPlugin> iplugin = std::make_unique<IPluginMock>();
175     iplugin->SetExecuteStrategy(strategy);
176     EXPECT_TRUE(strategy == iplugin->GetExecuteStrategy());
177 }
178 
179 /**
180  * @tc.name: TestSetPluginType
181  * @tc.desc: Test SetPluginType func.
182  * @tc.type: FUNC
183  */
HWTEST_F(IPluginTest, TestSetPluginType, TestSize.Level1)184 HWTEST_F(IPluginTest, TestSetPluginType, TestSize.Level1)
185 {
186     IPluginMock::PluginType type = IPluginMock::PluginType::BASIC;
187     std::unique_ptr<IPlugin> iplugin = std::make_unique<IPluginMock>();
188     iplugin->SetPluginType(type);
189     EXPECT_TRUE(type == iplugin->GetPluginType());
190 }
191 } // namespace TEST
192 } // namespace EDM
193 } // namespace OHOS