Add more tests and fixed incorrect behaviour in decompile task

Author: piraces

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "azure-devops-bicep-task",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Tasks for installing Bicep CLI and running Bicep CLI build commands",
   "main": "index.js",
   "scripts": {

package.json

@@ -90,7 +90,7 @@ export function checkForVersionCompatibility(outputProcess: OutputType): void {
 
     const bicepVersionNumber = Number.parseFloat(bicepToolVersion);
     if (
-        (bicepVersionNumber < 0.4 ||
+        (bicepVersionNumber < 0.3 ||
             bicepToolVersion === '0.3.255' ||
             bicepToolVersion === '0.3.126' ||
             bicepToolVersion === '0.3.1') &&

src/decompile/index.ts

@@ -16,7 +16,7 @@
     "version": {
       "Major": 0,
       "Minor": 3,
-      "Patch": 2
+      "Patch": 3
     },
     "instanceNameFormat": "Run Bicep CLI decompile command",
     "inputs": [

src/decompile/task.json

@@ -16,7 +16,7 @@
     "version": {
       "Major": 0,
       "Minor": 3,
-      "Patch": 2
+      "Patch": 3
     },
     "instanceNameFormat": "Install Bicep CLI",
     "inputs": [

src/install/task.json

@@ -16,7 +16,7 @@
     "version": {
       "Major": 0,
       "Minor": 3,
-      "Patch": 2
+      "Patch": 3
     },
     "instanceNameFormat": "Run Bicep CLI build command",
     "inputs": [

src/run/task.json

@@ -0,0 +1,69 @@
+import * as fs from 'fs';
+import { createDirectoryIfNotExists, getFilesList } from '../../../src/decompile/common/fileUtils';
+
+jest.mock('fs');
+
+const path = require('path');
+const glob = require('glob');
+
+const existsSyncMock = jest.spyOn(fs, 'existsSync');
+const mkdirSyncMock = jest.spyOn(fs, 'mkdirSync');
+const pathJoinMock = jest.spyOn(path, 'join');
+const globHasMagicMock = jest.spyOn(glob, 'hasMagic');
+const globSyncMock = jest.spyOn(glob, 'sync');
+
+function prepareMocks(exists = false) {
+    existsSyncMock.mockImplementation(() => exists);
+    mkdirSyncMock.mockImplementation(() => undefined);
+    globSyncMock.mockImplementation(() => []);
+}
+
+function restoreMocks() {
+    existsSyncMock.mockClear();
+    mkdirSyncMock.mockClear();
+    pathJoinMock.mockClear();
+    globHasMagicMock.mockClear();
+    globSyncMock.mockClear();
+}
+
+describe('getFilesList perform valid actions', () => {
+    afterEach(() => restoreMocks());
+
+    test('if path has not wildcards', () => {
+        prepareMocks();
+
+        getFilesList('./arm_templates');
+        expect(globHasMagicMock).toHaveBeenCalled();
+        expect(pathJoinMock).toHaveBeenCalled();
+        expect(globSyncMock).toHaveBeenCalledWith('arm_templates/**', { nodir: true });
+    });
+
+    test('if path has wildcards', () => {
+        prepareMocks();
+
+        getFilesList('./arm_templates/*.json');
+        expect(globHasMagicMock).toHaveBeenCalled();
+        expect(pathJoinMock).not.toHaveBeenCalled();
+        expect(globSyncMock).toHaveBeenCalledWith('./arm_templates/*.json', { nodir: true });
+    });
+});
+
+describe('createDirectoryIfNotExists creates directory if not exists', () => {
+    afterEach(() => restoreMocks());
+
+    test('if path already exists', () => {
+        prepareMocks(true);
+
+        createDirectoryIfNotExists('any_directory', false);
+        expect(existsSyncMock).toHaveBeenCalled();
+        expect(mkdirSyncMock).not.toHaveBeenCalled();
+    });
+
+    test('if path not exists', () => {
+        prepareMocks(false);
+
+        createDirectoryIfNotExists('any_directory', false);
+        expect(existsSyncMock).toHaveBeenCalled();
+        expect(mkdirSyncMock).toHaveBeenCalled();
+    });
+});

test/decompile/common/fileUtils.spec.ts

@@ -0,0 +1,91 @@
+import { OutputType } from '../../src/run/common/enums/outputType';
+import { ProcessingType } from '../../src/run/common/enums/processingType';
+import { checkInputsAreValid, getOutputTypeForFiles, getProcessingTypeForFiles } from '../../src/decompile/index';
+
+describe('checkInputsAreValid throws correct errors', () => {
+    test('if source directory is not defined and process type is multiple', () => {
+        expect(() =>
+            checkInputsAreValid(undefined, undefined, 'multiple', undefined, undefined, undefined),
+        ).toThrowError("The variable 'sourceDirectory' is mandatory when process is 'multiple'.");
+    });
+
+    test('if source directory is not defined and process type is undefined', () => {
+        expect(() =>
+            checkInputsAreValid(undefined, undefined, undefined, undefined, undefined, undefined),
+        ).toThrowError("The variable 'sourceDirectory' is mandatory when process is 'multiple'.");
+    });
+
+    test('if source file is not defined and process type is single', () => {
+        expect(() => checkInputsAreValid(undefined, undefined, 'single', undefined, undefined, undefined)).toThrowError(
+            "The variable 'sourceFile' is mandatory when process is 'single'.",
+        );
+    });
+
+    test('if output directory is not defined and output type is outDir', () => {
+        expect(() =>
+            checkInputsAreValid('any path', undefined, 'multiple', 'outDir', undefined, undefined),
+        ).toThrowError("The variable 'outDir' is mandatory when outputProcess is 'outDir'.");
+    });
+
+    test('if output file is not defined and output type is outFile', () => {
+        expect(() =>
+            checkInputsAreValid('any path', undefined, 'multiple', 'outFile', undefined, undefined),
+        ).toThrowError("The variable 'outFile' is mandatory when outputProcess is 'outFile'.");
+    });
+});
+
+describe('getProcessingTypeForFiles returns correct ProcessingType', () => {
+    test('if source directory is defined and process type is multiple then processing type is multiple', () => {
+        expect(getProcessingTypeForFiles('.', undefined, 'multiple')).toEqual(ProcessingType.Multiple);
+    });
+
+    test('if source directory is not defined and process type is multiple then processing type is Invalid', () => {
+        expect(getProcessingTypeForFiles(undefined, undefined, 'multiple')).toEqual(ProcessingType.Invalid);
+    });
+
+    test('if source directory is defined and process type is undefined then processing type is multiple', () => {
+        expect(getProcessingTypeForFiles('.', undefined, undefined)).toEqual(ProcessingType.Multiple);
+    });
+
+    test('if source directory is not defined and process type is undefined then processing type is Invalid', () => {
+        expect(getProcessingTypeForFiles(undefined, undefined, undefined)).toEqual(ProcessingType.Invalid);
+    });
+
+    test('if source file is defined and process type is single then processing type is single', () => {
+        expect(getProcessingTypeForFiles(undefined, '.', 'single')).toEqual(ProcessingType.Single);
+    });
+
+    test('if source file is not defined and process type is single then processing type is Invalid', () => {
+        expect(getProcessingTypeForFiles(undefined, undefined, 'single')).toEqual(ProcessingType.Invalid);
+    });
+});
+
+describe('getOutputTypeForFiles returns correct OutputType', () => {
+    test('if stdout enabled then returns OutputType.Stdout', () => {
+        expect(getOutputTypeForFiles(undefined, undefined, true, undefined)).toEqual(OutputType.Stdout);
+    });
+
+    test('if output file is set then returns OutputType.OutFile', () => {
+        expect(getOutputTypeForFiles(undefined, 'anyFile', undefined, undefined)).toEqual(OutputType.OutFile);
+    });
+
+    test('if output directory is set then returns OutputType.OutDir', () => {
+        expect(getOutputTypeForFiles('.', undefined, undefined, undefined)).toEqual(OutputType.OutDir);
+    });
+
+    test('if no option is set then returns OutputType.Default', () => {
+        expect(getOutputTypeForFiles(undefined, undefined, undefined, undefined)).toEqual(OutputType.Default);
+    });
+
+    test('if outputProcess is set to stdout then returns OutputType.Stdout', () => {
+        expect(getOutputTypeForFiles(undefined, undefined, undefined, 'stdout')).toEqual(OutputType.Stdout);
+    });
+
+    test('if outputProcess is set to outFile then returns OutputType.OutFile', () => {
+        expect(getOutputTypeForFiles(undefined, undefined, undefined, 'outFile')).toEqual(OutputType.OutFile);
+    });
+
+    test('if outputProcess is set to outDir then returns OutputType.OutDir', () => {
+        expect(getOutputTypeForFiles(undefined, undefined, undefined, 'outDir')).toEqual(OutputType.OutDir);
+    });
+});

test/decompile/index.spec.ts

@@ -1,24 +1,37 @@
+import { OutputType } from '../../src/run/common/enums/outputType';
 import { ProcessingType } from '../../src/run/common/enums/processingType';
-import { checkInputsAreValid, getProcessingTypeForFiles } from '../../src/run/index';
+import { checkInputsAreValid, getOutputTypeForFiles, getProcessingTypeForFiles } from '../../src/run/index';
 
 describe('checkInputsAreValid throws correct errors', () => {
     test('if source directory is not defined and process type is multiple', () => {
-        expect(() => checkInputsAreValid(undefined, undefined, 'multiple')).toThrowError(
-            "The variable 'sourceDirectory' is mandatory when process is 'multiple'.",
-        );
+        expect(() =>
+            checkInputsAreValid(undefined, undefined, 'multiple', undefined, undefined, undefined),
+        ).toThrowError("The variable 'sourceDirectory' is mandatory when process is 'multiple'.");
     });
 
     test('if source directory is not defined and process type is undefined', () => {
-        expect(() => checkInputsAreValid(undefined, undefined, undefined)).toThrowError(
-            "The variable 'sourceDirectory' is mandatory when process is 'multiple'.",
-        );
+        expect(() =>
+            checkInputsAreValid(undefined, undefined, undefined, undefined, undefined, undefined),
+        ).toThrowError("The variable 'sourceDirectory' is mandatory when process is 'multiple'.");
     });
 
     test('if source file is not defined and process type is single', () => {
-        expect(() => checkInputsAreValid(undefined, undefined, 'single')).toThrowError(
+        expect(() => checkInputsAreValid(undefined, undefined, 'single', undefined, undefined, undefined)).toThrowError(
             "The variable 'sourceFile' is mandatory when process is 'single'.",
         );
     });
+
+    test('if output directory is not defined and output type is outDir', () => {
+        expect(() =>
+            checkInputsAreValid('any path', undefined, 'multiple', 'outDir', undefined, undefined),
+        ).toThrowError("The variable 'outDir' is mandatory when outputProcess is 'outDir'.");
+    });
+
+    test('if output file is not defined and output type is outFile', () => {
+        expect(() =>
+            checkInputsAreValid('any path', undefined, 'multiple', 'outFile', undefined, undefined),
+        ).toThrowError("The variable 'outFile' is mandatory when outputProcess is 'outFile'.");
+    });
 });
 
 describe('getProcessingTypeForFiles returns correct ProcessingType', () => {
@@ -46,3 +59,33 @@ describe('getProcessingTypeForFiles returns correct ProcessingType', () => {
         expect(getProcessingTypeForFiles(undefined, undefined, 'single')).toEqual(ProcessingType.Invalid);
     });
 });
+
+describe('getOutputTypeForFiles returns correct OutputType', () => {
+    test('if stdout enabled then returns OutputType.Stdout', () => {
+        expect(getOutputTypeForFiles(undefined, undefined, true, undefined)).toEqual(OutputType.Stdout);
+    });
+
+    test('if output file is set then returns OutputType.OutFile', () => {
+        expect(getOutputTypeForFiles(undefined, 'anyFile', undefined, undefined)).toEqual(OutputType.OutFile);
+    });
+
+    test('if output directory is set then returns OutputType.OutDir', () => {
+        expect(getOutputTypeForFiles('.', undefined, undefined, undefined)).toEqual(OutputType.OutDir);
+    });
+
+    test('if no option is set then returns OutputType.Default', () => {
+        expect(getOutputTypeForFiles(undefined, undefined, undefined, undefined)).toEqual(OutputType.Default);
+    });
+
+    test('if outputProcess is set to stdout then returns OutputType.Stdout', () => {
+        expect(getOutputTypeForFiles(undefined, undefined, undefined, 'stdout')).toEqual(OutputType.Stdout);
+    });
+
+    test('if outputProcess is set to outFile then returns OutputType.OutFile', () => {
+        expect(getOutputTypeForFiles(undefined, undefined, undefined, 'outFile')).toEqual(OutputType.OutFile);
+    });
+
+    test('if outputProcess is set to outDir then returns OutputType.OutDir', () => {
+        expect(getOutputTypeForFiles(undefined, undefined, undefined, 'outDir')).toEqual(OutputType.OutDir);
+    });
+});

test/run/index.spec.ts

@@ -1,7 +1,7 @@
 {
     "manifestVersion": 1,
     "id": "bicep-tasks",
-    "version": "0.3.2",
+    "version": "0.3.3",
     "name": "Bicep Tasks",
     "publisher": "piraces",
     "description": "Provides Azure DevOps tasks to install and run Microsoft Bicep CLI commands (cross-platform)",