Skip to content

Commit

Permalink
[CrOS Cellular] Create helper class to test APN Revamp API
Browse files Browse the repository at this point in the history
APN data can be represented as Mojo interfaces, and as ONC dictionaries.
To tests the new APN Revamp API in CrosNetworkConfig, this change
introduces a helper class that creates and verifies APN data in these formats.

Bug: b:162365553
Change-Id: I64562364627eeffdf9432e138d8046f96ac21cf5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3999448
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Commit-Queue: Emmanuel Arias Soto <eariassoto@google.com>
Reviewed-by: Chad Duffin <chadduffin@chromium.org>
Reviewed-by: Gordon Seto <gordonseto@google.com>
Cr-Commit-Position: refs/heads/main@{#1067454}
  • Loading branch information
Emmanuel Arias Soto authored and Chromium LUCI CQ committed Nov 4, 2022
1 parent 52c3c5a commit b0b9e61
Show file tree
Hide file tree
Showing 4 changed files with 280 additions and 66 deletions.
16 changes: 16 additions & 0 deletions chromeos/services/network_config/BUILD.gn
Original file line number Diff line number Diff line change
Expand Up @@ -53,13 +53,29 @@ component("in_process_instance") {
]
}

source_set("test_support") {
testonly = true
deps = [
"//ash/constants:constants",
"//chromeos/ash/components/network",
"//chromeos/components/onc",
"//chromeos/services/network_config/public/mojom",
"//components/onc",
]
sources = [
"test_apn_data.cc",
"test_apn_data.h",
]
}

source_set("unit_tests") {
testonly = true

sources = [ "cros_network_config_unittest.cc" ]

deps = [
":network_config",
":test_support",
"//ash/constants:constants",
"//base",
"//base/test:test_support",
Expand Down
112 changes: 46 additions & 66 deletions chromeos/services/network_config/cros_network_config_unittest.cc
Original file line number Diff line number Diff line change
Expand Up @@ -40,6 +40,7 @@
#include "chromeos/login/login_state/login_state.h"
#include "chromeos/services/network_config/public/cpp/cros_network_config_test_observer.h"
#include "chromeos/services/network_config/public/mojom/cros_network_config.mojom-shared.h"
#include "chromeos/services/network_config/test_apn_data.h"
#include "components/captive_portal/core/captive_portal_detector.h"
#include "components/onc/onc_constants.h"
#include "components/onc/onc_pref_names.h"
Expand Down Expand Up @@ -70,11 +71,6 @@ constexpr char kCellularTestApnAuthenticationType1[] = "";
constexpr char kCellularTestApnIpType1[] = "";
constexpr char kCellularTestApnTypes1[] = "Default";

// TODO(b/162365553) Remove when shill constants are added.
constexpr char kShillApnId[] = "id";
constexpr char kShillApnAuthenticationType[] = "authentication_type";
constexpr char kShillApnTypes[] = "apn_types";

constexpr char kCellularTestApn2[] = "TEST.APN2";
constexpr char kCellularTestApnName2[] = "Test Apn 2";
constexpr char kCellularTestApnUsername2[] = "Test User";
Expand Down Expand Up @@ -148,17 +144,17 @@ void CompareTrafficCounters(
}

std::string CreateApnShillDict() {
return base::StringPrintf(
R"({"%s": "%s", "%s": "%s", "%s": "%s", "%s": "%s", "%s": "%s",
"%s": "%s", "%s": "%s", "%s": "%s", "%s": ["%s"]})",
shill::kApnProperty, kCellularTestApn1, shill::kApnNameProperty,
kCellularTestApnName1, shill::kApnUsernameProperty,
kCellularTestApnUsername1, shill::kApnPasswordProperty,
kCellularTestApnPassword1, shill::kApnAttachProperty,
kCellularTestApnAttach1, kShillApnId, kCellularTestApnId1,
kShillApnAuthenticationType, kCellularTestApnAuthenticationType1,
shill::kApnIpTypeProperty, kCellularTestApnIpType1, kShillApnTypes,
kCellularTestApnTypes1);
TestApnData test_apn_data;
test_apn_data.access_point_name = kCellularTestApn1;
test_apn_data.name = kCellularTestApnName1;
test_apn_data.username = kCellularTestApnUsername1;
test_apn_data.password = kCellularTestApnPassword1;
test_apn_data.attach = kCellularTestApnAttach1;
test_apn_data.id = kCellularTestApnId1;
test_apn_data.onc_authentication_type = kCellularTestApnAuthenticationType1;
test_apn_data.onc_ip_type = kCellularTestApnIpType1;
test_apn_data.onc_apn_types.emplace_back(kCellularTestApnTypes1);
return test_apn_data.AsApnShillDict();
}

} // namespace
Expand Down Expand Up @@ -359,27 +355,25 @@ class CrosNetworkConfigTest : public testing::Test {
}

void SetupAPNList() {
base::Value apn_list(base::Value::Type::LIST);
base::Value apn_entry1(base::Value::Type::DICTIONARY);
apn_entry1.SetStringKey(shill::kApnNameProperty, kCellularTestApnName1);
apn_entry1.SetStringKey(shill::kApnProperty, kCellularTestApn1);
apn_entry1.SetStringKey(shill::kApnUsernameProperty,
kCellularTestApnUsername1);
apn_entry1.SetStringKey(shill::kApnPasswordProperty,
kCellularTestApnPassword1);
apn_list.Append(std::move(apn_entry1));
base::Value apn_entry2(base::Value::Type::DICTIONARY);
apn_entry2.SetStringKey(shill::kApnNameProperty, kCellularTestApnName2);
apn_entry2.SetStringKey(shill::kApnProperty, kCellularTestApn2);
apn_entry2.SetStringKey(shill::kApnUsernameProperty,
kCellularTestApnUsername2);
apn_entry2.SetStringKey(shill::kApnPasswordProperty,
kCellularTestApnPassword2);
apn_entry2.SetStringKey(shill::kApnAttachProperty, kCellularTestApnAttach2);
apn_list.Append(std::move(apn_entry2));
base::Value::List apn_entries;
TestApnData apn_entry1;
apn_entry1.access_point_name = kCellularTestApn1;
apn_entry1.name = kCellularTestApnName1;
apn_entry1.username = kCellularTestApnUsername1;
apn_entry1.password = kCellularTestApnPassword1;
apn_entries.Append(apn_entry1.AsShillApn());

TestApnData apn_entry2;
apn_entry2.access_point_name = kCellularTestApn2;
apn_entry2.name = kCellularTestApnName2;
apn_entry2.username = kCellularTestApnUsername2;
apn_entry2.password = kCellularTestApnPassword2;
apn_entry2.attach = kCellularTestApnAttach2;
apn_entries.Append(apn_entry2.AsShillApn());

helper()->device_test()->SetDeviceProperty(
kCellularDevicePath, shill::kCellularApnListProperty, apn_list,
kCellularDevicePath, shill::kCellularApnListProperty,
base::Value(std::move(apn_entries)),
/*notify_changed=*/true);
base::RunLoop().RunUntilIdle();
}
Expand Down Expand Up @@ -1507,13 +1501,13 @@ TEST_F(CrosNetworkConfigTest, CustomAPN) {
// does not update the custom apn list.
auto config = mojom::ConfigProperties::New();
auto cellular_config = mojom::CellularConfigProperties::New();
auto new_apn = mojom::ApnProperties::New();
new_apn->access_point_name = kCellularTestApn1;
new_apn->name = kCellularTestApnName1;
new_apn->username = kCellularTestApnUsername1;
new_apn->password = kCellularTestApnPassword1;
new_apn->attach = kCellularTestApnAttach1;
cellular_config->apn = std::move(new_apn);
TestApnData test_apn_data1;
test_apn_data1.access_point_name = kCellularTestApn1;
test_apn_data1.name = kCellularTestApnName1;
test_apn_data1.username = kCellularTestApnUsername1;
test_apn_data1.password = kCellularTestApnPassword1;
test_apn_data1.attach = kCellularTestApnAttach1;
cellular_config->apn = test_apn_data1.AsMojoApn();
config->type_config = mojom::NetworkTypeConfigProperties::NewCellular(
std::move(cellular_config));
SetProperties(kGUID, std::move(config));
Expand All @@ -1524,13 +1518,13 @@ TEST_F(CrosNetworkConfigTest, CustomAPN) {
// Verify that custom APN list is updated properly.
config = mojom::ConfigProperties::New();
cellular_config = mojom::CellularConfigProperties::New();
new_apn = mojom::ApnProperties::New();
new_apn->access_point_name = kCellularTestApn3;
new_apn->name = kCellularTestApnName3;
new_apn->username = kCellularTestApnUsername3;
new_apn->password = kCellularTestApnPassword3;
new_apn->attach = kCellularTestApnAttach3;
cellular_config->apn = std::move(new_apn);
TestApnData test_apn_data3;
test_apn_data3.access_point_name = kCellularTestApn3;
test_apn_data3.name = kCellularTestApnName3;
test_apn_data3.username = kCellularTestApnUsername3;
test_apn_data3.password = kCellularTestApnPassword3;
test_apn_data3.attach = kCellularTestApnAttach3;
cellular_config->apn = test_apn_data3.AsMojoApn();
config->type_config = mojom::NetworkTypeConfigProperties::NewCellular(
std::move(cellular_config));
SetProperties(kGUID, std::move(config));
Expand All @@ -1548,23 +1542,9 @@ TEST_F(CrosNetworkConfigTest, CustomAPN) {
properties->type_properties->get_cellular()->custom_apn_list.has_value());
ASSERT_EQ(
1u, properties->type_properties->get_cellular()->custom_apn_list->size());
ASSERT_EQ(kCellularTestApn3, properties->type_properties->get_cellular()
->custom_apn_list->front()
->access_point_name);
ASSERT_EQ(kCellularTestApnName3, properties->type_properties->get_cellular()
->custom_apn_list->front()
->name);
ASSERT_EQ(kCellularTestApnUsername3,
properties->type_properties->get_cellular()
->custom_apn_list->front()
->username);
ASSERT_EQ(kCellularTestApnPassword3,
properties->type_properties->get_cellular()
->custom_apn_list->front()
->password);
ASSERT_EQ(kCellularTestApnAttach3, properties->type_properties->get_cellular()
->custom_apn_list->front()
->attach);
const mojom::ApnPropertiesPtr& first_apn =
properties->type_properties->get_cellular()->custom_apn_list->front();
EXPECT_TRUE(test_apn_data3.IsMojoApnEquals(*first_apn));
}

TEST_F(CrosNetworkConfigTest, ConnectedAPN_ApnRevampEnabled) {
Expand Down
145 changes: 145 additions & 0 deletions chromeos/services/network_config/test_apn_data.cc
Original file line number Diff line number Diff line change
@@ -0,0 +1,145 @@
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chromeos/services/network_config/test_apn_data.h"

#include "ash/constants/ash_features.h"
#include "chromeos/ash/components/network/policy_util.h"
#include "components/onc/onc_constants.h"
#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"

namespace chromeos::network_config {
namespace {
// TODO(b/162365553) Remove when shill constants are added.
constexpr char kShillApnId[] = "id";
constexpr char kShillApnAuthenticationType[] = "authentication_type";
constexpr char kShillApnTypes[] = "apn_types";
} // namespace

TestApnData::TestApnData()
: mojo_state(mojom::ApnState::kEnabled),
onc_state(::onc::cellular_apn::kStateEnabled),
mojo_authentication_type(mojom::ApnAuthenticationType::kAutomatic),
onc_authentication_type(
::onc::cellular_apn::kAuthenticationTypeAutomatic),
mojo_ip_type(mojom::ApnIpType::kAutomatic),
onc_ip_type(::onc::cellular_apn::kIpTypeAutomatic) {}

TestApnData::TestApnData(std::string access_point_name,
std::string name,
std::string username,
std::string password,
std::string attach,
std::string id,
mojom::ApnState mojo_state,
std::string onc_state,
mojom::ApnAuthenticationType mojo_authentication_type,
std::string onc_authentication_type,
mojom::ApnIpType mojo_ip_type,
std::string onc_ip_type,
const std::vector<mojom::ApnType>& mojo_apn_types,
const std::vector<std::string>& onc_apn_types)
: access_point_name(access_point_name),
name(name),
username(username),
password(password),
attach(attach),
id(id),
mojo_state(mojo_state),
onc_state(onc_state),
mojo_authentication_type(mojo_authentication_type),
onc_authentication_type(onc_authentication_type),
mojo_ip_type(mojo_ip_type),
onc_ip_type(onc_ip_type),
mojo_apn_types(mojo_apn_types),
onc_apn_types(onc_apn_types) {}

TestApnData::~TestApnData() = default;

mojom::ApnPropertiesPtr TestApnData::AsMojoApn() const {
auto apn = mojom::ApnProperties::New();
apn->access_point_name = access_point_name;
apn->name = name;
apn->username = username;
apn->password = password;
apn->attach = attach;
if (ash::features::IsApnRevampEnabled()) {
apn->id = id;
apn->authentication_type = mojo_authentication_type;
apn->ip_type = mojo_ip_type;
apn->apn_types = mojo_apn_types;
}
return apn;
}

base::Value::Dict TestApnData::AsOncApn() const {
base::Value::Dict apn;
apn.Set(::onc::cellular_apn::kAccessPointName, access_point_name);
apn.Set(::onc::cellular_apn::kName, name);
apn.Set(::onc::cellular_apn::kUsername, username);
apn.Set(::onc::cellular_apn::kPassword, password);
apn.Set(::onc::cellular_apn::kAttach, attach);
if (ash::features::IsApnRevampEnabled()) {
apn.Set(::onc::cellular_apn::kId, id);
apn.Set(::onc::cellular_apn::kState, onc_state);
apn.Set(::onc::cellular_apn::kAuthenticationType, onc_authentication_type);
apn.Set(::onc::cellular_apn::kIpType, onc_ip_type);

base::Value::List apn_types;
for (const std::string& apn_type : onc_apn_types)
apn_types.Append(apn_type);
apn.Set(::onc::cellular_apn::kApnTypes, std::move(apn_types));
}
return apn;
}

base::Value::Dict TestApnData::AsShillApn() const {
base::Value::Dict apn;
apn.Set(shill::kApnProperty, access_point_name);
apn.Set(shill::kApnNameProperty, name);
apn.Set(shill::kApnUsernameProperty, username);
apn.Set(shill::kApnPasswordProperty, password);
apn.Set(shill::kApnAttachProperty, attach);
if (ash::features::IsApnRevampEnabled()) {
apn.Set(kShillApnId, id);
apn.Set(kShillApnAuthenticationType, onc_authentication_type);
apn.Set(shill::kApnIpTypeProperty, onc_ip_type);

base::Value::List apn_types;
for (const std::string& apn_type : onc_apn_types)
apn_types.Append(apn_type);
apn.Set(kShillApnTypes, std::move(apn_types));
}
return apn;
}

std::string TestApnData::AsApnShillDict() const {
// This will serialize the dictionary into valid JSON
return AsShillApn().DebugString();
}

bool TestApnData::IsMojoApnEquals(const mojom::ApnProperties& apn) const {
bool ret = access_point_name == apn.access_point_name;

static auto MatchOptionalString =
[](const std::string& expected,
const absl::optional<std::string>& actual) -> bool {
if (actual.has_value())
return expected == *actual;
return expected.empty();
};
ret &= MatchOptionalString(name, apn.name);
ret &= MatchOptionalString(username, apn.username);
ret &= MatchOptionalString(password, apn.password);
ret &= MatchOptionalString(attach, apn.attach);

if (ash::features::IsApnRevampEnabled()) {
ret &= mojo_authentication_type == apn.authentication_type;
ret &= mojo_ip_type == apn.ip_type;
ret &= mojo_apn_types == apn.apn_types;
}
return ret;
}

} // namespace chromeos::network_config

0 comments on commit b0b9e61

Please sign in to comment.