Ejemplo n.º 1
0
class TestPagerDutyIncidentOutput(object):
    """Test class for PagerDutyIncidentOutput"""
    DESCRIPTOR = 'unit_test_pagerduty-incident'
    SERVICE = 'pagerduty-incident'
    CREDS = {
        'api': 'https://api.pagerduty.com',
        'token': 'mocked_token',
        'service_name': 'mocked_service_name',
        'service_id': 'mocked_service_id',
        'escalation_policy': 'mocked_escalation_policy',
        'escalation_policy_id': 'mocked_escalation_policy_id',
        'email_from': '*****@*****.**',
        'integration_key': 'mocked_key'
    }

    def setup(self):
        """Setup before each method"""
        self._dispatcher = PagerDutyIncidentOutput(REGION, ACCOUNT_ID,
                                                   FUNCTION_NAME, None)
        self._dispatcher._base_url = self.CREDS['api']
        remove_temp_secrets()
        output_name = self._dispatcher.output_cred_name(self.DESCRIPTOR)
        put_mock_creds(output_name, self.CREDS,
                       self._dispatcher.secrets_bucket, REGION, KMS_ALIAS)

    def test_get_default_properties(self):
        """PagerDutyIncidentOutput - Get Default Properties"""
        props = self._dispatcher._get_default_properties()
        assert_equal(len(props), 1)
        assert_equal(props['api'], 'https://api.pagerduty.com')

    def test_get_endpoint(self):
        """PagerDutyIncidentOutput - Get Endpoint"""
        endpoint = self._dispatcher._get_endpoint(self.CREDS['api'],
                                                  'testtest')
        assert_equal(endpoint, 'https://api.pagerduty.com/testtest')

    @patch('requests.get')
    def test_check_exists_get_id(self, get_mock):
        """PagerDutyIncidentOutput - Check Exists Get ID"""
        # GET /check
        get_mock.return_value.status_code = 200
        json_check = {'check': [{'id': 'checked_id'}]}
        get_mock.return_value.json.return_value = json_check

        checked = self._dispatcher._check_exists('filter', 'http://mock_url',
                                                 'check')
        assert_equal(checked, 'checked_id')

    @patch('requests.get')
    def test_check_exists_get_id_fail(self, get_mock):
        """PagerDutyIncidentOutput - Check Exists Get Id Fail"""
        get_mock.return_value.status_code = 200
        get_mock.return_value.json.return_value = dict()

        checked = self._dispatcher._check_exists('filter', 'http://mock_url',
                                                 'check')
        assert_false(checked)

    @patch('requests.get')
    def test_check_exists_no_get_id(self, get_mock):
        """PagerDutyIncidentOutput - Check Exists No Get Id"""
        # GET /check
        get_mock.return_value.status_code = 200
        json_check = {'check': [{'id': 'checked_id'}]}
        get_mock.return_value.json.return_value = json_check

        assert_true(
            self._dispatcher._check_exists('filter', 'http://mock_url',
                                           'check', False))

    @patch('requests.get')
    def test_user_verify_success(self, get_mock):
        """PagerDutyIncidentOutput - User Verify Success"""
        get_mock.return_value.status_code = 200
        json_check = {'users': [{'id': 'verified_user_id'}]}
        get_mock.return_value.json.return_value = json_check

        user_verified = self._dispatcher._user_verify('valid_user')
        assert_equal(user_verified['id'], 'verified_user_id')
        assert_equal(user_verified['type'], 'user_reference')

    @patch('requests.get')
    def test_user_verify_fail(self, get_mock):
        """PagerDutyIncidentOutput - User Verify Fail"""
        get_mock.return_value.status_code = 200
        json_check = {'not_users': [{'not_id': 'verified_user_id'}]}
        get_mock.return_value.json.return_value = json_check

        user_verified = self._dispatcher._user_verify('valid_user')
        assert_false(user_verified)

    @patch('requests.get')
    def test_policy_verify_success_no_default(self, get_mock):
        """PagerDutyIncidentOutput - Policy Verify Success (No Default)"""
        # GET /escalation_policies
        get_mock.return_value.status_code = 200
        json_check = {'escalation_policies': [{'id': 'good_policy_id'}]}
        get_mock.return_value.json.return_value = json_check

        policy_verified = self._dispatcher._policy_verify('valid_policy', '')
        assert_equal(policy_verified['id'], 'good_policy_id')
        assert_equal(policy_verified['type'], 'escalation_policy_reference')

    @patch('requests.get')
    def test_policy_verify_success_default(self, get_mock):
        """PagerDutyIncidentOutput - Policy Verify Success (Default)"""
        # GET /escalation_policies
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[200, 200])
        json_check_bad = {'no_escalation_policies': [{'id': 'bad_policy_id'}]}
        json_check_good = {'escalation_policies': [{'id': 'good_policy_id'}]}
        get_mock.return_value.json.side_effect = [
            json_check_bad, json_check_good
        ]

        policy_verified = self._dispatcher._policy_verify(
            'valid_policy', 'default_policy')
        assert_equal(policy_verified['id'], 'good_policy_id')
        assert_equal(policy_verified['type'], 'escalation_policy_reference')

    @patch('requests.get')
    def test_policy_verify_fail_default(self, get_mock):
        """PagerDutyIncidentOutput - Policy Verify Fail (Default)"""
        # GET /not_escalation_policies
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[400, 400])
        json_check_bad = {'escalation_policies': [{'id': 'bad_policy_id'}]}
        json_check_bad_default = {
            'escalation_policies': [{
                'id': 'good_policy_id'
            }]
        }
        get_mock.return_value.json.side_effect = [
            json_check_bad, json_check_bad_default
        ]

        assert_false(
            self._dispatcher._policy_verify('valid_policy', 'default_policy'))

    @patch('requests.get')
    def test_policy_verify_fail_no_default(self, get_mock):
        """PagerDutyIncidentOutput - Policy Verify Fail (No Default)"""
        # GET /not_escalation_policies
        get_mock.return_value.status_code = 200
        json_check = {
            'not_escalation_policies': [{
                'not_id': 'verified_policy_id'
            }]
        }
        get_mock.return_value.json.return_value = json_check

        assert_false(
            self._dispatcher._policy_verify('valid_policy', 'default_policy'))

    @patch('requests.get')
    def test_service_verify_success(self, get_mock):
        """PagerDutyIncidentOutput - Service Verify Success"""
        # GET /services
        get_mock.return_value.status_code = 200
        json_check = {'services': [{'id': 'verified_service_id'}]}
        get_mock.return_value.json.return_value = json_check

        service_verified = self._dispatcher._service_verify('valid_service')
        assert_equal(service_verified['id'], 'verified_service_id')
        assert_equal(service_verified['type'], 'service_reference')

    @patch('requests.get')
    def test_service_verify_fail(self, get_mock):
        """PagerDutyIncidentOutput - Service Verify Fail"""
        get_mock.return_value.status_code = 200
        json_check = {'not_services': [{'not_id': 'verified_service_id'}]}
        get_mock.return_value.json.return_value = json_check

        assert_false(self._dispatcher._service_verify('valid_service'))

    @patch('requests.get')
    def test_item_verify_success(self, get_mock):
        """PagerDutyIncidentOutput - Item Verify Success"""
        # GET /items
        get_mock.return_value.status_code = 200
        json_check = {'items': [{'id': 'verified_item_id'}]}
        get_mock.return_value.json.return_value = json_check

        item_verified = self._dispatcher._item_verify('valid_item', 'items',
                                                      'item_reference')

        assert_equal(item_verified['id'], 'verified_item_id')
        assert_equal(item_verified['type'], 'item_reference')

    @patch('requests.get')
    def test_item_verify_no_get_id_success(self, get_mock):
        """PagerDutyIncidentOutput - Item Verify No Get Id Success"""
        # GET /items
        get_mock.return_value.status_code = 200
        json_check = {'items': [{'id': 'verified_item_id'}]}
        get_mock.return_value.json.return_value = json_check

        assert_true(
            self._dispatcher._item_verify('valid_item', 'items',
                                          'item_reference', False))

    @patch('requests.get')
    def test_priority_verify_success(self, get_mock):
        """PagerDutyIncidentOutput - Priority Verify Success"""
        priority_name = 'priority_name'
        # GET /priorities
        get_mock.return_value.status_code = 200
        json_check = {
            'priorities': [{
                'id': 'verified_priority_id',
                'name': priority_name
            }]
        }
        get_mock.return_value.json.return_value = json_check

        context = {'incident_priority': priority_name}

        priority_verified = self._dispatcher._priority_verify(context)
        assert_equal(priority_verified['id'], 'verified_priority_id')
        assert_equal(priority_verified['type'], 'priority_reference')

    @patch('requests.get')
    def test_priority_verify_fail(self, get_mock):
        """PagerDutyIncidentOutput - Priority Verify Fail"""
        # GET /priorities
        get_mock.return_value.status_code = 404

        context = {'incident_priority': 'priority_name'}

        priority_not_verified = self._dispatcher._priority_verify(context)
        assert_equal(priority_not_verified, dict())

    @patch('requests.get')
    def test_priority_verify_empty(self, get_mock):
        """PagerDutyIncidentOutput - Priority Verify Empty"""
        # GET /priorities
        get_mock.return_value.status_code = 200
        json_check = {}
        get_mock.return_value.json.return_value = json_check

        context = {'incident_priority': 'priority_name'}

        priority_not_verified = self._dispatcher._priority_verify(context)
        assert_equal(priority_not_verified, dict())

    @patch('requests.get')
    def test_priority_verify_not_found(self, get_mock):
        """PagerDutyIncidentOutput - Priority Verify Not Found"""
        # GET /priorities
        get_mock.return_value.status_code = 200
        json_check = {
            'priorities': [{
                'id': 'verified_priority_id',
                'name': 'not_priority_name'
            }]
        }
        get_mock.return_value.json.return_value = json_check

        context = {'incident_priority': 'priority_name'}

        priority_not_verified = self._dispatcher._priority_verify(context)
        assert_equal(priority_not_verified, dict())

    @patch('requests.get')
    def test_priority_verify_invalid(self, get_mock):
        """PagerDutyIncidentOutput - Priority Verify Invalid"""
        # GET /priorities
        get_mock.return_value.status_code = 200
        json_check = {
            'not_priorities': [{
                'id': 'verified_priority_id',
                'name': 'priority_name'
            }]
        }
        get_mock.return_value.json.return_value = json_check

        context = {'incident_priority': 'priority_name'}

        priority_not_verified = self._dispatcher._priority_verify(context)
        assert_equal(priority_not_verified, dict())

    @patch('requests.get')
    def test_incident_assignment_user(self, get_mock):
        """PagerDutyIncidentOutput - Incident Assignment User"""
        context = {'assigned_user': '******'}
        get_mock.return_value.status_code = 200
        json_user = {'users': [{'id': 'verified_user_id'}]}
        get_mock.return_value.json.return_value = json_user

        assigned_key, assigned_value = self._dispatcher._incident_assignment(
            context)

        assert_equal(assigned_key, 'assignments')
        assert_equal(assigned_value[0]['assignee']['id'], 'verified_user_id')
        assert_equal(assigned_value[0]['assignee']['type'], 'user_reference')

    def test_incident_assignment_policy_no_default(self):
        """PagerDutyIncidentOutput - Incident Assignment Policy (No Default)"""
        context = {'assigned_policy_id': 'policy_id_to_assign'}

        assigned_key, assigned_value = self._dispatcher._incident_assignment(
            context)

        assert_equal(assigned_key, 'escalation_policy')
        assert_equal(assigned_value['id'], 'policy_id_to_assign')
        assert_equal(assigned_value['type'], 'escalation_policy_reference')

    @patch('requests.post')
    def test_add_note_incident_success(self, post_mock):
        """PagerDutyIncidentOutput - Add Note to Incident Success"""
        post_mock.return_value.status_code = 200
        json_note = {'note': {'id': 'created_note_id'}}
        post_mock.return_value.json.return_value = json_note

        note_id = self._dispatcher._add_incident_note('incident_id',
                                                      'this is the note')

        assert_equal(note_id, 'created_note_id')

    @patch('requests.post')
    def test_add_note_incident_fail(self, post_mock):
        """PagerDutyIncidentOutput - Add Note to Incident Fail"""
        post_mock.return_value.status_code = 200
        json_note = {'note': {'not_id': 'created_note_id'}}
        post_mock.return_value.json.return_value = json_note

        note_id = self._dispatcher._add_incident_note('incident_id',
                                                      'this is the note')

        assert_false(note_id)

    @patch('requests.post')
    def test_add_note_incident_bad_request(self, post_mock):
        """PagerDutyIncidentOutput - Add Note to Incident Bad Request"""
        post_mock.return_value.status_code = 400
        json_note = {'note': {'id': 'created_note_id'}}
        post_mock.return_value.json.return_value = json_note

        note_id = self._dispatcher._add_incident_note('incident_id',
                                                      'this is the note')

        assert_false(note_id)

    @patch('requests.post')
    def test_add_note_incident_no_response(self, post_mock):
        """PagerDutyIncidentOutput - Add Note to Incident No Response"""
        post_mock.return_value.status_code = 200
        json_note = {}
        post_mock.return_value.json.return_value = json_note

        note_id = self._dispatcher._add_incident_note('incident_id',
                                                      'this is the note')

        assert_false(note_id)

    @patch('requests.get')
    def test_item_verify_fail(self, get_mock):
        """PagerDutyIncidentOutput - Item Verify Fail"""
        # /not_items
        get_mock.return_value.status_code = 200
        json_check = {'not_items': [{'not_id': 'verified_item_id'}]}
        get_mock.return_value.json.return_value = json_check

        item_verified = self._dispatcher._item_verify('http://mock_url',
                                                      'valid_item', 'items',
                                                      'item_reference')
        assert_false(item_verified)

    @patch('logging.Logger.info')
    @patch('requests.put')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_success_good_user(self, get_mock, post_mock, put_mock,
                                        log_mock):
        """PagerDutyIncidentOutput - Dispatch Success, Good User"""
        # GET /users, /users
        json_user = {'users': [{'id': 'valid_user_id'}]}

        # GET /incidents
        json_lookup = {'incidents': [{'id': 'incident_id'}]}

        get_mock.return_value.status_code = 200
        get_mock.return_value.json.side_effect = [
            json_user, json_user, json_lookup
        ]

        # POST /incidents, /v2/enqueue, /incidents/incident_id/notes
        post_mock.return_value.status_code = 200
        json_incident = {'incident': {'id': 'incident_id'}}
        json_event = {'dedup_key': 'returned_dedup_key'}
        json_note = {'note': {'id': 'note_id'}}
        post_mock.return_value.json.side_effect = [
            json_incident, json_event, json_note
        ]

        # PUT /incidents/indicent_id/merge
        put_mock.return_value.status_code = 200

        ctx = {'pagerduty-incident': {'assigned_user': '******'}}

        assert_true(
            self._dispatcher.dispatch(get_alert(context=ctx), self.DESCRIPTOR))

        log_mock.assert_called_with('Successfully sent alert to %s:%s',
                                    self.SERVICE, self.DESCRIPTOR)

    @patch('logging.Logger.info')
    @patch('requests.put')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_success_good_policy(self, get_mock, post_mock, put_mock,
                                          log_mock):
        """PagerDutyIncidentOutput - Dispatch Success, Good Policy"""
        # GET /users
        json_user = {'users': [{'id': 'user_id'}]}

        # GET /incidents
        json_lookup = {'incidents': [{'id': 'incident_id'}]}

        get_mock.return_value.status_code = 200
        get_mock.return_value.json.side_effect = [json_user, json_lookup]

        # POST /incidents, /v2/enqueue, /incidents/incident_id/notes
        post_mock.return_value.status_code = 200
        json_incident = {'incident': {'id': 'incident_id'}}
        json_event = {'dedup_key': 'returned_dedup_key'}
        json_note = {'note': {'id': 'note_id'}}
        post_mock.return_value.json.side_effect = [
            json_incident, json_event, json_note
        ]

        # PUT /incidents/indicent_id/merge
        put_mock.return_value.status_code = 200

        ctx = {'pagerduty-incident': {'assigned_policy_id': 'valid_policy_id'}}

        assert_true(
            self._dispatcher.dispatch(get_alert(context=ctx), self.DESCRIPTOR))

        log_mock.assert_called_with('Successfully sent alert to %s:%s',
                                    self.SERVICE, self.DESCRIPTOR)

    @patch('logging.Logger.info')
    @patch('requests.put')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_success_with_priority(self, get_mock, post_mock,
                                            put_mock, log_mock):
        """PagerDutyIncidentOutput - Dispatch Success With Priority"""
        # GET /priorities, /users
        json_user = {'users': [{'id': 'user_id'}]}
        json_priority = {
            'priorities': [{
                'id': 'priority_id',
                'name': 'priority_name'
            }]
        }

        # GET /incidents
        json_lookup = {'incidents': [{'id': 'incident_id'}]}
        get_mock.return_value.status_code = 200
        get_mock.return_value.json.side_effect = [
            json_user, json_priority, json_lookup
        ]

        # POST /incidents, /v2/enqueue, /incidents/incident_id/notes
        post_mock.return_value.status_code = 200
        json_incident = {'incident': {'id': 'incident_id'}}
        json_event = {'dedup_key': 'returned_dedup_key'}
        json_note = {'note': {'id': 'note_id'}}
        post_mock.return_value.json.side_effect = [
            json_incident, json_event, json_note
        ]

        # PUT /incidents/indicent_id/merge
        put_mock.return_value.status_code = 200

        ctx = {
            'pagerduty-incident': {
                'assigned_policy_id': 'valid_policy_id',
                'incident_priority': 'priority_name'
            }
        }

        assert_true(
            self._dispatcher.dispatch(get_alert(context=ctx), self.DESCRIPTOR))

        log_mock.assert_called_with('Successfully sent alert to %s:%s',
                                    self.SERVICE, self.DESCRIPTOR)

    @patch('logging.Logger.info')
    @patch('requests.put')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_success_bad_user(self, get_mock, post_mock, put_mock,
                                       log_mock):
        """PagerDutyIncidentOutput - Dispatch Success, Bad User"""
        # GET /users, /users
        json_user = {'users': [{'id': 'user_id'}]}
        json_not_user = {'not_users': [{'id': 'user_id'}]}

        # GET /incidents
        json_lookup = {'incidents': [{'id': 'incident_id'}]}

        get_mock.return_value.status_code = 200
        get_mock.return_value.json.side_effect = [
            json_user, json_not_user, json_lookup
        ]

        # POST /incidents, /v2/enqueue, /incidents/incident_id/notes
        post_mock.return_value.status_code = 200
        json_incident = {'incident': {'id': 'incident_id'}}
        json_event = {'dedup_key': 'returned_dedup_key'}
        json_note = {'note': {'id': 'note_id'}}
        post_mock.return_value.json.side_effect = [
            json_incident, json_event, json_note
        ]

        # PUT /incidents/indicent_id/merge
        put_mock.return_value.status_code = 200

        ctx = {'pagerduty-incident': {'assigned_user': '******'}}

        assert_true(
            self._dispatcher.dispatch(get_alert(context=ctx), self.DESCRIPTOR))

        log_mock.assert_called_with('Successfully sent alert to %s:%s',
                                    self.SERVICE, self.DESCRIPTOR)

    @patch('logging.Logger.info')
    @patch('requests.put')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_success_no_context(self, get_mock, post_mock, put_mock,
                                         log_mock):
        """PagerDutyIncidentOutput - Dispatch Success, No Context"""
        # GET /users
        json_user = {'users': [{'id': 'user_id'}]}

        # GET /incidents
        json_lookup = {'incidents': [{'id': 'incident_id'}]}

        get_mock.return_value.status_code = 200
        get_mock.return_value.json.side_effect = [json_user, json_lookup]

        # POST /incidents, /v2/enqueue, /incidents/incident_id/notes
        post_mock.return_value.status_code = 200
        json_incident = {'incident': {'id': 'incident_id'}}
        json_event = {'dedup_key': 'returned_dedup_key'}
        json_note = {'note': {'id': 'note_id'}}
        post_mock.return_value.json.side_effect = [
            json_incident, json_event, json_note
        ]

        # PUT /incidents/indicent_id/merge
        put_mock.return_value.status_code = 200

        assert_true(self._dispatcher.dispatch(get_alert(), self.DESCRIPTOR))

        log_mock.assert_called_with('Successfully sent alert to %s:%s',
                                    self.SERVICE, self.DESCRIPTOR)

    @patch('logging.Logger.error')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_failure_bad_everything(self, get_mock, post_mock,
                                             log_mock):
        """PagerDutyIncidentOutput - Dispatch Failure: No User"""
        # GET /users, /users
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[200, 400])

        # Only set the return_value here since there will only be one successful call
        # that makes it to the point of calling the .json() method
        get_mock.return_value.json.return_value = {
            'users': [{
                'id': 'user_id'
            }]
        }

        # POST /incidents
        post_mock.return_value.status_code = 400

        assert_false(self._dispatcher.dispatch(get_alert(), self.DESCRIPTOR))

        log_mock.assert_called_with('Failed to send alert to %s:%s',
                                    self.SERVICE, self.DESCRIPTOR)

    @patch('logging.Logger.info')
    @patch('requests.put')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_success_no_merge_response(self, get_mock, post_mock,
                                                put_mock, log_mock):
        """PagerDutyIncidentOutput - Dispatch Success, No Merge Response"""
        # GET /users
        get_mock.return_value.status_code = 200
        json_user = {'users': [{'id': 'user_id'}]}
        json_lookup = {'incidents': [{'id': 'existing_incident_id'}]}
        get_mock.return_value.json.side_effect = [json_user, json_lookup]

        # POST /incidents, /v2/enqueue
        post_mock.return_value.status_code = 200
        json_incident = {'incident': {'id': 'incident_id'}}
        json_event = {'dedup_key': 'returned_dedup_key'}
        post_mock.return_value.json.side_effect = [json_incident, json_event]

        # PUT /incidents/indicent_id/merge
        put_mock.return_value.status_code = 200
        put_mock.return_value.json.return_value = {}

        ctx = {'pagerduty-incident': {'assigned_policy_id': 'valid_policy_id'}}

        assert_true(
            self._dispatcher.dispatch(get_alert(context=ctx), self.DESCRIPTOR))

        log_mock.assert_called_with('Successfully sent alert to %s:%s',
                                    self.SERVICE, self.DESCRIPTOR)

    @patch('logging.Logger.error')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_no_dispatch_no_incident_response(self, get_mock,
                                                       post_mock, log_mock):
        """PagerDutyIncidentOutput - Dispatch Failure, No Incident Response"""
        # /users
        get_mock.return_value.status_code = 200
        json_user = {'users': [{'id': 'user_id'}]}
        get_mock.return_value.json.return_value = json_user

        # /incidents
        post_mock.return_value.status_code = 200
        post_mock.return_value.json.return_value = {}

        assert_false(self._dispatcher.dispatch(get_alert(), self.DESCRIPTOR))

        log_mock.assert_called_with('Failed to send alert to %s:%s',
                                    self.SERVICE, self.DESCRIPTOR)

    @patch('logging.Logger.error')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_no_dispatch_no_incident_event(self, get_mock, post_mock,
                                                    log_mock):
        """PagerDutyIncidentOutput - Dispatch Failure, No Incident Event"""
        # /users
        get_mock.return_value.status_code = 200
        json_user = {'users': [{'id': 'user_id'}]}
        get_mock.return_value.json.return_value = json_user

        # /incidents, /v2/enqueue
        post_mock.return_value.status_code = 200
        json_incident = {'incident': {'id': 'incident_id'}}
        json_event = {}
        post_mock.return_value.json.side_effect = [json_incident, json_event]

        assert_false(self._dispatcher.dispatch(get_alert(), self.DESCRIPTOR))

        log_mock.assert_called_with('Failed to send alert to %s:%s',
                                    self.SERVICE, self.DESCRIPTOR)

    @patch('logging.Logger.error')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_no_dispatch_no_incident_key(self, get_mock, post_mock,
                                                  log_mock):
        """PagerDutyIncidentOutput - Dispatch Failure, No Incident Key"""
        # /users
        get_mock.return_value.status_code = 200
        json_user = {'users': [{'id': 'user_id'}]}
        get_mock.return_value.json.return_value = json_user

        # /incidents, /v2/enqueue
        post_mock.return_value.status_code = 200
        json_incident = {'incident': {'id': 'incident_id'}}
        json_event = {'not_dedup_key': 'returned_dedup_key'}
        post_mock.return_value.json.side_effect = [json_incident, json_event]

        assert_false(self._dispatcher.dispatch(get_alert(), self.DESCRIPTOR))

        log_mock.assert_called_with('Failed to send alert to %s:%s',
                                    self.SERVICE, self.DESCRIPTOR)

    @patch('logging.Logger.error')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_bad_dispatch(self, get_mock, post_mock, log_mock):
        """PagerDutyIncidentOutput - Dispatch Failure, Bad Request"""
        # /users
        get_mock.return_value.status_code = 200
        json_user = {'users': [{'id': 'user_id'}]}
        get_mock.return_value.json.return_value = json_user

        # /incidents
        post_mock.return_value.status_code = 400

        assert_false(self._dispatcher.dispatch(get_alert(), self.DESCRIPTOR))

        log_mock.assert_called_with('Failed to send alert to %s:%s',
                                    self.SERVICE, self.DESCRIPTOR)

    @patch('logging.Logger.error')
    @patch('requests.get')
    def test_dispatch_bad_email(self, get_mock, log_mock):
        """PagerDutyIncidentOutput - Dispatch Failure, Bad Email"""
        # /users
        get_mock.return_value.status_code = 400
        json_user = {'not_users': [{'id': 'no_user_id'}]}
        get_mock.return_value.json.return_value = json_user

        assert_false(self._dispatcher.dispatch(get_alert(), self.DESCRIPTOR))

        log_mock.assert_called_with('Failed to send alert to %s:%s',
                                    self.SERVICE, self.DESCRIPTOR)

    @patch('logging.Logger.error')
    def test_dispatch_bad_descriptor(self, log_mock):
        """PagerDutyIncidentOutput - Dispatch Failure, Bad Descriptor"""
        assert_false(self._dispatcher.dispatch(get_alert(), 'bad_descriptor'))

        log_mock.assert_called_with('Failed to send alert to %s:%s',
                                    self.SERVICE, 'bad_descriptor')
Ejemplo n.º 2
0
class TestPagerDutyIncidentOutput(object):
    """Test class for PagerDutyIncidentOutput"""
    DESCRIPTOR = 'unit_test_pagerduty-incident'
    SERVICE = 'pagerduty-incident'
    CREDS = {
        'api': 'https://api.pagerduty.com',
        'token': 'mocked_token',
        'service_name': 'mocked_service_name',
        'escalation_policy': 'mocked_escalation_policy',
        'email_from': '*****@*****.**'
    }

    def setup(self):
        """Setup before each method"""
        self._dispatcher = PagerDutyIncidentOutput(REGION, FUNCTION_NAME,
                                                   CONFIG)
        self._dispatcher._base_url = self.CREDS['api']
        remove_temp_secrets()
        output_name = self._dispatcher.output_cred_name(self.DESCRIPTOR)
        put_mock_creds(output_name, self.CREDS,
                       self._dispatcher.secrets_bucket, REGION, KMS_ALIAS)

    def test_get_default_properties(self):
        """PagerDutyIncidentOutput - Get Default Properties"""
        props = self._dispatcher._get_default_properties()
        assert_equal(len(props), 1)
        assert_equal(props['api'], 'https://api.pagerduty.com')

    def test_get_endpoint(self):
        """PagerDutyIncidentOutput - Get Endpoint"""
        endpoint = self._dispatcher._get_endpoint(self.CREDS['api'],
                                                  'testtest')
        assert_equal(endpoint, 'https://api.pagerduty.com/testtest')

    @patch('requests.get')
    def test_check_exists_get_id(self, get_mock):
        """PagerDutyIncidentOutput - Check Exists Get ID"""
        # /check
        get_mock.return_value.status_code = 200
        json_check = {'check': [{'id': 'checked_id'}]}
        get_mock.return_value.json.return_value = json_check

        checked = self._dispatcher._check_exists('filter', 'http://mock_url',
                                                 'check')
        assert_equal(checked, 'checked_id')

    @patch('requests.get')
    def test_check_exists_get_id_fail(self, get_mock):
        """PagerDutyIncidentOutput - Check Exists Get Id Fail"""
        get_mock.return_value.status_code = 200
        get_mock.return_value.json.return_value = dict()

        checked = self._dispatcher._check_exists('filter', 'http://mock_url',
                                                 'check')
        assert_false(checked)

    @patch('requests.get')
    def test_check_exists_no_get_id(self, get_mock):
        """Check Exists No Get Id - PagerDutyIncidentOutput"""
        # /check
        get_mock.return_value.status_code = 200
        json_check = {'check': [{'id': 'checked_id'}]}
        get_mock.return_value.json.return_value = json_check

        assert_true(
            self._dispatcher._check_exists('filter', 'http://mock_url',
                                           'check', False))

    @patch('requests.get')
    def test_user_verify_success(self, get_mock):
        """PagerDutyIncidentOutput - User Verify Success"""
        get_mock.return_value.status_code = 200
        json_check = {'users': [{'id': 'verified_user_id'}]}
        get_mock.return_value.json.return_value = json_check

        user_verified = self._dispatcher._user_verify('valid_user')
        assert_equal(user_verified['id'], 'verified_user_id')
        assert_equal(user_verified['type'], 'user_reference')

    @patch('requests.get')
    def test_user_verify_fail(self, get_mock):
        """PagerDutyIncidentOutput - User Verify Fail"""
        get_mock.return_value.status_code = 200
        json_check = {'not_users': [{'not_id': 'verified_user_id'}]}
        get_mock.return_value.json.return_value = json_check

        user_verified = self._dispatcher._user_verify('valid_user')
        assert_false(user_verified)

    @patch('requests.get')
    def test_policy_verify_success_no_default(self, get_mock):
        """PagerDutyIncidentOutput - Policy Verify Success (No Default)"""
        # /escalation_policies
        get_mock.return_value.status_code = 200
        json_check = {'escalation_policies': [{'id': 'good_policy_id'}]}
        get_mock.return_value.json.return_value = json_check

        policy_verified = self._dispatcher._policy_verify('valid_policy', '')
        assert_equal(policy_verified['id'], 'good_policy_id')
        assert_equal(policy_verified['type'], 'escalation_policy_reference')

    @patch('requests.get')
    def test_policy_verify_success_default(self, get_mock):
        """PagerDutyIncidentOutput - Policy Verify Success (Default)"""
        # /escalation_policies
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[200, 200])
        json_check_bad = {'no_escalation_policies': [{'id': 'bad_policy_id'}]}
        json_check_good = {'escalation_policies': [{'id': 'good_policy_id'}]}
        get_mock.return_value.json.side_effect = [
            json_check_bad, json_check_good
        ]

        policy_verified = self._dispatcher._policy_verify(
            'valid_policy', 'default_policy')
        assert_equal(policy_verified['id'], 'good_policy_id')
        assert_equal(policy_verified['type'], 'escalation_policy_reference')

    @patch('requests.get')
    def test_policy_verify_fail_default(self, get_mock):
        """PagerDutyIncidentOutput - Policy Verify Fail (Default)"""
        # /not_escalation_policies
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[400, 400])
        json_check_bad = {'escalation_policies': [{'id': 'bad_policy_id'}]}
        json_check_bad_default = {
            'escalation_policies': [{
                'id': 'good_policy_id'
            }]
        }
        get_mock.return_value.json.side_effect = [
            json_check_bad, json_check_bad_default
        ]

        assert_false(
            self._dispatcher._policy_verify('valid_policy', 'default_policy'))

    @patch('requests.get')
    def test_policy_verify_fail_no_default(self, get_mock):
        """PagerDutyIncidentOutput - Policy Verify Fail (No Default)"""
        # /not_escalation_policies
        get_mock.return_value.status_code = 200
        json_check = {
            'not_escalation_policies': [{
                'not_id': 'verified_policy_id'
            }]
        }
        get_mock.return_value.json.return_value = json_check

        assert_false(
            self._dispatcher._policy_verify('valid_policy', 'default_policy'))

    @patch('requests.get')
    def test_service_verify_success(self, get_mock):
        """PagerDutyIncidentOutput - Service Verify Success"""
        # /services
        get_mock.return_value.status_code = 200
        json_check = {'services': [{'id': 'verified_service_id'}]}
        get_mock.return_value.json.return_value = json_check

        service_verified = self._dispatcher._service_verify('valid_service')
        assert_equal(service_verified['id'], 'verified_service_id')
        assert_equal(service_verified['type'], 'service_reference')

    @patch('requests.get')
    def test_service_verify_fail(self, get_mock):
        """PagerDutyIncidentOutput - Service Verify Fail"""
        get_mock.return_value.status_code = 200
        json_check = {'not_services': [{'not_id': 'verified_service_id'}]}
        get_mock.return_value.json.return_value = json_check

        assert_false(self._dispatcher._service_verify('valid_service'))

    @patch('requests.get')
    def test_item_verify_success(self, get_mock):
        """PagerDutyIncidentOutput - Item Verify Success"""
        # /items
        get_mock.return_value.status_code = 200
        json_check = {'items': [{'id': 'verified_item_id'}]}
        get_mock.return_value.json.return_value = json_check

        item_verified = self._dispatcher._item_verify('valid_item', 'items',
                                                      'item_reference')

        assert_equal(item_verified['id'], 'verified_item_id')
        assert_equal(item_verified['type'], 'item_reference')

    @patch('requests.get')
    def test_item_verify_no_get_id_success(self, get_mock):
        """PagerDutyIncidentOutput - Item Verify No Get Id Success"""
        # /items
        get_mock.return_value.status_code = 200
        json_check = {'items': [{'id': 'verified_item_id'}]}
        get_mock.return_value.json.return_value = json_check

        assert_true(
            self._dispatcher._item_verify('valid_item', 'items',
                                          'item_reference', False))

    @patch('requests.get')
    def test_priority_verify_success(self, get_mock):
        """PagerDutyIncidentOutput - Priority Verify Success"""
        priority_name = 'priority_name'
        # /priorities
        get_mock.return_value.status_code = 200
        json_check = {
            'priorities': [{
                'id': 'verified_priority_id',
                'name': priority_name
            }]
        }
        get_mock.return_value.json.return_value = json_check

        context = {'incident_priority': priority_name}

        priority_verified = self._dispatcher._priority_verify(context)
        assert_equal(priority_verified['id'], 'verified_priority_id')
        assert_equal(priority_verified['type'], 'priority_reference')

    @patch('requests.get')
    def test_priority_verify_fail(self, get_mock):
        """PagerDutyIncidentOutput - Priority Verify Fail"""
        # /priorities
        get_mock.return_value.status_code = 404

        context = {'incident_priority': 'priority_name'}

        priority_not_verified = self._dispatcher._priority_verify(context)
        assert_equal(priority_not_verified, dict())

    @patch('requests.get')
    def test_priority_verify_empty(self, get_mock):
        """PagerDutyIncidentOutput - Priority Verify Empty"""
        # /priorities
        get_mock.return_value.status_code = 200
        json_check = {}
        get_mock.return_value.json.return_value = json_check

        context = {'incident_priority': 'priority_name'}

        priority_not_verified = self._dispatcher._priority_verify(context)
        assert_equal(priority_not_verified, dict())

    @patch('requests.get')
    def test_priority_verify_not_found(self, get_mock):
        """PagerDutyIncidentOutput - Priority Verify Not Found"""
        # /priorities
        get_mock.return_value.status_code = 200
        json_check = {
            'priorities': [{
                'id': 'verified_priority_id',
                'name': 'not_priority_name'
            }]
        }
        get_mock.return_value.json.return_value = json_check

        context = {'incident_priority': 'priority_name'}

        priority_not_verified = self._dispatcher._priority_verify(context)
        assert_equal(priority_not_verified, dict())

    @patch('requests.get')
    def test_priority_verify_invalid(self, get_mock):
        """PagerDutyIncidentOutput - Priority Verify Invalid"""
        # /priorities
        get_mock.return_value.status_code = 200
        json_check = {
            'not_priorities': [{
                'id': 'verified_priority_id',
                'name': 'priority_name'
            }]
        }
        get_mock.return_value.json.return_value = json_check

        context = {'incident_priority': 'priority_name'}

        priority_not_verified = self._dispatcher._priority_verify(context)
        assert_equal(priority_not_verified, dict())

    @patch('requests.get')
    def test_incident_assignment_user(self, get_mock):
        """PagerDutyIncidentOutput - Incident Assignment User"""
        context = {'assigned_user': '******'}
        get_mock.return_value.status_code = 200
        json_user = {'users': [{'id': 'verified_user_id'}]}
        get_mock.return_value.json.return_value = json_user

        assigned_key, assigned_value = self._dispatcher._incident_assignment(
            context)

        assert_equal(assigned_key, 'assignments')
        assert_equal(assigned_value[0]['assignee']['id'], 'verified_user_id')
        assert_equal(assigned_value[0]['assignee']['type'], 'user_reference')

    @patch('requests.get')
    def test_incident_assignment_policy_no_default(self, get_mock):
        """PagerDutyIncidentOutput - Incident Assignment Policy (No Default)"""
        context = {'assigned_policy': 'policy_to_assign'}
        get_mock.return_value.status_code = 200
        json_policy = {'escalation_policies': [{'id': 'verified_policy_id'}]}
        get_mock.return_value.json.return_value = json_policy

        assigned_key, assigned_value = self._dispatcher._incident_assignment(
            context)

        assert_equal(assigned_key, 'escalation_policy')
        assert_equal(assigned_value['id'], 'verified_policy_id')
        assert_equal(assigned_value['type'], 'escalation_policy_reference')

    @patch('requests.get')
    def test_incident_assignment_policy_default(self, get_mock):
        """PagerDutyIncidentOutput - Incident Assignment Policy (Default)"""
        context = {'assigned_policy': 'bad_invalid_policy_to_assign'}
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[200, 200])
        json_bad_policy = {
            'not_escalation_policies': [{
                'id': 'bad_policy_id'
            }]
        }
        json_good_policy = {
            'escalation_policies': [{
                'id': 'verified_policy_id'
            }]
        }
        get_mock.return_value.json.side_effect = [
            json_bad_policy, json_good_policy
        ]

        assigned_key, assigned_value = self._dispatcher._incident_assignment(
            context)

        assert_equal(assigned_key, 'escalation_policy')
        assert_equal(assigned_value['id'], 'verified_policy_id')
        assert_equal(assigned_value['type'], 'escalation_policy_reference')

    @patch('requests.get')
    def test_item_verify_fail(self, get_mock):
        """PagerDutyIncidentOutput - Item Verify Fail"""
        # /not_items
        get_mock.return_value.status_code = 200
        json_check = {'not_items': [{'not_id': 'verified_item_id'}]}
        get_mock.return_value.json.return_value = json_check

        item_verified = self._dispatcher._item_verify('http://mock_url',
                                                      'valid_item', 'items',
                                                      'item_reference')
        assert_false(item_verified)

    @patch('logging.Logger.info')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_success_good_user(self, get_mock, post_mock, log_mock):
        """PagerDutyIncidentOutput - Dispatch Success, Good User"""
        # /users, /users, /services
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[200, 200, 200])
        json_user = {'users': [{'id': 'valid_user_id'}]}
        json_service = {'services': [{'id': 'service_id'}]}
        get_mock.return_value.json.side_effect = [
            json_user, json_user, json_service
        ]

        # /incidents
        post_mock.return_value.status_code = 200

        ctx = {'pagerduty-incident': {'assigned_user': '******'}}

        assert_true(
            self._dispatcher.dispatch(descriptor=self.DESCRIPTOR,
                                      rule_name='rule_name',
                                      alert=get_alert(context=ctx)))

        log_mock.assert_called_with('Successfully sent alert to %s',
                                    self.SERVICE)

    @patch('logging.Logger.info')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_success_good_policy(self, get_mock, post_mock, log_mock):
        """PagerDutyIncidentOutput - Dispatch Success, Good Policy"""
        # /users, /escalation_policies, /services
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[200, 200, 200])
        json_user = {'users': [{'id': 'user_id'}]}
        json_policy = {'escalation_policies': [{'id': 'policy_id'}]}
        json_service = {'services': [{'id': 'service_id'}]}
        get_mock.return_value.json.side_effect = [
            json_user, json_policy, json_service
        ]

        # /incidents
        post_mock.return_value.status_code = 200

        ctx = {'pagerduty-incident': {'assigned_policy': 'valid_policy'}}

        assert_true(
            self._dispatcher.dispatch(descriptor=self.DESCRIPTOR,
                                      rule_name='rule_name',
                                      alert=get_alert(context=ctx)))

        log_mock.assert_called_with('Successfully sent alert to %s',
                                    self.SERVICE)

    @patch('logging.Logger.info')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_success_with_priority(self, get_mock, post_mock,
                                            log_mock):
        """PagerDutyIncidentOutput - Dispatch Success With Priority"""
        # /priorities, /users, /escalation_policies, /services
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[200, 200, 200, 200])
        json_user = {'users': [{'id': 'user_id'}]}
        json_priority = {
            'priorities': [{
                'id': 'priority_id',
                'name': 'priority_name'
            }]
        }
        json_policy = {'escalation_policies': [{'id': 'policy_id'}]}
        json_service = {'services': [{'id': 'service_id'}]}
        get_mock.return_value.json.side_effect = [
            json_user, json_priority, json_policy, json_service
        ]

        # /incidents
        post_mock.return_value.status_code = 200

        ctx = {
            'pagerduty-incident': {
                'assigned_policy': 'valid_policy',
                'incident_priority': 'priority_name'
            }
        }

        assert_true(
            self._dispatcher.dispatch(descriptor=self.DESCRIPTOR,
                                      rule_name='rule_name',
                                      alert=get_alert(context=ctx)))

        log_mock.assert_called_with('Successfully sent alert to %s',
                                    self.SERVICE)

    @patch('logging.Logger.info')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_success_bad_user(self, get_mock, post_mock, log_mock):
        """PagerDutyIncidentOutput - Dispatch Success, Bad User"""
        # /users, /users, /escalation_policies, /services
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[200, 200, 200, 200])
        json_user = {'users': [{'id': 'user_id'}]}
        json_not_user = {'not_users': [{'id': 'user_id'}]}
        json_policy = {'escalation_policies': [{'id': 'policy_id'}]}
        json_service = {'services': [{'id': 'service_id'}]}
        get_mock.return_value.json.side_effect = [
            json_user, json_not_user, json_policy, json_service
        ]

        # /incidents
        post_mock.return_value.status_code = 200

        ctx = {'pagerduty-incident': {'assigned_user': '******'}}

        assert_true(
            self._dispatcher.dispatch(descriptor=self.DESCRIPTOR,
                                      rule_name='rule_name',
                                      alert=get_alert(context=ctx)))

        log_mock.assert_called_with('Successfully sent alert to %s',
                                    self.SERVICE)

    @patch('logging.Logger.info')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_success_no_context(self, get_mock, post_mock, log_mock):
        """PagerDutyIncidentOutput - Dispatch Success, No Context"""
        # /users, /escalation_policies, /services
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[200, 200, 200])
        json_user = {'users': [{'id': 'user_id'}]}
        json_policy = {'escalation_policies': [{'id': 'policy_id'}]}
        json_service = {'services': [{'id': 'service_id'}]}
        get_mock.return_value.json.side_effect = [
            json_user, json_policy, json_service
        ]

        # /incidents
        post_mock.return_value.status_code = 200

        assert_true(
            self._dispatcher.dispatch(descriptor=self.DESCRIPTOR,
                                      rule_name='rule_name',
                                      alert=get_alert()))

        log_mock.assert_called_with('Successfully sent alert to %s',
                                    self.SERVICE)

    @patch('logging.Logger.error')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_failure_bad_everything(self, get_mock, post_mock,
                                             log_mock):
        """PagerDutyIncidentOutput - Dispatch Failure: No User, Bad Policy, Bad Service"""
        # /users, /users, /escalation_policies, /services
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[200, 400, 400, 400])
        json_user = {'users': [{'id': 'user_id'}]}
        get_mock.return_value.json.side_effect = [
            json_user, dict(), dict(), dict()
        ]

        # /incidents
        post_mock.return_value.status_code = 400

        assert_false(
            self._dispatcher.dispatch(descriptor=self.DESCRIPTOR,
                                      rule_name='rule_name',
                                      alert=get_alert()))

        log_mock.assert_called_with('Failed to send alert to %s', self.SERVICE)

    @patch('logging.Logger.info')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_success_bad_policy(self, get_mock, post_mock, log_mock):
        """PagerDutyIncidentOutput - Dispatch Success, Bad Policy"""
        # /users, /escalation_policies, /escalation_policies, /services
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[200, 400, 200, 200])
        json_user = {'users': [{'id': 'user_id'}]}
        json_bad_policy = dict()
        json_good_policy = {'escalation_policies': [{'id': 'policy_id'}]}
        json_service = {'services': [{'id': 'service_id'}]}
        get_mock.return_value.json.side_effect = [
            json_user, json_bad_policy, json_good_policy, json_service
        ]

        # /incidents
        post_mock.return_value.status_code = 200

        ctx = {'pagerduty-incident': {'assigned_policy': 'valid_policy'}}

        assert_true(
            self._dispatcher.dispatch(descriptor=self.DESCRIPTOR,
                                      rule_name='rule_name',
                                      alert=get_alert(context=ctx)))

        log_mock.assert_called_with('Successfully sent alert to %s',
                                    self.SERVICE)

    @patch('logging.Logger.error')
    @patch('requests.post')
    @patch('requests.get')
    def test_dispatch_bad_dispatch(self, get_mock, post_mock, log_mock):
        """PagerDutyIncidentOutput - Dispatch Failure, Bad Request"""
        # /users, /escalation_policies, /services
        type(get_mock.return_value).status_code = PropertyMock(
            side_effect=[200, 200, 200])
        json_user = {'users': [{'id': 'user_id'}]}
        json_policy = {'escalation_policies': [{'id': 'policy_id'}]}
        json_service = {'services': [{'id': 'service_id'}]}
        get_mock.return_value.json.side_effect = [
            json_user, json_policy, json_service
        ]

        # /incidents
        post_mock.return_value.status_code = 400

        assert_false(
            self._dispatcher.dispatch(descriptor=self.DESCRIPTOR,
                                      rule_name='rule_name',
                                      alert=get_alert()))

        log_mock.assert_called_with('Failed to send alert to %s', self.SERVICE)

    @patch('logging.Logger.error')
    @patch('requests.get')
    def test_dispatch_bad_email(self, get_mock, log_mock):
        """PagerDutyIncidentOutput - Dispatch Failure, Bad Email"""
        # /users, /escalation_policies, /services
        get_mock.return_value.status_code = 400
        json_user = {'not_users': [{'id': 'no_user_id'}]}
        get_mock.return_value.json.return_value = json_user

        assert_false(
            self._dispatcher.dispatch(descriptor=self.DESCRIPTOR,
                                      rule_name='rule_name',
                                      alert=get_alert()))

        log_mock.assert_called_with('Failed to send alert to %s', self.SERVICE)

    @patch('logging.Logger.error')
    def test_dispatch_bad_descriptor(self, log_mock):
        """PagerDutyIncidentOutput - Dispatch Failure, Bad Descriptor"""
        assert_false(
            self._dispatcher.dispatch(descriptor='bad_descriptor',
                                      rule_name='rule_name',
                                      alert=get_alert()))

        log_mock.assert_called_with('Failed to send alert to %s', self.SERVICE)