import { handler } from '@functions/swg-lambda-fetch-profile';
import { SQSEvent, SQSRecord } from 'aws-lambda';
import { Db } from 'mongodb';
import Redis from 'ioredis';
import config from 'config';

import {
  connectToRedis,
  getMongoConnection,
  disconnectMongoConnection,
  getRecordMessage,
  createUserSWGProfile,
  createWebRule,
  createBypassRule,
  createInternalResourcesBypassRule,
  createSwgStatus,
  createGroup,
  createSwgRootCertificate,
  urlCategories,
  createTpProfile,
  appCtrlApplications,
  updateUserSWGProfile,
} from '../../helper';
import IAgentPlatformsTypes from '@libs/types/IAgentPlatformsTypes';
import TpStatus from '@libs/types/TpStatus';

const tenantId = 'tenant-swg-001';
const userId = 'user-swg-001';
const userId2 = 'user-swg-002';
const userId3 = 'user-swg-003';
const groupId = 'group-swg-001';
const bypassRulesId = 'bypassRule-swg-001';
const tpProfileId = 'tpProfile-swg-001';
const webRulesId = 'webRule-swg-001';
const webRulesIdWithAppCtrlId = 'webRule-swg-002';
const deviceIdentifier = 'deviceIdentifier-001';
const deviceIdentifier2 = 'deviceIdentifier-002';
const connectionMode = 'device';
const eventTypeAgentConnect = 'agent.webSocket.connected';
const eventTypeProfileUpdate = 'profile.update.list';

let normalizedAppVersion = '11.2.0.0';
// To be deprecated
const appVersion = 'osx_7.0.3.38';
const platform: IAgentPlatformsTypes = IAgentPlatformsTypes.MACOS;
const fireflyTenantWithAppCtrl = 'tenant-swg-appCtrl-001';
jest.mock('ky', () => ({
  post: jest.fn(),
}));
const mockedResponse = { ok: true };

describe('test fetch-profile handler', () => {
  let db: Db;
  let redisClient: Redis;
  beforeAll(async () => {
    redisClient = await connectToRedis();
    db = await getMongoConnection();
    await urlCategories(db.collection('UrlCategories'));
    await appCtrlApplications(db.collection('ApplicationControlApplications'));
    await createTpProfile(db.collection('ThreatPreventionProfile'), { tenantId, tpProfileId });
    await createUserSWGProfile(db.collection('UserSWGProfile'), {
      userId,
      tenantId,
      enabled: true,
      groupsOfUser: [groupId],
      bypassRules: [bypassRulesId],
      webRules: [webRulesId],
    });
    await createUserSWGProfile(db.collection('UserSWGProfile'), {
      userId: userId2,
      tenantId,
      enabled: true,
      groupsOfUser: [groupId],
      bypassRules: [bypassRulesId],
      webRules: [webRulesId],
      threatPreventionStatus: TpStatus.active,
      threatPreventionProfile: tpProfileId,
    });

    await createWebRule(db.collection('RuleWeb'), {
      tenantId,
      webRulesId,
    });
    await createBypassRule(db.collection('RuleBypass'), {
      tenantId,
      bypassRulesId,
    });
    await createInternalResourcesBypassRule(db.collection('RuleBypassInternalResources'));
    await createSwgStatus(db.collection('SwgStatus'), {
      tenantId,
    });
    await createGroup(db.collection('Group'), {
      tenantId,
      id: 'groupId-001',
      users: [`${userId}`, `${userId2}`, 'user-003'],
    });
    await createGroup(db.collection('Group'), {
      tenantId,
      id: 'groupId-002',
      users: [`${userId}`, 'user-003', 'user-005'],
    });
    await createSwgRootCertificate(db.collection('SWGRootCertificate'), {
      tenantId,
      id: 'SwgRootCertificateId-001',
    });
    await createWebRule(
      db.collection('RuleWeb'),
      {
        tenantId: fireflyTenantWithAppCtrl,
        webRulesId: webRulesIdWithAppCtrlId,
      },
      true,
    );

    await createUserSWGProfile(db.collection('UserSWGProfile'), {
      userId: userId3,
      tenantId: fireflyTenantWithAppCtrl,
      enabled: true,
      groupsOfUser: [groupId],
      bypassRules: [],
      webRules: [webRulesIdWithAppCtrlId],
    });
  });
  beforeEach(() => {
    jest.clearAllMocks();
    require('ky').post.mockResolvedValue(mockedResponse);
  });
  it('test001 should process successfully a message of type agent.webSocket.connected ', async () => {
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '1',
      body: {
        tenantId,
        userId,
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toStrictEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-001');
  });

  it('test002 should process successfully a two message of type agent.webSocket.connected', async () => {
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '1',
      body: {
        tenantId,
        userId,
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });
    const recordMessageSuccess2: SQSRecord = getRecordMessage({
      messageId: '2',
      body: {
        tenantId,
        userId: userId2,
        deviceIdentifier: deviceIdentifier2,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });
    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess, recordMessageSuccess2],
    };
    const res = await handler(sqsEvent);
    expect(res).toStrictEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(2);
    expect(require('ky').post).toMatchSnapshot('test-002');
  });

  it('test003 should fail message of type agent.webSocket.connected', async () => {
    const mockedErrorResponse = { ok: false };
    require('ky').post.mockResolvedValueOnce(mockedErrorResponse);

    const recordMessageFailed: SQSRecord = getRecordMessage({
      messageId: '3',
      body: {
        tenantId,
        userId,
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });
    const sqsEvent: SQSEvent = {
      Records: [recordMessageFailed],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [
        {
          itemIdentifier: '3',
        },
      ],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-003');
  });

  it('test004 should fail 1 message and 1 message process successfully of type agent.webSocket.connected', async () => {
    require('ky').post.mockClear();
    require('ky').post.mockImplementation((url: string, json: object) => {
      if (JSON.stringify(json).includes(userId)) {
        return { ok: false };
      }
      return { ok: true };
    });
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '4',
      body: {
        tenantId,
        userId,
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });
    const recordMessageSuccess2: SQSRecord = getRecordMessage({
      messageId: '5',
      body: {
        tenantId,
        userId: userId2,
        deviceIdentifier: deviceIdentifier2,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });
    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess, recordMessageSuccess2],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [
        {
          itemIdentifier: '4',
        },
      ],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(2);
    expect(require('ky').post).toMatchSnapshot('test-004');
  });

  it('test005 should process successfully a message of type profile.update.list ', async () => {
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '6',
      body: [{ tenantId, userId, normalizedAppVersion, platform, deviceIdentifier }],
      eventTypeValue: eventTypeProfileUpdate,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toStrictEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-005');
  });

  it('test006 should process successfully a two message of type profile.update.list', async () => {
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '7',
      body: [{ tenantId, userId, normalizedAppVersion, platform, deviceIdentifier }],
      eventTypeValue: eventTypeProfileUpdate,
    });

    const recordMessageSuccess2: SQSRecord = getRecordMessage({
      messageId: '8',
      body: [{ tenantId, userId: userId2, normalizedAppVersion, platform, deviceIdentifier }],
      eventTypeValue: eventTypeProfileUpdate,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess, recordMessageSuccess2],
    };
    const res = await handler(sqsEvent);
    expect(res).toStrictEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(2);
    expect(require('ky').post).toMatchSnapshot('test-006');
  });

  it('test007 should fail message of type profile.update.list ', async () => {
    const mockedErrorResponse = { ok: false };
    require('ky').post.mockResolvedValueOnce(mockedErrorResponse);

    const recordMessageFailed: SQSRecord = getRecordMessage({
      messageId: '9',
      body: [{ tenantId, userId, normalizedAppVersion, platform, deviceIdentifier }],
      eventTypeValue: eventTypeProfileUpdate,
    });
    const sqsEvent: SQSEvent = {
      Records: [recordMessageFailed],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [
        {
          itemIdentifier: '9',
        },
      ],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-007');
  });

  it('test008 should fail 1 message and 1 message process successfully of type profile.update.list ', async () => {
    require('ky').post.mockClear();
    require('ky').post.mockImplementation((url: string, json: object) => {
      if (JSON.stringify(json).includes(userId)) {
        return { ok: false };
      }
      return { ok: true };
    });
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '10',
      body: [{ tenantId, userId, normalizedAppVersion, platform, deviceIdentifier }],
      eventTypeValue: eventTypeProfileUpdate,
    });
    const recordMessageSuccess2: SQSRecord = getRecordMessage({
      messageId: '11',
      body: [{ tenantId, userId: userId2, normalizedAppVersion, platform, deviceIdentifier }],
      eventTypeValue: eventTypeProfileUpdate,
    });
    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess, recordMessageSuccess2],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [
        {
          itemIdentifier: '10',
        },
      ],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(2);
    expect(require('ky').post).toMatchSnapshot('test-008');
  });

  it('test009 should process successfully a two messages of types agent.webSocket.connected and profile.update.list ', async () => {
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '12',
      body: {
        tenantId,
        userId,
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const recordMessageSuccess2: SQSRecord = getRecordMessage({
      messageId: '13',
      body: [
        { tenantId, userId: userId2, normalizedAppVersion, platform, appVersion, deviceIdentifier },
      ],
      eventTypeValue: eventTypeProfileUpdate,
    });
    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess, recordMessageSuccess2],
    };
    const res = await handler(sqsEvent);
    expect(res).toStrictEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(2);
    expect(require('ky').post).toMatchSnapshot('test-009');
  });

  it('test010 should fail two messages of types agent.webSocket.connected and profile.update.list ', async () => {
    const mockedErrorResponse = { ok: false };
    require('ky').post.mockResolvedValue(mockedErrorResponse);
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '14',
      body: {
        tenantId,
        userId,
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const recordMessageSuccess2: SQSRecord = getRecordMessage({
      messageId: '15',
      body: [{ tenantId, userId: userId2, normalizedAppVersion, platform, deviceIdentifier }],
      eventTypeValue: eventTypeProfileUpdate,
    });
    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess, recordMessageSuccess2],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [{ itemIdentifier: '14' }, { itemIdentifier: '15' }],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(2);
    expect(require('ky').post).toMatchSnapshot('test-010');
  });

  it('test011 should schema validation failed for two messages type agent.webSocket.connected and profile.update.list ', async () => {
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '16',
      body: { tenantId, userId, deviceIdentifier },
      eventTypeValue: eventTypeAgentConnect,
    });

    const recordMessageSuccess2: SQSRecord = getRecordMessage({
      messageId: '17',
      body: [{ tenantId }],
      eventTypeValue: eventTypeProfileUpdate,
    });
    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess, recordMessageSuccess2],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(0);
  });

  it('test012 userId not exist should return general profile ', async () => {
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '18',
      body: {
        tenantId,
        userId: 'user-003',
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-012');
  });

  it('test013 tenantId no rule userId not exist should return general profile', async () => {
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '19',
      body: {
        tenantId: 'not-exist',
        userId: 'user-003',
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-013');
  });

  it('test014 ffKey.swg.firefly exist on tenant return true', async () => {
    const fireflyTenant = 'tenantId-firefly';
    redisClient.set(
      `${config.get('redis.cacheFFKeyTenant')}${fireflyTenant}`,
      JSON.stringify([config.get('swgFirefly')]),
    );
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '20',
      body: {
        tenantId: fireflyTenant,
        userId: 'user-003',
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-014');
  });

  it('test015 ffKey.swg.firefly exist not tenant return false', async () => {
    const fireflyTenant = 'tenantId-firefly-not-exist';
    redisClient.set(`${config.get('redis.cacheFFKeyTenant')}${fireflyTenant}`, JSON.stringify([]));
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '21',
      body: {
        tenantId: fireflyTenant,
        userId: 'user-003',
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-015');
  });

  it('`test016` ffKey.swg.firefly exist on GA return true', async () => {
    const fireflyTenant = 'tenantId-firefly-002';
    redisClient.set(
      config.get('redis.cacheGaFeatureKey'),
      JSON.stringify([config.get('swgFirefly')]),
    );
    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '22',
      body: {
        tenantId: fireflyTenant,
        userId: 'user-003',
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-016');
  });

  it('test017 ffKey.swg.firefly exist on GA and tenant return true', async () => {
    const fireflyTenant = 'tenantId-firefly-003';
    redisClient.set(
      `${config.get('redis.cacheFFKeyTenant')}${fireflyTenant}`,
      JSON.stringify([config.get('swgFirefly')]),
    );
    redisClient.set(
      config.get('redis.cacheGaFeatureKey'),
      JSON.stringify([config.get('swgFirefly')]),
    );

    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '23',
      body: {
        tenantId: fireflyTenant,
        userId: 'user-003',
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-017');
  });

  it('test018 ffKey.swg.firefly exist on GA and tenant return true firefly return exception', async () => {
    process.env.ENFORCE_SCHEMA_VERSION = 'no-schema';
    process.env.ENFORCE_TEMPLATE_VERSION = 'no-template';

    const fireflyTenant = 'tenantId-firefly-003';
    redisClient.set(
      `${config.get('redis.cacheFFKeyTenant')}${fireflyTenant}`,
      JSON.stringify([config.get('swgFirefly')]),
    );
    redisClient.set(
      config.get('redis.cacheGaFeatureKey'),
      JSON.stringify([config.get('swgFirefly')]),
    );

    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '24',
      body: {
        tenantId: fireflyTenant,
        userId: 'user-003',
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-018');
    delete process.env.ENFORCE_SCHEMA_VERSION;
    delete process.env.ENFORCE_TEMPLATE_VERSION;
  });

  it('test019 ffKey.swg.firefly is active , ver not support application control with application control destination filter out rule', async () => {
    process.env.ENFORCE_SCHEMA_VERSION = '';
    process.env.ENFORCE_TEMPLATE_VERSION = '';
    redisClient.set(
      `${config.get('redis.cacheFFKeyTenant')}${fireflyTenantWithAppCtrl}`,
      JSON.stringify([config.get('swgFirefly')]),
    );
    redisClient.set(
      config.get('redis.cacheGaFeatureKey'),
      JSON.stringify([config.get('swgFirefly')]),
    );

    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '25',
      body: {
        tenantId: fireflyTenantWithAppCtrl,
        userId: userId3,
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-019');
    delete process.env.ENFORCE_SCHEMA_VERSION;
    delete process.env.ENFORCE_TEMPLATE_VERSION;
  });

  it('test020 ffKey.swg.firefly is active , ver not support application control with application control and categories destination filter out application control destination only', async () => {
    process.env.ENFORCE_SCHEMA_VERSION = '';
    process.env.ENFORCE_TEMPLATE_VERSION = '';
    redisClient.set(
      `${config.get('redis.cacheFFKeyTenant')}${fireflyTenantWithAppCtrl}`,
      JSON.stringify([config.get('swgFirefly')]),
    );
    redisClient.set(
      config.get('redis.cacheGaFeatureKey'),
      JSON.stringify([config.get('swgFirefly')]),
    );

    await updateUserSWGProfile(db.collection('UserSWGProfile'), {
      userId: userId3,
      tenantId: fireflyTenantWithAppCtrl,
      enabled: true,
      groupsOfUser: [groupId],
      bypassRules: [],
      webRules: [webRulesIdWithAppCtrlId, webRulesId],
    });

    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '26',
      body: {
        tenantId: fireflyTenantWithAppCtrl,
        userId: userId3,
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-020');
    delete process.env.ENFORCE_SCHEMA_VERSION;
    delete process.env.ENFORCE_TEMPLATE_VERSION;
  });

  it('test021 ffKey.swg.firefly is active , ver support application control with application control destination', async () => {
    process.env.ENFORCE_SCHEMA_VERSION = '';
    process.env.ENFORCE_TEMPLATE_VERSION = '';
    normalizedAppVersion = '11.4.0.0';
    redisClient.set(
      `${config.get('redis.cacheFFKeyTenant')}${fireflyTenantWithAppCtrl}`,
      JSON.stringify([config.get('swgFirefly')]),
    );
    redisClient.set(
      config.get('redis.cacheGaFeatureKey'),
      JSON.stringify([config.get('swgFirefly')]),
    );

    await updateUserSWGProfile(db.collection('UserSWGProfile'), {
      userId: userId3,
      tenantId: fireflyTenantWithAppCtrl,
      enabled: true,
      groupsOfUser: [groupId],
      bypassRules: [],
      webRules: [webRulesIdWithAppCtrlId],
    });

    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '27',
      body: {
        tenantId: fireflyTenantWithAppCtrl,
        userId: userId3,
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion,
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-021');
    delete process.env.ENFORCE_SCHEMA_VERSION;
    delete process.env.ENFORCE_TEMPLATE_VERSION;
  });

  it('test022 ver not support application control and not support firefly', async () => {
    process.env.ENFORCE_SCHEMA_VERSION = '';
    process.env.ENFORCE_TEMPLATE_VERSION = '';

    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '25',
      body: {
        tenantId: fireflyTenantWithAppCtrl,
        userId: userId3,
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion: '1.11.0.0',
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-22');
    delete process.env.ENFORCE_SCHEMA_VERSION;
    delete process.env.ENFORCE_TEMPLATE_VERSION;
  });

  it('test023 ver not support application control and not support firefly with application control and categories destination filter out application control destination only', async () => {
    process.env.ENFORCE_SCHEMA_VERSION = '';
    process.env.ENFORCE_TEMPLATE_VERSION = '';

    await updateUserSWGProfile(db.collection('UserSWGProfile'), {
      userId: userId3,
      tenantId: fireflyTenantWithAppCtrl,
      enabled: true,
      groupsOfUser: [groupId],
      bypassRules: [],
      webRules: [webRulesIdWithAppCtrlId, webRulesId],
    });

    const recordMessageSuccess: SQSRecord = getRecordMessage({
      messageId: '26',
      body: {
        tenantId: fireflyTenantWithAppCtrl,
        userId: userId3,
        deviceIdentifier,
        connectionMode,
        normalizedAppVersion: '1.11.0.0',
        platform,
        appVersion,
      },
      eventTypeValue: eventTypeAgentConnect,
    });

    const sqsEvent: SQSEvent = {
      Records: [recordMessageSuccess],
    };
    const res = await handler(sqsEvent);
    expect(res).toEqual({
      batchItemFailures: [],
    });
    expect(require('ky').post).toHaveBeenCalledTimes(1);
    expect(require('ky').post).toMatchSnapshot('test-23');
    delete process.env.ENFORCE_SCHEMA_VERSION;
    delete process.env.ENFORCE_TEMPLATE_VERSION;
  });

  afterAll(async () => {
    await redisClient.quit(() => {});
    await disconnectMongoConnection();
  });
});