@docupace/pipeline 1.0.39-matttest.42 → 1.0.39-matttest.44

package/jest.config.js

@@ -0,0 +1,14 @@
+export default {
+  testEnvironment: 'node',
+  testMatch: [
+    '**/tests/**/*.test.js'
+  ],
+  collectCoverageFrom: [
+    'src/**/*.js',
+    '!src/**/cli.js'
+  ],
+  transform: {},
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1'
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@docupace/pipeline",
-  "version": "1.0.39-matttest.42",
+  "version": "1.0.39-matttest.44",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -33,14 +33,19 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.17.0",
+    "@jest/globals": "^30.0.0-beta.3",
     "esbuild": "^0.24.0",
     "eslint": "^9.17.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.2.1",
     "globals": "^15.14.0",
+    "jest": "^29.7.0",
     "prettier": "^3.4.2"
   },
   "scripts": {
+    "test": "NODE_OPTIONS=\"--experimental-vm-modules\" jest",
+    "test:watch": "NODE_OPTIONS=\"--experimental-vm-modules\" jest --watch",
+    "test:coverage": "NODE_OPTIONS=\"--experimental-vm-modules\" jest --coverage",
     "test-deploy-core": "dp-next-cli deploy-core-pipeline dev template",
     "test-deploy-from-site": "dp-next-cli deploy-from-site --from-env dev --to-env dev --from-site financialdev --to-site template --deploy-core true",
     "test-run-pipline": "dp-next-cli run-pipeline -r docupace-next-e2e -b master -p run-tests-qa",

package/src/next/config.js

@@ -35,17 +35,35 @@ export const environmentConfig = {
 export const appInfo = {
   'graphql-server': {
     repositoryName: 'docupace-graphql-server',
-    imageName: 'docupace-graphql-serve',
+    imageName: 'docupace-graphql-server',
     deployAttributes: [
       'image.tag',
       'graphqlServer.siteConfigRemoteBranch',
       'graphqlServer.standardConfigRemoteBranch',
     ],
   },
+  cc: {
+    repositoryName: 'docupace-ui-main',
+    imageName: 'cc-ui-app',
+    deployAttributes: ['image.tag'],
+    getAppRevision: (config) => {
+      const version = config.image.tag.slice(1);
+      return 'cc-ui-app@' + version;
+    },
+  },
   ui: {
     repositoryName: 'docupace-ui-main',
     imageName: 'enterprise-ui-app',
     deployAttributes: ['image.tag'],
+    getAppRevision: (config) => {
+      const tag = config.image.tag;
+      const version = tag.startsWith('v') ? tag.slice(1) : tag;
+      if (semver.gt(version, UI_MONO_VERSION)) {
+        return 'enterprise-ui-app@' + version;
+      } else {
+        return tag;
+      }
+    },
     updateConfigFunction: (config) => {
       if (config.image.repository.endsWith('/docupace-ui-main')) {
         const tag = config.image.tag;

package/src/next/deploy.js

@@ -303,7 +303,13 @@ export async function deployAppWithTag(application, env, site, deployTag) {
 
   if (env !== 'dev') {
     const appDetails = appInfo[application];
-    await copy2(appDetails.repositoryName, 'dev', env, deployTag);
+    await copy2(
+      appDetails.repositoryName,
+      'dev',
+      env,
+      deployTag,
+      appDetails.imageName,
+    );
   }
 
   const { repoPath, deployConfigFilePath, deployConfig } =
@@ -390,6 +396,7 @@ export async function deployApp(
       fromEnv,
       toEnv,
       fromDeployConfig.image.tag,
+      appDetails.imageName,
     );
   }
 
@@ -419,7 +426,9 @@ export async function deployApp(
     deployConfigFilePath: toDeployAppConfigFilePath,
   } = await readDeployConfig(application, toEnv, toSite, 'app');
 
-  toDeployAppConfig.revision = fromDeployConfig.image.tag;
+  toDeployAppConfig.revision = appDetails.getAppRevision
+    ? appDetails.getAppRevision(fromDeployConfig)
+    : fromDeployConfig.image.tag;
 
   // Write updated configuration to the target YAML file
   writeDeployConfig(toDeployConfigFilePath, toDeployConfig);

package/tests/README.md

@@ -0,0 +1,164 @@
+# Unit Tests for Pipeline Shared Scripts
+
+This directory contains comprehensive unit tests for all modules in the `src/next` directory.
+
+## Test Structure
+
+The test suite covers the following modules:
+
+### Core Modules
+- **alias.js** - Tests for Auth0 alias creation functionality
+- **apache.js** - Tests for Apache site configuration
+- **config.js** - Tests for environment and application configuration
+- **connect.js** - Tests for Connect site cloning and configuration
+- **copy.js** - Tests for Docker image copying between registries
+- **deploy.js** - Tests for deployment functionality (GitOps, YAML config management)
+- **haproxy.js** - Tests for HAProxy configuration synchronization
+- **jenkins.js** - Tests for Jenkins job triggering and monitoring
+- **jira.js** - Tests for Jira API integration
+- **logger.js** - Tests for command logging wrapper
+- **pipline.js** - Tests for Bitbucket pipeline triggering
+- **publish.js** - Tests for Docker image publishing
+- **pull.js** - Tests for Docker image pulling
+- **sonar.js** - Tests for SonarQube analysis
+- **util.js** - Tests for utility functions (monorepo, git operations)
+- **vault.js** - Tests for HashiCorp Vault integration
+
+## Running Tests
+
+### Run All Tests
+```bash
+npm test
+```
+
+### Run Tests with Coverage
+```bash
+npm run test:coverage
+```
+
+### Run Tests in Watch Mode
+```bash
+npm run test:watch
+```
+
+### Run Specific Test File
+```bash
+npm test tests/next/config.test.js
+```
+
+### Run Tests Matching Pattern
+```bash
+npm test -- --testNamePattern="should create alias"
+```
+
+## Test Features
+
+### Mocking Strategy
+- **External Dependencies**: All external libraries (axios, zx, fs-extra) are mocked
+- **Environment Variables**: Tests use isolated environment variable mocking
+- **File System**: File system operations are mocked to avoid actual file I/O
+- **Shell Commands**: All shell commands via zx are mocked for isolation
+
+### Test Coverage
+Each test file covers:
+- **Happy Path Scenarios**: Normal operation with valid inputs
+- **Error Handling**: Error cases and edge conditions
+- **Environment Variable Validation**: Missing or invalid environment variables
+- **API Error Handling**: Network failures and API errors
+- **Input Validation**: Invalid or missing function parameters
+
+### Example Test Structure
+```javascript
+import { jest } from '@jest/globals';
+import { functionToTest } from '../../src/next/module.js';
+
+// Mock external dependencies
+const mockDependency = jest.fn();
+jest.unstable_mockModule('external-library', () => ({
+  default: mockDependency,
+}));
+
+describe('module.js', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Reset environment variables
+  });
+
+  describe('functionToTest', () => {
+    it('should perform expected operation', async () => {
+      // Arrange - set up mocks and test data
+      // Act - call the function
+      // Assert - verify results and mock calls
+    });
+
+    it('should handle error cases', async () => {
+      // Test error scenarios
+    });
+  });
+});
+```
+
+## Test Configuration
+
+The test suite uses Jest with the following configuration:
+- **Test Environment**: Node.js
+- **Test Pattern**: `**/tests/**/*.test.js`
+- **Coverage**: Collects coverage from `src/**/*.js` (excluding CLI files)
+- **Module Type**: ES Modules
+
+## Common Test Patterns
+
+### Testing Async Functions
+```javascript
+it('should handle async operations', async () => {
+  mockFunction.mockResolvedValue(expectedResult);
+  const result = await functionUnderTest();
+  expect(result).toEqual(expectedResult);
+});
+```
+
+### Testing Error Handling
+```javascript
+it('should handle errors gracefully', async () => {
+  mockFunction.mockRejectedValue(new Error('Test error'));
+  await expect(functionUnderTest()).rejects.toThrow('Test error');
+});
+```
+
+### Testing Environment Variables
+```javascript
+it('should use environment variables', () => {
+  process.env.TEST_VAR = 'test-value';
+  const result = functionUnderTest();
+  expect(result).toContain('test-value');
+});
+```
+
+### Testing Shell Commands
+```javascript
+it('should execute correct shell commands', async () => {
+  mock$.mockResolvedValue({ stdout: 'success' });
+  await functionUnderTest();
+  expect(mock$).toHaveBeenCalledWith(
+    expect.arrayContaining([expect.stringContaining('expected-command')])
+  );
+});
+```
+
+## Adding New Tests
+
+When adding new tests:
+
+1. Create a new test file following the naming convention: `module-name.test.js`
+2. Import required testing utilities from `@jest/globals`
+3. Mock external dependencies using `jest.unstable_mockModule`
+4. Follow the AAA pattern (Arrange, Act, Assert)
+5. Test both success and failure scenarios
+6. Mock all external dependencies to ensure test isolation
+
+## Notes
+
+- Tests are designed to run in isolation without external dependencies
+- All file system operations, network calls, and shell commands are mocked
+- Environment variables are reset between tests to prevent cross-test pollution
+- The test suite focuses on unit testing individual functions rather than integration testing

package/tests/WORKING_TEST_GUIDE.md

@@ -0,0 +1,222 @@
+# Working Test Guide for ES Modules
+
+This guide explains how to write working unit tests for the ES modules in this project.
+
+## Problem
+
+The original comprehensive test files had issues with ES module imports and Jest configuration. The main issues were:
+
+1. ES module import syntax not working properly with Jest
+2. Mock configuration problems with `jest.unstable_mockModule`
+3. Template literal expectations not matching actual zx calls
+
+## Solution
+
+Use the working pattern demonstrated in the example files:
+- `tests/simple.test.js` - Basic Jest functionality
+- `tests/next/config-simple.test.js` - Testing modules without mocking
+- `tests/next/pull-simple.test.js` - Testing modules with mocking
+
+## Working Test Pattern
+
+### 1. Basic Test Structure
+
+```javascript
+// Import Jest utilities
+import { jest } from '@jest/globals';
+
+// For modules that need mocking, mock BEFORE importing
+const mockFunction = jest.fn();
+jest.unstable_mockModule('external-module', () => ({
+  functionName: mockFunction,
+}));
+
+// Import the module under test AFTER mocking dependencies
+const { functionToTest } = await import('../../src/next/module.js');
+
+describe('module.js', () => {
+  // Test implementation
+});
+```
+
+### 2. Testing Modules Without External Dependencies
+
+```javascript
+import { jest } from '@jest/globals';
+
+// Import module directly
+let configModule;
+beforeAll(async () => {
+  configModule = await import('../../src/next/config.js');
+});
+
+describe('config.js', () => {
+  it('should have correct configuration', () => {
+    expect(configModule.environments).toEqual(['dev', 'qa', 'uat', 'stage', 'prod']);
+  });
+});
+```
+
+### 3. Testing Modules With External Dependencies
+
+```javascript
+import { jest } from '@jest/globals';
+
+// Mock dependencies BEFORE importing
+const mock$ = jest.fn();
+jest.unstable_mockModule('zx', () => ({
+  $: mock$,
+}));
+
+// Import after mocking
+const { functionToTest } = await import('../../src/next/module.js');
+
+describe('module.js', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call external dependency correctly', async () => {
+    mock$.mockResolvedValue({ stdout: 'success' });
+    
+    await functionToTest('arg1', 'arg2');
+    
+    // For zx template literals, match the exact structure
+    expect(mock$).toHaveBeenCalledWith(
+      ['command ', ' ', ''],  // Template literal parts
+      'arg1',                  // First interpolated value
+      'arg2'                   // Second interpolated value
+    );
+  });
+});
+```
+
+### 4. Understanding zx Template Literal Calls
+
+When zx processes a template literal like:
+```javascript
+await $`docker pull ${registry}/${image}`;
+```
+
+The mock receives:
+- First argument: Array of string parts: `['docker pull ', '/', '']`
+- Subsequent arguments: The interpolated values: `registry`, `image`
+
+So your test expectation should be:
+```javascript
+expect(mock$).toHaveBeenCalledWith(
+  ['docker pull ', '/', ''],
+  'registry-value',
+  'image-value'
+);
+```
+
+### 5. Environment Variable Testing
+
+```javascript
+describe('function with env vars', () => {
+  const originalEnv = process.env;
+  
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+  });
+  
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+  
+  it('should use environment variables', () => {
+    process.env.TEST_VAR = 'test-value';
+    // Test implementation
+  });
+});
+```
+
+## Running Tests
+
+### Prerequisites
+Make sure you have the correct configuration:
+
+**jest.config.js:**
+```javascript
+export default {
+  testEnvironment: 'node',
+  testMatch: [
+    '**/tests/**/*.test.js'
+  ],
+  collectCoverageFrom: [
+    'src/**/*.js',
+    '!src/**/cli.js'
+  ],
+  transform: {},
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1'
+  }
+};
+```
+
+**package.json scripts:**
+```json
+{
+  "scripts": {
+    "test": "NODE_OPTIONS=\"--experimental-vm-modules\" jest",
+    "test:watch": "NODE_OPTIONS=\"--experimental-vm-modules\" jest --watch",
+    "test:coverage": "NODE_OPTIONS=\"--experimental-vm-modules\" jest --coverage"
+  }
+}
+```
+
+### Commands
+
+```bash
+# Run all tests
+npm test
+
+# Run specific test file
+npm test tests/next/config-simple.test.js
+
+# Run with coverage
+npm run test:coverage
+
+# Run in watch mode
+npm run test:watch
+```
+
+## Creating New Tests
+
+1. **Create test file**: `tests/next/your-module.test.js`
+2. **Follow the pattern**: Use the working examples as templates
+3. **Mock dependencies**: Mock external modules before importing your module
+4. **Test thoroughly**: Include happy path, error cases, and edge conditions
+5. **Verify expectations**: Make sure zx template literal expectations match the actual call structure
+
+## Example Test Files
+
+- `tests/simple.test.js` - Basic Jest functionality test
+- `tests/next/config-simple.test.js` - Configuration testing without mocks
+- `tests/next/pull-simple.test.js` - Full example with mocking and zx calls
+
+## Common Issues and Solutions
+
+### Issue: `Cannot use import statement outside a module`
+**Solution**: Make sure you're using `NODE_OPTIONS="--experimental-vm-modules"` and the module is imported correctly.
+
+### Issue: Mock expectations don't match
+**Solution**: Log the actual mock calls to see the exact structure:
+```javascript
+console.log('Mock calls:', mock$.mock.calls);
+```
+
+### Issue: Environment variables not working
+**Solution**: Make sure to properly reset environment variables in `beforeEach`/`afterEach`.
+
+## Writing Comprehensive Tests
+
+For each module, test:
+1. **Happy path**: Normal operation with valid inputs
+2. **Error handling**: What happens when external calls fail
+3. **Input validation**: Invalid or missing parameters
+4. **Environment variables**: Missing or invalid env vars
+5. **Edge cases**: Boundary conditions and unusual inputs
+
+This working pattern provides a solid foundation for testing all the ES modules in the project while avoiding the common pitfalls with Jest and ES module configuration.

package/tests/next/alias.test.js

@@ -0,0 +1,99 @@
+import { jest } from '@jest/globals';
+import { createAlias } from '../../src/next/alias.js';
+
+// Mock the @docupace/core-client module
+const mockDomainApi = {
+  listRecords: jest.fn(),
+  create: jest.fn(),
+};
+
+const mockBasicAuth = jest.fn();
+
+jest.unstable_mockModule('@docupace/core-client', () => ({
+  BasicAuth: mockBasicAuth,
+  DomainApi: jest.fn(() => mockDomainApi),
+}));
+
+describe('alias.js', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('createAlias', () => {
+    it('should create an alias successfully', async () => {
+      const mockUserRecord = { id: 'user123' };
+      mockDomainApi.listRecords.mockResolvedValue({
+        records: [mockUserRecord],
+      });
+      mockDomainApi.create.mockResolvedValue();
+
+      await createAlias(
+        'https://www.dev.docupaceinc.com/financialdev',
+        'testuser',
+        'password',
+        'Connect',
+        'testalias@clients'
+      );
+
+      expect(mockBasicAuth).toHaveBeenCalledWith('testuser', 'password');
+      expect(mockDomainApi.listRecords).toHaveBeenCalledWith(50, {
+        filter: expect.stringContaining('testuser'),
+      });
+      expect(mockDomainApi.create).toHaveBeenCalledWith({
+        domainId: 302,
+        '5001': 'user123',
+        '9102': 'Connect',
+        '9504': 'testalias@clients',
+      });
+    });
+
+    it('should handle API errors gracefully', async () => {
+      mockDomainApi.listRecords.mockRejectedValue(new Error('API Error'));
+
+      await expect(
+        createAlias(
+          'https://www.dev.docupaceinc.com/financialdev',
+          'testuser',
+          'password',
+          'Connect',
+          'testalias@clients'
+        )
+      ).rejects.toThrow('API Error');
+    });
+
+    it('should create correct user filter', async () => {
+      const mockUserRecord = { id: 'user123' };
+      mockDomainApi.listRecords.mockResolvedValue({
+        records: [mockUserRecord],
+      });
+
+      await createAlias(
+        'https://www.dev.docupaceinc.com/financialdev',
+        'testuser',
+        'password',
+        'Connect',
+        'testalias@clients'
+      );
+
+      const filterCall = mockDomainApi.listRecords.mock.calls[0][1];
+      const parsedFilter = JSON.parse(filterCall.filter);
+      
+      expect(parsedFilter).toEqual({
+        orSections: [
+          {
+            andSections: [
+              {
+                attrId: 9501,
+                '@type': 'string',
+                not: false,
+                orSections: [
+                  { searchType: 'EXACT_MATCH', matchToValues: ['testuser'] },
+                ],
+              },
+            ],
+          },
+        ],
+      });
+    });
+  });
+});