mqtt_msg_attr=mqtt_msg_attr),
enclose_metadata=False)
# Registering EdgeSystem
reg_edge_system = aws.register(edge_system)
# Creating CPU Metric
cpu_utilization = Metric(
name="CPUUtilization",
unit=None,
interval=10,
aggregation_size=2,
sampling_function=read_cpu_utilization
)
# Registering Metric and creating Parent-Child relationship
reg_cpu_utilization = aws.register(cpu_utilization)
aws.create_relationship(reg_edge_system, reg_cpu_utilization)
# Publishing Registered CPU Utilization Metric to AWS
# Publish topic for this metric is config['CustomPubTopic']
reg_cpu_utilization.start_collecting()
# Creating Simulated Device
dht_sensor = SimulatedDevice("SimulatedDHTSensor")
# Registering Device and creating Parent-Child relationship
reg_dht_sensor = aws.register(dht_sensor)
aws.create_relationship(reg_edge_system, reg_dht_sensor)
# Creating Temperature Metric
temp_metric = Metric(
name="LivingRoomTemperature",
entity_type="Metric",
unit=ureg.degC,
interval=1,
protocol=config['protocol'],
transport=['transport'],
conn_disconn_timeout=config['ConnectDisconnectTimeout']),
enclose_metadata=True)
# Registering EdgeSystem
reg_edge_system = aws.register(edge_system)
# Creating CPU Metric
cpu_utilization = Metric(name="CPUUtilization",
unit=None,
interval=10,
aggregation_size=2,
sampling_function=read_cpu_utilization)
# Registering Metric and creating Parent-Child relationship
reg_cpu_utilization = aws.register(cpu_utilization)
aws.create_relationship(reg_edge_system, reg_cpu_utilization)
# Publishing Registered CPU Utilization Metric to AWS
reg_cpu_utilization.start_collecting()
# Creating Simulated Device
dht_sensor = SimulatedDevice("SimulatedDHTSensor")
# Registering Device and creating Parent-Child relationship
reg_dht_sensor = aws.register(dht_sensor)
aws.create_relationship(reg_edge_system, reg_dht_sensor)
# Creating Temperature Metric
temp_metric = Metric(name="LivingRoomTemperature",
entity_type="Metric",
unit=ureg.degC,
interval=1,
aggregation_size=5,
sampling_function=get_living_room_temperature)
class DCCUtilityTest(unittest.TestCase):
"""
Unit test cases for DCC Utility global functions
"""
def setUp(self):
"""
Setup all required parameters required during the tests
:return: None
"""
# EdgeSystem name
self.edge_system = Dell5KEdgeSystem("TestEdgeSystem")
# Mocking the DataCenterComponent init method
with mock.patch("liota.dccs.aws_iot.DataCenterComponent.__init__"
) as mocked_dcc:
self.aws = AWSIoT("Mocked DCC", enclose_metadata=True)
def tearDown(self):
"""
Clean up all parameters used in test cases
:return: None
"""
self.edge_system = Dell5KEdgeSystem("TestEdgeSystem")
self.aws = None
def test_implementation_get_formatted_data_no_data(self):
"""
Test case to check the implementation of _format_data for empty metric data.
:return: None
"""
# Mocking the DataCenterComponent init method
with mock.patch("liota.dccs.aws_iot.DataCenterComponent.__init__"
) as mocked_dcc:
self.aws = AWSIoT("Mocked DCC", enclose_metadata=False)
# Register the edge
registered_entity = self.aws.register(self.edge_system)
# Creating test Metric
test_metric = Metric(name="Test_Metric",
unit=None,
interval=10,
aggregation_size=2,
sampling_function=sampling_function)
registered_metric = self.aws.register(test_metric)
# Creating the parent-child relationship
self.aws.create_relationship(registered_entity, registered_metric)
# Getting the parent child relationship array from registered metric
# formatted_data = self.aws._format_data(registered_metric)
formatted_data = get_formatted_data(registered_metric, False)
# Check two dicts are equal or not
self.assertEqual(None, formatted_data,
"Check implementation of get_formatted_data")
def test_implementation_get_formatted_data_with_enclose_metadata(self):
"""
Test case to check the implementation of get_formatted_data method with enclose_metadata option of AWSIoT class.
RegisteredEdgeSystem->RegisteredMetric
:return: None
"""
# Register the edge
registered_entity = self.aws.register(self.edge_system)
# Creating test Metric
test_metric = Metric(name="Test_Metric",
unit=None,
interval=10,
aggregation_size=2,
sampling_function=sampling_function)
registered_metric = self.aws.register(test_metric)
# Creating the parent-child relationship
self.aws.create_relationship(registered_entity, registered_metric)
timestamp = getUTCmillis()
registered_metric.values.put((timestamp, 10))
expected_output = {
"edge_system_name": registered_entity.ref_entity.name,
"metric_name": registered_metric.ref_entity.name,
"metric_data": [{
"value": 10,
"timestamp": timestamp
}],
"unit": "null"
}
# Getting the parent child relationship array from registered metric
formatted_data = get_formatted_data(registered_metric, True)
formatted_json_data = json.loads(formatted_data)
# Check two dicts are equal or not
self.assertEqual(
validate_json(formatted_json_data) == validate_json(
expected_output), True,
"Check implementation of get_formatted_data")
def test_implementation_get_formatted_data_without_enclose_metatadata(
self):
"""
Test case to check the output given by get_formatted_data method without enclosed meta_data option.
RegisteredEdgeSystem->RegisteredMetric
:return: None
"""
# Mocking the DataCenterComponent init method
with mock.patch("liota.dccs.aws_iot.DataCenterComponent.__init__"
) as mocked_dcc:
self.aws = AWSIoT("Mocked DCC", enclose_metadata=False)
# Register the edge
registered_entity = self.aws.register(self.edge_system)
# Creating test Metric
test_metric = Metric(name="Test_Metric",
unit=None,
interval=10,
aggregation_size=2,
sampling_function=sampling_function)
registered_metric = self.aws.register(test_metric)
# Creating the parent-child relationship
self.aws.create_relationship(registered_entity, registered_metric)
# Get current timestamp
timestamp = getUTCmillis()
registered_metric.values.put((timestamp, 10))
# Expected output without enclosed metadata
expected_output = {
"metric_name": registered_metric.ref_entity.name,
"metric_data": [{
"value": 10,
"timestamp": timestamp
}],
"unit": "null"
}
# Getting the parent child relationship array from registered metric
formatted_data = get_formatted_data(registered_metric, False)
# Convert json string to dict for the comparision
formatted_json_data = json.loads(formatted_data)
# Check two dicts are equal or not
self.assertEqual(
validate_json(formatted_json_data) == validate_json(
expected_output), True,
"Check implementation of get_formatted_data")
def test_implementation_get_formatted_data_with_enclose_metadata_device(
self):
"""
Test case to test the implementation of get_formatted_data method with enclose_metadata option.
RegisteredEdgeSystem->RegisteredDevice->RegisteredMetric
:return: None
"""
# Register the edge
registered_entity = self.aws.register(self.edge_system)
# Creating Simulated Device
test_sensor = SimulatedDevice("TestSensor")
# Registering Device and creating Parent-Child relationship
reg_test_sensor = self.aws.register(test_sensor)
self.aws.create_relationship(registered_entity, reg_test_sensor)
# Creating test Metric
test_metric = Metric(name="Test_Metric",
unit=ureg.degC,
interval=10,
aggregation_size=2,
sampling_function=sampling_function)
registered_metric = self.aws.register(test_metric)
# Creating the parent-child relationship
self.aws.create_relationship(reg_test_sensor, registered_metric)
# Get current timestamp
timestamp = getUTCmillis()
registered_metric.values.put((timestamp, 10))
# Expected output without enclosed metadata
expected_output = {
"edge_system_name": registered_entity.ref_entity.name,
"metric_name": registered_metric.ref_entity.name,
"device_name": reg_test_sensor.ref_entity.name,
"metric_data": [{
"value": 10,
"timestamp": timestamp
}],
"unit": "null"
}
unit_tuple = parse_unit(ureg.degC)
if unit_tuple[0] is None:
# Base and Derived Units
expected_output['unit'] = unit_tuple[1]
else:
# Prefixed or non-SI Units
expected_output['unit'] = unit_tuple[0] + unit_tuple[1]
# Getting the parent child relationship array from registered metric
formatted_data = get_formatted_data(registered_metric, True)
# Convert json string to dict for the comparision
formatted_json_data = json.loads(formatted_data)
# Check two dicts are equal or not
self.assertEqual(
validate_json(formatted_json_data) == validate_json(
expected_output), True,
"Check implementation of get_formatted_data")
def test_implementation_get_formatted_data_with_enclose_metadata_device_exception_flow(
self):
"""
Test case to test the implementation of get_formatted_data method with enclose_metadata option.
RegisteredEdgeSystem->RegisteredDevice->RegisteredMetric
:return: None
"""
# Mock the get_formatted_data
with mock.patch("liota.lib.utilities.dcc_utility.parse_unit"
) as mocked_parse_unit:
# Method to be invoked on calling the parse_unit function
mocked_parse_unit.side_effect = raise_exception
# Register the edge
registered_entity = self.aws.register(self.edge_system)
# Creating Simulated Device
test_sensor = SimulatedDevice("TestSensor")
# Registering Device and creating Parent-Child relationship
reg_test_sensor = self.aws.register(test_sensor)
self.aws.create_relationship(registered_entity, reg_test_sensor)
# Creating test Metric
test_metric = Metric(name="Test_Metric",
unit=ureg.degC,
interval=10,
aggregation_size=2,
sampling_function=sampling_function)
registered_metric = self.aws.register(test_metric)
# Creating the parent-child relationship
self.aws.create_relationship(reg_test_sensor, registered_metric)
# Get current timestamp
timestamp = getUTCmillis()
registered_metric.values.put((timestamp, 10))
# Expected output without enclosed metadata
expected_output = {
"edge_system_name": registered_entity.ref_entity.name,
"metric_name": registered_metric.ref_entity.name,
"device_name": reg_test_sensor.ref_entity.name,
"metric_data": [{
"value": 10,
"timestamp": timestamp
}],
"unit": "null"
}
# Getting the parent child relationship array from registered metric
formatted_data = get_formatted_data(registered_metric, True)
# Convert json string to dict for the comparision
formatted_json_data = json.loads(formatted_data)
# Check two dicts are equal or not
self.assertEqual(
validate_json(formatted_json_data) == validate_json(
expected_output), True,
"Check implementation of get_formatted_data")
def test_validation_get_entity_hierarchy(self):
"""
Test case to check the validation of _get_entity_hierarchy method for Metric object.
:return: None
"""
# Creating test Metric
test_metric = Metric(name="Test_Metric",
unit=None,
interval=10,
aggregation_size=2,
sampling_function=sampling_function)
# Checking whether implementation raising the TypeError for invalid input
with self.assertRaises(TypeError):
get_entity_hierarchy(test_metric)
def test_implementation_get_entity_hierarchy(self):
"""
Test case to check get_entity_entity_hierarchy() for RegisteredEdgeSystem->RegisteredMetric
:return: None
"""
# Register the edge
registered_entity = self.aws.register(self.edge_system)
# Creating test Metric
test_metric = Metric(name="Test_Metric",
unit=None,
interval=10,
aggregation_size=2,
sampling_function=sampling_function)
registered_metric = self.aws.register(test_metric)
# Creating the parent-child relationship
self.aws.create_relationship(registered_entity, registered_metric)
# Getting the parent child relationship array from registered metric
entity_hierarchy = get_entity_hierarchy(registered_metric)
self.assertSequenceEqual(
[
registered_entity.ref_entity.name,
registered_metric.ref_entity.name
], entity_hierarchy,
"Check the implementation of _get_entity_hierarchy for "
"RegisteredEdgeSystem->RegisteredMetric")
def test_implementation_get_entity_hierarchy_device_metric(self):
"""
Test case to check get_entity_entity_hierarchy() for RegisteredEdgeSystem->RegisteredDevice->RegisteredMetric
:return: None
"""
# Register the edge
registered_entity = self.aws.register(self.edge_system)
# Creating Simulated Device
test_sensor = SimulatedDevice("TestSensor")
# Registering Device and creating Parent-Child relationship
reg_test_sensor = self.aws.register(test_sensor)
self.aws.create_relationship(registered_entity, reg_test_sensor)
# Creating test Metric
test_metric = Metric(name="Test_Metric",
unit=ureg.degC,
interval=10,
aggregation_size=2,
sampling_function=sampling_function)
registered_metric = self.aws.register(test_metric)
# Creating the parent-child relationship
self.aws.create_relationship(reg_test_sensor, registered_metric)
# Getting the parent child relationship array from registered metric
entity_hierarchy = get_entity_hierarchy(registered_metric)
self.assertSequenceEqual(
[
registered_entity.ref_entity.name,
reg_test_sensor.ref_entity.name,
registered_metric.ref_entity.name
], entity_hierarchy,
"Check the implementation of _get_entity_hierarchy for "
"RegisteredEdgeSystem->RegisteredDevice->RegisteredMetric")