OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/macros.h" | 5 #include "base/macros.h" |
6 #include "base/message_loop/message_loop.h" | 6 #include "base/message_loop/message_loop.h" |
7 #include "base/run_loop.h" | 7 #include "base/run_loop.h" |
| 8 #include "base/strings/string_number_conversions.h" |
8 #include "base/strings/stringprintf.h" | 9 #include "base/strings/stringprintf.h" |
9 #include "chromeos/dbus/dbus_thread_manager.h" | 10 #include "chromeos/dbus/dbus_thread_manager.h" |
10 #include "chromeos/dbus/shill_device_client.h" | 11 #include "chromeos/dbus/shill_device_client.h" |
11 #include "chromeos/dbus/shill_profile_client.h" | 12 #include "chromeos/dbus/shill_profile_client.h" |
12 #include "chromeos/dbus/shill_service_client.h" | 13 #include "chromeos/dbus/shill_service_client.h" |
13 #include "chromeos/login/login_state.h" | 14 #include "chromeos/login/login_state.h" |
14 #include "chromeos/network/managed_network_configuration_handler.h" | 15 #include "chromeos/network/managed_network_configuration_handler.h" |
15 #include "chromeos/network/network_handler.h" | 16 #include "chromeos/network/network_handler.h" |
16 #include "chromeos/network/network_state.h" | 17 #include "chromeos/network/network_state.h" |
17 #include "chromeos/network/network_state_handler.h" | 18 #include "chromeos/network/network_state_handler.h" |
| 19 #include "components/onc/onc_constants.h" |
18 #include "extensions/browser/api/networking_private/networking_private_api.h" | 20 #include "extensions/browser/api/networking_private/networking_private_api.h" |
19 #include "extensions/browser/api_unittest.h" | 21 #include "extensions/browser/api_unittest.h" |
20 #include "extensions/common/value_builder.h" | 22 #include "extensions/common/value_builder.h" |
21 #include "third_party/cros_system_api/dbus/shill/dbus-constants.h" | 23 #include "third_party/cros_system_api/dbus/shill/dbus-constants.h" |
22 | 24 |
23 namespace extensions { | 25 namespace extensions { |
24 | 26 |
25 namespace { | 27 namespace { |
26 | 28 |
27 const char kUserHash[] = "test_user_hash"; | 29 const char kUserHash[] = "test_user_hash"; |
28 const char kUserProfilePath[] = "/network_profile/user/shill"; | 30 const char kUserProfilePath[] = "/network_profile/user/shill"; |
29 | 31 |
30 const char kWifiDevicePath[] = "/device/stub_wifi_device"; | 32 const char kWifiDevicePath[] = "/device/stub_wifi_device"; |
31 | 33 |
32 const char kSharedWifiServicePath[] = "/service/shared_wifi"; | 34 const char kSharedWifiServicePath[] = "/service/shared_wifi"; |
33 const char kSharedWifiGuid[] = "shared_wifi_guid"; | 35 const char kSharedWifiGuid[] = "shared_wifi_guid"; |
34 const char kSharedWifiName[] = "shared_wifi"; | 36 const char kSharedWifiName[] = "shared_wifi"; |
35 | 37 |
36 const char kPrivateWifiServicePath[] = "/service/private_wifi"; | 38 const char kPrivateWifiServicePath[] = "/service/private_wifi"; |
37 const char kPrivateWifiGuid[] = "private_wifi_guid"; | 39 const char kPrivateWifiGuid[] = "private_wifi_guid"; |
38 const char kPrivateWifiName[] = "private_wifi"; | 40 const char kPrivateWifiName[] = "private_wifi"; |
39 | 41 |
| 42 const char kManagedUserWifiGuid[] = "managed_user_wifi_guid"; |
| 43 const char kManagedUserWifiSsid[] = "managed_user_wifi"; |
| 44 |
| 45 const char kManagedDeviceWifiGuid[] = "managed_device_wifi_guid"; |
| 46 const char kManagedDeviceWifiSsid[] = "managed_device_wifi"; |
| 47 |
40 } // namespace | 48 } // namespace |
41 | 49 |
42 class NetworkingPrivateApiTest : public ApiUnitTest { | 50 class NetworkingPrivateApiTest : public ApiUnitTest { |
43 public: | 51 public: |
44 NetworkingPrivateApiTest() {} | 52 NetworkingPrivateApiTest() {} |
45 ~NetworkingPrivateApiTest() override {} | 53 ~NetworkingPrivateApiTest() override {} |
46 | 54 |
47 void SetUp() override { | 55 void SetUp() override { |
48 ApiUnitTest::SetUp(); | 56 ApiUnitTest::SetUp(); |
49 | 57 |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
121 shill::kProfileProperty, | 129 shill::kProfileProperty, |
122 base::Value(kUserProfilePath)); | 130 base::Value(kUserProfilePath)); |
123 profile_test_->AddService(kUserProfilePath, kPrivateWifiServicePath); | 131 profile_test_->AddService(kUserProfilePath, kPrivateWifiServicePath); |
124 } | 132 } |
125 | 133 |
126 void SetUpNetworkPolicy() { | 134 void SetUpNetworkPolicy() { |
127 chromeos::ManagedNetworkConfigurationHandler* config_handler = | 135 chromeos::ManagedNetworkConfigurationHandler* config_handler = |
128 chromeos::NetworkHandler::Get() | 136 chromeos::NetworkHandler::Get() |
129 ->managed_network_configuration_handler(); | 137 ->managed_network_configuration_handler(); |
130 | 138 |
| 139 const std::string user_policy_ssid = kManagedUserWifiSsid; |
| 140 std::unique_ptr<base::ListValue> user_policy_onc = |
| 141 ListBuilder() |
| 142 .Append(DictionaryBuilder() |
| 143 .Set("GUID", kManagedUserWifiGuid) |
| 144 .Set("Type", "WiFi") |
| 145 .Set("WiFi", |
| 146 DictionaryBuilder() |
| 147 .Set("Passphrase", "fake") |
| 148 .Set("SSID", user_policy_ssid) |
| 149 .Set("HexSSID", |
| 150 base::HexEncode(user_policy_ssid.c_str(), |
| 151 user_policy_ssid.size())) |
| 152 .Set("Security", "WPA-PSK") |
| 153 .Build()) |
| 154 .Build()) |
| 155 .Build(); |
| 156 |
131 config_handler->SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUserHash, | 157 config_handler->SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUserHash, |
132 base::ListValue(), base::DictionaryValue()); | 158 *user_policy_onc, base::DictionaryValue()); |
133 | 159 |
| 160 const std::string device_policy_ssid = kManagedDeviceWifiSsid; |
| 161 std::unique_ptr<base::ListValue> device_policy_onc = |
| 162 ListBuilder() |
| 163 .Append(DictionaryBuilder() |
| 164 .Set("GUID", kManagedDeviceWifiGuid) |
| 165 .Set("Type", "WiFi") |
| 166 .Set("WiFi", |
| 167 DictionaryBuilder() |
| 168 .Set("SSID", device_policy_ssid) |
| 169 .Set("HexSSID", base::HexEncode( |
| 170 device_policy_ssid.c_str(), |
| 171 device_policy_ssid.size())) |
| 172 .Set("Security", "None") |
| 173 .Build()) |
| 174 .Build()) |
| 175 .Build(); |
134 config_handler->SetPolicy(::onc::ONC_SOURCE_DEVICE_POLICY, "", | 176 config_handler->SetPolicy(::onc::ONC_SOURCE_DEVICE_POLICY, "", |
135 base::ListValue(), base::DictionaryValue()); | 177 *device_policy_onc, base::DictionaryValue()); |
136 } | 178 } |
137 | 179 |
138 void AddSharedNetworkToUserProfile() { | 180 void AddSharedNetworkToUserProfile() { |
139 service_test_->SetServiceProperty(kSharedWifiServicePath, | 181 service_test_->SetServiceProperty(kSharedWifiServicePath, |
140 shill::kProfileProperty, | 182 shill::kProfileProperty, |
141 base::Value(kUserProfilePath)); | 183 base::Value(kUserProfilePath)); |
142 profile_test_->AddService(kUserProfilePath, kSharedWifiServicePath); | 184 profile_test_->AddService(kUserProfilePath, kSharedWifiServicePath); |
143 | 185 |
144 base::RunLoop().RunUntilIdle(); | 186 base::RunLoop().RunUntilIdle(); |
145 } | 187 } |
(...skipping 19 matching lines...) Expand all Loading... |
165 chromeos::ShillDeviceClient::TestInterface* device_test_; | 207 chromeos::ShillDeviceClient::TestInterface* device_test_; |
166 | 208 |
167 DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateApiTest); | 209 DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateApiTest); |
168 }; | 210 }; |
169 | 211 |
170 TEST_F(NetworkingPrivateApiTest, SetSharedNetworkProperties) { | 212 TEST_F(NetworkingPrivateApiTest, SetSharedNetworkProperties) { |
171 EXPECT_EQ(networking_private::kErrorAccessToSharedConfig, | 213 EXPECT_EQ(networking_private::kErrorAccessToSharedConfig, |
172 RunFunctionAndReturnError( | 214 RunFunctionAndReturnError( |
173 new NetworkingPrivateSetPropertiesFunction(), | 215 new NetworkingPrivateSetPropertiesFunction(), |
174 base::StringPrintf( | 216 base::StringPrintf( |
175 "[\"%s\", {\"WiFi\": {\"Passphrase\": \"passphrase\"}}]", | 217 R"(["%s", {"WiFi": {"Passphrase": "passphrase"}}])", |
176 kSharedWifiGuid))); | 218 kSharedWifiGuid))); |
177 } | 219 } |
178 | 220 |
179 TEST_F(NetworkingPrivateApiTest, SetPrivateNetworkPropertiesWebUI) { | 221 TEST_F(NetworkingPrivateApiTest, SetPrivateNetworkPropertiesWebUI) { |
180 scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties = | 222 scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties = |
181 new NetworkingPrivateSetPropertiesFunction(); | 223 new NetworkingPrivateSetPropertiesFunction(); |
182 set_properties->set_source_context_type(Feature::WEBUI_CONTEXT); | 224 set_properties->set_source_context_type(Feature::WEBUI_CONTEXT); |
183 | 225 |
184 RunFunction( | 226 RunFunction( |
185 set_properties.get(), | 227 set_properties.get(), |
186 base::StringPrintf("[\"%s\", {\"Priority\": 0}]", kSharedWifiGuid)); | 228 base::StringPrintf(R"(["%s", {"Priority": 0}])", kSharedWifiGuid)); |
187 EXPECT_EQ(ExtensionFunction::SUCCEEDED, *set_properties->response_type()); | 229 EXPECT_EQ(ExtensionFunction::SUCCEEDED, *set_properties->response_type()); |
188 | 230 |
189 const chromeos::NetworkState* network = | 231 const chromeos::NetworkState* network = |
190 chromeos::NetworkHandler::Get() | 232 chromeos::NetworkHandler::Get() |
191 ->network_state_handler() | 233 ->network_state_handler() |
192 ->GetNetworkStateFromGuid(kSharedWifiGuid); | 234 ->GetNetworkStateFromGuid(kSharedWifiGuid); |
193 ASSERT_TRUE(network); | 235 ASSERT_TRUE(network); |
194 EXPECT_FALSE(network->IsPrivate()); | 236 EXPECT_FALSE(network->IsPrivate()); |
195 EXPECT_EQ(0, GetNetworkPriority(network)); | 237 EXPECT_EQ(0, GetNetworkPriority(network)); |
196 } | 238 } |
197 | 239 |
198 TEST_F(NetworkingPrivateApiTest, SetPrivateNetworkProperties) { | 240 TEST_F(NetworkingPrivateApiTest, SetPrivateNetworkProperties) { |
199 scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties = | 241 scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties = |
200 new NetworkingPrivateSetPropertiesFunction(); | 242 new NetworkingPrivateSetPropertiesFunction(); |
201 RunFunction( | 243 RunFunction( |
202 set_properties.get(), | 244 set_properties.get(), |
203 base::StringPrintf("[\"%s\", {\"Priority\": 0}]", kPrivateWifiGuid)); | 245 base::StringPrintf(R"(["%s", {"Priority": 0}])", kPrivateWifiGuid)); |
204 EXPECT_EQ(ExtensionFunction::SUCCEEDED, *set_properties->response_type()); | 246 EXPECT_EQ(ExtensionFunction::SUCCEEDED, *set_properties->response_type()); |
205 | 247 |
206 const chromeos::NetworkState* network = | 248 const chromeos::NetworkState* network = |
207 chromeos::NetworkHandler::Get() | 249 chromeos::NetworkHandler::Get() |
208 ->network_state_handler() | 250 ->network_state_handler() |
209 ->GetNetworkStateFromGuid(kPrivateWifiGuid); | 251 ->GetNetworkStateFromGuid(kPrivateWifiGuid); |
210 ASSERT_TRUE(network); | 252 ASSERT_TRUE(network); |
211 EXPECT_TRUE(network->IsPrivate()); | 253 EXPECT_TRUE(network->IsPrivate()); |
212 EXPECT_EQ(0, GetNetworkPriority(network)); | 254 EXPECT_EQ(0, GetNetworkPriority(network)); |
213 } | 255 } |
214 | 256 |
215 TEST_F(NetworkingPrivateApiTest, CreateSharedNetwork) { | 257 TEST_F(NetworkingPrivateApiTest, CreateSharedNetwork) { |
216 EXPECT_EQ( | 258 EXPECT_EQ( |
217 networking_private::kErrorAccessToSharedConfig, | 259 networking_private::kErrorAccessToSharedConfig, |
218 RunFunctionAndReturnError(new NetworkingPrivateCreateNetworkFunction(), | 260 RunFunctionAndReturnError(new NetworkingPrivateCreateNetworkFunction(), |
219 "[true, {" | 261 R"([true, { |
220 " \"Type\": \"WiFi\"," | 262 "Type": "WiFi", |
221 " \"WiFi\": {" | 263 "WiFi": { |
222 " \"SSID\": \"New network\"," | 264 "SSID": "New network", |
223 " \"Security\": \"None\"" | 265 "Security": "None" |
224 "}}]")); | 266 } |
| 267 }])")); |
225 } | 268 } |
226 | 269 |
227 TEST_F(NetworkingPrivateApiTest, CreateSharedNetworkWebUI) { | 270 TEST_F(NetworkingPrivateApiTest, CreateSharedNetworkWebUI) { |
228 scoped_refptr<NetworkingPrivateCreateNetworkFunction> create_network = | 271 scoped_refptr<NetworkingPrivateCreateNetworkFunction> create_network = |
229 new NetworkingPrivateCreateNetworkFunction(); | 272 new NetworkingPrivateCreateNetworkFunction(); |
230 create_network->set_source_context_type(Feature::WEBUI_CONTEXT); | 273 create_network->set_source_context_type(Feature::WEBUI_CONTEXT); |
231 | 274 |
232 std::unique_ptr<base::Value> result = | 275 std::unique_ptr<base::Value> result = |
233 RunFunctionAndReturnValue(create_network.get(), | 276 RunFunctionAndReturnValue(create_network.get(), |
234 "[true, {" | 277 R"([true, { |
235 " \"Priority\": 1," | 278 "Priority": 1, |
236 " \"Type\": \"WiFi\"," | 279 "Type": "WiFi", |
237 " \"WiFi\": {" | 280 "WiFi": { |
238 " \"SSID\": \"New network\"," | 281 "SSID": "New network", |
239 " \"Security\": \"None\"" | 282 "Security": "None" |
240 "}}]"); | 283 } |
| 284 }])"); |
241 | 285 |
242 ASSERT_TRUE(result); | 286 ASSERT_TRUE(result); |
243 ASSERT_TRUE(result->is_string()); | 287 ASSERT_TRUE(result->is_string()); |
244 | 288 |
245 std::string guid = result->GetString(); | 289 std::string guid = result->GetString(); |
246 const chromeos::NetworkState* network = chromeos::NetworkHandler::Get() | 290 const chromeos::NetworkState* network = chromeos::NetworkHandler::Get() |
247 ->network_state_handler() | 291 ->network_state_handler() |
248 ->GetNetworkStateFromGuid(guid); | 292 ->GetNetworkStateFromGuid(guid); |
249 ASSERT_TRUE(network); | 293 ASSERT_TRUE(network); |
250 EXPECT_FALSE(network->IsPrivate()); | 294 EXPECT_FALSE(network->IsPrivate()); |
251 ASSERT_EQ(1, GetNetworkPriority(network)); | 295 ASSERT_EQ(1, GetNetworkPriority(network)); |
252 } | 296 } |
253 | 297 |
254 TEST_F(NetworkingPrivateApiTest, CreatePrivateNetwork) { | 298 TEST_F(NetworkingPrivateApiTest, CreatePrivateNetwork) { |
255 std::unique_ptr<base::Value> result = | 299 std::unique_ptr<base::Value> result = |
256 RunFunctionAndReturnValue(new NetworkingPrivateCreateNetworkFunction(), | 300 RunFunctionAndReturnValue(new NetworkingPrivateCreateNetworkFunction(), |
257 "[false, {" | 301 R"([false, { |
258 " \"Priority\": 1," | 302 "Priority": 1, |
259 " \"Type\": \"WiFi\"," | 303 "Type": "WiFi", |
260 " \"WiFi\": {" | 304 "WiFi": { |
261 " \"SSID\": \"New WiFi\"," | 305 "SSID": "New WiFi", |
262 " \"Security\": \"WPA-PSK\"" | 306 "Security": "WPA-PSK" |
263 "}}]"); | 307 } |
| 308 }])"); |
264 | 309 |
265 ASSERT_TRUE(result); | 310 ASSERT_TRUE(result); |
266 ASSERT_TRUE(result->is_string()); | 311 ASSERT_TRUE(result->is_string()); |
267 | 312 |
268 // Test the created config can be changed now. | 313 // Test the created config can be changed now. |
269 std::string guid = result->GetString(); | 314 std::string guid = result->GetString(); |
270 const chromeos::NetworkState* network = chromeos::NetworkHandler::Get() | 315 const chromeos::NetworkState* network = chromeos::NetworkHandler::Get() |
271 ->network_state_handler() | 316 ->network_state_handler() |
272 ->GetNetworkStateFromGuid(guid); | 317 ->GetNetworkStateFromGuid(guid); |
273 ASSERT_TRUE(network); | 318 ASSERT_TRUE(network); |
274 EXPECT_TRUE(network->IsPrivate()); | 319 EXPECT_TRUE(network->IsPrivate()); |
275 EXPECT_EQ(1, GetNetworkPriority(network)); | 320 EXPECT_EQ(1, GetNetworkPriority(network)); |
276 | 321 |
277 scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties = | 322 scoped_refptr<NetworkingPrivateSetPropertiesFunction> set_properties = |
278 new NetworkingPrivateSetPropertiesFunction(); | 323 new NetworkingPrivateSetPropertiesFunction(); |
279 | 324 |
280 RunFunction(set_properties.get(), | 325 RunFunction(set_properties.get(), |
281 base::StringPrintf("[\"%s\", {\"Priority\": 2}]", guid.c_str())); | 326 base::StringPrintf(R"(["%s", {"Priority": 2}])", guid.c_str())); |
282 EXPECT_EQ(ExtensionFunction::SUCCEEDED, *set_properties->response_type()); | 327 EXPECT_EQ(ExtensionFunction::SUCCEEDED, *set_properties->response_type()); |
283 | 328 |
284 EXPECT_EQ(2, GetNetworkPriority(network)); | 329 EXPECT_EQ(2, GetNetworkPriority(network)); |
285 } | 330 } |
286 | 331 |
| 332 TEST_F(NetworkingPrivateApiTest, CreatePrivateNetwork_NonMatchingSsids) { |
| 333 const std::string network_ssid = "new_wifi_config"; |
| 334 const std::string network_hex_ssid = |
| 335 base::HexEncode(network_ssid.c_str(), network_ssid.size()); |
| 336 std::unique_ptr<base::Value> result = |
| 337 RunFunctionAndReturnValue(new NetworkingPrivateCreateNetworkFunction(), |
| 338 base::StringPrintf(R"([false, { |
| 339 "Priority": 1, |
| 340 "Type": "WiFi", |
| 341 "WiFi": { |
| 342 "SSID": "New WiFi", |
| 343 "HexSSID": "%s", |
| 344 "Security": "WPA-PSK" |
| 345 } |
| 346 }])", |
| 347 network_hex_ssid.c_str())); |
| 348 |
| 349 ASSERT_TRUE(result); |
| 350 ASSERT_TRUE(result->is_string()); |
| 351 |
| 352 // Test the created config can be changed now. |
| 353 const std::string guid = result->GetString(); |
| 354 const chromeos::NetworkState* network = chromeos::NetworkHandler::Get() |
| 355 ->network_state_handler() |
| 356 ->GetNetworkStateFromGuid(guid); |
| 357 ASSERT_TRUE(network); |
| 358 EXPECT_TRUE(network->IsPrivate()); |
| 359 EXPECT_EQ(1, GetNetworkPriority(network)); |
| 360 EXPECT_EQ(network_hex_ssid, network->GetHexSsid()); |
| 361 EXPECT_EQ(network_ssid, network->name()); |
| 362 } |
| 363 |
| 364 TEST_F(NetworkingPrivateApiTest, |
| 365 CreateAlreadyConfiguredUserPrivateNetwork_BySsid) { |
| 366 EXPECT_EQ( |
| 367 "NetworkAlreadyConfigured", |
| 368 RunFunctionAndReturnError(new NetworkingPrivateCreateNetworkFunction(), |
| 369 base::StringPrintf(R"([false, { |
| 370 "Priority": 1, |
| 371 "Type": "WiFi", |
| 372 "WiFi": { |
| 373 "SSID": "%s", |
| 374 "Security": "WPA-PSK" |
| 375 } |
| 376 }])", |
| 377 kManagedUserWifiSsid))); |
| 378 } |
| 379 |
| 380 TEST_F(NetworkingPrivateApiTest, |
| 381 CreateAlreadyConfiguredUserPrivateNetwork_ByHexSsid) { |
| 382 std::string network_hex_ssid = |
| 383 base::HexEncode(kManagedUserWifiSsid, sizeof(kManagedUserWifiSsid) - 1); |
| 384 EXPECT_EQ( |
| 385 "NetworkAlreadyConfigured", |
| 386 RunFunctionAndReturnError(new NetworkingPrivateCreateNetworkFunction(), |
| 387 base::StringPrintf(R"([false, { |
| 388 "Priority": 1, |
| 389 "Type": "WiFi", |
| 390 "WiFi": { |
| 391 "HexSSID": "%s", |
| 392 "Security": "WPA-PSK" |
| 393 } |
| 394 }])", |
| 395 network_hex_ssid.c_str()))); |
| 396 } |
| 397 |
| 398 TEST_F(NetworkingPrivateApiTest, |
| 399 CreateAlreadyConfiguredUserPrivateNetwork_NonMatchingSsids) { |
| 400 std::string network_hex_ssid = |
| 401 base::HexEncode(kManagedUserWifiSsid, sizeof(kManagedUserWifiSsid) - 1); |
| 402 // HexSSID should take presedence over SSID. |
| 403 EXPECT_EQ( |
| 404 "NetworkAlreadyConfigured", |
| 405 RunFunctionAndReturnError(new NetworkingPrivateCreateNetworkFunction(), |
| 406 base::StringPrintf(R"([false, { |
| 407 "Priority": 1, |
| 408 "Type": "WiFi", |
| 409 "WiFi": { |
| 410 "SSID": "wrong_ssid", |
| 411 "HexSSID": "%s", |
| 412 "Security": "WPA-PSK" |
| 413 } |
| 414 }])", |
| 415 network_hex_ssid.c_str()))); |
| 416 } |
| 417 |
| 418 TEST_F(NetworkingPrivateApiTest, |
| 419 CreateAlreadyConfiguredUserPrivateNetwork_ByHexSSID) { |
| 420 std::string network_hex_ssid = |
| 421 base::HexEncode(kManagedUserWifiSsid, sizeof(kManagedUserWifiSsid) - 1); |
| 422 EXPECT_EQ( |
| 423 "NetworkAlreadyConfigured", |
| 424 RunFunctionAndReturnError(new NetworkingPrivateCreateNetworkFunction(), |
| 425 base::StringPrintf(R"([false, { |
| 426 "Priority": 1, |
| 427 "Type": "WiFi", |
| 428 "WiFi": { |
| 429 "HexSSID": "%s", |
| 430 "Security": "WPA-PSK" |
| 431 } |
| 432 }])", |
| 433 network_hex_ssid.c_str()))); |
| 434 } |
| 435 |
| 436 TEST_F(NetworkingPrivateApiTest, CreateAlreadyConfiguredDeviceNetwork) { |
| 437 EXPECT_EQ( |
| 438 "NetworkAlreadyConfigured", |
| 439 RunFunctionAndReturnError(new NetworkingPrivateCreateNetworkFunction(), |
| 440 base::StringPrintf(R"([false, { |
| 441 "Priority": 1, |
| 442 "Type": "WiFi", |
| 443 "WiFi": { |
| 444 "SSID": "%s" |
| 445 } |
| 446 }])", |
| 447 kManagedDeviceWifiSsid))); |
| 448 } |
| 449 |
| 450 TEST_F(NetworkingPrivateApiTest, |
| 451 CreateAlreadyConfiguredDeviceNetwork_ByHexSSID) { |
| 452 std::string network_hex_ssid = base::HexEncode( |
| 453 kManagedDeviceWifiSsid, sizeof(kManagedDeviceWifiSsid) - 1); |
| 454 EXPECT_EQ( |
| 455 "NetworkAlreadyConfigured", |
| 456 RunFunctionAndReturnError(new NetworkingPrivateCreateNetworkFunction(), |
| 457 base::StringPrintf(R"([false, { |
| 458 "Priority": 1, |
| 459 "Type": "WiFi", |
| 460 "WiFi": { |
| 461 "HexSSID": "%s", |
| 462 "Security": "WPA-PSK" |
| 463 } |
| 464 }])", |
| 465 network_hex_ssid.c_str()))); |
| 466 } |
| 467 |
287 } // namespace extensions | 468 } // namespace extensions |
OLD | NEW |