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 "location_without_permission_test.h"
17 
18 #include "accesstoken_kit.h"
19 #include "message_parcel.h"
20 #include "nativetoken_kit.h"
21 #include "token_setproc.h"
22 
23 #ifdef FEATURE_GNSS_SUPPORT
24 #include "cached_locations_callback_napi.h"
25 #endif
26 #include "constant_definition.h"
27 #ifdef FEATURE_GEOCODE_SUPPORT
28 #include "geo_address.h"
29 #endif
30 #ifdef FEATURE_GNSS_SUPPORT
31 #include "gnss_status_callback_napi.h"
32 #include "i_cached_locations_callback.h"
33 #endif
34 #include "i_locator_callback.h"
35 #include "location_switch_callback_napi.h"
36 #include "locator.h"
37 #include "location_log.h"
38 #include "locator_callback_proxy.h"
39 #include "locator_impl.h"
40 #include "geofence_sdk.h"
41 #ifdef FEATURE_GNSS_SUPPORT
42 #include "nmea_message_callback_napi.h"
43 #endif
44 #include "request_config.h"
45 #include "permission_manager.h"
46 #include "geofence_request.h"
47 #include "locator_ability.h"
48 
49 using namespace testing::ext;
50 namespace OHOS {
51 namespace Location {
52 const int32_t LOCATION_WITHOUT_PERM = 1;
SetUp()53 void LocationWithoutPermissionTest::SetUp()
54 {
55     MockNativePermission();
56 }
57 
TearDown()58 void LocationWithoutPermissionTest::TearDown()
59 {
60 }
61 
MockNativePermission()62 void LocationWithoutPermissionTest::MockNativePermission()
63 {
64     const char *perms[] = {
65         ACCESS_BACKGROUND_LOCATION.c_str(),
66     };
67     NativeTokenInfoParams infoInstance = {
68         .dcapsNum = 0,
69         .permsNum = LOCATION_WITHOUT_PERM,
70         .aclsNum = 0,
71         .dcaps = nullptr,
72         .perms = perms,
73         .acls = nullptr,
74         .processName = "LocatorPermissionTest",
75         .aplStr = "system_basic",
76     };
77     tokenId_ = GetAccessTokenId(&infoInstance);
78     SetSelfTokenID(tokenId_);
79     Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
80 }
81 
82 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutSettingsPermission001, TestSize.Level1)
83 {
84     GTEST_LOG_(INFO)
85         << "LocationWithoutPermissionTest, LocatorWithoutSettingsPermission001, TestSize.Level1";
86     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutSettingsPermission001 begin");
87     auto locatorImpl = Locator::GetInstance();
88     EXPECT_NE(nullptr, locatorImpl);
89     auto switchCallbackHost =
90         sptr<LocationSwitchCallbackNapi>(new (std::nothrow) LocationSwitchCallbackNapi());
91     EXPECT_NE(nullptr, switchCallbackHost);
92     EXPECT_EQ(true, locatorImpl->RegisterSwitchCallback(switchCallbackHost->AsObject(), 1000));
93     EXPECT_EQ(true, locatorImpl->UnregisterSwitchCallback(switchCallbackHost->AsObject()));
94     locatorImpl->EnableAbility(true);
95     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutSettingsPermission001 end");
96 }
97 
98 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutLocationPermission001, TestSize.Level1)
99 {
100     GTEST_LOG_(INFO)
101         << "LocationWithoutPermissionTest, LocatorWithoutLocationPermission001, TestSize.Level1";
102     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermission001 begin");
103     auto locatorImpl = Locator::GetInstance();
104     EXPECT_NE(nullptr, locatorImpl);
105 
106     std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
107     requestConfig->SetPriority(PRIORITY_ACCURACY);
108     sptr<ILocatorCallback> callbackStub = new (std::nothrow) LocatorCallbackStub();
109     locatorImpl->StartLocating(requestConfig, callbackStub);
110     locatorImpl->StopLocating(callbackStub);
111 
112     EXPECT_EQ(nullptr, locatorImpl->GetCachedLocation());
113 #ifdef FEATURE_GEOCODE_SUPPORT
114     locatorImpl->IsGeoServiceAvailable();
115     MessageParcel request001;
116     std::list<std::shared_ptr<GeoAddress>> geoAddressList001;
117     locatorImpl->GetAddressByCoordinate(request001, geoAddressList001);
118     MessageParcel request002;
119     std::list<std::shared_ptr<GeoAddress>> geoAddressList002;
120     locatorImpl->GetAddressByLocationName(request002, geoAddressList002);
121 #endif
122     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermission001 end");
123 }
124 
125 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutLocationPermission002, TestSize.Level1)
126 {
127     GTEST_LOG_(INFO)
128         << "LocationWithoutPermissionTest, LocatorWithoutLocationPermission002, TestSize.Level1";
129     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermission002 begin");
130     auto locatorImpl = Locator::GetInstance();
131     EXPECT_NE(nullptr, locatorImpl);
132     bool state = false;
133     EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl->IsLocationEnabledV9(state));
134 #ifdef FEATURE_GNSS_SUPPORT
135     auto gnssCallbackHost =
136         sptr<GnssStatusCallbackNapi>(new (std::nothrow) GnssStatusCallbackNapi());
137     EXPECT_NE(nullptr, gnssCallbackHost);
138     EXPECT_EQ(true, locatorImpl->RegisterGnssStatusCallback(gnssCallbackHost->AsObject(), 1000));
139     EXPECT_EQ(true, locatorImpl->UnregisterGnssStatusCallback(gnssCallbackHost->AsObject()));
140 
141     auto nmeaCallbackHost =
142         sptr<NmeaMessageCallbackNapi>(new (std::nothrow) NmeaMessageCallbackNapi());
143     EXPECT_NE(nullptr, nmeaCallbackHost);
144     EXPECT_EQ(true, locatorImpl->RegisterNmeaMessageCallback(nmeaCallbackHost->AsObject(), 1000));
145     EXPECT_EQ(true, locatorImpl->UnregisterNmeaMessageCallback(nmeaCallbackHost->AsObject()));
146 #endif
147     locatorImpl->IsLocationPrivacyConfirmed(1);
148     EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->SetLocationPrivacyConfirmStatus(1, true));
149 #ifdef FEATURE_GNSS_SUPPORT
150     if (state) {
151         EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->FlushCachedGnssLocations());
152     }
153 #endif
154     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermission002 end");
155 }
156 
157 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutLocationPermission003, TestSize.Level1)
158 {
159     GTEST_LOG_(INFO)
160         << "LocationWithoutPermissionTest, LocatorWithoutLocationPermission003, TestSize.Level1";
161     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermission003 begin");
162     auto locatorImpl = Locator::GetInstance();
163     EXPECT_NE(nullptr, locatorImpl);
164 #ifdef FEATURE_GNSS_SUPPORT
165     locatorImpl->GetCachedGnssLocationsSize();
166 
167     auto cachedLocationsCallbackHost =
168         sptr<CachedLocationsCallbackNapi>(new (std::nothrow) CachedLocationsCallbackNapi());
169     EXPECT_NE(nullptr, cachedLocationsCallbackHost);
170     auto cachedCallback = sptr<ICachedLocationsCallback>(cachedLocationsCallbackHost);
171     EXPECT_NE(nullptr, cachedCallback);
172     auto request = std::make_unique<CachedGnssLocationsRequest>();
173     EXPECT_NE(nullptr, request);
174     request->reportingPeriodSec = 10;
175     request->wakeUpCacheQueueFull = true;
176     locatorImpl->RegisterCachedLocationCallback(request, cachedCallback);
177     locatorImpl->UnregisterCachedLocationCallback(cachedCallback);
178 #endif
179     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermission003 end");
180 }
181 
182 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutSettingsPermissionV9001, TestSize.Level1)
183 {
184     GTEST_LOG_(INFO)
185         << "LocationWithoutPermissionTest, LocatorWithoutSettingsPermissionV9001, TestSize.Level1";
186     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutSettingsPermissionV9001 begin");
187     auto locatorImpl = Locator::GetInstance();
188     EXPECT_NE(nullptr, locatorImpl);
189     EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->EnableAbilityV9(true));
190     EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->SetLocationPrivacyConfirmStatusV9(1, true));
191     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutSettingsPermissionV9001 end");
192 }
193 
194 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutLocationPermissionV9001, TestSize.Level1)
195 {
196     GTEST_LOG_(INFO)
197         << "LocationWithoutPermissionTest, LocatorWithoutLocationPermissionV9001, TestSize.Level1";
198     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermissionV9001 begin");
199     auto locatorImpl = Locator::GetInstance();
200     EXPECT_NE(nullptr, locatorImpl);
201 
202     bool state = false;
203     EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl->IsLocationEnabledV9(state));
204 
205     std::unique_ptr<RequestConfig> requestConfig = std::make_unique<RequestConfig>();
206     requestConfig->SetPriority(PRIORITY_ACCURACY);
207     sptr<ILocatorCallback> callbackStub = new (std::nothrow) LocatorCallbackStub();
208     if (state) {
209         EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->StartLocatingV9(requestConfig, callbackStub));
210     }
211     EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->StopLocatingV9(callbackStub));
212 
213     std::unique_ptr loc = std::make_unique<Location>();
214     if (state) {
215         EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->GetCachedLocationV9(loc));
216     }
217     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermissionV9001 end");
218 }
219 
220 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutLocationPermissionV9002, TestSize.Level1)
221 {
222     GTEST_LOG_(INFO)
223         << "LocationWithoutPermissionTest, LocatorWithoutLocationPermissionV9002, TestSize.Level1";
224     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermissionV9002 begin");
225     auto locatorImpl = Locator::GetInstance();
226     EXPECT_NE(nullptr, locatorImpl);
227 
228     bool state = false;
229     EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl->IsLocationEnabledV9(state));
230 #ifdef FEATURE_GNSS_SUPPORT
231     auto gnssCallbackHost =
232         sptr<GnssStatusCallbackNapi>(new (std::nothrow) GnssStatusCallbackNapi());
233     EXPECT_NE(nullptr, gnssCallbackHost);
234     if (state) {
235         EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->RegisterGnssStatusCallbackV9(gnssCallbackHost->AsObject()));
236     }
237     EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->UnregisterGnssStatusCallbackV9(gnssCallbackHost->AsObject()));
238 
239     auto nmeaCallbackHost =
240         sptr<NmeaMessageCallbackNapi>(new (std::nothrow) NmeaMessageCallbackNapi());
241     EXPECT_NE(nullptr, nmeaCallbackHost);
242     if (state) {
243         EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->RegisterNmeaMessageCallbackV9(nmeaCallbackHost->AsObject()));
244     }
245     EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->UnregisterNmeaMessageCallbackV9(nmeaCallbackHost->AsObject()));
246     if (state) {
247         EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->FlushCachedGnssLocationsV9());
248     }
249 #endif
250     std::set<int> pidList;
251     pidList.insert(1000);
252     EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->ProxyForFreeze(pidList, false));
253     EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->ResetAllProxy());
254     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermissionV9002 end");
255 }
256 
257 HWTEST_F(LocationWithoutPermissionTest, LocatorWithoutLocationPermissionV9003, TestSize.Level1)
258 {
259     GTEST_LOG_(INFO)
260         << "LocationWithoutPermissionTest, LocatorWithoutLocationPermissionV9003, TestSize.Level1";
261     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermissionV9003 begin");
262     auto locatorImpl = Locator::GetInstance();
263     auto geofenceSdk = GeofenceManager::GetInstance();
264     EXPECT_NE(nullptr, locatorImpl);
265 
266     bool state = false;
267     EXPECT_EQ(ERRCODE_SUCCESS, locatorImpl->IsLocationEnabledV9(state));
268 #ifdef FEATURE_GNSS_SUPPORT
269     GeoFence geofence;
270     geofence.latitude = 35.1;
271     geofence.longitude = 40.2;
272     geofence.radius = 2.2;
273     geofence.expiration = 12.2;
274     std::shared_ptr<GeofenceRequest> fenceRequest = std::make_shared<GeofenceRequest>();
275     fenceRequest->SetGeofence(geofence);
276     if (state) {
277         EXPECT_EQ(ERRCODE_PERMISSION_DENIED, geofenceSdk->AddFenceV9(fenceRequest));
278         EXPECT_EQ(ERRCODE_PERMISSION_DENIED, geofenceSdk->RemoveFenceV9(fenceRequest));
279     } else {
280         EXPECT_EQ(ERRCODE_SWITCH_OFF, geofenceSdk->AddFenceV9(fenceRequest));
281         EXPECT_EQ(ERRCODE_SWITCH_OFF, geofenceSdk->RemoveFenceV9(fenceRequest));
282     }
283 
284     int size = -1;
285     if (state) {
286         EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->GetCachedGnssLocationsSizeV9(size));
287     } else {
288         EXPECT_EQ(ERRCODE_SWITCH_OFF, locatorImpl->GetCachedGnssLocationsSizeV9(size));
289     }
290     EXPECT_EQ(0, size);
291 
292     auto cachedLocationsCallbackHost =
293         sptr<CachedLocationsCallbackNapi>(new (std::nothrow) CachedLocationsCallbackNapi());
294     EXPECT_NE(nullptr, cachedLocationsCallbackHost);
295     auto cachedCallback = sptr<ICachedLocationsCallback>(cachedLocationsCallbackHost);
296     EXPECT_NE(nullptr, cachedCallback);
297     auto request = std::make_unique<CachedGnssLocationsRequest>();
298     EXPECT_NE(nullptr, request);
299     request->reportingPeriodSec = 10;
300     request->wakeUpCacheQueueFull = true;
301     if (state) {
302         EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->RegisterCachedLocationCallbackV9(request, cachedCallback));
303     } else {
304         EXPECT_EQ(ERRCODE_SWITCH_OFF, locatorImpl->RegisterCachedLocationCallbackV9(request, cachedCallback));
305     }
306     EXPECT_EQ(ERRCODE_PERMISSION_DENIED, locatorImpl->UnregisterCachedLocationCallbackV9(cachedCallback));
307 #endif
308     LBSLOGI(LOCATOR, "[LocationWithoutPermissionTest] LocatorWithoutLocationPermissionV9003 end");
309 }
310 }  // namespace Location
311 }  // namespace OHOS