Build If-env

manifests/plugins/csv-lookup/success.yml

@@ -23,4 +23,4 @@ tree:
         - timestamp: 2023-08-06T00:00
           duration: 3600
           cloud/provider: Google Cloud
-          cloud/region: asia-east-1
+          cloud/region: asia-east1

manifests/plugins/divide/success.yml

@@ -2,7 +2,7 @@ name: divide
 description: success path
 tags:
 initialize:
-#  outputs: ['yaml']
+  outputs: ['yaml']
   plugins:
     cloud-metadata:
       method: CloudMetadata

manifests/plugins/sum/success.yml

@@ -2,7 +2,7 @@ name: sum
 description: successful path
 tags:
 initialize:
-  outputs: ['yaml']
+  # outputs: ['yaml']
   plugins:
     sum:
       method: Sum

package.json

@@ -7,8 +7,9 @@
     "email": "[email protected]"
   },
   "bin": {
+    "if-diff": "./build/diff.js",
     "if-run": "./build/index.js",
-    "if-diff": "./build/diff.js"
+    "if-env": "./build/env.js"
   },
   "bugs": {
     "url": "https://github.com/Green-Software-Foundation/if/issues/new?assignees=&labels=feedback&projects=&template=feedback.md&title=Feedback+-+"
@@ -37,6 +38,7 @@
     "@types/luxon": "^3.4.2",
     "@types/node": "^20.8.9",
     "axios-mock-adapter": "^1.22.0",
+    "cross-env": "7.0.3",
     "fixpack": "^4.0.0",
     "gts": "^5.0.0",
     "husky": "^8.0.0",
@@ -74,6 +76,7 @@
     "fix": "gts fix",
     "fix:package": "fixpack",
     "if-diff": "npx ts-node src/diff.ts",
+    "if-env": "cross-env CURRENT_DIR=$(node -p \"process.env.INIT_CWD\") npx ts-node src/env.ts",
     "if-run": "npx ts-node src/index.ts",
     "lint": "gts lint",
     "pre-commit": "lint-staged",
@@ -85,4 +88,4 @@
   },
   "stability": "stable",
   "types": "src/index.d.ts"
-}
+}

src/__mocks__/fs/index.ts

@@ -93,3 +93,11 @@ export const writeFile = async (pathToFile: string, content: string) => {
   expect(pathToFile).toBe(mockPathToFile);
   expect(content).toBe(mockObject);
 };
+
+export const stat = async (filePath: string) => {
+  if (filePath === 'true') {
+    return true;
+  } else {
+    throw new Error('File not found.');
+  }
+};

src/__tests__/unit/util/args.test.ts

@@ -1,5 +1,14 @@
 const processRunningPath = process.cwd();
 
+jest.mock('../../../util/helpers', () => ({
+  isFileExists: () => {
+    if (process.env.fileExists === 'true') {
+      return true;
+    }
+    return false;
+  },
+}));
+
 jest.mock('ts-command-line-args', () => ({
   __esModule: true,
   parse: () => {
@@ -60,6 +69,22 @@ jest.mock('ts-command-line-args', () => ({
         throw new Error('mock-error');
       case 'diff-throw':
         throw 'mock-error';
+      /** If-env mocks */
+      // case 'env-manifest-is-missing':
+      //   return;
+      case 'manifest-install-provided':
+        return {
+          install: true,
+          manifest: 'mock-manifest.yaml',
+        };
+      case 'manifest-is-not-yaml':
+        return {manifest: 'manifest'};
+      case 'manifest-path-invalid':
+        throw new Error(MANIFEST_NOT_FOUND);
+      case 'env-throw-error':
+        throw new Error('mock-error');
+      case 'env-throw':
+        throw 'mock-error';
       default:
         return {
           manifest: 'mock-manifest.yaml',
@@ -72,7 +97,11 @@ jest.mock('ts-command-line-args', () => ({
 import * as path from 'node:path';
 import {ERRORS} from '@grnsft/if-core';
 
-import {parseIEProcessArgs, parseIfDiffArgs} from '../../../util/args';
+import {
+  parseIEProcessArgs,
+  parseIfDiffArgs,
+  parseIfEnvArgs,
+} from '../../../util/args';
 
 import {STRINGS} from '../../../config';
 
@@ -84,6 +113,7 @@ const {
   TARGET_IS_NOT_YAML,
   INVALID_TARGET,
   SOURCE_IS_NOT_YAML,
+  MANIFEST_NOT_FOUND,
 } = STRINGS;
 
 describe('util/args: ', () => {
@@ -299,5 +329,79 @@ describe('util/args: ', () => {
     });
   });
 
+  describe('parseIfEnvArgs(): ', () => {
+    it('executes if `manifest` is missing.', async () => {
+      process.env.fileExists = 'true';
+      process.env.result = 'manifest-is-missing';
+      const response = await parseIfEnvArgs();
+
+      expect.assertions(1);
+
+      expect(response).toEqual({install: undefined});
+    });
+
+    it('executes if `manifest` and `install` are provided.', async () => {
+      process.env.fileExists = 'true';
+      process.env.result = 'manifest-install-provided';
+
+      const response = await parseIfEnvArgs();
+
+      expect.assertions(2);
+      expect(response).toHaveProperty('install');
+      expect(response).toHaveProperty('manifest');
+    });
+
+    it('throws an error if `manifest` is not a yaml.', async () => {
+      process.env.fileExists = 'true';
+      process.env.result = 'manifest-is-not-yaml';
+      expect.assertions(1);
+
+      try {
+        await parseIfEnvArgs();
+      } catch (error) {
+        if (error instanceof Error) {
+          expect(error).toEqual(new CliInputError(FILE_IS_NOT_YAML));
+        }
+      }
+    });
+
+    it('throws an error if `manifest` path is invalid.', async () => {
+      process.env.fileExists = 'false';
+      expect.assertions(1);
+
+      try {
+        await parseIfEnvArgs();
+      } catch (error) {
+        if (error instanceof Error) {
+          expect(error).toEqual(new CliInputError(MANIFEST_NOT_FOUND));
+        }
+      }
+    });
+
+    it('throws an error if parsing failed.', async () => {
+      process.env.result = 'env-throw-error';
+      expect.assertions(1);
+
+      try {
+        await parseIfEnvArgs();
+      } catch (error) {
+        if (error instanceof Error) {
+          expect(error).toEqual(new CliInputError('mock-error'));
+        }
+      }
+    });
+
+    it('throws error if parsing failed (not instance of error).', async () => {
+      process.env.result = 'env-throw';
+      expect.assertions(1);
+
+      try {
+        await parseIfEnvArgs();
+      } catch (error) {
+        expect(error).toEqual('mock-error');
+      }
+    });
+  });
+
   process.env = originalEnv;
 });

src/__tests__/unit/util/helpers.test.ts

@@ -1,3 +1,9 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+jest.mock('fs/promises', () => require('../../../__mocks__/fs'));
+
+const mockInfo = jest.fn();
 const mockWarn = jest.fn();
 const mockError = jest.fn();
 
@@ -6,22 +12,30 @@ jest.mock('node:readline/promises', () =>
 );
 jest.mock('../../../util/logger', () => ({
   logger: {
+    info: mockInfo,
     warn: mockWarn,
     error: mockError,
   },
 }));
+
 import {ERRORS} from '@grnsft/if-core';
+
 import {
   andHandle,
   checkIfEqual,
   formatNotMatchingLog,
   mergeObjects,
   oneIsPrimitive,
   parseManifestFromStdin,
+  isFileExists,
+  installDependencies,
+  initPackageJsonIfNotExists,
 } from '../../../util/helpers';
 import {Difference} from '../../../types/lib/compare';
+import {STRINGS} from '../../../config/strings';
 
 const {WriteFileError} = ERRORS;
+const {INITIALIZING_PACKAGE_JSON, INSTALLING_NPM_PACKAGES} = STRINGS;
 
 describe('util/helpers: ', () => {
   describe('andHandle(): ', () => {
@@ -47,9 +61,7 @@ describe('util/helpers: ', () => {
       expect(mockError).toHaveBeenCalledTimes(1);
     });
   });
-});
 
-describe('util/helpers: ', () => {
   describe('mergeObjects(): ', () => {
     it('does not override input.', () => {
       expect.assertions(1);
@@ -408,4 +420,92 @@ description: mock-description
       expect(response).toBeFalsy();
     });
   });
+
+  describe('isFileExists(): ', () => {
+    it('returns true if the file exists.', async () => {
+      const result = await isFileExists('true');
+
+      expect.assertions(1);
+      expect(result).toEqual(true);
+    });
+
+    it('returns fale if the file does not exist.', async () => {
+      const result = await isFileExists('false');
+
+      expect.assertions(1);
+      expect(result).toEqual(false);
+    });
+  });
+
+  describe('npm manipulation tests.', () => {
+    const helpers = require('../../../util/helpers');
+    const folderPath = path.resolve(__dirname, 'npm-test');
+
+    beforeAll(() => {
+      if (!fs.existsSync(folderPath)) {
+        fs.mkdirSync(folderPath, {recursive: true});
+      }
+    });
+
+    afterAll(() => {
+      if (fs.existsSync(folderPath)) {
+        fs.rmSync(folderPath, {recursive: true, force: true});
+      }
+    });
+
+    describe('initPackageJsonIfNotExists(): ', () => {
+      it('initializes package.json if it does not exist.', async () => {
+        const spyExecPromise = jest.spyOn(helpers, 'execPromise');
+        isFileExists('true');
+
+        await initPackageJsonIfNotExists(folderPath);
+
+        expect.assertions(2);
+        expect(mockInfo).toHaveBeenCalledWith(INITIALIZING_PACKAGE_JSON);
+        expect(spyExecPromise).toHaveBeenCalledWith('npm init -y', {
+          cwd: folderPath,
+        });
+      });
+
+      it('returns the package.json path if it exists.', async () => {
+        const packageJsonPath = path.resolve(folderPath, 'package.json');
+        isFileExists('false');
+
+        const result = await initPackageJsonIfNotExists(folderPath);
+
+        expect.assertions(1);
+        expect(result).toBe(packageJsonPath);
+      });
+    });
+
+    describe('installDependencies(): ', () => {
+      const dependencies = {
+        '@grnsft/if': '^0.3.3-beta.0',
+      };
+
+      it('calls execPromise with the correct arguments.', async () => {
+        const spyExecPromise = jest.spyOn(helpers, 'execPromise');
+        const formattedDependencies = ['@grnsft/[email protected]'];
+        expect.assertions(1);
+
+        await installDependencies(folderPath, dependencies);
+
+        expect(spyExecPromise).toHaveBeenCalledWith(
+          `npm install ${formattedDependencies.join(' ')}`,
+          {cwd: folderPath}
+        );
+      }, 30000);
+
+      it('logs the installation message.', async () => {
+        const dependencies = {
+          '@grnsft/if': '^0.3.3-beta.0',
+        };
+
+        await installDependencies(folderPath, dependencies);
+
+        expect.assertions(1);
+        expect(mockInfo).toHaveBeenCalledWith(INSTALLING_NPM_PACKAGES);
+      });
+    });
+  });
 });