def test_get(self):
def get(url, params, **kwargs):
pass
with patch.object(requests, 'get', side_effects=get) as mock_get:
test_path = 'test_path'
client = Client(TEST_API_URL)
client.get(test_path)
self.assertTrue(mock_get.called)
expected_url_call = TEST_API_URL + '/' + test_path
mock_get.assert_called_with(expected_url_call, headers=AUTH_HEADERS)
def test_delete(self):
def delete(url, **kwargs):
pass
with patch.object(requests, 'delete',
side_effects=delete) as mock_delete:
test_path = 'test_path'
client = Client(TEST_API_URL)
client.delete(test_path)
self.assertTrue(mock_delete.called)
expected_url_call = TEST_API_URL + '/' + test_path
mock_delete.assert_called_with(expected_url_call, headers=AUTH_HEADERS)
def test_create_fake_moira_trigger_and_alerting_prefix_exists_token_not_exists(
self):
valid_config = 'tests/valid_config_second.yaml'
data = read_from_file(valid_config)
trigger_count = len(data.triggers)
client = Client(self.url)
with patch.object(client, 'get',
return_value={'list':
[]}), patch.object(client,
'put',
return_value={}):
trigger_manager = TriggerManager(client)
tag_manager = TagManager(client)
contact_manager = ContactManager(client)
subscription_manager = SubscriptionManager(client)
with patch.object(
self.moira, '_trigger', return_value=trigger_manager
) as _trigger_mock, patch.object(
self.moira, '_contact', return_value=contact_manager
) as _contact_mock, patch.object(
self.moira, '_tag',
return_value=tag_manager) as _tag_mock, patch.object(
self.moira,
'_subscription',
return_value=subscription_manager), patch.object(
self.redis, 'exists',
return_value=0) as _redis_exists, patch.object(
self.redis, 'sadd',
return_value=1) as _redis_sadd:
_contact_mock.fetch_by_current_user.return_value = []
_contact_mock.add = Mock(
side_effect=lambda value, contact_type: Contact(
id=str(uuid.uuid4()), type=contact_type, value=value))
trigger_orig = MoiraAlert(self.moira, self.redis, self.token)
trigger_orig.setup(data)
args, kwargs = _trigger_mock.create.call_args_list[0]
kwargs.pop('name')
count_contacts_in_alerting_block = self._get_count_key_by_dict(
data.alerting, 'contacts')
count_contacts_in_alerting_block += 2 # + 2 contacts from escalations
self.assertTrue(_tag_mock.fetch_assigned_triggers_by_tags.called)
self.assertDictKeysEqual(
{
k: v
for k, v in data.triggers[0].to_custom_dict().items()
if k not in ('name', )
},
kwargs,
)
self.assertTrue(_contact_mock.add.called)
self.assertTrue(_trigger_mock.create.called)
self.assertEqual(_contact_mock.add.call_count,
count_contacts_in_alerting_block)
self.assertEqual(_trigger_mock.create.call_count, trigger_count)
self.assertEqual(_redis_exists.call_count, 1)
self.assertEqual(_redis_sadd.call_count, trigger_count)
def test_fetch_assigned_triggers(self):
client = Client(self.api_url)
tag_manager = TagManager(client)
extra_data = {'key': 'value'}
tag_name = 'tag_name'
subscription_id = '3c01399e-1d40-46dd-934f-318e8255fd3e'
trigger_id = '123'
return_value = {
'list': [{
'data':
extra_data,
'name':
tag_name,
'subscriptions': [{
'contacts': ['1'],
'enabled':
True,
'id':
subscription_id,
'days': [{
'name': 'Mon',
'enabled': True
}, {
'name': 'Tue',
'enabled': True
}, {
'name': 'Wed',
'enabled': True
}, {
'name': 'Thu',
'enabled': True
}, {
'name': 'Fri',
'enabled': True
}, {
'name': 'Sat',
'enabled': True
}, {
'name': 'Sun',
'enabled': True
}],
'endOffset':
1439,
'startOffset':
0,
'tzOffset':
-180
}],
'triggers': [trigger_id]
}]
}
with patch.object(client, 'get',
return_value=return_value) as get_mock:
triggers = tag_manager.fetch_assigned_triggers(tag_name)
self.assertTrue(get_mock.called)
get_mock.assert_called_with('trigger/')
self.assertEqual(1, len(triggers))
def test_put(self):
def put(url, data, **kwargs):
pass
with patch.object(requests, 'put', side_effects=put) as mock_put:
test_path = 'test_path'
test_data = {'test': 'test'}
client = Client(TEST_API_URL)
client.put(test_path, data=test_data)
self.assertTrue(mock_put.called)
expected_url_call = TEST_API_URL + '/' + test_path
mock_put.assert_called_with(expected_url_call,
data=test_data,
headers=AUTH_HEADERS)
def test_stats(self):
client = Client(self.api_url)
tag_manager = TagManager(client)
tag_name = 'tag_name'
subscription_id = '3c01399e-1d40-46dd-934f-318e8255fd3e'
return_value = {
'list': [{
'name':
tag_name,
'subscriptions': [{
'tags': ['test'],
'contacts': ['3c01399e-1d40-46dd-934f-318e8255fd3e'],
'enabled':
True,
'id':
subscription_id,
'days': [{
'name': 'Mon',
'enabled': True
}, {
'name': 'Tue',
'enabled': True
}, {
'name': 'Wed',
'enabled': True
}, {
'name': 'Thu',
'enabled': True
}, {
'name': 'Fri',
'enabled': True
}, {
'name': 'Sat',
'enabled': True
}, {
'name': 'Sun',
'enabled': True
}],
'endOffset':
1439,
'startOffset':
0,
'tzOffset':
0
}],
'triggers': []
}]
}
with patch.object(client, 'get',
return_value=return_value) as get_mock:
stats = tag_manager.stats()
self.assertTrue(get_mock.called)
self.assertEqual(1, len(stats))
self.assertEqual(tag_name, stats[0].name)
self.assertEqual(1, len(stats[0].subscriptions))
self.assertEqual(subscription_id, stats[0].subscriptions[0].id)
def test_fetch_all(self):
client = Client(self.api_url)
subscription_manager = SubscriptionManager(client)
with patch.object(client, 'get', return_value={'list': []}) as get_mock:
subscription_manager.fetch_all()
self.assertTrue(get_mock.called)
get_mock.assert_called_with('subscription')
def test_fetch_all(self):
client = Client(self.api_url)
contact_manager = ContactManager(client)
with patch.object(client, 'get', return_value={'list': []}) as get_mock:
contact_manager.fetch_all()
self.assertTrue(get_mock.called)
get_mock.assert_called_with('contact')
def test_get_notifier_state(self):
client = Client(self.api_url)
health_manager = HealthManager(client)
with patch.object(client, 'get', return_value={'state': 'OK'}) as get_mock:
health_manager.get_notifier_state()
self.assertTrue(get_mock.called)
get_mock.assert_called_with('health/notifier')
def test_get_invalid_response(self):
def get(url, params, **kwargs):
return FakeResponse()
response = FakeResponse()
with patch.object(requests,
'get',
side_effects=get,
return_value=response) as mock_get:
test_path = 'test_path'
client = Client(TEST_API_URL)
with self.assertRaises(InvalidJSONError):
client.get(test_path)
self.assertTrue(mock_get.called)
expected_url_call = TEST_API_URL + '/' + test_path
mock_get.assert_called_with(expected_url_call, headers=AUTH_HEADERS)
def test_delete_all_bad_response(self):
client = Client(self.api_url)
notification_manager = NotificationManager(client)
with patch.object(client, 'delete') as delete_mock:
res = notification_manager.delete_all()
self.assertTrue(delete_mock.called)
self.assertFalse(res)
delete_mock.assert_called_with('notification/all')
def test_fetch_all_bad_response(self):
client = Client(self.api_url)
contact_manager = ContactManager(client)
with patch.object(client, 'get', return_value={}) as get_mock:
with self.assertRaises(ResponseStructureError):
contact_manager.fetch_all()
self.assertTrue(get_mock.called)
get_mock.assert_called_with('contact')
def test_fetch_all(self):
client = Client(self.api_url)
trigger_manager = TriggerManager(client)
with patch.object(client, 'get', return_value={'list':
[]}) as get_mock:
trigger_manager.fetch_all()
self.assertTrue(get_mock.called)
get_mock.assert_called_with('trigger/')
def test_get_notifier_state_bad_response(self):
client = Client(self.api_url)
health_manager = HealthManager(client)
with patch.object(client, 'get', return_value={}) as get_mock:
with self.assertRaises(ResponseStructureError):
health_manager.get_notifier_state()
self.assertTrue(get_mock.called)
get_mock.assert_called_with('health/notifier')
def test_delete_invalid_response(self):
def delete(url, **kwargs):
return FakeResponse()
response = FakeResponse()
with patch.object(requests,
'delete',
side_effects=delete,
return_value=response) as mock_delete:
test_path = 'test_path'
client = Client(TEST_API_URL)
with self.assertRaises(InvalidJSONError):
client.delete(test_path)
self.assertTrue(mock_delete.called)
expected_url_call = TEST_API_URL + '/' + test_path
mock_delete.assert_called_with(expected_url_call, headers=AUTH_HEADERS)
def test_delete_fail(self):
client = Client(self.api_url)
contact_manager = ContactManager(client)
contact_id = '1'
with patch.object(client, 'delete') as delete_mock:
res = contact_manager.delete(contact_id)
self.assertTrue(delete_mock.called)
self.assertFalse(res)
delete_mock.assert_called_with('contact/' + contact_id)
def test_delete(self):
client = Client(self.api_url)
contact_manager = ContactManager(client)
contact_id = '1'
with patch.object(client, 'delete', new=Mock(side_effect=InvalidJSONError(b''))) as delete_mock:
res = contact_manager.delete(contact_id)
self.assertTrue(delete_mock.called)
self.assertTrue(res)
delete_mock.assert_called_with('contact/' + contact_id)
def test_delete(self):
client = Client(self.api_url)
tag_manager = TagManager(client)
tag = 'tag'
with patch.object(client, 'delete') as delete_mock:
res = tag_manager.delete(tag)
self.assertTrue(delete_mock.called)
self.assertTrue(res)
delete_mock.assert_called_with('tag/' + tag)
def test_delete_fail(self):
client = Client(self.api_url)
subscription_manager = SubscriptionManager(client)
subscription_id = '1'
with patch.object(client, 'delete') as delete_mock:
res = subscription_manager.delete(subscription_id)
self.assertTrue(delete_mock.called)
self.assertFalse(res)
delete_mock.assert_called_with('subscription/' + subscription_id)
def test_delete_all(self):
client = Client(self.api_url)
notification_manager = NotificationManager(client)
with patch.object(
client, 'delete',
new=Mock(side_effect=InvalidJSONError(b''))) as delete_mock:
res = notification_manager.delete_all()
self.assertTrue(delete_mock.called)
self.assertTrue(res)
delete_mock.assert_called_with('notification/all')
def test_delete(self):
client = Client(self.api_url)
trigger_manager = TriggerManager(client)
trigger_id = '1'
with patch.object(client, 'delete') as delete_mock:
res = trigger_manager.delete(trigger_id)
self.assertTrue(delete_mock.called)
self.assertTrue(res)
delete_mock.assert_called_with('trigger/' + trigger_id)
def test_test_fail(self):
client = Client(self.api_url)
subscription_manager = SubscriptionManager(client)
subscription_id = '1'
with patch.object(client, 'put') as put_mock:
res = subscription_manager.test(subscription_id)
self.assertTrue(put_mock.called)
self.assertFalse(res)
put_mock.assert_called_with('subscription/' + subscription_id + '/test')
def test_test(self):
client = Client(self.api_url)
subscription_manager = SubscriptionManager(client)
subscription_id = '1'
with patch.object(client, 'put', new=Mock(side_effect=InvalidJSONError(b''))) as put_mock:
res = subscription_manager.test(subscription_id)
self.assertTrue(put_mock.called)
self.assertTrue(res)
put_mock.assert_called_with('subscription/' + subscription_id + '/test')
def test_fetch_all(self):
client = Client(self.api_url)
contact_manager = NotificationManager(client)
with patch.object(client, 'get', return_value={'list':
[]}) as get_mock:
contact_manager.fetch_all()
params = {'end': -1, 'start': 0}
self.assertTrue(get_mock.called)
get_mock.assert_called_with('notification', params=params)
def test_enable_notifications(self):
client = Client(self.api_url)
health_manager = HealthManager(client)
with patch.object(client, 'put', return_value={'state': 'OK'}) as put_mock:
res = health_manager.enable_notifications()
data = {'state': 'OK'}
self.assertTrue(put_mock.called)
self.assertTrue(res)
put_mock.assert_called_with('health/notifier', json=data)
def test_fetch_all_bad_response(self):
client = Client(self.api_url)
contact_manager = NotificationManager(client)
with patch.object(client, 'get', return_value={}) as get_mock:
with self.assertRaises(ResponseStructureError):
contact_manager.fetch_all()
params = {'end': -1, 'start': 0}
self.assertTrue(get_mock.called)
get_mock.assert_called_with('notification', params=params)
def test_delete_fail(self):
client = Client(self.api_url)
pattern_manager = PatternManager(client)
pattern_id = '1'
with patch.object(client, 'delete') as delete_mock:
res = pattern_manager.delete(pattern_id)
self.assertTrue(delete_mock.called)
self.assertFalse(res)
delete_mock.assert_called_with('pattern/' + pattern_id)
def test_enable_notifications_bad_response(self):
client = Client(self.api_url)
health_manager = HealthManager(client)
with patch.object(client, 'put') as put_mock:
with self.assertRaises(ResponseStructureError):
health_manager.enable_notifications()
data = {'state': 'OK'}
self.assertTrue(put_mock.called)
put_mock.assert_called_with('health/notifier', json=data)
def test_delete(self):
client = Client(self.api_url)
subscription_manager = SubscriptionManager(client)
subscription_id = '1'
with patch.object(client, 'delete', new=Mock(side_effect=InvalidJSONError(b''))) as delete_mock:
res = subscription_manager.delete(subscription_id)
self.assertTrue(delete_mock.called)
self.assertTrue(res)
delete_mock.assert_called_with('subscription/' + subscription_id)
def test_delete(self):
client = Client(self.api_url)
pattern_manager = PatternManager(client)
pattern_id = '1'
with patch.object(
client, 'delete',
new=Mock(side_effect=InvalidJSONError(b''))) as delete_mock:
res = pattern_manager.delete(pattern_id)
self.assertTrue(delete_mock.called)
self.assertTrue(res)
delete_mock.assert_called_with('pattern/' + pattern_id)
