improve: add more test (#17)

improve: add more test

- [x] improve test coverage for  rosClient
- [x] improve test coverage for  iacHelper
- [x] improve test coverage for  getVersion

Refs:

---------

Signed-off-by: seven <[email protected]>

Author: Blankll

jest.config.js

@@ -2,6 +2,7 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
+  testTimeout: 30000,
   testPathIgnorePatterns: ['/node_modules/', '/dist/'],
 };
 

tests/common/getVersion.test.ts

@@ -0,0 +1,11 @@
+import { getVersion } from '../../src/common';
+
+jest.mock('../../package.json', () => ({
+  version: '1.0.0',
+}));
+
+describe('getVersion', () => {
+  it('should return the version from package.json', () => {
+    expect(getVersion()).toBe('1.0.0');
+  });
+});

tests/common/iacHelper.test.ts

@@ -1,27 +1,78 @@
+import * as ros from '@alicloud/ros-cdk-core';
 import * as ossDeployment from '@alicloud/ros-cdk-ossdeployment';
-import { getFileSource } from '../../src/common';
+import { getFileSource, replaceReference } from '../../src/common';
 import fs from 'node:fs';
+import { context } from '../fixtures/contextFixture';
 
 jest.mock('@alicloud/ros-cdk-ossdeployment');
-
+jest.mock('@alicloud/ros-cdk-core');
 const fcName = 'testFunction';
 const location = 'tests/fixtures/artifacts/artifact.zip';
 
-describe('getFileSource', () => {
-  it('should return the correct ossDeployment source', () => {
-    getFileSource(fcName, location);
-    expect(ossDeployment.Source.asset).toHaveBeenCalledWith(
-      `${process.cwd()}/${location}`,
-      {},
-      `${fcName}/50861cd99a3a678356030f5f189300af.zip`,
-    );
+describe('Unit test for iacHelper', () => {
+  beforeEach(() => {
+    jest.restoreAllMocks();
+  });
+  describe('Unit test for getFileSource', () => {
+    it('should return the correct ossDeployment source', () => {
+      getFileSource(fcName, location);
+      expect(ossDeployment.Source.asset).toHaveBeenCalledWith(
+        `${process.cwd()}/${location}`,
+        {},
+        `${fcName}/50861cd99a3a678356030f5f189300af.zip`,
+      );
+    });
+
+    it('should throw an error if the path is a directory', () => {
+      jest.spyOn(fs, 'lstatSync').mockReturnValue({ isDirectory: () => true } as fs.Stats);
+
+      expect(() => getFileSource(fcName, location)).toThrow(
+        'The provided path is a directory, not a file.',
+      );
+    });
   });
 
-  it('should throw an error if the path is a directory', () => {
-    jest.spyOn(fs, 'lstatSync').mockReturnValue({ isDirectory: () => true } as fs.Stats);
+  describe('Unit test for replaceReference', () => {
+    it('should return the value if it does not contain any reference', () => {
+      const value = 'testValue';
+      expect(replaceReference(value, context)).toEqual(value);
+      expect(ros.Fn.ref).not.toHaveBeenCalled();
+    });
+
+    it('should return the value if it contains a stage reference', () => {
+      const value = 'testValue-${ctx.stage}';
+      expect(replaceReference(value, context)).toEqual('testValue-test');
+
+      expect(ros.Fn.ref).not.toHaveBeenCalled();
+    });
+
+    it('should return the value if it match a vars reference', () => {
+      replaceReference('${vars.testVar}', context);
+
+      expect(ros.Fn.ref).toHaveBeenCalledWith('testVar');
+    });
+
+    it('should return the value if it match a stages reference', () => {
+      replaceReference('${stages.testStage}', context);
+      expect(ros.Fn.findInMap).toHaveBeenCalledWith('stages', 'test', 'testStage');
+    });
+
+    it('should return the value if it contains a stages reference', () => {
+      replaceReference('abcd-${stages.testVar}-efg', context);
+
+      expect(ros.Fn.sub).toHaveBeenCalledWith('abcd-${testVar}-efg');
+    });
+
+    it('should return the value if it contains both stages reference and vars references', () => {
+      replaceReference('abcd-${stages.testVar}-efg-${vars.newTestVar}-hij', context);
+
+      expect(ros.Fn.sub).toHaveBeenCalledWith('abcd-${testVar}-efg-${newTestVar}-hij');
+    });
+
+    it('should return the value if it contains a functions reference', () => {
+      replaceReference('${functions.testFunction}', context);
 
-    expect(() => getFileSource(fcName, location)).toThrow(
-      'The provided path is a directory, not a file.',
-    );
+      expect(ros.Fn.getAtt).toHaveBeenCalledWith('testFunction', 'FunctionName');
+    });
   });
 });

tests/common/rosClient.test.ts

@@ -0,0 +1,88 @@
+import { logger, rosStackDeploy } from '../../src/common';
+import { context } from '../fixtures/contextFixture';
+import { lang } from '../../src/lang';
+
+const mockedCreateStack = jest.fn();
+const mockedUpdateStack = jest.fn();
+const mockedListStacks = jest.fn();
+const mockedGetStack = jest.fn();
+
+jest.mock('@alicloud/ros20190910', () => ({
+  ...jest.requireActual('@alicloud/ros20190910'),
+  __esModule: true,
+  default: jest.fn().mockImplementation(() => ({
+    createStack: () => mockedCreateStack(),
+    updateStack: () => mockedUpdateStack(),
+    listStacks: () => mockedListStacks(),
+    getStack: () => mockedGetStack(),
+  })),
+}));
+
+jest.mock('../../src/common/logger');
+
+describe('Unit test for rosClient', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should create a new stack if it does not exist', async () => {
+    mockedListStacks.mockResolvedValue({ statusCode: 200, body: { stacks: [] } });
+    mockedCreateStack.mockResolvedValue({ body: { stackId: 'newStackId' } });
+    mockedGetStack.mockResolvedValue({ body: { status: 'CREATE_COMPLETE' } });
+
+    await rosStackDeploy('newStack', {}, context);
+
+    expect(mockedCreateStack).toHaveBeenCalled();
+    expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('createStack success'));
+  });
+
+  it('should update an existing stack if it exists', async () => {
+    mockedListStacks.mockResolvedValue({
+      statusCode: 200,
+      body: { stacks: [{ stackId: 'existingStackId', Status: 'CREATE_COMPLETE' }] },
+    });
+    mockedUpdateStack.mockResolvedValue({ body: { stackId: 'existingStackId' } });
+    mockedGetStack.mockResolvedValue({ body: { status: 'UPDATE_COMPLETE' } });
+
+    await rosStackDeploy('existingStack', {}, context);
+
+    expect(mockedUpdateStack).toHaveBeenCalled();
+    expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('stackUpdate success'));
+  });
+
+  it('should throw an error if the stack is in progress', async () => {
+    mockedListStacks.mockResolvedValue({
+      statusCode: 200,
+      body: { stacks: [{ stackId: 'inProgressStackId', Status: 'CREATE_IN_PROGRESS' }] },
+    });
+
+    await expect(rosStackDeploy('inProgressStack', {}, context)).rejects.toThrow(
+      'fail to update stack, because stack status is CREATE_IN_PROGRESS',
+    );
+  });
+
+  it('should notify user with warning logs when update completely same stack', async () => {
+    mockedListStacks.mockResolvedValue({
+      statusCode: 200,
+      body: { stacks: [{ stackId: 'existingStackId', Status: 'CREATE_COMPLETE' }] },
+    });
+    mockedUpdateStack.mockRejectedValueOnce({
+      data: { statusCode: 400, Message: 'Update the completely same stack' },
+    });
+    mockedGetStack.mockResolvedValue({ body: { status: 'UPDATE_COMPLETE' } });
+
+    await rosStackDeploy('existingStack', {}, context);
+
+    expect(logger.warn).toHaveBeenCalledWith(`${lang.__('UPDATE_COMPLETELY_SAME_STACK')}`);
+  });
+
+  it('should throw error when deploy stack failed', async () => {
+    mockedListStacks.mockResolvedValue({ statusCode: 200, body: { stacks: [] } });
+    mockedCreateStack.mockResolvedValueOnce({ body: { stackId: 'newStackId' } });
+    mockedGetStack.mockResolvedValue({ body: { status: 'ROLLBACK_COMPLETE' } });
+
+    await expect(rosStackDeploy('newStack', {}, context)).rejects.toThrow(
+      `Stack operation failed with status: ROLLBACK_COMPLETE`,
+    );
+  });
+});

tests/fixtures/contextFixture.ts

@@ -0,0 +1,15 @@
+import { ActionContext } from '../../src/types';
+
+export const context: ActionContext = {
+  stage: 'test',
+  stackName: 'testStack',
+  region: 'cn-hangzhou',
+  accessKeyId: 'testAccessKeyId',
+  accessKeySecret: 'testAccessKeySecret',
+  iacLocation: 'path/to/iac/location',
+  parameters: [
+    { key: 'testVar', value: 'testVarValue' },
+    { key: 'newTestVar', value: 'newTestVarValue' },
+  ],
+  tags: [{ key: 'owner', value: 'geekfun' }],
+};