Blue/Green Refactor (#229)

* fresh new branch

* Added coverage to gitignore

Signed-off-by: Jaiveer Katariya <jaiveerkatariya@Jaiveers-MBP.lan>

* reverted package-lock.json

Signed-off-by: Jaiveer Katariya <jaiveerkatariya@Jaiveers-MBP.lan>
Co-authored-by: Jaiveer Katariya <jaiveerkatariya@Jaiveers-MBP.lan>

src/strategyHelpers/blueGreen/blueGreenHelper.test.ts

@@ -1,18 +1,25 @@
 import {
-   createWorkloadsWithLabel,
-   deleteWorkloadsAndServicesWithLabel,
+   deployWithLabel,
+   deleteGreenObjects,
+   fetchResource,
+   getDeploymentMatchLabels,
    getManifestObjects,
    getNewBlueGreenObject,
    GREEN_LABEL_VALUE,
-   isServiceRouted,
-   NONE_LABEL_VALUE
+   isServiceRouted
 } from './blueGreenHelper'
+import {BlueGreenDeployment} from '../../types/blueGreenTypes'
 import * as bgHelper from './blueGreenHelper'
 import {Kubectl} from '../../types/kubectl'
 import * as fileHelper from '../../utilities/fileUtils'
+import {K8sObject} from '../../types/k8sObject'
+import * as manifestUpdateUtils from '../../utilities/manifestUpdateUtils'
+import {ExecOutput} from '@actions/exec'
 
 jest.mock('../../types/kubectl')
 
+const kubectl = new Kubectl('')
+
 describe('bluegreenhelper functions', () => {
    let testObjects
    beforeEach(() => {
@@ -25,7 +32,29 @@ describe('bluegreenhelper functions', () => {
          .mockImplementationOnce(() => [''])
    })
 
-   test('it should parse objects correctly from one file', () => {
+   test('correctly deletes services and workloads according to label', async () => {
+      jest.spyOn(bgHelper, 'deleteObjects').mockReturnValue({} as Promise<void>)
+
+      const value = await deleteGreenObjects(
+         kubectl,
+         [].concat(
+            testObjects.deploymentEntityList,
+            testObjects.serviceEntityList
+         )
+      )
+
+      expect(value).toHaveLength(2)
+      expect(value).toContainEqual({
+         name: 'nginx-service-green',
+         kind: 'Service'
+      })
+      expect(value).toContainEqual({
+         name: 'nginx-deployment-green',
+         kind: 'Deployment'
+      })
+   })
+
+   test('parses objects correctly from one file (getManifestObjects)', () => {
       expect(testObjects.deploymentEntityList[0].kind).toBe('Deployment')
       expect(testObjects.serviceEntityList[0].kind).toBe('Service')
       expect(testObjects.ingressEntityList[0].kind).toBe('Ingress')
@@ -35,40 +64,16 @@ describe('bluegreenhelper functions', () => {
       ).toBe('nginx')
    })
 
-   test('correctly makes new blue green object', () => {
-      const modifiedDeployment = getNewBlueGreenObject(
-         testObjects.deploymentEntityList[0],
-         GREEN_LABEL_VALUE
+   test('parses other kinds of objects (getManifestObjects)', () => {
+      const otherObjectsCollection = getManifestObjects([
+         'test/unit/manifests/anomaly-objects-test.yml'
+      ])
+      expect(
+         otherObjectsCollection.unroutedServiceEntityList[0].metadata.name
+      ).toBe('unrouted-service')
+      expect(otherObjectsCollection.otherObjects[0].metadata.name).toBe(
+         'foobar-rollout'
       )
-      //@ts-ignore
-      expect(modifiedDeployment.metadata.name).toBe('nginx-deployment-green')
-      //@ts-ignore
-      expect(modifiedDeployment.metadata.labels['k8s.deploy.color']).toBe(
-         'green'
-      )
-
-      const modifiedSvc = getNewBlueGreenObject(
-         testObjects.serviceEntityList[0],
-         GREEN_LABEL_VALUE
-      )
-      //@ts-ignore
-      expect(modifiedSvc.metadata.name).toBe('nginx-service-green')
-      //@ts-ignore
-      expect(modifiedSvc.metadata.labels['k8s.deploy.color']).toBe('green')
-   })
-
-   test('correctly makes labeled workloads', () => {
-      const kubectl = new Kubectl('')
-      expect(Kubectl).toBeCalledTimes(1)
-      const cwlResult = createWorkloadsWithLabel(
-         kubectl,
-         testObjects.deploymentEntityList,
-         GREEN_LABEL_VALUE
-      )
-      cwlResult.then((value) => {
-         //@ts-ignore
-         expect(value.newFilePaths[0]).toBe('')
-      })
    })
 
    test('correctly classifies routed services', () => {
@@ -87,42 +92,105 @@ describe('bluegreenhelper functions', () => {
       ).toBe(false)
    })
 
-   test('correctly deletes services and workloads according to label', () => {
-      const kubectl = new Kubectl('')
-      jest.spyOn(bgHelper, 'deleteObjects').mockReturnValue({} as Promise<void>)
-
-      let objectsToDelete = deleteWorkloadsAndServicesWithLabel(
+   test('correctly makes labeled workloads', async () => {
+      const cwlResult: BlueGreenDeployment = await deployWithLabel(
          kubectl,
-         NONE_LABEL_VALUE,
          testObjects.deploymentEntityList,
-         testObjects.serviceEntityList
+         GREEN_LABEL_VALUE
       )
-      objectsToDelete.then((value) => {
-         expect(value).toHaveLength(2)
-         expect(value).toContainEqual
-         ;({name: 'nginx-service', kind: 'Service'})
-         expect(value).toContainEqual({
-            name: 'nginx-deployment',
-            kind: 'Deployment'
-         })
-      })
+      expect(cwlResult.deployResult.manifestFiles[0]).toBe('')
+   })
 
-      objectsToDelete = deleteWorkloadsAndServicesWithLabel(
-         kubectl,
-         GREEN_LABEL_VALUE,
-         testObjects.deploymentEntityList,
-         testObjects.serviceEntityList
+   test('correctly makes new blue green object (getNewBlueGreenObject and addBlueGreenLabelsAndAnnotations)', () => {
+      const modifiedDeployment = getNewBlueGreenObject(
+         testObjects.deploymentEntityList[0],
+         GREEN_LABEL_VALUE
       )
-      objectsToDelete.then((value) => {
-         expect(value).toHaveLength(2)
-         expect(value).toContainEqual({
-            name: 'nginx-service-green',
-            kind: 'Service'
+
+      expect(modifiedDeployment.metadata.name).toBe('nginx-deployment-green')
+      expect(modifiedDeployment.metadata.labels['k8s.deploy.color']).toBe(
+         'green'
+      )
+
+      const modifiedSvc = getNewBlueGreenObject(
+         testObjects.serviceEntityList[0],
+         GREEN_LABEL_VALUE
+      )
+
+      expect(modifiedSvc.metadata.name).toBe('nginx-service-green')
+      expect(modifiedSvc.metadata.labels['k8s.deploy.color']).toBe('green')
+   })
+
+   test('correctly fetches k8s objects', async () => {
+      const mockExecOutput = {
+         stderr: '',
+         stdout: JSON.stringify(testObjects.deploymentEntityList[0]),
+         exitCode: 0
+      }
+
+      jest
+         .spyOn(kubectl, 'getResource')
+         .mockImplementation(() => Promise.resolve(mockExecOutput))
+      const fetched = await fetchResource(
+         kubectl,
+         'nginx-deployment',
+         'Deployment'
+      )
+      expect(fetched.metadata.name).toBe('nginx-deployment')
+   })
+
+   test('exits when fails to fetch k8s objects', async () => {
+      const mockExecOutput = {
+         stdout: 'this should not matter',
+         exitCode: 0,
+         stderr: 'this is a fake error'
+      } as ExecOutput
+      jest
+         .spyOn(kubectl, 'getResource')
+         .mockImplementation(() => Promise.resolve(mockExecOutput))
+      let fetched = await fetchResource(
+         kubectl,
+         'nginx-deployment',
+         'Deployment'
+      )
+      expect(fetched).toBe(null)
+
+      jest.spyOn(kubectl, 'getResource').mockImplementation()
+      fetched = await fetchResource(kubectl, 'nginx-deployment', 'Deployment')
+      expect(fetched).toBe(null)
+   })
+
+   test('returns null when fetch fails to unset k8s objects', async () => {
+      const mockExecOutput = {
+         stdout: 'this should not matter',
+         exitCode: 0,
+         stderr: 'this is a fake error'
+      } as ExecOutput
+      jest
+         .spyOn(manifestUpdateUtils, 'UnsetClusterSpecificDetails')
+         .mockImplementation(() => {
+            throw new Error('test error')
          })
-         expect(value).toContainEqual({
-            name: 'nginx-deployment-green',
-            kind: 'Deployment'
-         })
-      })
+      expect(
+         await fetchResource(kubectl, 'nginx-deployment', 'Deployment')
+      ).toBe(null)
+   })
+
+   test('gets deployment labels', () => {
+      const mockLabels = new Map<string, string>()
+      mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = GREEN_LABEL_VALUE
+      const mockPodObject: K8sObject = {
+         kind: 'Pod',
+         metadata: {name: 'testPod', labels: mockLabels},
+         spec: {}
+      }
+      expect(
+         getDeploymentMatchLabels(mockPodObject)[
+            bgHelper.BLUE_GREEN_VERSION_LABEL
+         ]
+      ).toBe(GREEN_LABEL_VALUE)
+      expect(
+         getDeploymentMatchLabels(testObjects.deploymentEntityList[0])['app']
+      ).toBe('nginx')
    })
 })