def test_omci_agent_default_init(self):
agent = OpenOMCIAgent(MockCore)
self.assertTrue(isinstance(agent.core, type(MockCore)))
self.assertTrue(isinstance(agent.database_class, type(MibDbExternal)))
self.assertEqual(len(agent.device_ids()), 0)
assert_raises(KeyError, agent.get_device, 'deadbeef')
class TestOmciConfiguration(TestCase):
"""
Test the OMCI read-only Configuration library methods
"""
def setUp(self):
self.adapter_agent = MockAdapterAgent()
custom = deepcopy(OpenOmciAgentDefaults)
custom['mib-synchronizer']['database'] = MibDbVolatileDict
self.omci_agent = OpenOMCIAgent(MockCore, support_classes=custom)
self.omci_agent.start()
def tearDown(self):
if self.omci_agent is not None:
self.omci_agent.stop()
if self.adapter_agent is not None:
self.adapter_agent.tearDown()
def setup_mock_olt(self, device_id=DEFAULT_OLT_DEVICE_ID):
handler = MockOltHandler(self.adapter_agent, device_id)
self.adapter_agent.add_device(handler.device)
return handler
def setup_mock_onu(self,
parent_id=DEFAULT_OLT_DEVICE_ID,
device_id=DEFAULT_ONU_DEVICE_ID,
pon_id=DEFAULT_PON_ID,
onu_id=DEFAULT_ONU_ID,
serial_no=DEFAULT_ONU_SN):
handler = MockOnuHandler(self.adapter_agent, parent_id, device_id,
pon_id, onu_id)
handler.serial_number = serial_no
onu = MockOnu(serial_no, self.adapter_agent, handler.device_id) \
if serial_no is not None else None
handler.onu_mock = onu
return handler
def setup_one_of_each(self):
# Most tests will use at lease one or more OLT and ONU
self.olt_handler = self.setup_mock_olt()
self.onu_handler = self.setup_mock_onu(
parent_id=self.olt_handler.device_id)
self.onu_device = self.onu_handler.onu_mock
self.adapter_agent.add_child_device(self.olt_handler.device,
self.onu_handler.device)
# Add device to OpenOMCI
self.onu_device = self.omci_agent.add_device(DEFAULT_ONU_DEVICE_ID,
self.adapter_agent)
# Allow timeout trigger support while in disabled state for mib sync
# to make tests run cleanly while profiling.
self.onu_device.mib_synchronizer.machine.add_transition(
'timeout', 'disabled', 'disabled')
def not_called(self, _reason):
assert False, 'Should never be called'
def _stuff_database(self, entries):
"""
Stuff the MIB database with some entries that we will use during tests
"""
database = self.onu_device.mib_synchronizer._database
# Stuff a value into last in sync. This makes it look like
# the ONU has been in in-sync at least once.
self.onu_device.mib_synchronizer.last_mib_db_sync = datetime.utcnow()
# Entry is a tuple of (class_id, instance_id, {attributes})
for entry in entries:
database.set(DEFAULT_ONU_DEVICE_ID, entry[0], entry[1], entry[2])
def test_OMCCVersion(self):
for key, value in OMCCVersion.__members__.items():
self.assertEqual(OMCCVersion.to_enum(OMCCVersion[key].value),
value)
self.assertEqual(OMCCVersion.to_enum(-1), OMCCVersion.Unknown)
@deferred(timeout=50000)
def test_defaults(self):
self.setup_one_of_each()
self.assertEqual(len(self.omci_agent.device_ids()), 1)
@raises(AssertionError)
def do_my_tests(_results):
config = self.onu_device.configuration
# Should raise assertion if never been synchronized
config.version
# No capabilities available until started
self.assertIsNone(self.onu_device.configuration)
# Yield context so that MIB Database callLater runs. This is a waiting
# Async task from when the OpenOMCIAgent was started. But also start the
# device so that it's queued async state machines can run as well
self.onu_device.start()
d = asleep(0.2)
d.addCallbacks(do_my_tests, self.not_called)
return d
@deferred(timeout=5)
def test_in_sync_but_empty(self):
self.setup_one_of_each()
self.assertEqual(len(self.omci_agent.device_ids()), 1)
def stuff_db(_results):
self._stuff_database([])
def do_my_tests(_results):
config = self.onu_device.configuration
# On no Class ID for requested property, None should be
# returned
self.assertIsNone(config.version)
self.assertIsNone(config.traffic_management_option)
self.assertIsNone(config.onu_survival_time)
self.assertIsNone(config.equipment_id)
self.assertIsNone(config.omcc_version)
self.assertIsNone(config.vendor_product_code)
self.assertIsNone(config.total_priority_queues)
self.assertIsNone(config.total_traffic_schedulers)
self.assertIsNone(config.total_gem_ports)
self.assertIsNone(config.uptime)
self.assertIsNone(config.connectivity_capability)
self.assertIsNone(config.qos_configuration_flexibility)
self.assertIsNone(config.priority_queue_scale_factor)
self.assertIsNone(config.cardholder_entities)
self.assertIsNone(config.circuitpack_entities)
self.assertIsNone(config.software_images)
self.assertIsNone(config.ani_g_entities)
self.assertIsNone(config.uni_g_entities)
# No capabilities available until started
self.assertIsNone(self.onu_device.configuration)
# Yield context so that MIB Database callLater runs.
self.onu_device.start()
d = asleep(0.2)
d.addCallbacks(stuff_db, self.not_called)
d.addCallbacks(do_my_tests, self.not_called)
return d
@deferred(timeout=5)
def test_in_sync_with_ont_g_values(self):
self.setup_one_of_each()
self.assertEqual(len(self.omci_agent.device_ids()), 1)
version = 'abcDEF'
tm_opt = 2
onu_survival = 123
def stuff_db(_results):
self._stuff_database([(OntG.class_id, 0, {
'version': version,
'traffic_management_options': tm_opt,
'ont_survival_time': onu_survival
})])
def do_my_tests(_results):
config = self.onu_device.configuration
# On no Class ID for requested property, None should be
# returned
self.assertEqual(config.version, version)
self.assertEqual(config.traffic_management_option, tm_opt)
self.assertEqual(config.onu_survival_time, onu_survival)
# No capabilities available until started
self.assertIsNone(self.onu_device.configuration)
# Yield context so that MIB Database callLater runs.
self.onu_device.start()
d = asleep(0.2)
d.addCallbacks(stuff_db, self.not_called)
d.addCallbacks(do_my_tests, self.not_called)
return d
@deferred(timeout=5)
def test_in_sync_with_ont_2g_values(self):
self.setup_one_of_each()
self.assertEqual(len(self.omci_agent.device_ids()), 1)
equip_id = 'br-549'
omcc_ver = OMCCVersion.G_988_2012
vend_code = 0x1234
queues = 64
scheds = 8
gem_ports = 24
uptime = 12345
conn_capp = 0x00aa
qos_flex = 0x001b
queue_scale = 1
def stuff_db(_results):
self._stuff_database([(Ont2G.class_id, 0, {
'equipment_id': equip_id,
'omcc_version': omcc_ver.value,
'vendor_product_code': vend_code,
'total_priority_queue_number': queues,
'total_traffic_scheduler_number': scheds,
'total_gem_port_id_number': gem_ports,
'sys_uptime': uptime,
'connectivity_capability': conn_capp,
'qos_configuration_flexibility': qos_flex,
'priority_queue_scale_factor': queue_scale
})])
def do_my_tests(_results):
config = self.onu_device.configuration
self.assertEqual(config.equipment_id, equip_id)
self.assertEqual(config.omcc_version, omcc_ver)
self.assertEqual(config.vendor_product_code, vend_code)
self.assertEqual(config.total_priority_queues, queues)
self.assertEqual(config.total_traffic_schedulers, scheds)
self.assertEqual(config.total_gem_ports, gem_ports)
self.assertEqual(config.uptime, uptime)
self.assertEqual(config.connectivity_capability, conn_capp)
self.assertEqual(config.qos_configuration_flexibility, qos_flex)
self.assertEqual(config.priority_queue_scale_factor, queue_scale)
# No capabilities available until started
self.assertIsNone(self.onu_device.configuration)
# Yield context so that MIB Database callLater runs.
self.onu_device.start()
d = asleep(0.2)
d.addCallbacks(stuff_db, self.not_called)
d.addCallbacks(do_my_tests, self.not_called)
return d
@deferred(timeout=5)
def test_in_sync_with_cardholder_values(self):
self.setup_one_of_each()
self.assertEqual(len(self.omci_agent.device_ids()), 1)
ch_entity = 0x102
unit_type = 255
clie_code = 'abc123'
prot_ptr = 0
def stuff_db(_results):
self._stuff_database([(Cardholder.class_id, ch_entity, {
'actual_plugin_unit_type': unit_type,
'actual_equipment_id': clie_code,
'protection_profile_pointer': prot_ptr,
})])
def do_my_tests(_results):
config = self.onu_device.configuration
cardholder = config.cardholder_entities
self.assertTrue(isinstance(cardholder, dict))
self.assertEqual(len(cardholder), 1)
self.assertEqual(cardholder[ch_entity]['entity-id'], ch_entity)
self.assertEqual(cardholder[ch_entity]['is-single-piece'],
ch_entity >= 256)
self.assertEqual(cardholder[ch_entity]['slot-number'],
ch_entity & 0xFF)
self.assertEqual(cardholder[ch_entity]['actual-plug-in-type'],
unit_type)
self.assertEqual(cardholder[ch_entity]['actual-equipment-id'],
clie_code)
self.assertEqual(cardholder[ch_entity]['protection-profile-ptr'],
prot_ptr)
# No capabilities available until started
self.assertIsNone(self.onu_device.configuration)
# Yield context so that MIB Database callLater runs.
self.onu_device.start()
d = asleep(0.2)
d.addCallbacks(stuff_db, self.not_called)
d.addCallbacks(do_my_tests, self.not_called)
return d
@deferred(timeout=5)
def test_in_sync_with_circuitpack_values(self):
self.setup_one_of_each()
self.assertEqual(len(self.omci_agent.device_ids()), 1)
cp_entity = 0x100
num_ports = 1
serial_num = 'ABCD01234'
cp_version = '1234ABCD'
vendor_id = 'AB-9876'
tconts = 2
pqueues = 64
sched_count = 8
def stuff_db(_results):
self._stuff_database([(CircuitPack.class_id, cp_entity, {
'number_of_ports':
num_ports,
'serial_number':
serial_num,
'version':
cp_version,
'vendor_id':
vendor_id,
'total_tcont_buffer_number':
tconts,
'total_priority_queue_number':
pqueues,
'total_traffic_scheduler_number':
sched_count,
})])
def do_my_tests(_results):
config = self.onu_device.configuration
circuitpack = config.circuitpack_entities
self.assertTrue(isinstance(circuitpack, dict))
self.assertEqual(len(circuitpack), 1)
self.assertEqual(circuitpack[cp_entity]['entity-id'], cp_entity)
self.assertEqual(circuitpack[cp_entity]['number-of-ports'],
num_ports)
self.assertEqual(circuitpack[cp_entity]['serial-number'],
serial_num)
self.assertEqual(circuitpack[cp_entity]['version'], cp_version)
self.assertEqual(circuitpack[cp_entity]['vendor-id'], vendor_id)
self.assertEqual(circuitpack[cp_entity]['total-tcont-count'],
tconts)
self.assertEqual(
circuitpack[cp_entity]['total-priority-queue-count'], pqueues)
self.assertEqual(
circuitpack[cp_entity]['total-traffic-sched-count'],
sched_count)
# No capabilities available until started
self.assertIsNone(self.onu_device.configuration)
# Yield context so that MIB Database callLater runs.
self.onu_device.start()
d = asleep(0.2)
d.addCallbacks(stuff_db, self.not_called)
d.addCallbacks(do_my_tests, self.not_called)
return d
@deferred(timeout=5)
def test_in_sync_with_software_values(self):
self.setup_one_of_each()
self.assertEqual(len(self.omci_agent.device_ids()), 1)
sw_entity = 0x200
sw_version = 'Beta-0.0.2'
sw_hash = md5("just_a_test").hexdigest()
prod_code = 'MySoftware'
sw_active = True
sw_committed = True
sw_valid = True
def stuff_db(_results):
self._stuff_database([(SoftwareImage.class_id, sw_entity, {
'version': sw_version,
'is_committed': sw_committed,
'is_active': sw_active,
'is_valid': sw_valid,
'product_code': prod_code,
'image_hash': sw_hash,
})])
def do_my_tests(_results):
config = self.onu_device.configuration
images = config.software_images
self.assertTrue(isinstance(images, list))
self.assertEqual(len(images), 1)
self.assertEqual(
images[0].name,
'running-revision' if sw_active else 'candidate-revision')
self.assertEqual(images[0].version, sw_version)
self.assertEqual(images[0].is_active, 1 if sw_active else 0)
self.assertEqual(images[0].is_committed, 1 if sw_committed else 0)
self.assertEqual(images[0].is_valid, 1 if sw_valid else 0)
self.assertEqual(images[0].hash, sw_hash)
# No capabilities available until started
self.assertIsNone(self.onu_device.configuration)
# Yield context so that MIB Database callLater runs.
self.onu_device.start()
d = asleep(0.2)
d.addCallbacks(stuff_db, self.not_called)
d.addCallbacks(do_my_tests, self.not_called)
return d
@deferred(timeout=5)
def test_in_sync_with_ani_g_values(self):
self.setup_one_of_each()
self.assertEqual(len(self.omci_agent.device_ids()), 1)
entity_id = 0x0106
tconts = 4
dba_report = 4
def stuff_db(_results):
self._stuff_database([(AniG.class_id, entity_id, {
'total_tcont_number': tconts,
'piggyback_dba_reporting': dba_report
})])
def do_my_tests(_results):
config = self.onu_device.configuration
anig = config.ani_g_entities
self.assertTrue(isinstance(anig, dict))
self.assertEqual(len(anig), 1)
self.assertEqual(anig[entity_id]['entity-id'], entity_id)
self.assertEqual(anig[entity_id]['slot-number'],
(entity_id >> 8) & 0xff)
self.assertEqual(anig[entity_id]['port-number'], entity_id & 0xff)
self.assertEqual(anig[entity_id]['total-tcont-count'], tconts)
self.assertEqual(anig[entity_id]['piggyback-dba-reporting'],
dba_report)
# No capabilities available until started
self.assertIsNone(self.onu_device.configuration)
# Yield context so that MIB Database callLater runs.
self.onu_device.start()
d = asleep(0.2)
d.addCallbacks(stuff_db, self.not_called)
d.addCallbacks(do_my_tests, self.not_called)
return d
@deferred(timeout=5)
def test_in_sync_with_uni_g_values(self):
self.setup_one_of_each()
self.assertEqual(len(self.omci_agent.device_ids()), 1)
entity_id = 0x4321
mgmt_cap = 0
def stuff_db(_results):
self._stuff_database([(UniG.class_id, entity_id, {
'management_capability': mgmt_cap
})])
def do_my_tests(_results):
config = self.onu_device.configuration
unig = config.uni_g_entities
self.assertTrue(isinstance(unig, dict))
self.assertEqual(len(unig), 1)
self.assertEqual(unig[entity_id]['entity-id'], entity_id)
self.assertEqual(unig[entity_id]['management-capability'],
mgmt_cap)
# No capabilities available until started
self.assertIsNone(self.onu_device.configuration)
# Yield context so that MIB Database callLater runs.
self.onu_device.start()
d = asleep(0.2)
d.addCallbacks(stuff_db, self.not_called)
d.addCallbacks(do_my_tests, self.not_called)
return d
class TestOnuDeviceEntry(TestCase):
"""
Test the ONU Device Entry methods
"""
def setUp(self):
self.adapter_agent = MockAdapterAgent()
custom = deepcopy(OpenOmciAgentDefaults)
custom['mib-synchronizer']['database'] = MibDbVolatileDict
self.agent = OpenOMCIAgent(MockCore, support_classes=custom)
self.agent.start()
def tearDown(self):
if self.agent is not None:
self.agent.stop()
if self.adapter_agent is not None:
self.adapter_agent.tearDown()
def setup_mock_olt(self, device_id=DEFAULT_OLT_DEVICE_ID):
handler = MockOltHandler(self.adapter_agent, device_id)
self.adapter_agent.add_device(handler.device)
return handler
def setup_mock_onu(self,
parent_id=DEFAULT_OLT_DEVICE_ID,
device_id=DEFAULT_ONU_DEVICE_ID,
pon_id=DEFAULT_PON_ID,
onu_id=DEFAULT_ONU_ID,
serial_no=DEFAULT_ONU_SN):
handler = MockOnuHandler(self.adapter_agent, parent_id, device_id,
pon_id, onu_id)
handler.serial_number = serial_no
onu = MockOnu(serial_no, self.adapter_agent, handler.device_id) \
if serial_no is not None else None
handler.onu_mock = onu
return handler
def setup_one_of_each(self):
# Most tests will use at lease one or more OLT and ONU
self.olt_handler = self.setup_mock_olt()
self.onu_handler = self.setup_mock_onu(
parent_id=self.olt_handler.device_id)
self.onu_device = self.onu_handler.onu_mock
self.adapter_agent.add_child_device(self.olt_handler.device,
self.onu_handler.device)
def test_add_remove_device(self):
self.setup_one_of_each()
self.assertEqual(len(self.agent.device_ids()), 0)
onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID,
self.adapter_agent)
self.assertIsNotNone(onu_device)
self.assertEqual(len(self.agent.device_ids()), 1)
self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID),
onu_device)
# No MIB if not started
assert_raises(KeyError, onu_device.query_mib)
self.agent.remove_device(DEFAULT_ONU_DEVICE_ID)
self.assertEqual(len(self.agent.device_ids()), 1)
def test_delete_device(self):
self.setup_one_of_each()
self.assertEqual(len(self.agent.device_ids()), 0)
onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID,
self.adapter_agent)
self.assertIsNotNone(onu_device)
self.assertEqual(len(self.agent.device_ids()), 1)
self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID),
onu_device)
# Can delete if it was not started
onu_device.delete()
self.assertEqual(len(self.agent.device_ids()), 0)
##########################################
# Delete of ONU device okay if it is started
onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID,
self.adapter_agent)
self.assertIsNotNone(onu_device)
self.assertEqual(len(self.agent.device_ids()), 1)
self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID),
onu_device)
# Start it and then delete it
onu_device.start()
onu_device.delete()
self.assertEqual(len(self.agent.device_ids()), 0)
@deferred(timeout=5)
def test_mib_query_fails_if_dev_not_started(self):
self.setup_one_of_each()
onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID,
self.adapter_agent)
self.assertIsNotNone(onu_device)
self.assertEqual(len(self.agent.device_ids()), 1)
self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID),
onu_device)
def not_called(_reason):
assert False, 'Should never be called'
def check_status(_results):
# Device not yet started. Query should fail with KeyError since
# ONU is not in database yet
assert_raises(KeyError, onu_device.query_mib)
# Yield context so that MIB Database callLater runs. This is a waiting
# Async task from when the OpenOMCIAgent was started.
d = asleep(0.2)
d.addCallbacks(check_status, not_called)
return d
@deferred(timeout=5)
def test_mib_query_ok_if_dev_started(self):
self.setup_one_of_each()
onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID,
self.adapter_agent)
self.assertIsNotNone(onu_device)
self.assertEqual(len(self.agent.device_ids()), 1)
self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID),
onu_device)
def not_called(_reason):
onu_device.stop()
assert False, 'Should never be called'
def check_status(_results):
# Device started. Query will succeed but nothing should be populated
# but the most basic items
results = onu_device.query_mib()
self.assertTrue(isinstance(results, dict))
self.assertEqual(results.get(DEVICE_ID_KEY), DEFAULT_ONU_DEVICE_ID)
self.assertIsNotNone(results.get(VERSION_KEY))
self.assertIsNotNone(results.get(CREATED_KEY))
self.assertIsNone(
results.get(MODIFIED_KEY)) # Created! but not yet modified
self.assertEqual(results.get(MDS_KEY), 0)
self.assertIsNone(results.get(LAST_SYNC_KEY))
self.assertIsNone(results.get(CLASS_ID_KEY))
# Stopping still allows a query. Note you just delete a device
# to clean up any associated databases
onu_device.stop()
results = onu_device.query_mib()
self.assertTrue(isinstance(results, dict))
# Yield context so that MIB Database callLater runs. This is a waiting
# Async task from when the OpenOMCIAgent was started. But also start the
# device so that it's queued async state machines can run as well
onu_device.start()
d = asleep(0.2)
d.addCallbacks(check_status, not_called)
return d
@deferred(timeout=5)
def test_delete_scrubs_mib(self):
self.setup_one_of_each()
onu_device = self.agent.add_device(DEFAULT_ONU_DEVICE_ID,
self.adapter_agent)
self.assertIsNotNone(onu_device)
self.assertEqual(len(self.agent.device_ids()), 1)
self.assertEqual(self.agent.get_device(DEFAULT_ONU_DEVICE_ID),
onu_device)
def not_called(_reason):
onu_device.stop()
assert False, 'Should never be called'
def check_status(_results):
# Device started. Query will succeed but nothing should be populated
# but the most basic items
results = onu_device.query_mib()
self.assertTrue(isinstance(results, dict))
self.assertEqual(results.get(DEVICE_ID_KEY), DEFAULT_ONU_DEVICE_ID)
# Delete should wipe out any MIB data. Note that a delete of a started
# or stopped ONU device is allowed. In this case we are deleting a
# started ONU Device
onu_device.delete()
assert_raises(Exception, onu_device.query_mib)
# TODO: When capabilities are supported, make sure capabilities get cleared as well
# Yield context so that MIB Database callLater runs. This is a waiting
# Async task from when the OpenOMCIAgent was started. But also start the
# device so that it's queued async state machines can run as well
onu_device.start()
d = asleep(0.2)
d.addCallbacks(check_status, not_called)
return d
