def get_obj_param_values_to_set(
desired_cfg: EnodebConfiguration,
device_cfg: EnodebConfiguration,
data_model: DataModel,
) -> Dict[ParameterName, Dict[ParameterName, Any]]:
""" Returns a map from object name to (a map of param name to value) """
param_values = {}
objs = desired_cfg.get_object_names()
for obj_name in objs:
param_values[obj_name] = {}
params = desired_cfg.get_parameter_names_for_object(obj_name)
for name in params:
new = desired_cfg.get_parameter_for_object(name, obj_name)
old = device_cfg.get_parameter_for_object(name, obj_name)
_type = data_model.get_parameter(name).type
if not are_tr069_params_equal(new, old, _type):
param_values[obj_name][name] = new
return param_values
class EnodebConfigurationFactoryTest(TestCase):
def setUp(self):
self.data_model = BaicellsTrDataModel()
self.cfg = EnodebConfiguration(BaicellsTrDataModel())
self.device_cfg = EnodebConfiguration(BaicellsTrDataModel())
def tearDown(self):
self.data_model = None
self.cfg = None
self.device_cfg = None
def test_set_pci(self):
pci = 3
_set_pci(self.cfg, pci)
self.assertEqual(self.cfg.get_parameter(ParameterName.PCI), pci,
'PCI value should be same as what was set')
with self.assertRaises(ConfigurationError):
_set_pci(self.cfg, 505)
def test_set_bandwidth(self):
mhz = 15
_set_bandwidth(self.cfg, self.data_model, mhz)
self.assertEqual(self.cfg.get_parameter(ParameterName.DL_BANDWIDTH),
mhz,
'Should have set %s' % ParameterName.DL_BANDWIDTH)
self.assertEqual(self.cfg.get_parameter(ParameterName.UL_BANDWIDTH),
mhz,
'Should have set %s' % ParameterName.UL_BANDWIDTH)
def test_set_tdd_subframe_config(self):
# Not TDD mode, should not try to set anything
self.device_cfg.set_parameter(ParameterName.DUPLEX_MODE_CAPABILITY,
'Not TDDMode')
subframe = 0
special_subframe = 0
_set_tdd_subframe_config(self.device_cfg, self.cfg, subframe,
special_subframe)
self.assertTrue(ParameterName.SUBFRAME_ASSIGNMENT not in
self.cfg.get_parameter_names())
# Invalid subframe assignment
self.device_cfg.set_parameter(ParameterName.DUPLEX_MODE_CAPABILITY,
'TDDMode')
_set_tdd_subframe_config(self.device_cfg, self.cfg, subframe,
special_subframe)
self.assertIn(ParameterName.SUBFRAME_ASSIGNMENT,
self.cfg.get_parameter_names(),
'Expected a subframe assignment')
def test_set_management_server(self):
_set_management_server(self.cfg)
self.assertEqual(
self.cfg.get_parameter(ParameterName.PERIODIC_INFORM_ENABLE), True,
'Expected periodic inform enable to be true')
self.assertTrue(
isinstance(
self.cfg.get_parameter(ParameterName.PERIODIC_INFORM_INTERVAL),
int), 'Expected periodic inform interval to ani integer')
def test_set_s1_connection(self):
invalid_mme_ip = 1234
invalid_mme_port = '8080'
mme_ip = '192.168.0.1'
mme_port = 8080
# MME IP should be a string
with self.assertRaises(ConfigurationError):
_set_s1_connection(self.cfg, invalid_mme_ip, mme_port)
# MME Port should be an integer
with self.assertRaises(ConfigurationError):
_set_s1_connection(self.cfg, mme_ip, invalid_mme_port)
# Check the ip and port are sort properly
_set_s1_connection(self.cfg, mme_ip, mme_port)
self.assertEqual(self.cfg.get_parameter(ParameterName.MME_IP), mme_ip,
'Expected mme ip to be set')
self.assertEqual(self.cfg.get_parameter(ParameterName.MME_PORT),
mme_port, 'Expected mme port to be set')
def test_set_perf_mgmt(self):
mgmt_ip = '192.168.0.1'
mgmt_upload_interval = 300
mgmt_port = 8080
_set_perf_mgmt(self.cfg, mgmt_ip, mgmt_port)
self.assertTrue(self.cfg.get_parameter(ParameterName.PERF_MGMT_ENABLE),
'Expected perf mgmt to be enabled')
self.assertEqual(
self.cfg.get_parameter(ParameterName.PERF_MGMT_UPLOAD_INTERVAL),
mgmt_upload_interval, 'Expected upload interval to be set')
expected_url = 'http://192.168.0.1:8080/'
self.assertEqual(
self.cfg.get_parameter(ParameterName.PERF_MGMT_UPLOAD_URL),
expected_url, 'Incorrect Url')
def test_set_misc_static_params(self):
# IPSec enable as integer
self.device_cfg.set_parameter(ParameterName.IP_SEC_ENABLE, 0)
self.data_model.set_parameter_presence(ParameterName.GPS_ENABLE, True)
_set_misc_static_params(self.device_cfg, self.cfg, self.data_model)
self.assertTrue(
isinstance(self.cfg.get_parameter(ParameterName.IP_SEC_ENABLE),
int),
'Should support an integer IP_SEC_ENABLE parameter')
# IPSec enable as boolean
self.device_cfg.set_parameter(ParameterName.IP_SEC_ENABLE, 'False')
_set_misc_static_params(self.device_cfg, self.cfg, self.data_model)
self.assertTrue(
isinstance(self.cfg.get_parameter(ParameterName.IP_SEC_ENABLE),
bool),
'Should support a boolean IP_SEC_ENABLE parameter')
self.assertEqual(
self.cfg.get_parameter(ParameterName.LOCAL_GATEWAY_ENABLE), 0,
'Should be disabled')
self.assertEqual(self.cfg.get_parameter(ParameterName.CELL_RESERVED),
False, 'Should be disabled')
self.assertEqual(self.cfg.get_parameter(ParameterName.MME_POOL_ENABLE),
False, 'Should be disabled')
def test_set_plmnids_tac(self):
# We only handle a single PLMNID for now
plmnids = '1, 2, 3, 4'
tac = 1
with self.assertRaises(ConfigurationError):
_set_plmnids_tac(self.cfg, plmnids, tac)
# Max PLMNID length is 6 characters
plmnids = '1234567'
with self.assertRaises(ConfigurationError):
_set_plmnids_tac(self.cfg, plmnids, tac)
# Check that only one PLMN element is enabled
plmnids = '1'
_set_plmnids_tac(self.cfg, plmnids, tac)
self.assertTrue(
self.cfg.get_parameter_for_object(ParameterName.PLMN_N_ENABLE % 1,
ParameterName.PLMN_N % 1),
'First PLMN should be enabled')
self.assertFalse(self.cfg.has_object(ParameterName.PLMN_N % 2),
'Second PLMN should be disabled')
def test_set_earafcn_freq_band_mode(self):
# Invalid earfcndl
with self.assertRaises(ConfigurationError):
invalid_earfcndl = -1
_set_earfcn_freq_band_mode(self.device_cfg, self.cfg,
self.data_model, invalid_earfcndl)
# Duplex_mode is TDD but capability is FDD
with self.assertRaises(ConfigurationError):
self.device_cfg.set_parameter(ParameterName.DUPLEX_MODE_CAPABILITY,
'FDDMode')
earfcndl = 38650 # Corresponds to TDD
_set_earfcn_freq_band_mode(self.device_cfg, self.cfg,
self.data_model, earfcndl)
# Duplex_mode is FDD but capability is TDD
with self.assertRaises(ConfigurationError):
self.device_cfg.set_parameter(ParameterName.DUPLEX_MODE_CAPABILITY,
'TDDMode')
earfcndl = 0 # Corresponds to FDD
_set_earfcn_freq_band_mode(self.device_cfg, self.cfg,
self.data_model, earfcndl)
def test_get_enb_config(self):
mconfig = EnodebConfigBuilder.get_mconfig()
enb_config = _get_enb_config(mconfig, self.device_cfg)
self.assertTrue(enb_config.earfcndl == 39150,
"Should give earfcndl from default eNB config")
mconfig = EnodebConfigBuilder.get_multi_enb_mconfig()
self.device_cfg.set_parameter(ParameterName.SERIAL_NUMBER,
'120200002618AGP0003')
enb_config = _get_enb_config(mconfig, self.device_cfg)
self.assertTrue(enb_config.earfcndl == 39151,
"Should give earfcndl from specific eNB config")
class EnodebConfigurationTest(TestCase):
def setUp(self):
self.config = EnodebConfiguration(CaviumTrDataModel)
def tearDown(self):
self.config = None
def test_data_model(self) -> None:
data_model = self.config.data_model
expected = CaviumTrDataModel
self.assertEqual(data_model, expected, 'Data model fetch incorrect')
def test_get_has_set_parameter(self) -> None:
param = ParameterName.ADMIN_STATE
self.config.set_parameter(param, True)
self.assertTrue(self.config.has_parameter(param),
'Expected to have parameter')
param_value = self.config.get_parameter(param)
expected = True
self.assertEqual(param_value, expected,
'Parameter value does not match what was set')
def test_add_has_delete_object(self) -> None:
object_name = ParameterName.PLMN_N % 1
self.assertFalse(self.config.has_object(object_name))
self.config.add_object(object_name)
self.assertTrue(self.config.has_object(object_name))
self.config.delete_object(object_name)
self.assertFalse(self.config.has_object(object_name))
def test_get_parameter_names(self) -> None:
# Should start off as an empty list
names_list = self.config.get_parameter_names()
self.assertEqual(len(names_list), 0, 'Expected 0 names')
# Should grow as we set parameters
self.config.set_parameter(ParameterName.ADMIN_STATE, True)
names_list = self.config.get_parameter_names()
self.assertEqual(len(names_list), 1, 'Expected 1 name')
# Parameter names should not include objects
self.config.add_object(ParameterName.PLMN)
names_list = self.config.get_parameter_names()
self.assertEqual(len(names_list), 1, 'Expected 1 name')
def test_get_object_names(self) -> None:
# Should start off as an empty list
obj_list = self.config.get_object_names()
self.assertEqual(len(obj_list), 0, 'Expected 0 names')
# Should grow as we set parameters
self.config.add_object(ParameterName.PLMN)
obj_list = self.config.get_object_names()
self.assertEqual(len(obj_list), 1, 'Expected 1 names')
def test_get_set_parameter_for_object(self) -> None:
self.config.add_object(ParameterName.PLMN_N % 1)
self.config.set_parameter_for_object(
ParameterName.PLMN_N_CELL_RESERVED % 1, True,
ParameterName.PLMN_N % 1)
param_value = self.config.get_parameter_for_object(
ParameterName.PLMN_N_CELL_RESERVED % 1, ParameterName.PLMN_N % 1)
self.assertTrue(
param_value,
'Expected that the param for object was set correctly')
def test_get_parameter_names_for_object(self) -> None:
# Should start off empty
self.config.add_object(ParameterName.PLMN_N % 1)
param_list = self.config.get_parameter_names_for_object(
ParameterName.PLMN_N % 1)
self.assertEqual(len(param_list), 0, 'Should be an empty param list')
# Should increment as we set parameters
self.config.set_parameter_for_object(
ParameterName.PLMN_N_CELL_RESERVED % 1, True,
ParameterName.PLMN_N % 1)
param_list = self.config.get_parameter_names_for_object(
ParameterName.PLMN_N % 1)
self.assertEqual(len(param_list), 1, 'Should not be an empty list')
class EnodebConfigurationFactoryTest(TestCase):
def setUp(self):
self.cfg = EnodebConfiguration(BaicellsTrDataModel)
self.device_cfg = EnodebConfiguration(BaicellsTrDataModel)
def tearDown(self):
self.cfg = None
self.device_cfg = None
def _get_mconfig(self):
return {
"@type": "type.googleapis.com/magma.mconfig.EnodebD",
"bandwidthMhz": 20,
"specialSubframePattern": 7,
"earfcndl": 44490,
"logLevel": "INFO",
"plmnidList": "00101",
"pci": 260,
"allowEnodebTransmit": False,
"subframeAssignment": 2,
"tac": 1
},
def _get_service_config(self):
return {
"tr069": {
"interface": "eth1",
"port": 48080,
"perf_mgmt_port": 8081,
"public_ip": "192.88.99.142",
},
"reboot_enodeb_on_mme_disconnected": True,
"s1_interface": "eth1",
}
def test_set_pci(self):
pci = 3
_set_pci(self.cfg, pci)
self.assertEqual(self.cfg.get_parameter(ParameterName.PCI), pci,
'PCI value should be same as what was set')
with self.assertRaises(ConfigurationError):
_set_pci(self.cfg, 505)
def test_set_bandwidth(self):
mhz = 15
_set_bandwidth(self.cfg, mhz)
self.assertEqual(self.cfg.get_parameter(ParameterName.DL_BANDWIDTH),
mhz,
'Should have set %s' % ParameterName.DL_BANDWIDTH)
self.assertEqual(self.cfg.get_parameter(ParameterName.UL_BANDWIDTH),
mhz,
'Should have set %s' % ParameterName.UL_BANDWIDTH)
def test_set_tdd_subframe_config(self):
# Not TDD mode, should not try to set anything
self.device_cfg.set_parameter(
ParameterName.DUPLEX_MODE_CAPABILITY, 'Not TDDMode')
subframe = 0
special_subframe = 0
_set_tdd_subframe_config(self.device_cfg, self.cfg, subframe,
special_subframe)
self.assertTrue(ParameterName.SUBFRAME_ASSIGNMENT not in
self.cfg.get_parameter_names())
# Invalid subframe assignment
self.device_cfg.set_parameter(
ParameterName.DUPLEX_MODE_CAPABILITY, 'TDDMode')
_set_tdd_subframe_config(self.device_cfg, self.cfg, subframe,
special_subframe)
self.assertIn(ParameterName.SUBFRAME_ASSIGNMENT,
self.cfg.get_parameter_names(),
'Expected a subframe assignment')
def test_set_management_server(self):
_set_management_server(self.cfg)
self.assertEqual(
self.cfg.get_parameter(ParameterName.PERIODIC_INFORM_ENABLE),
True, 'Expected periodic inform enable to be true')
self.assertTrue(
isinstance(
self.cfg.get_parameter(ParameterName.PERIODIC_INFORM_INTERVAL),
int),
'Expected periodic inform interval to ani integer'
)
def test_set_s1_connection(self):
invalid_mme_ip = 1234
invalid_mme_port = '8080'
mme_ip = '192.168.0.1'
mme_port = 8080
# MME IP should be a string
with self.assertRaises(ConfigurationError):
_set_s1_connection(self.cfg, invalid_mme_ip, mme_port)
# MME Port should be an integer
with self.assertRaises(ConfigurationError):
_set_s1_connection(self.cfg, mme_ip, invalid_mme_port)
# Check the ip and port are sort properly
_set_s1_connection(self.cfg, mme_ip, mme_port)
self.assertEqual(
self.cfg.get_parameter(ParameterName.MME_IP), mme_ip,
'Expected mme ip to be set')
self.assertEqual(
self.cfg.get_parameter(ParameterName.MME_PORT), mme_port,
'Expected mme port to be set')
def test_set_perf_mgmt(self):
mgmt_ip = '192.168.0.1'
mgmt_upload_interval = 300
mgmt_port = 8080
_set_perf_mgmt(self.cfg, mgmt_ip, mgmt_port)
self.assertTrue(
self.cfg.get_parameter(ParameterName.PERF_MGMT_ENABLE),
'Expected perf mgmt to be enabled')
self.assertEqual(
self.cfg.get_parameter(ParameterName.PERF_MGMT_UPLOAD_INTERVAL),
mgmt_upload_interval, 'Expected upload interval to be set')
expected_url = 'http://192.168.0.1:8080/'
self.assertEqual(
self.cfg.get_parameter(ParameterName.PERF_MGMT_UPLOAD_URL),
expected_url, 'Incorrect Url')
def test_set_misc_static_params(self):
# IPSec enable as integer
data_model = BaicellsTrDataModel
self.device_cfg.set_parameter(ParameterName.IP_SEC_ENABLE, 0)
_set_misc_static_params(self.device_cfg, self.cfg, data_model)
self.assertTrue(
isinstance(
self.cfg.get_parameter(ParameterName.IP_SEC_ENABLE), int),
'Should support an integer IP_SEC_ENABLE parameter')
# IPSec enable as boolean
self.device_cfg.set_parameter(ParameterName.IP_SEC_ENABLE, 'False')
_set_misc_static_params(self.device_cfg, self.cfg, data_model)
self.assertTrue(
isinstance(
self.cfg.get_parameter(ParameterName.IP_SEC_ENABLE), bool),
'Should support a boolean IP_SEC_ENABLE parameter')
self.assertEqual(
self.cfg.get_parameter(ParameterName.LOCAL_GATEWAY_ENABLE), 0,
'Should be disabled')
self.assertEqual(
self.cfg.get_parameter(ParameterName.CELL_RESERVED), False,
'Should be disabled')
self.assertEqual(
self.cfg.get_parameter(ParameterName.MME_POOL_ENABLE), False,
'Should be disabled')
def test_set_plmnids_tac(self):
# We only handle a single PLMNID for now
data_model = BaicellsTrDataModel
plmnids = '1, 2, 3, 4'
tac = 1
with self.assertRaises(ConfigurationError):
_set_plmnids_tac(self.cfg, data_model, plmnids, tac)
# Max PLMNID length is 6 characters
plmnids = '1234567'
with self.assertRaises(ConfigurationError):
_set_plmnids_tac(self.cfg, data_model, plmnids, tac)
# Check that only one PLMN element is enabled
plmnids = '1'
_set_plmnids_tac(self.cfg, data_model, plmnids, tac)
self.assertTrue(
self.cfg.get_parameter_for_object(
ParameterName.PLMN_N_ENABLE % 1, ParameterName.PLMN_N % 1),
'First PLMN should be enabled')
self.assertFalse(self.cfg.has_object(ParameterName.PLMN_N % 2),
'Second PLMN should be disabled')
def test_set_earafcn_freq_band_mode(self):
# Invalid earfcndl
with self.assertRaises(ConfigurationError):
invalid_earfcndl = -1
_set_earfcn_freq_band_mode(self.device_cfg, self.cfg,
invalid_earfcndl)
# Duplex_mode is TDD but capability is FDD
with self.assertRaises(ConfigurationError):
self.device_cfg.set_parameter(
ParameterName.DUPLEX_MODE_CAPABILITY, 'FDDMode')
earfcndl = 38650 # Corresponds to TDD
_set_earfcn_freq_band_mode(self.device_cfg, self.cfg, earfcndl)
# Duplex_mode is FDD but capability is TDD
with self.assertRaises(ConfigurationError):
self.device_cfg.set_parameter(
ParameterName.DUPLEX_MODE_CAPABILITY, 'TDDMode')
earfcndl = 0 # Corresponds to FDD
_set_earfcn_freq_band_mode(self.device_cfg, self.cfg, earfcndl)
