Add get file path API

Signed-off-by: Rahul Krishna <i.m.ralk@gmail.com>

Author: rahlk

src/analysis/java/JavaAnalysis.ts

@@ -22,8 +22,6 @@ import { JApplication, JCompilationUnit } from "../../models/java";
 import * as types from "../../models/java/types";
 import { JType } from "../../models/java";
 import os from "os";
-import JSONStream from "JSONStream";
-declare module "JSONStream";
 import crypto from "crypto";
 import { createLogger } from "src/utils";
 
@@ -108,6 +106,7 @@ export class JavaAnalysis {
 
       // Read the analysis result from the temporary file
       try {
+        const JSONStream = require("JSONStream");
         const stream = fs.createReadStream(path.join(tmpFilePath, "analysis.json")).pipe(JSONStream.parse());
         const result = {} as types.JApplicationType;
 
@@ -297,4 +296,6 @@ export class JavaAnalysis {
     }
     throw new Error(`Class ${qualifiedName} not found in the application.`);
   }
+
+
 }

test/unit/analysis/java/JavaAnalysis.test.ts

@@ -3,30 +3,30 @@ import { daytraderJavaAnalysis } from "../../../conftest";
 import { expect, test } from "bun:test";
 import { logger } from "../../../../src/utils";
 
-test("Must get analysis object from JavaAnalysis object", () => {
+test("Should get analysis object from JavaAnalysis object", () => {
   expect(daytraderJavaAnalysis).toBeDefined();
 });
 
-test("Must get JApplication instance", async () => {
+test("Should get JApplication instance", async () => {
   const jApplication = await daytraderJavaAnalysis.getApplication();
   expect(jApplication).toBeDefined();
 });
 
-test("Must get Symbol Table", async () => {
+test("Should get Symbol Table", async () => {
   const symbolTable = await daytraderJavaAnalysis.getSymbolTable();
   expect(symbolTable).toBeDefined();
 });
 
-test("Must get all classes in a Java application", async () => {
+test("Should get all classes in a Java application", async () => {
   await expect(daytraderJavaAnalysis.getAllClasses()).toBeDefined();
 });
 
-test("Must get a specific class the application", async () => {
+test("Should get a specific class the application", async () => {
   const tradeDirectObject = await daytraderJavaAnalysis.getClassByQualifiedName("com.ibm.websphere.samples.daytrader.impl.direct.TradeDirect");
   expect(async () => JType.parse(tradeDirectObject)).not.toThrow();
 });
 
-test("Must throw error when a requested class in the application does not exist", async () => {
+test("Should throw error when a requested class in the application does not exist", async () => {
   /**
    * Quick note to self: There is a subtle difference between await expect(...) and expect(await ...)
    * When there is an error, the reject happens even before the expect can be honored. So instead, we await the expect
@@ -36,27 +36,27 @@ test("Must throw error when a requested class in the application does not exist"
     "Class this.class.does.not.Exist not found in the application.");
 });
 
-test("Must get all methods in the application", () => {
+test("Should get all methods in the application", () => {
   return daytraderJavaAnalysis.getAllMethods().then((methods) => {
     expect(methods).toBeDefined()
   });
 });
 
-test("Must get all methods in a specific class in the application", async () => {
+test("Should get all methods in a specific class in the application", async () => {
   expect(
     (
       await daytraderJavaAnalysis.getAllMethodsByClass("com.ibm.websphere.samples.daytrader.impl.direct.TradeDirect")).length
   ).toBeGreaterThan(0)
 });
 
-test("Must get a specific method in a specific class in the application", async () => {
+test("Should get a specific method in a specific class in the application", async () => {
   const method = await daytraderJavaAnalysis.getMethodByQualifiedName(
     "com.ibm.websphere.samples.daytrader.impl.direct.TradeDirect", "publishQuotePriceChange(QuoteDataBean, BigDecimal, BigDecimal, double)");
 
   expect(async () => JCallable.parse(method)).not.toThrow();
 });
 
-test("Must get parameters of a specific method in a specific class in the application", async () => {
+test("Should get parameters of a specific method in a specific class in the application", async () => {
   const parameters = await daytraderJavaAnalysis.getMethodParameters(
     "com.ibm.websphere.samples.daytrader.impl.direct.TradeDirect", "publishQuotePriceChange(QuoteDataBean, BigDecimal, BigDecimal, double)");
 
@@ -70,7 +70,7 @@ test("Must get parameters of a specific method in a specific class in the applic
   logger.success("All parameters are valid JCallableParameter instances");
 });
 
-test("Must get parameters of a specific method in a specific class in the application given the callable object", async () => {
+test("Should get parameters of a specific method in a specific class in the application given the callable object", async () => {
   const method = await daytraderJavaAnalysis.getMethodByQualifiedName(
     "com.ibm.websphere.samples.daytrader.impl.direct.TradeDirect", "publishQuotePriceChange(QuoteDataBean, BigDecimal, BigDecimal, double)");
   const parameters = await daytraderJavaAnalysis.getMethodParametersFromCallable(method);
@@ -85,3 +85,10 @@ test("Must get parameters of a specific method in a specific class in the applic
   logger.success("All parameters are valid JCallableParameter instances");
 });
 
+
+test("Should get file path for a specific class in the application", async () => {
+  const filePath = await daytraderJavaAnalysis.getJavaFilePathByQualifiedName("com.ibm.websphere.samples.daytrader.impl.direct.TradeDirect");
+  expect(filePath).toBeDefined();
+  expect(filePath).toContain(
+    "main/java/com/ibm/websphere/samples/daytrader/impl/direct/TradeDirect.java");
+});

test/unit/utils/loggers.test.ts

@@ -1,35 +1,35 @@
 import { test, expect } from 'bun:test';
 import { logger, createLogger } from '../../../src/utils/logger';
 
-test("Must create a logger instance", () => {
+test("Should create a logger instance", () => {
     expect(logger).toBeDefined();
 });
 
-test("Must log info message without throwing", () => {
+test("Should log info message without throwing", () => {
     expect(() => logger.info("This is an info message")).not.toThrow();
 });
 
-test("Must log success message without throwing", () => {
+test("Should log success message without throwing", () => {
     expect(() => logger.success("This is a success message")).not.toThrow();
 });
 
-test("Must log warning message without throwing", () => {
+test("Should log warning message without throwing", () => {
     expect(() => logger.warn("This is a warning message")).not.toThrow();
 });
 
-test("Must log error message without throwing", () => {
+test("Should log error message without throwing", () => {
     expect(() => logger.error("This is an error message")).not.toThrow();
 });
 
-test("Must log debug message without throwing", () => {
+test("Should log debug message without throwing", () => {
     expect(() => logger.debug("This is a debug message")).not.toThrow();
 });
 
-test("Must pretty print JSON without throwing", () => {
+test("Should pretty print JSON without throwing", () => {
     expect(() => logger.prettyJson("Test Object", { foo: "bar", baz: 42 })).not.toThrow();
 });
 
-test("Must create scoped logger instance", () => {
+test("Should create scoped logger instance", () => {
     const scopedLogger = createLogger("TestScope");
     expect(scopedLogger).toBeDefined();
 });