Merge pull request #6 from twan-westerhof/main

fix: add terminateOperation flag to /sync call
AmericanAirlines · Aug 15, 2024 · 054b9d6 · 054b9d6
2 parents 53ad92f + e816d1e
commit 054b9d6
Show file tree

Hide file tree

Showing 6 changed files with 211 additions and 2 deletions.
diff --git a/.changeset/bright-queens-raise.md b/.changeset/bright-queens-raise.md
@@ -0,0 +1,5 @@
+---
+'@roadiehq/backstage-plugin-argo-cd': patch
+---
+
+Adding the terminateOperation flag to the /sync endpoint. It is an optional boolean flag that can be set to true and it will terminate the previous Sync in progress before starting a new sync. This is a non-breaking change because if the flag is not provided and set to true the existing logic will not be impacted.
diff --git a/plugins/backend/backstage-plugin-argo-cd-backend/src/service/argocd.service.ts b/plugins/backend/backstage-plugin-argo-cd-backend/src/service/argocd.service.ts
@@ -496,6 +496,7 @@ export class ArgoService implements ArgoServiceApi {
 
   async resyncAppOnAllArgos({
     appSelector,
+    terminateOperation,
   }: ResyncProps): Promise<SyncResponse[][]> {
     const argoAppResp: findArgoAppResp[] = await this.findArgoApp({
       selector: appSelector,
@@ -506,6 +507,19 @@ export class ArgoService implements ArgoServiceApi {
           try {
             const token = await this.getArgoToken(argoInstance);
             try {
+              if (terminateOperation) {
+                const terminateResp = argoInstance.appName.map(
+                  (argoApp: any): Promise<any> => {
+                    return this.terminateArgoAppOperation({
+                      baseUrl: argoInstance.url,
+                      argoAppName: argoApp,
+                      argoToken: token,
+                    });
+                  },
+                );
+                await Promise.all(terminateResp);
+              }
+
               const resp = argoInstance.appName.map(
                 (argoApp: any): Promise<SyncResponse> => {
                   return this.syncArgoApp({
@@ -524,7 +538,6 @@ export class ArgoService implements ArgoServiceApi {
           }
         },
       );
-
       return await Promise.all(parallelSyncCalls);
     }
     return [];

diff --git a/plugins/backend/backstage-plugin-argo-cd-backend/src/service/argocd.test.ts b/plugins/backend/backstage-plugin-argo-cd-backend/src/service/argocd.test.ts
@@ -805,6 +805,123 @@ describe('ArgoCD service', () => {
         ],
       ]);
     });
+
+    it('should sync all apps with terminateOperation flag on', async () => {
+      // findArgoApp
+      fetchMock.mockResponseOnce(
+        JSON.stringify({
+          items: [
+            {
+              metadata: {
+                name: 'testAppName',
+                namespace: 'testNamespace',
+              },
+            },
+          ],
+        }),
+      );
+      // token
+      fetchMock.mockResponseOnce(
+        JSON.stringify({
+          token: 'testToken',
+        }),
+      );
+      // terminateOperation
+      fetchMock.mockResponseOnce(JSON.stringify({}), { status: 200 });
+      // sync
+      fetchMock.mockResponseOnce('{}');
+      const resp = await argoService.resyncAppOnAllArgos({
+        appSelector: 'testApp',
+        terminateOperation: true,
+      });
+
+      expect(resp).toStrictEqual([
+        [
+          {
+            message: 'Re-synced testAppName on argoInstance1',
+            status: 'Success',
+          },
+        ],
+      ]);
+    });
+
+    it('should fail to sync all apps when terminateOperation fails', async () => {
+      // findArgoApp
+      fetchMock.mockResponseOnce(
+        JSON.stringify({
+          items: [
+            {
+              metadata: {
+                name: 'testAppName',
+                namespace: 'testNamespace',
+              },
+            },
+          ],
+        }),
+      );
+      // token
+      fetchMock.mockResponseOnce(
+        JSON.stringify({
+          token: 'testToken',
+        }),
+      );
+      // terminateOperation
+      fetchMock.mockResponseOnce(JSON.stringify({ status: 400 }));
+      // sync
+      fetchMock.mockResponseOnce(JSON.stringify({}), { status: 400 });
+
+      const resp = await argoService.resyncAppOnAllArgos({
+        appSelector: 'testApp',
+        terminateOperation: true,
+      });
+
+      expect(resp).toStrictEqual([
+        [
+          {
+            message: 'Failed to resync testAppName on argoInstance1',
+            status: 'Failure',
+          },
+        ],
+      ]);
+    });
+
+    it('should not sync all apps when terminateOperation errors', async () => {
+      // findArgoApp
+      fetchMock.mockResponseOnce(
+        JSON.stringify({
+          items: [
+            {
+              metadata: {
+                name: 'testAppName',
+                namespace: 'testNamespace',
+              },
+            },
+          ],
+        }),
+      );
+      // token
+      fetchMock.mockResponseOnce(
+        JSON.stringify({
+          token: 'testToken',
+        }),
+      );
+      // terminateOperation
+      fetchMock.mockRejectOnce(new Error('Failed on terminateOperation step'));
+
+      const resp = await argoService.resyncAppOnAllArgos({
+        appSelector: 'testApp',
+        terminateOperation: true,
+      });
+
+      expect(resp).toStrictEqual([
+        [
+          {
+            message: 'Failed on terminateOperation step',
+            status: 'Failure',
+          },
+        ],
+      ]);
+    });
   });
 
   describe('deleteAppandProject', () => {

diff --git a/plugins/backend/backstage-plugin-argo-cd-backend/src/service/router.test.ts b/plugins/backend/backstage-plugin-argo-cd-backend/src/service/router.test.ts
@@ -18,6 +18,7 @@ const mockGetArgoInstanceArray = jest.fn();
 const mockUpdateArgoProjectAndApp = jest.fn();
 const mockGetArgoApplicationInfo = jest.fn();
 const mockTerminateArgoAppOperation = jest.fn();
+const mockResyncAppOnAllArgos = jest.fn();
 jest.mock('./argocd.service', () => {
   return {
     ArgoService: jest.fn().mockImplementation(() => {
@@ -33,6 +34,7 @@ jest.mock('./argocd.service', () => {
         updateArgoProjectAndApp: mockUpdateArgoProjectAndApp,
         getArgoApplicationInfo: mockGetArgoApplicationInfo,
         terminateArgoAppOperation: mockTerminateArgoAppOperation,
+        resyncAppOnAllArgos: mockResyncAppOnAllArgos,
       };
     }),
   };
@@ -347,6 +349,72 @@ describe('router', () => {
     });
   });
 
+  describe('POST /sync', () => {
+    it('succeeds in syncing argo application', async () => {
+      const mockedResponseObj = {
+        status: 'Success',
+        message: 'Re-synced application on argoInstance',
+      };
+      mockResyncAppOnAllArgos.mockResolvedValueOnce(mockedResponseObj);
+
+      const resp = await request(app).post('/sync').send({
+        appSelector: 'backstage-name:application',
+        terminateOperation: true,
+      });
+
+      expect(resp.body).toEqual(
+        expect.objectContaining({
+          status: 'Success',
+          message: 'Re-synced application on argoInstance',
+        }),
+      );
+      expect(resp.status).toBe(200);
+    });
+
+    it('fails to sync because of some error', async () => {
+      const mockedResponseObj = {
+        message: 'Failed to sync your app, backstage-name:application.',
+        status: 500,
+      };
+      mockResyncAppOnAllArgos.mockRejectedValueOnce(new Error());
+
+      const resp = await request(app).post('/sync').send({
+        appSelector: 'backstage-name:application',
+      });
+
+      expect(resp.body).toEqual(mockedResponseObj);
+    });
+
+    it('succeeds in syncing multiple argo applications', async () => {
+      const mockedResponseObj = {
+        status: 'Success',
+        message: 'Re-synced application on argoInstance',
+      };
+      mockResyncAppOnAllArgos.mockResolvedValueOnce([
+        mockedResponseObj,
+        mockedResponseObj,
+      ]);
+
+      const resp = await request(app).post('/sync').send({
+        appSelector: 'backstage-name:application',
+      });
+
+      expect(resp.body).toEqual(
+        expect.objectContaining([
+          {
+            status: 'Success',
+            message: 'Re-synced application on argoInstance',
+          },
+          {
+            status: 'Success',
+            message: 'Re-synced application on argoInstance',
+          },
+        ]),
+      );
+      expect(resp.status).toBe(200);
+    });
+  });
+
   describe('DELETE /argoInstance/:argoInstanceName/applications/:argoAppName/operation', () => {
     it('succeeds in terminating current operation', async () => {
       const mockedResponseObj = {

diff --git a/plugins/backend/backstage-plugin-argo-cd-backend/src/service/router.ts b/plugins/backend/backstage-plugin-argo-cd-backend/src/service/router.ts
@@ -353,8 +353,13 @@ export function createRouter({
   });
   router.post('/sync', async (request, response) => {
     const appSelector = request.body.appSelector;
+    const terminateOperation: boolean =
+      Boolean(request.body.terminateOperation) ?? false;
     try {
-      const argoSyncResp = await argoSvc.resyncAppOnAllArgos({ appSelector });
+      const argoSyncResp = await argoSvc.resyncAppOnAllArgos({
+        appSelector,
+        terminateOperation,
+      });
       return response.send(argoSyncResp);
     } catch (e: any) {
       return response.status(e.status || 500).send({

diff --git a/plugins/backend/backstage-plugin-argo-cd-backend/src/service/types.ts b/plugins/backend/backstage-plugin-argo-cd-backend/src/service/types.ts
@@ -127,6 +127,7 @@ export interface SyncArgoApplicationProps {
 
 export interface ResyncProps {
   appSelector: string;
+  terminateOperation?: boolean;
 }
 
 export interface ArgoServiceApi {