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_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 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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)
def test_zmon_update_check_defintion(monkeypatch, c, skip, 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.update_check_definition(c)
else:
check = zmon.update_check_definition(c, skip_validation=skip)
assert check == result
post.assert_called_with(zmon.endpoint(client.CHECK_DEF), json=c)
def test_zmon_update_alert_defintion(monkeypatch, a, result):
fail = True
if type(result) is dict:
fail = False
put = MagicMock()
put.return_value.json.return_value = result
monkeypatch.setattr('requests.Session.put', put)
zmon = Zmon(URL, token=TOKEN)
if fail:
with pytest.raises(result):
zmon.update_alert_definition(a)
else:
check = zmon.update_alert_definition(a)
assert check == result
put.assert_called_with(zmon.endpoint(client.ALERT_DEF, a['id']), json=a)
def test_zmon_update_grafana_dashboard(monkeypatch, g, 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.update_grafana_dashboard(g)
else:
check = zmon.update_grafana_dashboard(g)
assert check == result
post.assert_called_with(zmon.endpoint(client.GRAFANA), json=g)
def test_zmon_search_team(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'
teams = ['team-1', 'team-2']
search = zmon.search(q, teams=teams)
assert search == result
get.assert_called_with(zmon.endpoint(client.SEARCH),
params={
'query': q,
'teams': 'team-1,team-2'
},
timeout=DEFAULT_TIMEOUT)
def test_zmon_get_check_defintion(monkeypatch, text, result):
get = MagicMock()
get.return_value.text = text
get.return_value.json.return_value = result
if type(result) != dict:
get.return_value.raise_for_status.side_effect = result
monkeypatch.setattr('requests.Session.get', get)
zmon = Zmon(URL, token=TOKEN)
if type(result) == dict:
res = zmon.get_check_definition(1)
assert res == result
else:
with pytest.raises(result):
zmon.get_check_definition(1)
get.assert_called_with(zmon.endpoint(client.CHECK_DEF, 1))
def test_zmon_create_alert_defintion(monkeypatch, a, 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_alert_definition(a)
else:
check = zmon.create_alert_definition(a)
assert check == result
post.assert_called_with(zmon.endpoint(client.ALERT_DEF),
json=a,
timeout=DEFAULT_TIMEOUT)
