def test_zmon_headers(monkeypatch):
zmon = Zmon(URL, token=TOKEN)
assert zmon.session.headers['Authorization'] == 'Bearer {}'.format(TOKEN)
zmon = Zmon(URL, username='******', password='******')
assert zmon.session.auth == ('user1', 'password')
zmon = Zmon(URL, token=TOKEN)
assert zmon.session.headers['User-Agent'] == client.ZMON_USER_AGENT
zmon = Zmon(URL, token=TOKEN, user_agent='zmon-client-wrapper/0.5')
assert zmon.session.headers['User-Agent'] == 'zmon-client-wrapper/0.5'
zmon = Zmon(URL, token=TOKEN, verify=False)
assert zmon.session.verify is False
def test_zmon_add_entity(monkeypatch, e, result):
fail = True
if type(result) is dict:
fail = False
put = MagicMock()
resp = MagicMock()
resp.ok = True
put.return_value = resp
monkeypatch.setattr('requests.Session.put', put)
zmon = Zmon(URL, token=TOKEN)
if fail:
with pytest.raises(result):
zmon.add_entity(e)
else:
r = zmon.add_entity(e)
assert r.ok is True
put.assert_called_with(zmon.endpoint(client.ENTITIES,
trailing_slash=False),
data=json.dumps(result),
timeout=DEFAULT_TIMEOUT)
def test_zmon_switch_active_user(monkeypatch, success):
del_success, put_success = success
delete = MagicMock()
delete.return_value.ok = del_success
if not del_success:
delete.return_value.raise_for_status.side_effect = RuntimeError
put = MagicMock()
put.return_value.ok = put_success
put.return_value.text = '1'
if not put_success:
put.return_value.raise_for_status.side_effect = RuntimeError
monkeypatch.setattr('requests.Session.delete', delete)
monkeypatch.setattr('requests.Session.put', put)
zmon = Zmon(URL, token=TOKEN)
if not del_success or not put_success:
with pytest.raises(RuntimeError):
zmon.switch_active_user('g', 'u')
else:
switched = zmon.switch_active_user('g', 'u')
assert switched is True
delete.assert_called_with(zmon.endpoint(client.GROUPS, 'g', 'active'))
if del_success:
put.assert_called_with(zmon.endpoint(client.GROUPS, 'g', 'active',
'u'),
timeout=DEFAULT_TIMEOUT)
def test_zmon_view_urls(monkeypatch):
zmon = Zmon(URL, token=TOKEN)
# Checks
check = {'id': 1}
assert '{}#/check-definitions/view/1/'.format(
URL) == zmon.check_definition_url(check)
# Alerts
alert = {'id': 1}
assert '{}#/alert-details/1/'.format(URL) == zmon.alert_details_url(alert)
# Dashboard
dashboard_id = 1
assert '{}#/dashboards/views/1/'.format(URL) == zmon.dashboard_url(
dashboard_id)
# Token
token = '1234'
assert '{}/tv/1234/'.format(URL) == zmon.token_login_url(token)
# Grafana
dashboard = {'id': 'grafana-dash'}
assert '{}/visualization/dashboard/grafana-dash'.format(
URL) == zmon.grafana_dashboard_url(dashboard)
def validate_sli_source(config, source, ignore_keys=False):
if 'zmon_url' not in config:
config = set_config_file()
zmon = Zmon(config['zmon_url'], token=zign.api.get_token('uid', ['uid']))
check_id = int(source['check_id'])
try:
check = zmon.get_check_definition(check_id)
except Exception:
raise SLRClientError(
'Check definition {} does not seem to exist!'.format(check_id))
alerts = zmon.get_alert_definitions()
filtered = [
alert for alert in alerts if alert['check_definition_id'] == check_id
]
if not filtered:
raise SLRClientError(
'Check definition has no alerts. Please create an Alert for this check on ZMON {}'
.format(zmon.check_definition_url(check)))
if ignore_keys:
return
keys = [k for k in source['keys'] if '.*' not in k]
if not keys:
# Do not validate keys if we have wildcards
return
sli_exists = False
sample_data = set()
for alert in filtered:
if sli_exists:
break
alert_data = zmon.get_alert_data(alert['id'])
values = {
v['entity']: v['results'][0]['value']
for v in alert_data if len(v['results'])
}
for entity, data in values.items():
if type(data) is dict:
flattened = flatten(data)
data_keys = flattened.keys()
sample_data.update(list(data_keys))
if not (set(keys) - set(data_keys)):
sli_exists = True
break
if not sli_exists:
raise SLRClientError(
'Some SLI keys do not exist. Please check the data returned from the check and the corresponding keys '
'in the SLI source. Found the following keys returned from check {}: {}'
.format(check_id, set(sample_data)))
def get_client(config):
verify = config.get('verify', True)
if 'user' in config and 'password' in config:
return Zmon(config['url'],
username=config['user'],
password=config['password'],
verify=verify)
elif os.environ.get('ZMON_TOKEN'):
return Zmon(config['url'],
token=os.environ.get('ZMON_TOKEN'),
verify=verify)
elif 'token' in config:
return Zmon(config['url'], token=config['token'], verify=verify)
raise RuntimeError(
'Failed to intitialize ZMON client. Invalid configuration!')
def get_clients(zmon_url, verify=True) -> Zmon:
"""Return Pykube and Zmon client instances as a tuple."""
# Get token if set as ENV variable. This is useful in development.
zmon_token = os.getenv('ZMON_AGENT_TOKEN')
if not zmon_token:
zmon_token = tokens.get('uid')
return Zmon(zmon_url, token=zmon_token, verify=verify)
def test_zmon_set_name(monkeypatch):
put = MagicMock()
put.return_value = MagicMock()
monkeypatch.setattr('requests.Session.put', put)
zmon = Zmon(URL, token=TOKEN)
zmon.add_phone('user1@something', 'user1')
put.assert_called_with(zmon.endpoint(client.GROUPS, 'user1@something', client.PHONE, 'user1'))
def test_zmon_get_alert_defintions(monkeypatch, resp, result):
get = MagicMock()
get.return_value.json.return_value = resp
monkeypatch.setattr('requests.Session.get', get)
zmon = Zmon(URL, token=TOKEN)
res = zmon.get_alert_definitions()
assert res == result
get.assert_called_with(zmon.endpoint(client.ACTIVE_ALERT_DEF))
def test_zmon_add_member(monkeypatch):
put = MagicMock()
put.return_value.text = '1'
monkeypatch.setattr('requests.Session.put', put)
zmon = Zmon(URL, token=TOKEN)
added = zmon.add_member('group', 'user1')
assert added is True
put.assert_called_with(zmon.endpoint(client.GROUPS, 'group', client.MEMBER, 'user1'))
def test_zmon_add_phone(monkeypatch):
put = MagicMock()
put.return_value.text = '1'
monkeypatch.setattr('requests.Session.put', put)
zmon = Zmon(URL, token=TOKEN)
added = zmon.add_phone('user1@something', '12345')
assert added is True
put.assert_called_with(zmon.endpoint(client.GROUPS, 'user1@something', client.PHONE, '12345'))
def test_zmon_remove_phone(monkeypatch):
delete = MagicMock()
delete.return_value.text = '1'
monkeypatch.setattr('requests.Session.delete', delete)
zmon = Zmon(URL, token=TOKEN)
deleted = zmon.remove_phone('user1@something', '12345')
assert deleted is True
delete.assert_called_with(zmon.endpoint(client.GROUPS, 'user1@something', client.PHONE, '12345'))
def test_zmon_delete_check_definition(monkeypatch, result):
delete = MagicMock()
delete.return_value.ok = result
monkeypatch.setattr('requests.Session.delete', delete)
zmon = Zmon(URL, token=TOKEN)
res = zmon.delete_check_definition(1)
assert res.ok is result
delete.assert_called_with(zmon.endpoint(client.CHECK_DEF, 1))
def test_zmon_remove_member(monkeypatch):
delete = MagicMock()
delete.return_value.text = '1'
monkeypatch.setattr('requests.Session.delete', delete)
zmon = Zmon(URL, token=TOKEN)
deleted = zmon.remove_member('group', 'user1')
assert deleted is True
delete.assert_called_with(zmon.endpoint(client.GROUPS, 'group', client.MEMBER, 'user1'))
def test_zmon_delete_entity(monkeypatch, result):
delete = MagicMock()
delete.return_value.text = result
monkeypatch.setattr('requests.Session.delete', delete)
zmon = Zmon(URL, token=TOKEN)
deleted = zmon.delete_entity(1)
assert deleted is (result == '1')
delete.assert_called_with(zmon.endpoint(client.ENTITIES, 1))
def test_zmon_get_dashboard(monkeypatch):
get = MagicMock()
result = {'id': 1, 'type': 'dummy'}
get.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.get', get)
zmon = Zmon(URL, token=TOKEN)
res = zmon.get_dashboard(1)
assert res == result
get.assert_called_with(zmon.endpoint(client.DASHBOARD, 1))
def test_zmon_get_token(monkeypatch):
post = MagicMock()
result = '1111'
post.return_value.text = result
monkeypatch.setattr('requests.Session.post', post)
zmon = Zmon(URL, token=TOKEN)
check = zmon.get_onetime_token()
assert check == result
post.assert_called_with(zmon.endpoint(client.TOKENS), json={})
def test_zmon_get_alert_defintion(monkeypatch):
get = MagicMock()
result = {'id': 1, 'type': 'dummy'}
get.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.get', get)
zmon = Zmon(URL, token=TOKEN)
check = zmon.get_alert_definition(1)
assert check == result
get.assert_called_with(zmon.endpoint(client.ALERT_DEF, 1))
def test_zmon_alert_data(monkeypatch):
get = MagicMock()
result = {'entity-1': []}
get.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.get', get)
zmon = Zmon(URL, token=TOKEN)
check = zmon.get_alert_data(1)
assert check == result
get.assert_called_with(zmon.endpoint(client.ALERT_DATA, 1, 'all-entities'))
def test_zmon_get_groups(monkeypatch):
get = MagicMock()
result = [1, 2, 3]
get.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.get', get)
zmon = Zmon(URL, token=TOKEN)
check = zmon.get_groups()
assert check == result
get.assert_called_with(zmon.endpoint(client.GROUPS))
def test_zmon_get_grafana_dashboard(monkeypatch):
get = MagicMock()
result = {'dashboard': {}}
get.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.get', get)
zmon = Zmon(URL, token=TOKEN)
check = zmon.get_grafana_dashboard(1)
assert check == result
get.assert_called_with(zmon.endpoint(client.GRAFANA, 1))
def test_zmon_update_dashboard(monkeypatch, d):
post = MagicMock()
result = 1
post.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.post', post)
zmon = Zmon(URL, token=TOKEN)
res = zmon.update_dashboard(d)
assert res == result
url = zmon.endpoint(client.DASHBOARD, 1) if d['id'] else zmon.endpoint(client.DASHBOARD)
post.assert_called_with(url, json=d)
def validate_sli(config, data_source):
if 'zmon_url' not in config:
config = set_config_file()
zmon = Zmon(config['zmon_url'], token=zign.api.get_token('uid', ['uid']))
check_id = int(data_source['definition']['check_id'])
try:
zmon.get_check_definition(check_id)
except:
raise SLRClientError(
'Check definition {} does not seem to exist!'.format(check_id))
alerts = zmon.get_alert_definitions()
filtered = [
alert for alert in alerts if alert['check_definition_id'] == check_id
]
if not filtered:
raise SLRClientError(
'Check definition has no alerts. Please create an Alert for this check on ZMON.'
)
keys = data_source['definition']['keys']
sli_exists = False
sample_data = {}
for alert in filtered:
if sli_exists:
break
alert_data = zmon.get_alert_data(alert['id'])
values = {
v['entity']: v['results'][0]['value']
for v in alert_data if len(v['results'])
}
for entity, data in values.items():
if type(data) is dict:
data_keys = data.keys()
if data_keys:
sample_data = data_keys
if not (set(keys) - set(data_keys)):
sli_exists = True
break
if not sli_exists:
raise SLRClientError(
'Some SLI keys do not exist. Please check the data returned from the check and the corresponding keys '
'in the data-source. Found the following keys returned from check {}: {}'
.format(check_id, set(sample_data)))
def test_zmon_status(monkeypatch):
get = MagicMock()
result = {'status': 'success'}
get.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.get', get)
zmon = Zmon(URL, token=TOKEN)
status = zmon.status()
assert status == result
get.assert_called_with(zmon.endpoint(client.STATUS))
def test_zmon_get_entities(monkeypatch, q, result):
get = MagicMock()
get.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.get', get)
zmon = Zmon(URL, token=TOKEN)
res = zmon.get_entities(query=q)
assert res == result
params = {'query': json.dumps(q)} if q else None
get.assert_called_with(zmon.endpoint(client.ENTITIES), params=params)
def test_zmon_get_entity(monkeypatch):
get = MagicMock()
result = {'id': 1, 'type': 'dummy'}
get.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.get', get)
zmon = Zmon(URL, token=TOKEN)
res = zmon.get_entity(1)
assert res == result
get.assert_called_with(zmon.endpoint(client.ENTITIES, 1, trailing_slash=False))
def test_zmon_delete_alert_definition(monkeypatch):
delete = MagicMock()
result = {'status': 'success'}
delete.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.delete', delete)
zmon = Zmon(URL, token=TOKEN)
res = zmon.delete_alert_definition(1)
assert res == result
delete.assert_called_with(zmon.endpoint(client.ALERT_DEF, 1))
def test_zmon_search(monkeypatch):
get = MagicMock()
result = {'alerts': []}
get.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.get', get)
zmon = Zmon(URL, token=TOKEN)
q = 'health check'
search = zmon.search(q)
assert search == result
get.assert_called_with(zmon.endpoint(client.SEARCH), params={'query': q})
def test_zmon_list_tokens(monkeypatch):
get = MagicMock()
result = [1, 2, 3]
get.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.get', get)
zmon = Zmon(URL, token=TOKEN)
check = zmon.list_onetime_tokens()
assert check == result
get.assert_called_with(zmon.endpoint(client.TOKENS),
timeout=DEFAULT_TIMEOUT)
def test_zmon_create_downtime(monkeypatch, d, result):
fail = True
if type(result) is dict:
fail = False
post = MagicMock()
post.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.post', post)
zmon = Zmon(URL, token=TOKEN)
if fail:
with pytest.raises(result):
zmon.create_downtime(d)
else:
check = zmon.create_downtime(d)
assert check == result
post.assert_called_with(zmon.endpoint(client.DOWNTIME), json=d)
