pomanalyzer 1.0.0

package/test/fileUtils.test.js

@@ -0,0 +1,43 @@
+import { readFile } from '../src/utils/fileUtils';
+import fs from 'fs';
+
+jest.mock('fs');
+
+describe('File Utils', () => {
+  const mockFilePath = 'mock/path/to/file.txt';
+  const mockFileContent = 'Hello, World!';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should read file content correctly', async () => {
+    fs.readFile.mockImplementation((path, encoding, callback) => {
+      callback(null, mockFileContent);
+    });
+
+    const content = await readFile(mockFilePath);
+    expect(content).toBe(mockFileContent);
+    expect(fs.readFile).toHaveBeenCalledWith(mockFilePath, 'utf-8', expect.any(Function));
+  });
+
+  it('should reject promise when file read fails', async () => {
+    const mockError = new Error('File not found');
+    fs.readFile.mockImplementation((path, encoding, callback) => {
+      callback(mockError, null);
+    });
+
+    await expect(readFile(mockFilePath)).rejects.toThrow('File not found');
+    expect(fs.readFile).toHaveBeenCalledWith(mockFilePath, 'utf-8', expect.any(Function));
+  });
+
+  it('should handle non-UTF8 encodings if specified', async () => {
+    fs.readFile.mockImplementation((path, encoding, callback) => {
+      expect(encoding).toBe('utf-8'); // Default encoding
+      callback(null, mockFileContent);
+    });
+
+    await readFile(mockFilePath);
+    expect(fs.readFile).toHaveBeenCalledWith(mockFilePath, 'utf-8', expect.any(Function));
+  });
+});

package/test/outputFormatter.test.js

@@ -0,0 +1,57 @@
+import { printTable } from '../src/utils/outputFormatter';
+
+describe('Output Formatter', () => {
+  let consoleLogSpy, consoleTableSpy;
+
+  beforeEach(() => {
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+    consoleTableSpy = jest.spyOn(console, 'table').mockImplementation();
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleTableSpy.mockRestore();
+  });
+
+  it('should print a title and table for non-empty dependencies', () => {
+    const dependencies = [
+      { groupId: 'com.example', artifactId: 'example-artifact', version: '1.0.0' }
+    ];
+    const title = 'Test Dependencies';
+
+    printTable(dependencies, title);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(title);
+    expect(consoleTableSpy).toHaveBeenCalledWith(dependencies);
+  });
+
+  it('should print a message for empty dependencies', () => {
+    const dependencies = [];
+    const title = 'Empty Dependencies';
+
+    printTable(dependencies, title);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(`${title}: No data available.`);
+    expect(consoleTableSpy).not.toHaveBeenCalled();
+  });
+
+  it('should handle null dependencies', () => {
+    const dependencies = null;
+    const title = 'Null Dependencies';
+
+    printTable(dependencies, title);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(`${title}: No data available.`);
+    expect(consoleTableSpy).not.toHaveBeenCalled();
+  });
+
+  it('should handle undefined dependencies', () => {
+    const dependencies = undefined;
+    const title = 'Undefined Dependencies';
+
+    printTable(dependencies, title);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(`${title}: No data available.`);
+    expect(consoleTableSpy).not.toHaveBeenCalled();
+  });
+});

package/test/xmlParser.test.js

@@ -0,0 +1,71 @@
+import { parseXml } from '../src/utils/xmlParser';
+import xml2js from 'xml2js';
+
+jest.mock('xml2js');
+
+describe('XML Parser', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should parse valid XML content into a JavaScript object', async () => {
+    const xmlContent = '<project><properties><prop>value</prop></properties></project>';
+    const expectedResult = {
+      project: {
+        properties: [{ prop: ['value'] }]
+      }
+    };
+
+    xml2js.Parser.mockImplementation(() => ({
+      parseString: (content, callback) => {
+        expect(content).toBe(xmlContent);
+        callback(null, expectedResult);
+      }
+    }));
+
+    const result = await parseXml(xmlContent);
+    expect(result).toEqual(expectedResult);
+  });
+
+  it('should reject the promise when XML parsing fails', async () => {
+    const xmlContent = '<invalid>xml';
+    const errorMsg = 'XML parsing error';
+
+    xml2js.Parser.mockImplementation(() => ({
+      parseString: (content, callback) => {
+        callback(new Error(errorMsg), null);
+      }
+    }));
+
+    await expect(parseXml(xmlContent)).rejects.toThrow('Error parsing XML: ' + errorMsg);
+  });
+
+  it('should handle empty XML content', async () => {
+    const xmlContent = '';
+    const expectedResult = {};
+
+    xml2js.Parser.mockImplementation(() => ({
+      parseString: (content, callback) => {
+        callback(null, expectedResult);
+      }
+    }));
+
+    const result = await parseXml(xmlContent);
+    expect(result).toEqual(expectedResult);
+  });
+
+  it('should use the xml2js Parser with default options', async () => {
+    const xmlContent = '<project></project>';
+    const mockParseString = jest.fn((content, callback) => {
+      callback(null, {});
+    });
+
+    xml2js.Parser.mockImplementation(() => ({
+      parseString: mockParseString
+    }));
+
+    await parseXml(xmlContent);
+    expect(mockParseString).toHaveBeenCalledWith(xmlContent, expect.any(Function));
+    expect(xml2js.Parser).toHaveBeenCalledWith();
+  });
+});