def test_panoptes_resource_set(self):
panoptes_resource = self.__panoptes_resource
panoptes_resource_set = self.__panoptes_resource_set
self.assertEqual(panoptes_resource_set.add(panoptes_resource), None)
self.assertEqual(len(panoptes_resource_set), 1)
self.assertEqual(type(panoptes_resource_set.resources), set)
self.assertIsInstance(str(panoptes_resource_set), str)
self.assertIsInstance(iter(panoptes_resource_set), collections.Iterable)
self.assertEqual(panoptes_resource_set.next(), panoptes_resource)
self.assertEqual(panoptes_resource_set.remove(panoptes_resource), None)
self.assertEqual(len(panoptes_resource_set), 0)
self.assertEqual(panoptes_resource_set.resource_set_creation_timestamp, _TIMESTAMP)
with self.assertRaises(AssertionError):
panoptes_resource_set.resource_set_creation_timestamp = 0
panoptes_resource_2 = PanoptesResource(resource_site='test', resource_class='test',
resource_subclass='test',
resource_type='test', resource_id='test2', resource_endpoint='test',
resource_plugin='test',
resource_ttl=RESOURCE_MANAGER_RESOURCE_EXPIRE,
resource_creation_timestamp=_TIMESTAMP)
panoptes_resource_set.add(panoptes_resource)
panoptes_resource_set.add(panoptes_resource_2)
self.assertEqual(len(panoptes_resource_set.get_resources_by_site()['test']), 2)
self.assertEqual(panoptes_resource_set.resource_set_schema_version, "0.1")
panoptes_resource_set_json = {
u'resource_set_creation_timestamp': _TIMESTAMP,
u'resource_set_schema_version': u'0.1',
u'resources': [
{
u'resource_site': u'test',
u'resource_class': u'test',
u'resource_subclass': u'test',
u'resource_type': u'test',
u'resource_id': u'test2',
u'resource_endpoint': u'test',
u'resource_metadata': {
u'_resource_ttl': u'604800'
},
u'resource_creation_timestamp': _TIMESTAMP,
u'resource_plugin': u'test'
},
{
u'resource_site': u'test',
u'resource_class': u'test',
u'resource_subclass': u'test',
u'resource_type': u'test',
u'resource_id': u'test',
u'resource_endpoint': u'test',
u'resource_metadata': {
u'_resource_ttl': u'604800',
u'test': u'test'
},
u'resource_creation_timestamp': _TIMESTAMP,
u'resource_plugin': u'test'
}
]
}
self.assertEqual(ordered(panoptes_resource_set_json), ordered(json.loads(panoptes_resource_set.json)))
def test_basic_operations(self):
plugin = self.plugin_class()
results = plugin.run(self._plugin_context)
self.assertEqual(ordered(self._expected_results),
ordered(self._remove_timestamps(results)))
def test_enrichment_plugin_results(self):
"""Test plugin result and validate results with input data/results.json"""
plugin = self.plugin_class()
result = plugin.run(self._plugin_context)
self.assertIsNotNone(result)
result = ordered(json.loads(result.json()))
expected = ordered(self._expected_results)
self.assertEqual(result, expected)
def test_panoptes_metric_json_and_repr(self):
metric = PanoptesMetric(u'test_metric', 0, PanoptesMetricType.GAUGE,
mock_time.return_value)
serialized = json.loads(metric.json)
expected = {
u"metric_creation_timestamp": mock_time.return_value,
u"metric_name": u"test_metric",
u"metric_type": u"gauge",
u"metric_value": 0
}
self.assertEqual(ordered(serialized), ordered(expected))
def test_inactive_port(self):
"""Tests a valid resource_endpoint with an inactive port"""
self.plugin_conf['snmp']['port'] = 10161
self._results_data_file = 'data/bad_port_results.json'
self.set_expected_results()
plugin = self.plugin_class()
results = plugin.run(self._plugin_context_bad)
self.assertEqual(ordered(self._expected_results),
ordered(self._remove_timestamps(results)))
self._results_data_file = 'data/results.json'
def test_discovery_plugin_task(self, panoptes_context,
message_producer_property,
message_producer):
producer = MockPanoptesMessageProducer()
message_producer_property.return_value = message_producer.return_value = producer
panoptes_context.return_value = self._panoptes_context
discovery_plugin_task("Test Discovery Plugin")
plugin_result = producer.messages
self.assertEqual(len(plugin_result), 1)
plugin_result = plugin_result[0]
self.assertTrue('Test_Discovery_Plugin' in plugin_result['key'])
plugin_result['key'] = 'Test_Discovery_Plugin'
expected_result = {
'topic':
'test_site-resources',
'message':
'{"resource_set_creation_timestamp": 1.0, '
'"resource_set_schema_version": "0.1", "resources": '
'[{"resource_site": "test_site", "resource_class": '
'"test_class", "resource_subclass": "test_subclass", '
'"resource_type": "test_type", "resource_id": '
'"test_resource_id", "resource_endpoint": '
'"test_resource_endpoint", "resource_metadata": '
'{"_resource_ttl": "604800"},'
' "resource_creation_timestamp": 1.0,'
' "resource_plugin": "test_resource_plugin"}]}',
'key':
'Test_Discovery_Plugin'
}
plugin_result['message'] = re.sub(
r"resource_set_creation_timestamp\": \d+\.\d+,",
"resource_set_creation_timestamp\": 1.0,",
plugin_result['message'])
plugin_result['message'] = re.sub(
r"resource_creation_timestamp\": \d+\.\d+,",
"resource_creation_timestamp\": 1.0,", plugin_result['message'])
self.assertEqual(plugin_result['topic'], expected_result['topic'])
self.assertEqual(plugin_result['key'], expected_result['key'])
self.assertEqual(ordered(json.loads(plugin_result['message'])),
ordered(json.loads(expected_result['message'])))
def test_no_service_active(self):
"""Tests a valid resource_endpoint with no service active"""
self._resource_endpoint = u'192.0.2.1' # Per RFC 5737
self._snmp_conf[u'timeout'] = self._snmp_failure_timeout
self.results_data_file = u"from_file_no_service_active_results.json"
self.set_panoptes_resource()
self.set_plugin_context()
self.set_expected_results()
plugin = self.plugin_class()
if self._plugin_conf.get(u'enrichment'):
if self._plugin_conf[u'enrichment'].get(u'file'):
results = plugin.run(self._plugin_context)
self.assertEqual(ordered(self._expected_results),
ordered(self._remove_timestamps(results)))
self._resource_endpoint = u'127.0.0.1'
self._snmp_conf[u'timeout'] = self.snmp_timeout
self.results_data_file = u"results.json"
self.set_panoptes_resource()
self.set_plugin_context()
self.set_expected_results()
def test_plugin_ping_exception(self):
results = PluginPollingPing().run(self._panoptes_plugin_context)
self.assertEqual(ordered(json.loads(list(results)[0].json)),
ordered(TEST_PLUGIN_RESULT_EXCEPTION))
def test_plugin_ping_failure(self):
results = PluginPollingPing().run(self._panoptes_plugin_context)
self.assertEqual(ordered(json.loads(list(results)[0].json)),
ordered(TEST_PLUGIN_RESULT_FAILURE))
def test_plugin_ping_success(self):
results = PluginPollingPing().run(self._panoptes_plugin_context)
self.assertEqual(ordered(json.loads(list(results)[0].json)),
ordered(TEST_PLUGIN_RESULT_SUCCESS))
def test_polling_plugin_results(self):
"""Test plugin result and validate results with input data/results.json"""
plugin = self.plugin_class()
result = plugin.run(self._plugin_context)
self.assertEqual(ordered(json.loads(result.json())), ordered(self._expected_results))
def test_polling_plugin_agent(self, resource, panoptes_context,
message_producer, message_producer_property,
time):
producer = MockPanoptesMessageProducer()
time.return_value = 1
message_producer.return_value = producer
message_producer_property.return_value = producer
resource.return_value = self._panoptes_resource
panoptes_context.return_value = self._panoptes_context
polling_plugin_task('Test Polling Plugin', 'polling')
log_prefix = '[Test Polling Plugin] [plugin|test|site|test|class|test|' \
'subclass|test|type|test|id|test|endpoint|test]'
self._log_capture.check_present(
('panoptes.tests.test_runner', 'INFO',
'Attempting to execute plugin "Test Polling Plugin"'),
('panoptes.tests.test_runner', 'DEBUG',
'Loaded plugin "Test Polling Plugin", '
'version "0.1" of type "polling", category "polling"'),
('panoptes.tests.test_runner', 'DEBUG',
'Loaded plugin "Test Polling Plugin 2", '
'version "0.1" of type "polling", category "polling"'),
('panoptes.tests.test_runner', 'ERROR',
'No enrichment data found on KV store for plugin Test'
' Polling Plugin resource test namespace test using key test'),
('panoptes.tests.test_runner', 'DEBUG',
'Successfully created PanoptesEnrichmentCache enrichment_data '
'{} for plugin Test Polling Plugin'),
('panoptes.tests.test_runner', 'DEBUG',
'Attempting to get lock for plugin "Test Polling Plugin", '
'with lock path and identifier in seconds'),
('panoptes.tests.test_runner', 'INFO',
'{} Acquired lock'.format(log_prefix)),
('panoptes.tests.test_runner', 'INFO',
'{} Plugin returned a result set with 1 members'.format(
log_prefix)),
('panoptes.tests.test_runner', 'INFO',
'{} Callback function ran in seconds'.format(log_prefix)),
('panoptes.tests.test_runner', 'INFO',
'{} Ran in seconds'.format(log_prefix)),
('panoptes.tests.test_runner', 'INFO',
'{} Released lock'.format(log_prefix)),
('panoptes.tests.test_runner', 'INFO',
'{} GC took seconds. There are garbage objects.'.format(
log_prefix)),
('panoptes.tests.test_runner', 'DEBUG',
'Deleting module: yapsy_loaded_plugin_Test_Polling_Plugin'),
('panoptes.tests.test_runner', 'DEBUG',
'Deleting module: yapsy_loaded_plugin_Test_Polling_Plugin'),
('panoptes.tests.test_runner', 'DEBUG', 'Deleting module: '
'yapsy_loaded_plugin_Test_Polling_Plugin_Second_Instance'),
order_matters=False)
kafka_push_log = {
"metrics_group_type":
"Test",
"metrics_group_interval":
60,
"metrics_group_creation_timestamp":
1,
"metrics_group_schema_version":
"0.2",
"resource": {
"resource_site": "test",
"resource_class": "test",
"resource_subclass": "test",
"resource_type": "test",
"resource_id": "test",
"resource_endpoint": "test",
"resource_metadata": {
"_resource_ttl": "604800"
},
"resource_creation_timestamp": 1.0,
"resource_plugin": "test"
},
"metrics": [{
"metric_creation_timestamp": 1,
"metric_name": "test",
"metric_value": 0.0,
"metric_type": "gauge"
}],
"dimensions": []
}
# Timestamps need to be removed to check Panoptes Metrics
metric_groups_seen = 0
for line in self._log_capture.actual():
_, _, log = line
if 'resource_creation_timestamp' in log:
log = re.sub(r"resource_creation_timestamp\": \d+\.\d+,",
"resource_creation_timestamp\": 1.0,", log)
resource_match = re.search(r'{.*}', log)
if resource_match is not None:
self.assertEqual(
ordered(json.loads(resource_match.group(0))),
ordered(kafka_push_log))
if log.startswith('Sent metric group'):
metric_groups_seen += 1
if log.startswith('Going to send metric group'):
metric_groups_seen += 1
self.assertEqual(metric_groups_seen, 2)
def test_panoptes_resource(self):
panoptes_resource_metadata = self.__panoptes_resource_metadata
panoptes_resource = self.__panoptes_resource
self.assertIsInstance(panoptes_resource, PanoptesResource)
self.assertEqual(panoptes_resource.resource_site, 'test')
self.assertEqual(panoptes_resource.resource_class, 'test')
self.assertEqual(panoptes_resource.resource_subclass, 'test')
self.assertEqual(panoptes_resource.resource_type, 'test')
self.assertEqual(panoptes_resource.resource_id, 'test')
self.assertEqual(panoptes_resource.resource_endpoint, 'test')
self.assertEqual(panoptes_resource.resource_metadata, panoptes_resource_metadata)
self.assertEqual(panoptes_resource.resource_ttl, str(RESOURCE_MANAGER_RESOURCE_EXPIRE))
self.assertEqual(panoptes_resource, panoptes_resource)
self.assertFalse(panoptes_resource == '1')
self.assertIsInstance(str(panoptes_resource), str)
with self.assertRaises(AssertionError):
panoptes_resource.add_metadata(None, 'test')
with self.assertRaises(AssertionError):
panoptes_resource.add_metadata('', 'test')
with self.assertRaises(ValueError):
panoptes_resource.add_metadata('1', 'test')
with self.assertRaises(ValueError):
panoptes_resource.add_metadata('key', 'test|')
with self.assertRaises(AssertionError):
PanoptesResource(resource_site='', resource_class='test', resource_subclass='test',
resource_type='test', resource_id='test', resource_endpoint='test')
with self.assertRaises(AssertionError):
PanoptesResource(resource_site='test', resource_class='', resource_subclass='test',
resource_type='test', resource_id='test', resource_endpoint='test')
with self.assertRaises(AssertionError):
PanoptesResource(resource_site='test', resource_class='test', resource_subclass='',
resource_type='test', resource_id='test', resource_endpoint='test')
with self.assertRaises(AssertionError):
PanoptesResource(resource_site='test', resource_class='test', resource_subclass='test',
resource_type='', resource_id='test', resource_endpoint='test')
with self.assertRaises(AssertionError):
PanoptesResource(resource_site='test', resource_class='test', resource_subclass='test',
resource_type='test', resource_id='', resource_endpoint='test')
with self.assertRaises(AssertionError):
PanoptesResource(resource_site=None, resource_class='test', resource_subclass='test',
resource_type='test', resource_id='test', resource_endpoint='test')
with self.assertRaises(AssertionError):
PanoptesResource(resource_site='test', resource_class=None, resource_subclass='test',
resource_type='test', resource_id='test', resource_endpoint='test')
with self.assertRaises(AssertionError):
PanoptesResource(resource_site='test', resource_class='test', resource_subclass=None,
resource_type='test', resource_id='test', resource_endpoint='test')
with self.assertRaises(AssertionError):
PanoptesResource(resource_site='test', resource_class='test', resource_subclass='test',
resource_type=None, resource_id='test', resource_endpoint='test')
with self.assertRaises(AssertionError):
PanoptesResource(resource_site='test', resource_class='test', resource_subclass='test',
resource_type='test', resource_id=None, resource_endpoint='test')
with self.assertRaises(AssertionError):
PanoptesResource(resource_site='test', resource_class='test', resource_subclass='test',
resource_type='test', resource_id='test', resource_endpoint=None)
# Test json and raw representations of PanoptesResource
panoptes_resource_2 = PanoptesResource(resource_site='test', resource_class='test',
resource_subclass='test',
resource_type='test', resource_id='test', resource_endpoint='test',
resource_creation_timestamp=_TIMESTAMP,
resource_plugin='test')
self.assertEqual(panoptes_resource_2.resource_creation_timestamp, _TIMESTAMP)
panoptes_resource_2_json = {
u'resource_site': u'test',
u'resource_id': u'test',
u'resource_class': u'test',
u'resource_plugin': u'test',
u'resource_creation_timestamp': _TIMESTAMP,
u'resource_subclass': u'test',
u'resource_endpoint': u'test',
u'resource_metadata': {
u'_resource_ttl': u'604800'
},
u'resource_type': u'test'
}
self.assertEqual(ordered(json.loads(panoptes_resource_2.json)), ordered(panoptes_resource_2_json))
panoptes_resource_2_raw = collections.OrderedDict(
[('resource_site', 'test'),
('resource_class', 'test'),
('resource_subclass', 'test'),
('resource_type', 'test'),
('resource_id', 'test'),
('resource_endpoint', 'test'),
('resource_metadata', collections.OrderedDict(
[('_resource_ttl', '604800')])
),
('resource_creation_timestamp', _TIMESTAMP),
('resource_plugin', 'test')])
self.assertEqual(panoptes_resource_2.raw, panoptes_resource_2_raw)
# Test resource creation from dict
with open('tests/test_resources/input/resource_one.json') as f:
resource_specs = json.load(f)
resource_from_json = PanoptesResource.resource_from_dict(resource_specs['resources'][0])
panoptes_resource_3 = PanoptesResource(resource_site="test_site", resource_class="network",
resource_subclass="test_subclass", resource_type="test_type",
resource_id="test_id_1", resource_endpoint="test_endpoint_1",
resource_plugin="key")
self.assertEqual(resource_from_json, panoptes_resource_3)
def test_basic_operations(self):
self._plugin_context.config['main']['config_file'] = \
os.path.join(os.path.abspath(self.path), 'data/test.json')
result = self.plugin.run(self._plugin_context)
self.assertEqual(ordered(json.loads(result.json)), ordered(self._expected_results))