feat: parser unit tests

Author: AbhinavKumar-sf

src/utils/apex/parser/apexparser.ts

@@ -2,7 +2,6 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import * as fs from 'fs';
 import {
   ApexLexer,
   CommonTokenStream,
@@ -18,7 +17,7 @@ import { CharStreams, Token } from 'antlr4ts';
 import { ParseTreeWalker } from 'antlr4ts/tree/ParseTreeWalker';
 
 export class ApexASTParser {
-  private apexFilePath: string;
+  private apexFileContent: string;
   private implementsInterface: Map<string, Token> = new Map();
   // private callsMethods: Map<string, Token[]>;
   private interfaceName: string;
@@ -30,16 +29,15 @@ export class ApexASTParser {
     return this.implementsInterface;
   }
 
-  public constructor(apexFilePath: string, interfaceName: string, methodName: string) {
-    this.apexFilePath = apexFilePath;
+  public constructor(apexFileContent: string, interfaceName: string, methodName: string) {
+    this.apexFileContent = apexFileContent;
     this.interfaceName = interfaceName;
     this.methodName = methodName;
     this.astListener = this.createASTListener();
   }
 
   public parse(): CompilationUnitContext {
-    const fileContent = fs.readFileSync(this.apexFilePath).toString();
-    const lexer = new ApexLexer(new CaseInsensitiveInputStream(CharStreams.fromString(fileContent)));
+    const lexer = new ApexLexer(new CaseInsensitiveInputStream(CharStreams.fromString(this.apexFileContent)));
     const tokens = new CommonTokenStream(lexer);
     const parser = new ApexParser(tokens);
     const context = parser.compilationUnit();

test/utils/apex/parser/FormulaParserService.cls

@@ -0,0 +1,49 @@
+/*
+   The service implements Callable to support calling
+   FormulaParser functions from Core/Java.
+   The allowed functions are listed in FormulaParser FUNCTIONS_FROM_JAVA.
+*/
+global with sharing class FormulaParserService implements Callable
+{
+   /* global Object call(String action, Map<String, Object> args)
+    {
+        Map<String, Object> input = (Map<String, Object>) args.get('input');
+        Map<String, Object> output = (Map<String, Object>) args.get('output');
+
+        String function = (String)input.get('function');
+        if (function == null || String.isBlank(function))
+        {
+            return null;
+        }
+
+        List<Object> arguments = (input.get('arguments') != null && input.get('arguments') InstanceOf List<Object>)
+                    ? (List<Object>)input.get('arguments') : new List<Object>();
+
+        if (action == 'evaluateFunctionFromJava')
+        {
+            Object res = FormulaParser.evaluateFunctionFromJava(function, arguments);
+            if (res != null)
+            {
+                output.put('result', res);
+            }
+        }
+        return null;
+    }
+
+    global void evaluateFunctionFromJava(String function, List<Object> arguments)
+    {
+        Map < String, Object > testMap = new Map < String, Object > { 'BirthDate' => '1982-11-06' };
+		DRProcessResult result = DRGlobal.process(testMap, 'DRTurboTemp2');
+		//List < Object > resultMap = (List < Object >)((Map < String, Object >)result.toJson()).get('Contact');
+		//System.assertEquals(Date.newInstance(1982, 11, 6), ((Map < String, Object >)resultMap[0]).get('Birthdate'));
+    }*/
+
+    global void justForTest(String kkdbk) {
+        /* Specify Data Mapper extract or transform to call */
+        String DRName = 'DataMapperNewName'; 
+        /* Populate the input JSON */ 
+        Map<String, Object> myTransformData = new Map<String, Object>{'MyKey'=>'MyValue'}; 
+        /* Call the Data Mapper */ 
+        omnistudio.DRProcessResult result1 = omnistudio.DRGlobal.process(myTransformData, DRName);
+    }
+}

test/utils/apex/parser/apexparser.test.ts

@@ -3,11 +3,21 @@ import { ApexASTParser } from '../../../../src/utils/apex/parser/apexparser';
 
 describe('ApexASTParser', () => {
   it('should parse the Apex file and collect interface implementations, method calls, and class names', () => {
-    const apexFilePath = 'test/utils/apex/parser/resource/FormulaParserService.cls';
+    const apexFileContent = `global with sharing class FormulaParserService implements Callable{
+
+        global void justForTest(String kkdbk) {
+        /* Specify Data Mapper extract or transform to call */
+        String DRName = 'DataMapperNewName'; 
+        /* Populate the input JSON */ 
+        Map<String, Object> myTransformData = new Map<String, Object>{'MyKey'=>'MyValue'}; 
+        /* Call the Data Mapper */ 
+        omnistudio.DRProcessResult result1 = omnistudio.DRGlobal.process(myTransformData, DRName);
+    }
+    }`;
     const interfaceName = 'Callable';
     const methodName = 'yourMethod';
 
-    const apexParser = new ApexASTParser(apexFilePath, interfaceName, methodName);
+    const apexParser = new ApexASTParser(apexFileContent, interfaceName, methodName);
     apexParser.parse();
     const implementsInterface = apexParser.implemementsInterface;
     // const callsMethods = apexParser.getCallsMethods();
@@ -16,7 +26,7 @@ describe('ApexASTParser', () => {
     // Add your assertions here based on the expected results
     // implementsInterface.get(interfaceName);
     expect(implementsInterface.get(interfaceName).charPositionInLine).to.be.equal(58);
-    expect(implementsInterface.get(interfaceName).line).to.be.equal(6);
+    expect(implementsInterface.get(interfaceName).line).to.be.equal(1);
     // expect(callsMethods).to.not.be.empty;
     // expect(className).to.equal('YourClass');
   });