Use the new OCL parsing wrapper to clean up the check

Author: mcasperson

.idea/misc.xml

@@ -1,68 +1,9 @@
 #!/usr/bin/env node
 
-const {Lexer, NodeType, Parser, TokenType} = require("@octopusdeploy/ocl")
+const {parseOclWrapper} = require("@octopusdeploy/ocl/dist/wrapper")
 const fs = require("fs")
 const path =require("path")
-
-const FirstStepName = "Manual Intervention"
-const ManualInterventionType = "Octopus.Manual"
-
-/**
- * This function performs the validation of the Octopus CaC OCL file
- * @param ocl The OCL file to parse
- * @returns {Promise<unknown>} A promise with true if the validation succeeded, and false otherwise
- */
-function checkPr(ocl) {
-    return new Promise((resolve, reject) => {
-        // Read the deployment process OCL file
-        fs.readFile(ocl, 'utf8', (err, data) => {
-            // Any error reading the file fails the script
-            if (err) {
-                console.error(err)
-                resolve(false)
-                return
-            }
-
-            // These come from the @octopusdeploy/ocl dependency
-            const lexer = new Lexer(data)
-            const parser = new Parser(lexer)
-            const steps = parser.getAST()
-
-            // Test that we have any steps at all
-            if (steps.length === 0) {
-                console.log("Deployment process can not be empty")
-                resolve(false)
-                return
-            }
-
-            const firstStepName = getUnquotedPropertyValue(getProperty(steps[0], "name"))
-
-            if (!firstStepName) {
-                console.log("Failed to find the name of the first step")
-                resolve(false)
-                return
-            }
-
-            if (firstStepName !== FirstStepName) {
-                console.log("First step must be called " + FirstStepName + " (was " + firstStepName + ")")
-                resolve(false)
-                return
-            }
-
-            const action = getBlock(steps[0], "action")
-            const actionType = getUnquotedPropertyValue(getProperty(action, "action_type"))
-
-            if (actionType !== ManualInterventionType) {
-                console.log("First step must be a manual intervention step (was " + actionType + ")")
-                resolve(false)
-                return
-            }
-
-            console.log("All tests passed!")
-            resolve(true)
-        })
-    })
-}
+const {expect} = require("expect");
 
 // This is the entry point when the file is run by Node.js
 if (require.main === module) {
@@ -81,90 +22,21 @@ if (require.main === module) {
         })
 }
 
-/**
- * Returns the attribute node with the supplied name
- * @param ast The block to search
- * @param name The attribute name
- * @returns {undefined|any} The attribute node, or undefined if no match was found
- */
-function getProperty(ast, name) {
-    if (!ast) {
-        return undefined
-    }
-
-    return ast.children
-        .filter(c =>
-            c.type === NodeType.ATTRIBUTE_NODE &&
-            c.name.value === name)
-        .pop()
-}
+exports.checkPr = checkPr
 
 /**
- * Returns the block node with the supplied name
- * @param ast The block to search
- * @param name The block name
- * @returns {undefined|any} The block node, or undefined if no match was found
- */
-function getBlock(ast, name) {
-    if (!ast) {
-        return undefined
-    }
-
-    return ast.children
-        .filter(c =>
-            c.type === NodeType.BLOCK_NODE &&
-            c.name.value === name)
-        .pop()
-}
-
-/**
- * Returns the attribute node with the supplied name and value
- * @param ast The block to search
- * @param name The attribute name
- * @value name The attribute value
- * @returns {undefined|any} The attribute node, or undefined if no match was found
- */
-function getPropertyWithValue(ast, name, value) {
-    if (!ast) {
-        return undefined
-    }
-
-    return ast.children
-        .filter(c =>
-            c.type === NodeType.ATTRIBUTE_NODE &&
-            c.name.value === name &&
-            c.value.value.value === value)
-        .pop()
-}
-
-
-/**
- * Gets the value of the attribute node
- * @param ast The attribute node
- * @returns {undefined|*} The attribute node value, or undefined if ast was falsy or not an attribute
- */
-function getPropertyValue(ast) {
-    if (!ast || !ast.type === NodeType.ATTRIBUTE_NODE) {
-        return undefined
-    }
-
-    return ast.value.value.value
-}
-
-/**
- * Gets the unquoted value of the attribute node
- * @param ast The attribute node
- * @returns {undefined|*} The attribute node value with surrounding quotes removed, or undefined if ast was falsy or not an attribute
+ * This function performs the validation of the Octopus CaC OCL file
+ * @param ocl The OCL file to parse
+ * @returns {Promise<unknown>} A promise with true if the validation succeeded, and false otherwise
  */
-function getUnquotedPropertyValue(ast) {
-    if (!ast || !ast.type === NodeType.ATTRIBUTE_NODE) {
-        return undefined
-    }
-
-    const value = ast.value.value.value
-    const result = value.match(`"(.*?)"`)
-
-    return result === null ? value : result[1]
-}
-
-exports.checkPr = checkPr
+function checkPr(ocl) {
+    // Read the file
+    const fileContents = fs.readFileSync(ocl, 'utf-8')
+    // Parse the file
+    const deploymentProcess = parseOclWrapper(fileContents)
+
+    // Verify the contents
+    expect(deploymentProcess.step).not.toHaveLength(0)
+    expect(deploymentProcess.step[0].name).toBe("Manual Intervention")
+    expect(deploymentProcess.step[0].action[0].action_type).toBe("Octopus.Manual")
+}

pr_ocl_check/check.js

@@ -1,16 +1,13 @@
 const {checkPr} = require('./check')
 
 test('fail a process definition where the first step does not have the correct name', async () => {
-    const result = await checkPr('./test_deployment_processes/wrong_name.ocl')
-    expect(result).toBe(false)
+    expect(() => checkPr('./test_deployment_processes/wrong_name.ocl')).toThrow()
 })
 
 test('pass a process definition where the first step does not have the correct name', async () => {
-    const result = await checkPr('./test_deployment_processes/correct_name.ocl')
-    expect(result).toBe(true)
+    expect(() => checkPr('./test_deployment_processes/correct_name.ocl')).not.toThrow()
 })
 
 test('fail a process definition where the first step does not have the correct type', async () => {
-    const result = await checkPr('./test_deployment_processes/correct_name_wrong_type.ocl')
-    expect(result).toBe(false)
+    expect(() =>checkPr('./test_deployment_processes/correct_name_wrong_type.ocl')).toThrow()
 })