deployment-portal-fe/__tests__/helper/ChangeRequest.ts

import { getBreachedValues } from '../../src/helper/ChangeRequest';
import _ from 'lodash';

describe('Change request test', () => {
  describe('Create CR', () => {
    const limitObject = {
      deployment: {
        loadBalancers: {
          approvalFrom: [],
          forEach: {
            object: ['{"accessPolicies": ["officeIp"]}', '{"accessPolicies": ["cdn"]}'],
          },
        },
        securityGroup: {
          rules: {
            ingressCidr: { approvalFrom: ['Security'], values: ['0.0.0.0/0'] },
          },
        },
        hpa: {
          minReplicas: {
            approvalFrom: [],
            lowerBound: 5,
          },
        },
        instance: {
          cpu: {
            approvalFrom: [],
            upperBound: 4,
          },
        },
        elasticSearch: {
          approvalFrom: [],
          environments: ['qa', 'dev'],
          instance: {
            cpu: {
              approvalFrom: [],
              lowerBound: 2,
            },
            memory: {
              approvalFrom: [],
              upperBound: 4096,
            },
            diskSpace: {
              approvalFrom: [],
              upperBound: 30000,
            },
          },
        },
      },
    };

    const sampleManifestObject = {
      deployment: {
        id: 5,
        cluster: 'nonprod.np.navi-tech.in',
      },
      extraResources: {
        s3_buckets: {
          "bucketTag": "test-bucket",
          "corsPolicy": [],
          "isDeployed": false,
          "bucketPolicy": `{
        "Version": "2012-10-17",
        "Statement": [
          {
            "Effect": "Allow",
            "Principal": "*",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::your-bucket-name/*"
          }
        ]
      }`,
          "lifecycleRules": [],
          "enableAccessLog": false,
          "enablePublicBucket": false,
          "anonymizedBucketName": "test-bucket"
        }
      }
    };

    const preManifestObject: {
      deployment: { cluster: string; loadBalancers: any[]; id: number };
    } = {
      deployment: {
        id: 5,
        loadBalancers: [],
        cluster: 'nonprod.np.navi-tech.in',
      },
    };

    it('when value is decreased but still over upperBound', () => {
      const preManifestObject = _.cloneDeep(sampleManifestObject);
      const manifestObject = _.cloneDeep(sampleManifestObject);

      preManifestObject.deployment['instance'] = { cpu: 7 };
      manifestObject.deployment['instance'] = { cpu: 6 };

      const actual = getBreachedValues(limitObject, manifestObject, preManifestObject, false);
      expect(actual.length).toBe(0);
    });

    it('when value is increased but still lower than lowerBound', () => {
      const preManifestObject = _.cloneDeep(sampleManifestObject);
      const manifestObject = _.cloneDeep(sampleManifestObject);

      preManifestObject.deployment['hpa'] = { minReplicas: 2 };
      manifestObject.deployment['hpa'] = { minReplicas: 3 };

      const actual = getBreachedValues(limitObject, manifestObject, preManifestObject, false);
      expect(actual.length).toBe(0);
    });

    it('when 0.0.0.0/0 is whitelisted in ingress', () => {
      const manifestObject = _.cloneDeep(sampleManifestObject);
      manifestObject.deployment['securityGroup'] = [
        {
          ids: [],
          name: 'sgname',
          rules: [
            {
              description: '',
              fromPort: 443,
              ingressCidr: ['1.1.1.1/1', '0.0.0.0/0'],
            },
          ],
        },
      ];

      preManifestObject.deployment['securityGroup'] = [
        {
          ids: [],
          name: 'sgname',
          rules: [{ description: '', fromPort: 443, ingressCidr: ['1.1.1.1/1'] }],
        },
      ];

      const values = getBreachedValues(limitObject, manifestObject, preManifestObject, true);

      const expected = [
        {
          op: 'replace',
          path: '/deployment/securityGroup/0/rules/0/ingressCidr',
          limitPath: '/deployment/securityGroup/rules/ingressCidr',
          value: ['1.1.1.1/1', '0.0.0.0/0'],
        },
      ];

      expect(values).toStrictEqual(expected);
      expect(
        manifestObject.deployment['securityGroup'][0]['rules'][0]['ingressCidr'],
      ).toStrictEqual(preManifestObject.deployment['securityGroup'][0]['rules'][0]['ingressCidr']);
    });

    it('when internet policy is officeIp', () => {
      const manifestObject = _.cloneDeep(sampleManifestObject);
      const lb = {
        id: 8,
        endpoint: 'testonethree.np.navi-tech.in',
        extraSecurityGroups: [],
        accessPolicies: ['officeIp'],
        stickiness: false,
        isDeployed: false,
        idleTimeout: 60,
        name: 'alb3',
        type: 'alb',
      };
      manifestObject.deployment['loadBalancers'] = [lb];

      const actual = getBreachedValues(limitObject, manifestObject, preManifestObject, true);

      const expected = [
        {
          op: 'replace',
          path: '/deployment/loadBalancers/0',
          limitPath: '/deployment/loadBalancers',
          value: lb,
        },
      ];
      expect(actual).toStrictEqual(expected);
      expect(manifestObject.deployment['loadBalancers']).toStrictEqual(
        preManifestObject.deployment['loadBalancers'],
      );
    });

    describe('when internet policy is cdn', () => {
      const manifestObject = _.cloneDeep(sampleManifestObject);
      const lb = {
        id: 8,
        endpoint: 'testonethree.np.navi-tech.in',
        extraSecurityGroups: [],
        accessPolicies: ['cdn'],
        stickiness: false,
        isDeployed: false,
        idleTimeout: 60,
        name: 'alb3',
        type: 'alb',
      };
      manifestObject.deployment['loadBalancers'] = [lb];

      it('when lb already exists', () => {
        const preManifestObjectClone = _.cloneDeep(preManifestObject);
        preManifestObjectClone.deployment['loadBalancers'] = [
          {
            endpoint: 'testonethree.np.navi-tech.in',
            id: 8,
            accessPolicies: ['cdn'],
            extraSecurityGroups: [],
            isDeployed: false,
            stickiness: false,
            name: 'alb3',
            idleTimeout: 60,
            type: 'alb',
          },
        ];
        const actual = getBreachedValues(
          limitObject,
          manifestObject,
          preManifestObjectClone,
          false,
        );

        expect(actual.length).toBe(0);
      });

      it('when lb did not exist earlier', () => {
        const actual = getBreachedValues(limitObject, manifestObject, preManifestObject, false);

        const expected = [
          {
            op: 'replace',
            path: '/deployment/loadBalancers/0',
            limitPath: '/deployment/loadBalancers',
            value: lb,
          },
        ];
        expect(actual).toStrictEqual(expected);
      });
    });

    it('when elasticSearch is created in one of the blacklisted env with over the limit values', () => {
      const environment = 'qa';
      const manifest = {
        environment: environment,
        deployment: {
          elasticSearch: {
            kibana: null,
            enabled: true,
            instance: {
              cpu: '2',
              memory: '4Gi',
              password: '${elastic}',
              diskSpace: '40Gi',
              instanceName: 'instanename',
            },
          },
        },
      };

      const preManifest = {
        environment: environment,
        deployment: {},
      };

      const actual = getBreachedValues(limitObject, manifest, preManifest, false);
      const expected = [
        {
          op: 'add',
          path: '/deployment/elasticSearch',
          limitPath: '/deployment/elasticSearch',
          value: {
            kibana: null,
            enabled: true,
            instance: {
              cpu: '2',
              memory: '4Gi',
              password: '${elastic}',
              diskSpace: '40Gi',
              instanceName: 'instanename',
            },
          },
        },
        {
          op: 'add',
          path: '/deployment/elasticSearch/instance/cpu',
          limitPath: '/deployment/elasticSearch/instance/cpu',
          value: '2',
        },
        {
          op: 'add',
          path: '/deployment/elasticSearch/instance/memory',
          limitPath: '/deployment/elasticSearch/instance/memory',
          value: '4Gi',
        },
        {
          op: 'add',
          path: '/deployment/elasticSearch/instance/diskSpace',
          limitPath: '/deployment/elasticSearch/instance/diskSpace',
          value: '40Gi',
        },
      ];
      expect(actual).toStrictEqual(expected);
    });

    it('when lb type is alb in nonprod environment', () => {
      const manifestObject = _.cloneDeep(sampleManifestObject);
      const limitObject = {
        deployment: {
          loadBalancers: {
            approvalFrom: [],
            forEach: {
              object: ['{"type": "alb"}'],
            },
          },
        },
      };

      const lb = {
        id: 8,
        endpoint: 'endpoint',
        extraSecurityGroups: [],
        accessPolicies: ['internal'],
        stickiness: false,
        isDeployed: false,
        idleTimeout: 60,
        name: 'alb3',
        type: 'alb',
      };
      manifestObject.deployment['loadBalancers'] = [lb];

      const actual = getBreachedValues(limitObject, manifestObject, preManifestObject);

      expect(actual.length).toBe(1);
    });

    it('when diff in s3 policy', () =>{
      const preS3ManifestObject = _.cloneDeep(sampleManifestObject);
      const s3ManifestObject = _.cloneDeep(sampleManifestObject);
      const bucketPolicyCR = `{
        "Version": "2012-10-17",
        "Statement": [
          {
            "Effect": "Deny",
            "Principal": "*",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::your-bucket-name/*"
          }
        ]
      }`;
      const limitObject = {
           extraResources: {
             s3_buckets: {
               bucketPolicy: {
                 approvalFrom: ['Security'],
                 textDiff: true,
               }
             },
           }
      };

      s3ManifestObject.extraResources.s3_buckets.bucketPolicy = bucketPolicyCR;
      const actual = getBreachedValues(limitObject, s3ManifestObject, preS3ManifestObject);
        const expected = [
            {
                op: 'replace',
                path: '/extraResources/s3_buckets/bucketPolicy',
                limitPath: '/extraResources/s3_buckets/bucketPolicy',
                value: bucketPolicyCR,
            }
        ]
        expect(actual).toStrictEqual(expected);
    })
  });
});