def test_serial_change(self) -> None:
manager = self._get_manager()
ip = "192.168.60.145"
# Send an Inform
ctx1 = get_spyne_context_with_ip(ip)
inform_msg = Tr069MessageBuilder.get_inform('48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0001')
resp1 = manager.handle_tr069_message(ctx1, inform_msg)
self.assertTrue(isinstance(resp1, models.InformResponse),
'Should respond with an InformResponse')
handler1 = manager.get_handler_by_ip(ip)
# Send an Inform from the same serial, but different IP
ctx2 = get_spyne_context_with_ip(ip)
inform_msg = Tr069MessageBuilder.get_inform('48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0002')
resp2 = manager.handle_tr069_message(ctx2, inform_msg)
self.assertTrue(isinstance(resp2, models.InformResponse),
'Should respond with an InformResponse')
handler2 = manager.get_handler_by_ip(ip)
# Now check that the serial is associated with the second ip
self.assertTrue((handler1 is not handler2),
'After an IP switch, the manager should have moved '
'the handler to a new IP')
def test_count_plmns_less(self) -> None:
"""
Tests the Cavium provisioning up to GetObjectParameters.
In particular tests when the eNB reports NUM_PLMNS less
than actually listed. The eNB says there are no PLMNs
defined when actually there are two.
Verifies that the number of PLMNs is correctly accounted.
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.CAVIUM)
# Send an Inform message
inform_msg = Tr069MessageBuilder.get_inform('000FB7',
'OC-LTE',
'120200002618AGP0003',
['1 BOOT'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values: %s' % resp)
# Transient config response and request for parameter values
req = Tr069MessageBuilder.get_read_only_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values: %s' % resp)
# Send back typical values for the regular parameters
req = Tr069MessageBuilder.get_cavium_param_values_response(num_plmns=0)
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals')
# Send back some object parameters with TWO plmns
req = Tr069MessageBuilder.get_cavium_object_param_values_response(
num_plmns=2)
resp = acs_state_machine.handle_tr069_message(req)
# In this scenario, the ACS and thus state machine will not need
# to delete or add objects to the eNB configuration.
# SM should then just be attempting to set parameter values
self.assertTrue(isinstance(resp, models.SetParameterValues),
'State machine should be setting param values')
# Number of PLMNs should reflect object count
num_plmns_cur = \
acs_state_machine \
.device_cfg.get_parameter(ParameterName.NUM_PLMNS)
self.assertEqual(num_plmns_cur, 2)
def test_count_plmns_more_defined(self) -> None:
"""
Tests the Cavium provisioning up to GetObjectParameters.
In particular tests when the eNB has more PLMNs than is
currently defined in our data model (NUM_PLMNS_IN_CONFIG)
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.CAVIUM)
# Send an Inform message
inform_msg = Tr069MessageBuilder.get_inform('000FB7', 'OC-LTE',
'120200002618AGP0003',
['1 BOOT'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values: %s' % resp)
# Transient config response and request for parameter values
req = Tr069MessageBuilder.get_read_only_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values: %s' % resp)
# Send back regular parameters, and some absurd number of PLMNS
req = Tr069MessageBuilder.get_cavium_param_values_response(
num_plmns=100)
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals')
# Send back some object parameters with an absurd number of PLMNs
req = Tr069MessageBuilder.get_cavium_object_param_values_response(
num_plmns=100)
resp = acs_state_machine.handle_tr069_message(req)
# In this scenario, the ACS and thus state machine will not need
# to delete or add objects to the eNB configuration.
# SM should then just be attempting to set parameter values
self.assertTrue(isinstance(resp, models.SetParameterValues),
'State machine should be setting param values')
# Number of PLMNs should reflect data model
num_plmns_cur = \
acs_state_machine \
.device_cfg.get_parameter(ParameterName.NUM_PLMNS)
self.assertEqual(num_plmns_cur, 6)
def test_handle_registered_enb(self):
"""
When we have a config with eNB registered per serial, we should accept
TR-069 sessions from any registered eNB, and ereject from unregistered
eNB devices.
"""
manager = self._get_manager_multi_enb()
ip1 = "192.168.60.145"
ctx1 = get_spyne_context_with_ip(ip1)
inform_msg = Tr069MessageBuilder.get_inform('48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0003')
resp1 = manager.handle_tr069_message(ctx1, inform_msg)
self.assertTrue(isinstance(resp1, models.InformResponse),
'Should respond with an InformResponse')
ip2 = "192.168.60.146"
ctx2 = get_spyne_context_with_ip(ip2)
inform_msg = Tr069MessageBuilder.get_inform('48BF74',
'BaiBS_RTS_3.1.6',
'unregistered_ip')
resp2 = manager.handle_tr069_message(ctx2, inform_msg)
self.assertTrue(isinstance(resp2, models.DummyInput),
'Should respond with an empty HTTP response')
def test_manual_reboot(self) -> None:
"""
Test a scenario where a Magma user goes through the enodebd CLI to
reboot the Baicells eNodeB.
This checks the scenario where the command is not sent in the middle
of a TR-069 provisioning session.
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS_QAFB)
# User uses the CLI tool to get eNodeB to reboot
acs_state_machine.reboot_asap()
# And now the Inform message arrives from the eNodeB
inform_msg = \
Tr069MessageBuilder.get_qafb_inform('48BF74',
'BaiBS_QAFBv123',
'1202000181186TB0006',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'In reboot sequence, state machine should still '
'respond to an Inform with InformResponse.')
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.Reboot),
'In reboot sequence, state machine should send a '
'Reboot message.')
req = Tr069MessageBuilder.get_reboot_response()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.DummyInput),
'State machine should end TR-069 session after '
'receiving a RebootResponse')
def test_serial_not_found(self):
"""
Test that the SM manager doesn't crash if serial number is not found
in an Inform message under any expected param path.
"""
manager = self._get_manager()
ctx = get_spyne_context_with_ip("192.168.60.145")
inform_msg = models.Inform(
DeviceId=models.DeviceIdStruct(
Manufacturer='Unused',
OUI='48BF74',
ProductClass='Unused',
),
Event=models.EventList(EventStruct=[]),
ParameterList=models.ParameterValueList(ParameterValueStruct=[
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.DeviceInfo.HardwareVersion',
val_type='string',
data='VER.C',
),
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.DeviceInfo.ManufacturerOUI',
val_type='string',
data='48BF74',
),
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.DeviceInfo.SoftwareVersion',
val_type='string',
data='BaiBS_RTS_3.1.6',
),
]))
# No exception should be thrown, and we should return an empty response
resp = manager.handle_tr069_message(ctx, inform_msg)
self.assertTrue(isinstance(resp, models.DummyInput))
def test_provision(self) -> None:
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS_QAFB)
# Send an Inform message, wait for an InformResponse
inform_msg = \
Tr069MessageBuilder.get_qafb_inform(
'48BF74',
'BaiBS_QAFBv123',
'1202000181186TB0006',
['2 PERIODIC'],
)
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(
isinstance(resp, models.InformResponse),
'Should respond with an InformResponse',
)
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values',
)
req = Tr069MessageBuilder.get_qafb_read_only_param_values_response()
# Send back some typical values
# And then SM should request regular parameter values
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values',
)
# Send back typical values for the regular parameters
req = Tr069MessageBuilder.\
get_qafb_regular_param_values_response(
admin_state=False,
earfcndl=39150,
)
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals',
)
# Send back some typical values for object parameters
req = Tr069MessageBuilder.get_qafb_object_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.AddObject),
'State machine should be adding objects',
)
def test_missing_param_during_provisioning(self, _mock_func) -> None:
"""
Test the scenario where:
- enodebd is configuring the eNodeB
- eNB does not send all parameters due to bug
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS)
# Send an Inform message, wait for an InformResponse
inform_msg = Tr069MessageBuilder.get_inform()
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, three times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_read_only_param_values_response()
# Send back some typical values
# And then SM should request regular parameter values
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
# Send back typical values for the regular parameters
# Pretend that here the NumPLMNs was not sent because of a Baicells bug
req = Tr069MessageBuilder.\
get_regular_param_values_response(admin_state=False,
earfcndl=39150,
exclude_num_plmns=True)
resp = acs_state_machine.handle_tr069_message(req)
# The state machine will fail and go into an error state.
# It will send an empty http response to end the session.
# Regularly, the SM should be using info on the number
# of PLMNs to figure out which object parameter values
# to fetch.
self.assertTrue(isinstance(resp, models.DummyInput),
'State machine should be ending session')
def test_missing_mme_timeout_handler(self) -> None:
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS)
# Send an Inform message, wait for an InformResponse
inform_msg = Tr069MessageBuilder.get_inform(
'48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0003',
['2 PERIODIC'],
)
acs_state_machine.handle_tr069_message(inform_msg)
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
acs_state_machine.handle_tr069_message(req)
acs_state_machine.mme_timeout_handler.cancel()
acs_state_machine.mme_timeout_handler = None
# Send an Inform message, wait for an InformResponse
inform_msg = Tr069MessageBuilder.get_inform(
'48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0003',
['2 PERIODIC'],
)
acs_state_machine.handle_tr069_message(inform_msg)
def test_end_session_and_notify_dp_transition(self, mock_get_state):
"""Testing if SM steps in and out of BaicellsQRTBWaitNotifyDPState as per state map"""
mock_get_state.return_value = MOCK_CBSD_STATE
acs_state_machine = provision_clean_sm(state='check_wait_get_params', )
msg = Tr069MessageBuilder.param_values_qrtb_response(
GET_PARAMS_RESPONSE_PARAMS,
models.GetParameterValuesResponse,
)
# SM should transition from check_wait_get_params to end_session -> notify_dp automatically
# upon receiving response from the radio
acs_state_machine.handle_tr069_message(msg)
self.assertIsInstance(
acs_state_machine.state,
BaicellsQRTBNotifyDPState,
)
msg = Tr069MessageBuilder.get_inform(event_codes=['1 BOOT'])
# SM should go into wait_inform state, respond with Inform response and transition to wait_empty
acs_state_machine.handle_tr069_message(msg)
self.assertIsInstance(acs_state_machine.state, WaitEmptyMessageState)
def test_manual_reboot_during_provisioning(self) -> None:
"""
Test a scenario where a Magma user goes through the enodebd CLI to
reboot the Sercomm eNodeB.
This checks the scenario where the command is sent in the middle
of a TR-069 provisioning session.
"""
logging.root.level = logging.DEBUG
acs_state_machine = EnodebAcsStateMachineBuilder.build_acs_state_machine(
EnodebDeviceName.FREEDOMFI_ONE)
# Send an Inform message, wait for an InformResponse
inform = Tr069MessageBuilder.get_inform(
oui="000E8F",
sw_version="TEST3920@210901",
enb_serial="2006CW5000023",
)
resp = acs_state_machine.handle_tr069_message(inform)
self.assertTrue(
isinstance(resp, models.InformResponse),
'Should respond with an InformResponse',
)
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, three times
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values',
)
req = Tr069MessageBuilder.get_fault()
# User uses the CLI tool to get eNodeB to reboot
acs_state_machine.reboot_asap()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.Reboot),
'In reboot sequence, state machine should send a '
'Reboot message.',
)
req = Tr069MessageBuilder.get_reboot_response()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.DummyInput),
'State machine should end TR-069 session after '
'receiving a RebootResponse',
)
self.assertIsInstance(acs_state_machine.state, WaitInformMRebootState)
inform = Tr069MessageBuilder.get_inform(event_codes=["M Reboot"], )
resp = acs_state_machine.handle_tr069_message(inform)
self.assertIsInstance(resp, models.InformResponse)
self.assertIsInstance(acs_state_machine.state,
FreedomFiOneGetInitState)
def test_transition_depending_on_sas_enabled_flag(
self,
dp_mode,
expected_state,
mock_get_state,
):
"""Testing if SM steps in and out of FreedomFiOneWaitNotifyDPState as per state map depending on whether
sas_enabled param is set to True or False in the service config
Args:
dp_mode: bool flag to enable or disable dp mode
expected_state (Any): State
mock_get_state (Any): mocking get_cbsd_state method
"""
mock_get_state.return_value = MOCK_CBSD_STATE
acs_state_machine = EnodebAcsStateMachineBuilder.build_acs_state_machine(
EnodebDeviceName.FREEDOMFI_ONE)
acs_state_machine._service.config = _get_service_config(
dp_mode=dp_mode)
acs_state_machine.desired_cfg = build_desired_config(
acs_state_machine.mconfig,
acs_state_machine.service_config,
acs_state_machine.device_cfg,
acs_state_machine.data_model,
acs_state_machine.config_postprocessor,
)
# Need to fill these values in the device_cfg if we're going to transition to notify_dp state
acs_state_machine.device_cfg.set_parameter(SASParameters.SAS_USER_ID,
'test_user')
acs_state_machine.device_cfg.set_parameter(SASParameters.SAS_FCC_ID,
'test_fcc')
acs_state_machine.device_cfg.set_parameter(ParameterName.SERIAL_NUMBER,
'test_sn')
acs_state_machine.transition('check_wait_get_params')
msg = Tr069MessageBuilder.param_values_qrtb_response(
[], models.GetParameterValuesResponse)
# SM should transition from check_wait_get_params to end_session -> notify_dp automatically
# upon receiving response from the radio
acs_state_machine.handle_tr069_message(msg)
self.assertIsInstance(acs_state_machine.state, expected_state)
msg = Tr069MessageBuilder.get_inform(event_codes=['1 BOOT'])
# SM should go into wait_inform state, respond with Inform response and transition to FreedomFiOneGetInitState
acs_state_machine.handle_tr069_message(msg)
self.assertIsInstance(acs_state_machine.state,
FreedomFiOneGetInitState)
def test_manual_reboot_during_provisioning(self) -> None:
"""
Test a scenario where a Magma user goes through the enodebd CLI to
reboot the Baicells eNodeB.
This checks the scenario where the command is sent in the middle
of a TR-069 provisioning session.
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS_QAFB)
# Send an Inform message, wait for an InformResponse
inform_msg = \
Tr069MessageBuilder.get_qafb_inform(
'48BF74',
'BaiBS_QAFBv123',
'1202000181186TB0006',
['2 PERIODIC'],
)
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(
isinstance(resp, models.InformResponse),
'Should respond with an InformResponse',
)
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, three times
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values',
)
req = Tr069MessageBuilder.get_fault()
# User uses the CLI tool to get eNodeB to reboot
acs_state_machine.reboot_asap()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.Reboot),
'In reboot sequence, state machine should send a '
'Reboot message.',
)
req = Tr069MessageBuilder.get_reboot_response()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.DummyInput),
'State machine should end TR-069 session after '
'receiving a RebootResponse',
)
def test_initial_enb_bootup(self) -> None:
"""
Baicells does not support configuration during initial bootup of
eNB device. This is because it is in a REM process, and we just need
to wait for this process to finish, ~10 minutes. Attempting to
configure the device during this period will cause undefined
behavior.
As a result of this, end any provisoning sessions, which we can do
by just sending empty HTTP responses, not even using an
InformResponse.
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS)
# Send an Inform message
inform_msg = Tr069MessageBuilder.get_inform(
'48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0003',
['1 BOOT'],
)
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(
isinstance(resp, models.DummyInput),
'Should respond with an InformResponse',
)
def test_autoremediation_from_fault(self):
"""
Transition the state machine into the unexpected fault state, then
verify that it transitions itself back to WaitInform after an Inform
is received.
"""
sm = EnodebAcsStateMachineBuilder.build_acs_state_machine(
EnodebDeviceName.BAICELLS,
)
# Send an initial inform
inform_msg = Tr069MessageBuilder.get_inform(
'48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0003',
['2 PERIODIC'],
)
resp = sm.handle_tr069_message(inform_msg)
self.assertTrue(
isinstance(resp, models.InformResponse),
'Should respond with an InformResponse',
)
# Now send a fault
req = models.Fault()
req.FaultCode = 12345
req.FaultString = 'Test FaultString'
sm.handle_tr069_message(req)
self.assertTrue('Error' in sm.get_state(), 'Should be in error state')
# Send the Inform again, verify SM transitions out of fault
resp = sm.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.DummyInput))
self.assertEqual('Waiting for an Inform', sm.get_state())
def test_get_service_status_old(self):
manager = self._get_manager()
status = get_service_status_old(manager)
self.assertTrue(
status['enodeb_connected'] == '0',
'Should report no eNB connected',
)
##### Start session for the first IP #####
ctx1 = get_spyne_context_with_ip("192.168.60.145")
# Send an Inform message, wait for an InformResponse
inform_msg = Tr069MessageBuilder.get_inform(
'48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0001',
)
manager.handle_tr069_message(ctx1, inform_msg)
status = get_service_status_old(manager)
self.assertTrue(
status['enodeb_connected'] == '1',
'Should report an eNB as conencted',
)
self.assertTrue(
status['enodeb_serial'] == '120200002618AGP0001',
'eNodeB serial should match the earlier Inform',
)
def test_handle_one_ip(self):
manager = self._get_manager()
# Send in an Inform message, and we should get an InformResponse
ctx = get_spyne_context_with_ip()
inform = Tr069MessageBuilder.get_inform()
req = manager.handle_tr069_message(ctx, inform)
self.assertTrue(isinstance(req, models.InformResponse),
'State machine handler should reply with an '
'InformResponse')
def test_inform_from_baicells_qafb(self) -> None:
manager = self._get_manager()
ip = "192.168.60.145"
# Send an Inform
ctx1 = get_spyne_context_with_ip(ip)
inform_msg = Tr069MessageBuilder.get_qafb_inform(
'48BF74', 'BaiBS_QAFB_v1234', '120200002618AGP0001')
resp1 = manager.handle_tr069_message(ctx1, inform_msg)
self.assertTrue(isinstance(resp1, models.InformResponse),
'Should respond with an InformResponse')
def test_inform_from_unrecognized(self) -> None:
manager = self._get_manager()
ip = "192.168.60.145"
# Send an Inform
ctx1 = get_spyne_context_with_ip(ip)
inform_msg = Tr069MessageBuilder.get_qafb_inform(
'48BF74', 'Unrecognized device', '120200002618AGP0001')
resp1 = manager.handle_tr069_message(ctx1, inform_msg)
self.assertTrue(
isinstance(resp1, models.DummyInput),
'Should end provisioninng session with empty response')
def test_wait_queued_events_post_reboot_transition(self):
"""Testing if we step in and out of BaicellsQRTBQueuedEventsWaitState as per state map"""
acs_state_machine = provision_clean_sm(
state='wait_post_reboot_inform', )
msg = Tr069MessageBuilder.get_inform(event_codes=['1 BOOT'])
acs_state_machine.handle_tr069_message(msg)
self.assertIsInstance(
acs_state_machine.state,
BaicellsQRTBQueuedEventsWaitState,
)
msg = Tr069MessageBuilder.get_inform()
# Need to wait after reboot, timeout set to 0.5 sec
sleep(1)
acs_state_machine.handle_tr069_message(msg)
self.assertIsInstance(acs_state_machine.state, WaitInformState)
def test_notify_dp_sets_values_received_by_dp_in_desired_config(
self, mock_get_state) -> None:
expected_final_param_values = {
ParameterName.UL_BANDWIDTH: '100',
ParameterName.DL_BANDWIDTH: '100',
ParameterName.EARFCNUL: 55340,
ParameterName.EARFCNDL: 55340,
ParameterName.POWER_SPECTRAL_DENSITY: 34,
}
test_user = '******'
test_fcc_id = 'fcc_id'
test_serial_number = '123'
acs_state_machine = EnodebAcsStateMachineBuilder.build_acs_state_machine(
EnodebDeviceName.BAICELLS_QRTB)
acs_state_machine.desired_cfg = EnodebConfiguration(
BaicellsQRTBTrDataModel())
acs_state_machine.device_cfg.set_parameter(ParameterName.SAS_USER_ID,
test_user)
acs_state_machine.device_cfg.set_parameter(ParameterName.SAS_FCC_ID,
test_fcc_id)
acs_state_machine.device_cfg.set_parameter(ParameterName.SERIAL_NUMBER,
test_serial_number)
for param in expected_final_param_values:
with self.assertRaises(KeyError):
acs_state_machine.desired_cfg.get_parameter(param)
# Skip previous steps not to duplicate the code
acs_state_machine.transition('check_wait_get_params')
req = Tr069MessageBuilder.param_values_qrtb_response(
[],
models.GetParameterValuesResponse,
)
mock_get_state.return_value = MOCK_CBSD_STATE
resp = acs_state_machine.handle_tr069_message(req)
mock_get_state.assert_called_with(
CBSDRequest(serial_number=test_serial_number), )
self.assertTrue(isinstance(resp, models.DummyInput))
for param, value in expected_final_param_values.items():
self.assertEqual(
value,
acs_state_machine.desired_cfg.get_parameter(param),
)
def _get_ff_one_read_only_param_values_resp(
self, ) -> models.GetParameterValuesResponse:
msg = models.GetParameterValuesResponse()
param_val_list = []
param_val_list.append(
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.X_000E8F_DeviceFeature.X_000E8F_NEStatus'
'.X_000E8F_Sync_Status',
val_type='string',
data='InSync',
), )
param_val_list.append(
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.X_000E8F_DeviceFeature.X_000E8F_NEStatus'
'.X_000E8F_SAS_Status',
val_type='string',
data='SUCCESS',
), )
param_val_list.append(
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.X_000E8F_DeviceFeature.X_000E8F_NEStatus'
'.X_000E8F_eNB_Status',
val_type='string',
data='SUCCESS',
), )
param_val_list.append(
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.X_000E8F_DeviceFeature.X_000E8F_NEStatus'
'.X_000E8F_DEFGW_Status',
val_type='string',
data='SUCCESS',
), )
param_val_list.append(
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.FAP.GPS.ScanStatus',
val_type='string',
data='SUCCESS',
), )
param_val_list.append(
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.FAP.GPS.LockedLongitude',
val_type='int',
data='-105272892',
), )
param_val_list.append(
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.FAP.GPS.LockedLatitude',
val_type='int',
data='40019606',
), )
msg.ParameterList = models.ParameterValueList()
msg.ParameterList.ParameterValueStruct = param_val_list
return msg
def test_get_single_enb_status(self):
manager = self._get_manager()
ctx1 = get_spyne_context_with_ip("192.168.60.145")
inform_msg = Tr069MessageBuilder.get_inform('48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0001')
manager.handle_tr069_message(ctx1, inform_msg)
status = get_single_enb_status('120200002618AGP0001', manager)
self.assertEquals(status.connected,
SingleEnodebStatus.StatusProperty.Value('ON'),
'Status should be connected.')
self.assertEquals(status.configured,
SingleEnodebStatus.StatusProperty.Value('OFF'),
'Status should be not configured.')
def test_get_rpc_methods_cold(self) -> None:
"""
Test the scenario where:
- enodeB just booted
- enodeB is cold and has no state of ACS RPCMethods
- Simulate the enodeB performing the initial Inform and
the call for the GetRPCMethods, and the subsequent Empty
response for provisioning
finishing on the Baicells eNodeB
Verifies that the ACS will continue into provisioning
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder\
.build_acs_state_machine(EnodebDeviceName.BAICELLS_QAFB)
# Send an Inform message, wait for an InformResponse
inform_msg = \
Tr069MessageBuilder.get_inform(
'48BF74',
'BaiBS_QAFBv123',
'120200002618AGP0003',
['1 BOOT'],
)
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(
isinstance(resp, models.InformResponse),
'Should respond with an InformResponse',
)
# Send GetRPCMethods
req = models.GetRPCMethods()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.GetRPCMethodsResponse),
'State machine should be sending RPC methods',
)
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values',
)
def test_get_enodeb_all_status(self):
manager = self._get_manager()
##### Test Empty #####
enb_status_by_serial = get_all_enb_status(manager)
self.assertTrue(enb_status_by_serial == {}, "No eNB connected")
##### Start session for the first IP #####
ctx1 = get_spyne_context_with_ip("192.168.60.145")
# Send an Inform message, wait for an InformResponse
inform_msg = Tr069MessageBuilder.get_inform('48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0001')
manager.handle_tr069_message(ctx1, inform_msg)
enb_status_by_serial = get_all_enb_status(manager)
enb_status = enb_status_by_serial.get('120200002618AGP0001')
self.assertTrue(enb_status.enodeb_connected)
def test_wait_post_reboot_inform_transition(self):
"""Testing if SM steps in and out of BaicellsQRTBWaitInformRebootState as per state map"""
acs_state_machine = provision_clean_sm(state='wait_reboot')
acs_state_machine.handle_tr069_message(models.RebootResponse())
self.assertIsInstance(
acs_state_machine.state,
BaicellsQRTBWaitInformRebootState,
)
msg = Tr069MessageBuilder.get_inform(event_codes=['1 BOOT'])
acs_state_machine.handle_tr069_message(msg)
self.assertIsInstance(
acs_state_machine.state,
BaicellsQRTBQueuedEventsWaitState,
)
def test_reboot_without_getting_optional(self) -> None:
"""
The state machine should not skip figuring out which optional
parameters are present.
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS_OLD)
# Send an Inform message, wait for an InformResponse
inform_msg = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# And now reboot the eNodeB
acs_state_machine.transition('reboot')
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.Reboot))
req = Tr069MessageBuilder.get_reboot_response()
resp = acs_state_machine.handle_tr069_message(req)
# After the reboot has been received, enodebd should end the
# provisioning session
self.assertTrue(
isinstance(resp, models.DummyInput),
'After sending command to reboot the Baicells eNodeB, '
'enodeb should end the TR-069 session.')
# At this point, sometime after the eNodeB reboots, we expect it to
# send an Inform indicating reboot. Since it should be in REM process,
# we hold off on finishing configuration, and end TR-069 sessions.
req = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['1 BOOT', 'M Reboot'])
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.DummyInput),
'After receiving a post-reboot Inform, enodebd '
'should end TR-069 sessions for 10 minutes to wait '
'for REM process to finish.')
# Pretend that we have waited, and now we are in normal operation again
acs_state_machine.transition('wait_inform_post_reboot')
req = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.InformResponse),
'After receiving a post-reboot Inform, enodebd '
'should end TR-069 sessions for 10 minutes to wait '
'for REM process to finish.')
# Since we haven't figured out the presence of optional parameters, the
# state machine should be requesting them now. There are three for the
# Baicells state machine.
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'enodebd should be requesting params')
self.assertTrue(
len(resp.ParameterNames.string) == 1,
'Should be requesting optional params.')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param')
self.assertTrue(
len(resp.ParameterNames.string) == 1,
'Should be requesting optional params.')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param')
self.assertTrue(
len(resp.ParameterNames.string) == 1,
'Should be requesting optional params.')
def test_reboot_after_invasive_changes(self) -> None:
"""
Test the scenario where:
- eNodeB has already been powered for 10 minutes without configuration
- Setting parameters which are 'invasive' on the eNodeB
- Simulate the scenario up until reboot, and test that enodebd does
not try to complete configuration after reboot, because it is
waiting for REM process to finish running
- This test does not wait the ten minutes to simulate REM process
finishing on the Baicells eNodeB
'Invasive' parameters are those which require special behavior to apply
the changes for the eNodeB.
In the case of the Baicells eNodeB, properly applying changes to
invasive parameters requires rebooting the device.
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder\
.build_acs_state_machine(EnodebDeviceName.BAICELLS_OLD)
# Send an Inform message, wait for an InformResponse
inform_msg = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, five times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_read_only_param_values_response()
# Send back some typical values
# And then SM should request regular parameter values
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
# Send back typical values for the regular parameters
req = Tr069MessageBuilder.get_regular_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals')
# Send back some typical values for object parameters
req = Tr069MessageBuilder.get_object_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# In this scenario, the ACS and thus state machine will not need
# to delete or add objects to the eNB configuration.
# SM should then just be attempting to set parameter values
self.assertTrue(isinstance(resp, models.SetParameterValues),
'State machine should be setting param values')
# Send back confirmation that the parameters were successfully set
req = models.SetParameterValuesResponse()
req.Status = 0
resp = acs_state_machine.handle_tr069_message(req)
# Since invasive parameters have been set, then to apply the changes
# to the Baicells eNodeB, we need to reboot the device
self.assertTrue(isinstance(resp, models.Reboot))
req = Tr069MessageBuilder.get_reboot_response()
resp = acs_state_machine.handle_tr069_message(req)
# After the reboot has been received, enodebd should end the
# provisioning session
self.assertTrue(
isinstance(resp, models.DummyInput),
'After sending command to reboot the Baicells eNodeB, '
'enodeb should end the TR-069 session.')
# At this point, sometime after the eNodeB reboots, we expect it to
# send an Inform indicating reboot. Since it should be in REM process,
# we hold off on finishing configuration, and end TR-069 sessions.
req = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['1 BOOT', 'M Reboot'])
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.DummyInput),
'After receiving a post-reboot Inform, enodebd '
'should end TR-069 sessions for 10 minutes to wait '
'for REM process to finish.')
# Pretend that we have waited, and now we are in normal operation again
acs_state_machine.transition('wait_inform_post_reboot')
req = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.InformResponse),
'After receiving a post-reboot Inform, enodebd '
'should end TR-069 sessions for 10 minutes to wait '
'for REM process to finish.')
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'enodebd should be requesting params')
self.assertTrue(
len(resp.ParameterNames.string) > 1,
'Should be requesting transient params.')
def test_provision_without_invasive_changes(self) -> None:
"""
Test the scenario where:
- eNodeB has already been powered for 10 minutes without configuration
- Setting parameters which are 'non-invasive' on the eNodeB
'Invasive' parameters are those which require special behavior to apply
the changes for the eNodeB.
"""
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS_OLD)
# Send an Inform message, wait for an InformResponse
inform_msg = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC001',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, five times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_fault()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_read_only_param_values_response()
# Send back some typical values
# And then SM should request regular parameter values
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
# Send back typical values for the regular parameters
req = Tr069MessageBuilder.\
get_regular_param_values_response(admin_state=False,
earfcndl=39150)
resp = acs_state_machine.handle_tr069_message(req)
# SM will be requesting object parameter values
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting object param vals')
# Send back some typical values for object parameters
req = Tr069MessageBuilder.get_object_param_values_response()
resp = acs_state_machine.handle_tr069_message(req)
# In this scenario, the ACS and thus state machine will not need
# to delete or add objects to the eNB configuration.
# SM should then just be attempting to set parameter values
self.assertTrue(isinstance(resp, models.SetParameterValues),
'State machine should be setting param values')
# Send back confirmation that the parameters were successfully set
req = models.SetParameterValuesResponse()
req.Status = 0
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for read-only params
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
req = Tr069MessageBuilder.get_read_only_param_values_response()
# Send back some typical values
# And then SM should continue polling the read-only params
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(isinstance(resp, models.DummyInput),
'State machine should be ending session')
# If a different eNB is suddenly plugged in, or the same eNB sends a
# new Inform, enodebd should be able to handle it.
# Send an Inform message, wait for an InformResponse
inform_msg = \
Tr069MessageBuilder.get_inform('48BF74',
'BaiStation_V100R001C00B110SPC002',
'120200002618AGP0003',
['2 PERIODIC'])
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(isinstance(resp, models.InformResponse),
'Should respond with an InformResponse')
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, three times
self.assertTrue(isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values')
def test_gps_coords(self) -> None:
""" Check GPS coordinates are processed and stored correctly """
acs_state_machine = \
EnodebAcsStateMachineBuilder \
.build_acs_state_machine(EnodebDeviceName.BAICELLS)
# Send an Inform message, wait for an InformResponse
inform_msg = Tr069MessageBuilder.get_inform(
'48BF74',
'BaiBS_RTS_3.1.6',
'120200002618AGP0003',
['2 PERIODIC'],
)
resp = acs_state_machine.handle_tr069_message(inform_msg)
self.assertTrue(
isinstance(resp, models.InformResponse),
'Should respond with an InformResponse',
)
# Send an empty http request to kick off the rest of provisioning
req = models.DummyInput()
resp = acs_state_machine.handle_tr069_message(req)
# Expect a request for an optional parameter, three times
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values',
)
req = models.GetParameterValuesResponse()
param_val_list = [
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.X_BAICELLS_COM_GpsSyncEnable',
val_type='boolean',
data='true',
),
]
req.ParameterList = models.ParameterValueList()
req.ParameterList.ParameterValueStruct = param_val_list
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values',
)
req = models.GetParameterValuesResponse()
param_val_list = [
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.FAP.GPS.LockedLatitude',
val_type='int',
data='37483629',
),
]
req.ParameterList = models.ParameterValueList()
req.ParameterList.ParameterValueStruct = param_val_list
resp = acs_state_machine.handle_tr069_message(req)
self.assertTrue(
isinstance(resp, models.GetParameterValues),
'State machine should be requesting param values',
)
req = models.GetParameterValuesResponse()
param_val_list = [
Tr069MessageBuilder.get_parameter_value_struct(
name='Device.FAP.GPS.LockedLongitude',
val_type='int',
data='-122150583',
),
]
req.ParameterList = models.ParameterValueList()
req.ParameterList.ParameterValueStruct = param_val_list
acs_state_machine.handle_tr069_message(req)
gps_long = acs_state_machine.get_parameter(ParameterName.GPS_LONG)
gps_lat = acs_state_machine.get_parameter(ParameterName.GPS_LAT)
self.assertTrue(gps_long == '-122.150583', 'Should be valid longitude')
self.assertTrue(gps_lat == '37.483629', 'Should be valid latitude')
