def setUp(self):
"""
Initialize and patch the check, i.e.
"""
global account_id
with open(relative_path("../stackstate_checks/aws_topology.yaml"),
"r") as stream:
data_loaded = yaml.safe_load(stream)
top.reset()
aggregator.reset()
init_config = InitConfig({
"aws_access_key_id":
data_loaded["init_config"]["aws_access_key_id"],
"aws_secret_access_key":
data_loaded["init_config"]["aws_secret_access_key"],
"external_id":
data_loaded["init_config"]["external_id"],
})
role = data_loaded["instances"][0]["role_arn"]
account_id = role.split(":")[4]
instance = {
"role_arn": role,
"regions": regions,
}
instance.update({"apis_to_run": ["redshift"]})
self.check = AwsTopologyCheck(self.CHECK_NAME, InitConfig(init_config),
[instance])
def dynatrace_check(test_instance):
check = DynatraceCheck('dynatrace', {}, instances=[test_instance])
yield check
aggregator.reset()
telemetry.reset()
topology.reset()
check.commit_state(None)
def setUp(self):
"""
Initialize and patch the check, i.e.
"""
config = InitConfig({
"aws_access_key_id": "some_key",
"aws_secret_access_key": "some_secret",
"external_id": "secret_string"
})
self.patcher = patch("botocore.client.BaseClient._make_api_call")
self.mock_object = self.patcher.start()
self.api_results = deepcopy(API_RESULTS)
topology.reset()
aggregator.reset()
self.check = AwsTopologyCheck(self.CHECK_NAME, config, [self.instance])
def results(operation_name, api_params):
if operation_name == "AssumeRole" and "ExternalId" not in api_params:
raise ClientError({"Error": {
"Code": "AccessDenied"
}}, operation_name)
else:
return self.api_results.get(operation_name) or {}
self.mock_object.side_effect = results
def test_zabbix_no_problems(self):
"""
When there are no problems, we are expecting all host components to go to green.
To make this happen we need to send an event that says all is OK.
"""
# TODO this is needed because the aggregator retains events data across tests
aggregator.reset()
def _mocked_method_request(url, name, auth=None, params={}, request_id=1):
if name == "apiinfo.version":
return self._apiinfo_response()
elif name == "host.get":
return self._zabbix_host_response()
elif name == "problem.get":
response = self._zabbix_problem()
response['result'] = []
return response
else:
self.fail("TEST FAILED on making invalid request")
self.check.method_request = _mocked_method_request
self.check.login = lambda url, user, password: "******"
self.check.check(self.instance)
events = aggregator.events
self.assertEqual(len(events), 1)
self.assertEqual(events[0]['source_type_name'], 'Zabbix')
tags = events[0]['tags']
for tag in ['host_id:10084', 'severity:0', "triggers:[]",
"host:zabbix01.example.com", "host_name:Zabbix server"]:
if tag not in tags:
self.fail("Event does not have tag '%s', got: %s." % (tag, tags))
self.assertEqual(len(tags), 5)
def setUp(self):
"""
Initialize and patch the check, i.e.
"""
config = InitConfig({
"aws_access_key_id":
"some_key",
"aws_secret_access_key":
"some_secret",
"external_id":
"disable_external_id_this_is_unsafe",
})
self.patcher = patch("botocore.client.BaseClient._make_api_call")
self.mock_object = self.patcher.start()
self.api_results = deepcopy(API_RESULTS)
topology.reset()
aggregator.reset()
self.check = AwsTopologyCheck(self.CHECK_NAME, config, [self.instance])
state_descriptor = self.check._get_state_descriptor()
# clear the state
self.check.state_manager.clear(state_descriptor)
def results(operation_name, kwarg):
return self.api_results.get(operation_name) or {}
self.mock_object.side_effect = results
def setUp(self):
"""
Initialize and patch the check, i.e.
"""
self.check = MockedSplunkTopology(self.CHECK_NAME, {}, {},
[self.instance])
topology.reset()
aggregator.reset()
self.check.commit_state(None)
def setUp(self):
"""
Initialize and patch the check, i.e.
"""
self.check = ServicenowCheck('servicenow', {}, {}, [self.instance])
topology.reset()
aggregator.reset()
telemetry.reset()
self.check.commit_state(None)
def test_missing_relation_type_field(self, mock):
# TODO this is needed because the topology retains data across tests
aggregator.reset()
self.check.run()
service_checks = aggregator.service_checks("StaticTopology")
self.assertEqual(service_checks[0].status, 2)
self.assertEqual(service_checks[0].message,
"CSV header type not found in relation csv.")
def setUp(self):
"""
Initialize and patch the check, i.e.
"""
config = {}
self.check = AgentIntegrationSampleCheck(self.CHECK_NAME,
config,
instances=[self.instance])
# TODO this is needed because the topology retains data across tests
topology.reset()
aggregator.reset()
health.reset()
telemetry.reset()
def test_empty_relation_file(self):
config = {
'init_config': {},
'instances': [{
'type': 'csv',
'components_file': '/ignored/',
'relations_file': '/dev/null',
'delimiter': ';'
}]
}
# TODO this is needed because the topology retains data across tests
aggregator.reset()
self.check.check(config["instances"][0])
service_checks = aggregator.service_checks("StaticTopology")
self.assertEqual(service_checks[0].status, 2)
def test_zabbix_disabled_triggers(self):
"""
When there are no triggers enabled and return empty list for `trigger.get` call, then we are expecting no
problems and host will become green if it was red because there will be an event without any severity/problems.
"""
# TODO this is needed because the aggregator retains events data across tests
aggregator.reset()
def _mocked_method_request(url, name, auth=None, params={}, request_id=1):
if name == "apiinfo.version":
return self._apiinfo_response()
elif name == "host.get":
return self._zabbix_host_response()
elif name == "problem.get":
response = self._zabbix_problem()
return response
elif name == "trigger.get":
response = self._zabbix_trigger()
response['result'] = []
return response
else:
self.fail("TEST FAILED on making invalid request")
self.check.method_request = _mocked_method_request
self.check.login = lambda url, user, password: "******"
self.check.check(self.instance)
events = aggregator.events
self.assertEqual(len(events), 1)
tags = events[0]['tags']
for tag in [
'host_id:10084',
"host:zabbix01.example.com",
"host_name:Zabbix server",
"severity:0",
"triggers:[]"
]:
if tag not in tags:
self.fail("Event does not have tag '%s', got: %s." % (tag, tags))
self.assertEqual(len(tags), 5)
# check if OK service check generated
service_checks = aggregator.service_checks('Zabbix')
self.assertEqual(AgentCheck.OK, service_checks[0].status)
def test_check_invalid_initial_token(self):
"""
Splunk check should not work with invalid initial token and stop the check
"""
instance = {
'url': 'http://localhost:8089',
'authentication': {
'token_auth': {
'name': "admin",
'initial_token':
"dsfdgfhgjhkjuyr567uhfe345ythu7y6tre456sdx",
'audience': "search",
'renewal_days': 10
}
},
'component_saved_searches': [{
"name": "components",
"parameters": {}
}],
'relation_saved_searches': [],
'tags': ['mytag', 'mytag2']
}
self.check = MockedSplunkTopology(self.CHECK_NAME, {}, {}, [instance])
# Run once to initialize
assert self.check.run() == ''
aggregator.reset()
self.check.instance_data.splunk_client.invalid_token = True
assert self.check.run() == ''
msg = "Current in use authentication token is expired. Please provide a valid token in the YAML and restart " \
"the Agent"
service_checks = aggregator.service_checks(
SplunkTopology.SERVICE_CHECK_NAME)
self.assertEqual(service_checks[0].status, 2)
self.assertEqual(service_checks[0].message, msg)
def test_zabbix_problems(self):
# TODO this is needed because the aggregator retains events data across tests
aggregator.reset()
def _mocked_method_request(url, name, auth=None, params={}, request_id=1):
if name == "apiinfo.version":
return self._apiinfo_response()
elif name == "host.get":
return self._zabbix_host_response()
elif name == "problem.get":
return self._zabbix_problem()
elif name == "trigger.get":
return self._zabbix_trigger()
elif name == "event.get":
return self._zabbix_event()
else:
self.fail("TEST FAILED on making invalid request")
self.check.method_request = _mocked_method_request
self.check.login = lambda url, user, password: "******"
self.check.check(self.instance)
events = aggregator.events
self.assertEqual(len(events), 1)
self.assertEqual(events[0]['source_type_name'], 'Zabbix')
tags = events[0]['tags']
for tag in ['host_id:10084', 'severity:3',
"triggers:['Zabbix agent on {HOST.NAME} is unreachable for 5 minutes']",
"host:zabbix01.example.com", "host_name:Zabbix server"]:
if tag not in tags:
self.fail("Event does not have tag '%s', got: %s." % (tag, tags))
self.assertEqual(len(tags), 5)
def test_zabbix_acknowledge_problem(self):
"""
When there are problems, we are expecting all host components to go to yellow/red.
But acknowledging the problem should make the host components go back to green
To make this happen we need to send an event that says the problem is `acknowledged`.
"""
# TODO this is needed because the aggregator retains events data across tests
aggregator.reset()
self.event_response = {}
self.second_run = False
def _mocked_method_request(url, name, auth=None, params={}, request_id=1):
if name == "apiinfo.version":
return self._apiinfo_response()
elif name == "host.get":
return self._zabbix_host_response()
elif name == "problem.get":
response = self._zabbix_problem()
return response
elif name == "trigger.get":
response = self._zabbix_trigger()
return response
elif name == "event.get":
self.event_response = self._zabbix_event()
if not self.second_run:
# acknowledge the problem
self.event_response['result'][0]['acknowledged'] = '1'
self.second_run = True
else:
self.event_response['result'][0]['acknowledged'] = '0'
return self.event_response
else:
self.fail("TEST FAILED on making invalid request")
self.check.method_request = _mocked_method_request
self.check.login = lambda url, user, password: "******"
self.check.check(self.instance)
events = aggregator.events
self.assertEqual(len(events), 1)
tags = events[0]['tags']
for tag in [
'host_id:10084',
"host:zabbix01.example.com",
"host_name:Zabbix server",
"severity:0",
"triggers:[]"
]:
if tag not in tags:
self.fail("Event does not have tag '%s', got: %s." % (tag, tags))
self.assertEqual(len(tags), 5)
aggregator.reset()
# second run to revert the acknowledged problem to create the event again
self.check.check(self.instance)
events = aggregator.events
self.assertEqual(len(events), 1)
tags = events[0]['tags']
for tag in [
'host_id:10084',
"host:zabbix01.example.com",
"host_name:Zabbix server",
"severity:3",
"triggers:['Zabbix agent on {HOST.NAME} is unreachable for 5 minutes']"
]:
if tag not in tags:
self.fail("Event does not have tag '%s', got: %s." % (tag, tags))
self.assertEqual(len(tags), 5)
def test_zabbix_determine_most_severe_state(self):
"""
A host can have multiple active problems.
From the active problems we determine the most severe state and send that to StackState
"""
# TODO this is needed because the aggregator retains events data across tests
aggregator.reset()
def _mocked_method_request(url, name, auth=None, params={}, request_id=1):
if name == "apiinfo.version":
return self._apiinfo_response()
elif name == "host.get":
return self._zabbix_host_response()
elif name == "problem.get":
response = self._zabbix_problem()
response['result'].append({
"eventid": "100",
"source": "0",
"object": "0",
"objectid": "111",
"clock": "1549878981",
"ns": "221836547",
"r_eventid": "0",
"r_clock": "0",
"r_ns": "0",
"correlationid": "0",
"userid": "0",
"name": "My very own problem",
"acknowledged": "0",
"severity": "5",
"acknowledges": [],
"suppressed": 0
})
return response
elif name == "trigger.get":
return self._zabbix_trigger()
elif name == "event.get":
response = self._zabbix_event()
response['result'].append({
"eventid": "100",
"value": "1",
"severity": "5",
"acknowledged": "0",
"hosts": [
{
"hostid": "10084"
}
],
"relatedObject": {
"triggerid": "111",
"description": "My very own problem",
"priority": "5"
}
})
return response
else:
self.fail("TEST FAILED on making invalid request")
self.check.method_request = _mocked_method_request
self.check.login = lambda url, user, password: "******"
self.check.check(self.instance)
events = aggregator.events
self.assertEqual(len(events), 1)
self.assertEqual(events[0]['source_type_name'], 'Zabbix')
tags = events[0]['tags']
for tag in [
'host_id:10084',
'severity:5',
"triggers:['Zabbix agent on {HOST.NAME} is unreachable for 5 minutes', 'My very own problem']",
"host:zabbix01.example.com",
"host_name:Zabbix server"
]:
if tag not in tags:
self.fail("Event does not have tag '%s', got: %s." % (tag, tags))
self.assertEqual(len(tags), 5)
def solarwinds_check(test_instance):
check = SolarWindsCheck("solarwinds", {}, {}, instances=[test_instance])
yield check
aggregator.reset()
telemetry.reset()
topology.reset()
def aggregator():
from stackstate_checks.base.stubs import aggregator
aggregator.reset()
return aggregator
def setUp(self):
"""
Initialize and patch the check, i.e.
"""
self.recorder = []
method = getattr(self, self._testMethodName)
not_authorized = []
if hasattr(method, "not_authorized"):
not_authorized = method.not_authorized
events_file = None
if hasattr(method, "events_file"):
events_file = method.events_file
subdirectory = ""
if hasattr(method, "subdirectory"):
subdirectory = method.subdirectory
log_bucket_name = ""
if hasattr(method, "log_bucket_name"):
log_bucket_name = method.log_bucket_name
flowlog_bucket_name = ""
if hasattr(method, 'flowlog_bucket_name'):
flowlog_bucket_name = method.flowlog_bucket_name
use_gz = False
if hasattr(method, "gz"):
use_gz = method.gz
self.patcher = patch("botocore.client.BaseClient._make_api_call",
autospec=True)
self.extra_patch = patch(
"stackstate_checks.aws_topology.AwsTopologyCheck.must_run_full",
return_value=False)
self.mock_object = self.patcher.start()
self.extra_patch.start()
top.reset()
aggregator.reset()
init_config = InitConfig({
"aws_access_key_id":
"some_key",
"aws_secret_access_key":
"some_secret",
"external_id":
"disable_external_id_this_is_unsafe",
})
regions = self.get_region()
if not isinstance(regions, list):
regions = [regions]
instance = {
"role_arn":
"arn:aws:iam::{}:role/RoleName".format(self.get_account_id()),
"regions":
regions
}
if log_bucket_name:
instance.update({"log_bucket_name": log_bucket_name})
if flowlog_bucket_name:
instance.update({'flowlog_bucket_name': flowlog_bucket_name})
apis = []
instance.update({"apis_to_run": apis})
self.check = AwsTopologyCheck(self.CHECK_NAME, InitConfig(init_config),
[instance])
self.check.last_full_topology = datetime(2021, 5, 1, 0, 0,
0).replace(tzinfo=pytz.utc)
state_descriptor = self.check._get_state_descriptor()
# clear the state
self.check.state_manager.clear(state_descriptor)
self.mock_object.side_effect = wrapper(self,
not_authorized,
subdirectory,
use_gz,
events_file=events_file)
def setUp(self):
"""
Initialize and patch the check, i.e.
"""
method = getattr(self, self._testMethodName)
not_authorized = []
if hasattr(method, "not_authorized"):
not_authorized = method.not_authorized
cloudtrail_event = None
if hasattr(method, "cloudtrail_event"):
cloudtrail_event = method.cloudtrail_event
eventbridge_event = None
if hasattr(method, "eventbridge_event"):
eventbridge_event = method.eventbridge_event
filter = ""
if hasattr(method, "filter"):
filter = method.filter
subdirectory = ""
if hasattr(method, "subdirectory"):
subdirectory = method.subdirectory
self.patcher = patch("botocore.client.BaseClient._make_api_call",
autospec=True)
self.mock_object = self.patcher.start()
top.reset()
aggregator.reset()
init_config = InitConfig({
"aws_access_key_id":
"some_key",
"aws_secret_access_key":
"some_secret",
"external_id":
"disable_external_id_this_is_unsafe",
})
regions = self.get_region()
if not isinstance(regions, list):
regions = [regions]
instance = {
"role_arn":
"arn:aws:iam::{}:role/RoleName".format(self.get_account_id()),
"regions":
regions
}
api = self.get_api()
apis = None
if api:
if filter:
apis = [api + "|" + filter]
else:
apis = [api]
if cloudtrail_event:
apis = []
instance.update({"apis_to_run": apis})
self.check = AwsTopologyCheck(self.CHECK_NAME, InitConfig(init_config),
[instance])
self.check.last_full_topology = datetime(2021, 5, 1, 0, 0,
0).replace(tzinfo=pytz.utc)
def ignore_callback(self, *args, **kwargs):
return
self.check.get_flowlog_update = ignore_callback
if cloudtrail_event is None and eventbridge_event is None:
self.check.get_topology_update = ignore_callback
self.mock_object.side_effect = wrapper(
api,
not_authorized,
subdirectory,
event_name=cloudtrail_event,
eventbridge_event_name=eventbridge_event)
self.components_checked = 0
self.relations_checked = 0
def aggregator():
"""This fixture returns a mocked Agent aggregator with state cleared."""
__aggregator.reset()
return __aggregator
def setUp(self):
"""
Initialize and patch the check, i.e.
"""
self.recorder = []
method = getattr(self, self._testMethodName)
not_authorized = []
if hasattr(method, "not_authorized"):
not_authorized = method.not_authorized
events_file = None
if hasattr(method, "events_file"):
events_file = method.events_file
subdirectory = ""
if hasattr(method, "subdirectory"):
subdirectory = method.subdirectory
log_bucket_name = ""
if hasattr(method, "log_bucket_name"):
log_bucket_name = method.log_bucket_name
use_gz = False
if hasattr(method, "gz"):
use_gz = method.gz
self.patcher = patch("botocore.client.BaseClient._make_api_call",
autospec=True)
self.extrapatch = patch(
"stackstate_checks.aws_topology.AwsTopologyCheck.must_run_full",
return_value=False)
self.regpatch = patch(
"stackstate_checks.aws_topology.resources.ResourceRegistry.CLOUDTRAIL",
{
"test": {
"test": CollectorMock
},
"lambda.amazonaws.com": {
"PublishVersion20150331": CollectorMock,
"UpdateFunctionConfiguration20150331v2": CollectorMock
}
})
self.mock_object = self.patcher.start()
self.extrapatch.start()
self.regpatch.start()
top.reset()
aggregator.reset()
init_config = InitConfig({
"aws_access_key_id":
"some_key",
"aws_secret_access_key":
"some_secret",
"external_id":
"disable_external_id_this_is_unsafe",
})
regions = self.get_region()
if not isinstance(regions, list):
regions = [regions]
instance = {
"role_arn":
"arn:aws:iam::{}:role/RoleName".format(self.get_account_id()),
"regions":
regions,
"state": {
"last_full_topology": "2021-05-01T00:00:00"
},
}
if log_bucket_name:
instance.update({"log_bucket_name": log_bucket_name})
apis = []
instance.update({"apis_to_run": apis})
self.check = AwsTopologyCheck(self.CHECK_NAME, InitConfig(init_config),
[instance])
state_descriptor = self.check._get_state_descriptor()
# clear the state
self.check.state_manager.clear(state_descriptor)
self.mock_object.side_effect = wrapper(self,
not_authorized,
subdirectory,
use_gz,
events_file=events_file)
def setUp(self):
"""
Initialize and patch the check, i.e.
"""
method = getattr(self, self._testMethodName)
not_authorized = []
if hasattr(method, "not_authorized"):
not_authorized = method.not_authorized
cloudtrail_event = None
if hasattr(method, "cloudtrail_event"):
cloudtrail_event = method.cloudtrail_event
eventbridge_event = None
if hasattr(method, "eventbridge_event"):
eventbridge_event = method.eventbridge_event
filter = ""
if hasattr(method, "filter"):
filter = method.filter
subdirectory = ""
if hasattr(method, "subdirectory"):
subdirectory = method.subdirectory
self.patcher = patch("botocore.client.BaseClient._make_api_call",
autospec=True)
self.mock_object = self.patcher.start()
top.reset()
aggregator.reset()
init_config = InitConfig({
"aws_access_key_id":
"some_key",
"aws_secret_access_key":
"some_secret",
"external_id":
"disable_external_id_this_is_unsafe",
})
regions = self.get_region()
if not isinstance(regions, list):
regions = [regions]
instance = {
"role_arn":
"arn:aws:iam::{}:role/RoleName".format(self.get_account_id()),
"regions":
regions,
"state": {
"last_full_topology": "2021-05-01T00:00:00"
},
}
api = self.get_api()
apis = None
if api:
if filter:
apis = [api + "|" + filter]
else:
apis = [api]
if cloudtrail_event:
apis = []
instance.update({"apis_to_run": apis})
self.check = AwsTopologyCheck(self.CHECK_NAME, InitConfig(init_config),
[instance])
state_descriptor = self.check._get_state_descriptor()
# clear the state
self.check.state_manager.clear(state_descriptor)
self.mock_object.side_effect = wrapper(
api,
not_authorized,
subdirectory,
event_name=cloudtrail_event,
eventbridge_event_name=eventbridge_event)
self.components_checked = 0
self.relations_checked = 0
