text: /*
   * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
   * or more contributor license agreements. Licensed under the Elastic License;
   * you may not use this file except in compliance with the Elastic License.
   */
  
  import expect from '@kbn/expect';
  import { UserAtSpaceScenarios } from '../../scenarios';
  import { FtrProviderContext } from '../../../common/ftr_provider_context';
  import {
    AlertUtils,
    checkAAD,
    getUrlPrefix,
    getTestAlertData,
    ObjectRemover,
    getConsumerUnauthorizedErrorMessage,
    getProducerUnauthorizedErrorMessage,
  } from '../../../common/lib';
  
  // eslint-disable-next-line import/no-default-export
  export default function createDisableAlertTests({ getService }: FtrProviderContext) {
    const es = getService('legacyEs');
    const supertest = getService('supertest');
    const supertestWithoutAuth = getService('supertestWithoutAuth');
  
    describe('disable', () => {
      const objectRemover = new ObjectRemover(supertest);
  
      after(() => objectRemover.removeAll());
  
      async function getScheduledTask(id: string) {
        return await es.get({
          id: `task:${id}`,
          index: '.kibana_task_manager',
        });
      }
  
      for (const scenario of UserAtSpaceScenarios) {
        const { user, space } = scenario;
        const alertUtils = new AlertUtils({ user, space, supertestWithoutAuth });
  
        describe(scenario.id, () => {
          it('should handle disable alert request appropriately', async () => {
            const { body: createdAction } = await supertest
              .post(`${getUrlPrefix(space.id)}/api/actions/action`)
              .set('kbn-xsrf', 'foo')
              .send({
                name: 'MY action',
                actionTypeId: 'test.noop',
                config: {},
                secrets: {},
              })
              .expect(200);
  
            const { body: createdAlert } = await supertest
              .post(`${getUrlPrefix(space.id)}/api/alerts/alert`)
              .set('kbn-xsrf', 'foo')
              .send(
                getTestAlertData({
                  enabled: true,
                  actions: [
                    {
                      id: createdAction.id,
                      group: 'default',
                      params: {},
                    },
                  ],
                })
              )
              .expect(200);
            objectRemover.add(space.id, createdAlert.id, 'alert', 'alerts');
  
            const response = await alertUtils.getDisableRequest(createdAlert.id);
  
            switch (scenario.id) {
              case 'no_kibana_privileges at space1':
              case 'space_1_all at space2':
              case 'global_read at space1':
                expect(response.statusCode).to.eql(403);
                expect(response.body).to.eql({
                  error: 'Forbidden',
                  message: getConsumerUnauthorizedErrorMessage(
                    'disable',
                    'test.noop',
                    'alertsFixture'
                  ),
                  statusCode: 403,
                });
                // Ensure task still exists
                await getScheduledTask(createdAlert.scheduledTaskId);
                break;
              case 'space_1_all_alerts_none_actions at space1':
              case 'superuser at space1':
              case 'space_1_all at space1':
              case 'space_1_all_with_restricted_fixture at space1':
                expect(response.statusCode).to.eql(204);
                expect(response.body).to.eql('');
                try {
                  await getScheduledTask(createdAlert.scheduledTaskId);
                  throw new Error('Should have removed scheduled task');
                } catch (e) {
                  expect(e.status).to.eql(404);
                }
                // Ensure AAD isn't broken
                await checkAAD({
                  supertest,
                  spaceId: space.id,
                  type: 'alert',
                  id: createdAlert.id,
                });
                break;
              default:
                throw new Error(`Scenario untested: ${JSON.stringify(scenario)}`);
            }
          });
  
          it('should handle disable alert request appropriately when consumer is the same as producer', async () => {
            const { body: createdAlert } = await supertest
              .post(`${getUrlPrefix(space.id)}/api/alerts/alert`)
              .set('kbn-xsrf', 'foo')
              .send(
                getTestAlertData({
                  alertTypeId: 'test.restricted-noop',
                  consumer: 'alertsRestrictedFixture',
                  enabled: true,
                })
              )
              .expect(200);
            objectRemover.add(space.id, createdAlert.id, 'alert', 'alerts');
  
            const response = await alertUtils.getDisableRequest(createdAlert.id);
  
            switch (scenario.id) {
              case 'no_kibana_privileges at space1':
              case 'space_1_all at space2':
              case 'global_read at space1':
              case 'space_1_all at space1':
              case 'space_1_all_alerts_none_actions at space1':
                expect(response.statusCode).to.eql(403);
                expect(response.body).to.eql({
                  error: 'Forbidden',
                  message: getConsumerUnauthorizedErrorMessage(
                    'disable',
                    'test.restricted-noop',
                    'alertsRestrictedFixture'
                  ),
                  statusCode: 403,
                });
                break;
              case 'superuser at space1':
              case 'space_1_all_with_restricted_fixture at space1':
                expect(response.statusCode).to.eql(204);
                expect(response.body).to.eql('');
                try {
                  await getScheduledTask(createdAlert.scheduledTaskId);
                  throw new Error('Should have removed scheduled task');
                } catch (e) {
                  expect(e.status).to.eql(404);
                }
                break;
              default:
                throw new Error(`Scenario untested: ${JSON.stringify(scenario)}`);
            }
          });
  
          it('should handle disable alert request appropriately when consumer is not the producer', async () => {
            const { body: createdAlert } = await supertest
              .post(`${getUrlPrefix(space.id)}/api/alerts/alert`)
              .set('kbn-xsrf', 'foo')
              .send(
                getTestAlertData({
                  alertTypeId: 'test.unrestricted-noop',
                  consumer: 'alertsFixture',
                  enabled: true,
                })
              )
              .expect(200);
            objectRemover.add(space.id, createdAlert.id, 'alert', 'alerts');
  
            const response = await alertUtils.getDisableRequest(createdAlert.id);
  
            switch (scenario.id) {
              case 'no_kibana_privileges at space1':
              case 'space_1_all at space2':
              case 'global_read at space1':
                expect(response.statusCode).to.eql(403);
                expect(response.body).to.eql({
                  error: 'Forbidden',
                  message: getConsumerUnauthorizedErrorMessage(
                    'disable',
                    'test.unrestricted-noop',
                    'alertsFixture'
                  ),
                  statusCode: 403,
                });
                break;
              case 'space_1_all at space1':
              case 'space_1_all_alerts_none_actions at space1':
                expect(response.statusCode).to.eql(403);
                expect(response.body).to.eql({
                  error: 'Forbidden',
                  message: getProducerUnauthorizedErrorMessage(
                    'disable',
                    'test.unrestricted-noop',
                    'alertsRestrictedFixture'
                  ),
                  statusCode: 403,
                });
                break;
              case 'superuser at space1':
              case 'space_1_all_with_restricted_fixture at space1':
                expect(response.statusCode).to.eql(204);
                expect(response.body).to.eql('');
                try {
                  await getScheduledTask(createdAlert.scheduledTaskId);
                  throw new Error('Should have removed scheduled task');
                } catch (e) {
                  expect(e.status).to.eql(404);
                }
                break;
              default:
                throw new Error(`Scenario untested: ${JSON.stringify(scenario)}`);
            }
          });
  
          it('should handle disable alert request appropriately when consumer is "alerts"', async () => {
            const { body: createdAlert } = await supertest
              .post(`${getUrlPrefix(space.id)}/api/alerts/alert`)
              .set('kbn-xsrf', 'foo')
              .send(
                getTestAlertData({
                  alertTypeId: 'test.noop',
                  consumer: 'alerts',
                  enabled: true,
                })
              )
              .expect(200);
            objectRemover.add(space.id, createdAlert.id, 'alert', 'alerts');
  
            const response = await alertUtils.getDisableRequest(createdAlert.id);
  
            switch (scenario.id) {
              case 'no_kibana_privileges at space1':
              case 'space_1_all at space2':
                expect(response.statusCode).to.eql(403);
                expect(response.body).to.eql({
                  error: 'Forbidden',
                  message: getConsumerUnauthorizedErrorMessage('disable', 'test.noop', 'alerts'),
                  statusCode: 403,
                });
                break;
              case 'global_read at space1':
                expect(response.statusCode).to.eql(403);
                expect(response.body).to.eql({
                  error: 'Forbidden',
                  message: getProducerUnauthorizedErrorMessage(
                    'disable',
                    'test.noop',
                    'alertsFixture'
                  ),
                  statusCode: 403,
                });
                break;
              case 'superuser at space1':
              case 'space_1_all at space1':
              case 'space_1_all_alerts_none_actions at space1':
              case 'space_1_all_with_restricted_fixture at space1':
                expect(response.statusCode).to.eql(204);
                expect(response.body).to.eql('');
                try {
                  await getScheduledTask(createdAlert.scheduledTaskId);
                  throw new Error('Should have removed scheduled task');
                } catch (e) {
                  expect(e.status).to.eql(404);
                }
                break;
              default:
                throw new Error(`Scenario untested: ${JSON.stringify(scenario)}`);
            }
          });
  
          it('should still be able to disable alert when AAD is broken', async () => {
            const { body: createdAlert } = await supertest
              .post(`${getUrlPrefix(space.id)}/api/alerts/alert`)
              .set('kbn-xsrf', 'foo')
              .send(getTestAlertData({ enabled: true }))
              .expect(200);
            objectRemover.add(space.id, createdAlert.id, 'alert', 'alerts');
  
            await supertest
              .put(
                `${getUrlPrefix(space.id)}/api/alerts_fixture/saved_object/alert/${createdAlert.id}`
              )
              .set('kbn-xsrf', 'foo')
              .send({
                attributes: {
                  name: 'bar',
                },
              })
              .expect(200);
  
            const response = await alertUtils.getDisableRequest(createdAlert.id);
  
            switch (scenario.id) {
              case 'no_kibana_privileges at space1':
              case 'space_1_all at space2':
              case 'global_read at space1':
                expect(response.statusCode).to.eql(403);
                expect(response.body).to.eql({
                  error: 'Forbidden',
                  message: getConsumerUnauthorizedErrorMessage(
                    'disable',
                    'test.noop',
                    'alertsFixture'
                  ),
                  statusCode: 403,
                });
                // Ensure task still exists
                await getScheduledTask(createdAlert.scheduledTaskId);
                break;
              case 'superuser at space1':
              case 'space_1_all at space1':
              case 'space_1_all_alerts_none_actions at space1':
              case 'space_1_all_with_restricted_fixture at space1':
                expect(response.statusCode).to.eql(204);
                expect(response.body).to.eql('');
                try {
                  await getScheduledTask(createdAlert.scheduledTaskId);
                  throw new Error('Should have removed scheduled task');
                } catch (e) {
                  expect(e.status).to.eql(404);
                }
                // Ensure AAD isn't broken
                await checkAAD({
                  supertest,
                  spaceId: space.id,
                  type: 'alert',
                  id: createdAlert.id,
                });
                break;
              default:
                throw new Error(`Scenario untested: ${JSON.stringify(scenario)}`);
            }
          });
  
          it(`shouldn't disable alert from another space`, async () => {
            const { body: createdAlert } = await supertest
              .post(`${getUrlPrefix('other')}/api/alerts/alert`)
              .set('kbn-xsrf', 'foo')
              .send(getTestAlertData({ enabled: true }))
              .expect(200);
            objectRemover.add('other', createdAlert.id, 'alert', 'alerts');
  
            const response = await alertUtils.getDisableRequest(createdAlert.id);
  
            expect(response.statusCode).to.eql(404);
            switch (scenario.id) {
              case 'no_kibana_privileges at space1':
              case 'space_1_all at space2':
              case 'global_read at space1':
              case 'superuser at space1':
              case 'space_1_all at space1':
              case 'space_1_all_alerts_none_actions at space1':
              case 'space_1_all_with_restricted_fixture at space1':
                expect(response.body).to.eql({
                  statusCode: 404,
                  error: 'Not Found',
                  message: `Saved object [alert/${createdAlert.id}] not found`,
                });
                break;
              default:
                throw new Error(`Scenario untested: ${JSON.stringify(scenario)}`);
            }
          });
        });
      }
    });
  }
  