increase coverage (#19)

* increase coverage

* increase coverage

Author: aelmanaa

README.md

@@ -1,7 +1,7 @@
 # Token Pools Calldata Generator
 
 [![CI](https://github.com/smartcontractkit/token-pools-calldata/actions/workflows/ci.yml/badge.svg)](https://github.com/smartcontractkit/token-pools-calldata/actions/workflows/ci.yml)
-[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](LICENSE)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Node: >=22.0.0](https://img.shields.io/badge/node-%3E%3D22.0.0-brightgreen)](package.json)
 [![pnpm](https://img.shields.io/badge/maintained%20with-pnpm-cc00ff.svg)](https://pnpm.io/)
 

jest.config.ts

@@ -6,7 +6,14 @@ export default {
   transform: {
     '^.+\\.ts$': 'ts-jest',
   },
-  collectCoverageFrom: ['src/**/*.ts', '!src/**/*.d.ts', '!src/test/**', '!src/typechain/**'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/test/**',
+    '!src/typechain/**',
+    // CLI entry point is integration code - tested via E2E, not unit tests
+    '!src/cli.ts',
+  ],
   coverageDirectory: 'coverage',
   coverageReporters: ['text', 'lcov', 'html', 'json-summary'],
   coverageThreshold: {

package.json

@@ -25,7 +25,7 @@
   },
   "keywords": [],
   "author": "",
-  "license": "ISC",
+  "license": "MIT",
   "devDependencies": {
     "@typechain/ethers-v6": "^0.5.1",
     "@types/jest": "^30.0.0",

src/test/output/OutputService.test.ts

@@ -0,0 +1,246 @@
+/**
+ * Tests for OutputService
+ * Covers high-level output operations for CLI commands
+ */
+
+import { OutputService } from '../../output/OutputService';
+import { OutputWriterFactory } from '../../output/OutputWriter';
+import {
+  SafeOperationType,
+  SafeTransactionBuilderJSON,
+  SAFE_TX_BUILDER_VERSION,
+} from '../../types/safe';
+import { OUTPUT_FORMAT } from '../../config';
+
+// Mock the OutputWriter module
+jest.mock('../../output/OutputWriter', () => {
+  const mockCalldataWriter = {
+    write: jest.fn().mockResolvedValue(undefined),
+  };
+  const mockJsonWriter = {
+    write: jest.fn().mockResolvedValue(undefined),
+  };
+  return {
+    CalldataWriter: jest.fn(() => mockCalldataWriter),
+    JsonWriter: jest.fn(() => mockJsonWriter),
+    OutputWriterFactory: {
+      createCalldataWriter: jest.fn(() => mockCalldataWriter),
+      createJsonWriter: jest.fn(() => mockJsonWriter),
+    },
+  };
+});
+
+describe('OutputService', () => {
+  let service: OutputService;
+  let mockCalldataWriter: { write: jest.Mock };
+  let mockJsonWriter: { write: jest.Mock };
+
+  const mockTransaction = {
+    to: '0x779877A7B0D9E8603169DdbD7836e478b4624789',
+    value: '0',
+    data: '0x1234567890abcdef',
+    operation: SafeOperationType.Call,
+  };
+
+  const mockSafeJson: SafeTransactionBuilderJSON = {
+    version: '1.18.0',
+    chainId: '84532',
+    createdAt: Date.now(),
+    meta: {
+      name: 'Test Transaction',
+      description: 'Test Description',
+      txBuilderVersion: SAFE_TX_BUILDER_VERSION,
+      createdFromSafeAddress: '0x5419c6d83473d1c653e7b51e8568fafedce94f01',
+      createdFromOwnerAddress: '0x0000000000000000000000000000000000000000',
+    },
+    transactions: [
+      {
+        to: '0x779877A7B0D9E8603169DdbD7836e478b4624789',
+        value: '0',
+        data: '0x1234567890abcdef',
+        operation: SafeOperationType.Call,
+        contractMethod: {
+          inputs: [],
+          name: 'testFunction',
+          payable: false,
+        },
+        contractInputsValues: null,
+      },
+    ],
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    service = new OutputService();
+    mockCalldataWriter = OutputWriterFactory.createCalldataWriter() as unknown as {
+      write: jest.Mock;
+    };
+    mockJsonWriter = OutputWriterFactory.createJsonWriter() as unknown as { write: jest.Mock };
+  });
+
+  describe('writeCalldata', () => {
+    it('should write single transaction calldata to console', async () => {
+      await service.writeCalldata(mockTransaction);
+
+      expect(OutputWriterFactory.createCalldataWriter).toHaveBeenCalled();
+      expect(mockCalldataWriter.write).toHaveBeenCalledWith(mockTransaction.data, {
+        type: 'console',
+      });
+    });
+
+    it('should write single transaction calldata to file', async () => {
+      const outputPath = 'output/calldata.txt';
+      await service.writeCalldata(mockTransaction, outputPath);
+
+      expect(OutputWriterFactory.createCalldataWriter).toHaveBeenCalled();
+      expect(mockCalldataWriter.write).toHaveBeenCalledWith(mockTransaction.data, {
+        type: 'file',
+        path: outputPath,
+      });
+    });
+
+    it('should write multiple transactions calldata to console', async () => {
+      const transactions = [mockTransaction, { ...mockTransaction, data: '0xabcdef1234567890' }];
+
+      await service.writeCalldata(transactions);
+
+      expect(mockCalldataWriter.write).toHaveBeenCalledWith(
+        `${mockTransaction.data}\n0xabcdef1234567890`,
+        { type: 'console' },
+      );
+    });
+
+    it('should write multiple transactions calldata to file', async () => {
+      const transactions = [
+        mockTransaction,
+        { ...mockTransaction, data: '0xabcdef1234567890' },
+        { ...mockTransaction, data: '0x9999999999999999' },
+      ];
+      const outputPath = 'output/batch.txt';
+
+      await service.writeCalldata(transactions, outputPath);
+
+      expect(mockCalldataWriter.write).toHaveBeenCalledWith(
+        `${mockTransaction.data}\n0xabcdef1234567890\n0x9999999999999999`,
+        { type: 'file', path: outputPath },
+      );
+    });
+
+    it('should handle empty transaction array', async () => {
+      const transactions: (typeof mockTransaction)[] = [];
+
+      await service.writeCalldata(transactions);
+
+      expect(mockCalldataWriter.write).toHaveBeenCalledWith('', { type: 'console' });
+    });
+  });
+
+  describe('writeSafeJson', () => {
+    it('should write Safe JSON to console', async () => {
+      await service.writeSafeJson(mockSafeJson);
+
+      expect(OutputWriterFactory.createJsonWriter).toHaveBeenCalled();
+      expect(mockJsonWriter.write).toHaveBeenCalledWith(JSON.stringify(mockSafeJson), {
+        type: 'console',
+      });
+    });
+
+    it('should write Safe JSON to file', async () => {
+      const outputPath = 'output/safe.json';
+      await service.writeSafeJson(mockSafeJson, outputPath);
+
+      expect(OutputWriterFactory.createJsonWriter).toHaveBeenCalled();
+      expect(mockJsonWriter.write).toHaveBeenCalledWith(JSON.stringify(mockSafeJson), {
+        type: 'file',
+        path: outputPath,
+      });
+    });
+
+    it('should handle Safe JSON with multiple transactions', async () => {
+      const multiTxSafeJson: SafeTransactionBuilderJSON = {
+        ...mockSafeJson,
+        transactions: [
+          mockSafeJson.transactions[0]!,
+          {
+            ...mockSafeJson.transactions[0]!,
+            data: '0xsecondtx',
+          },
+        ],
+      };
+
+      await service.writeSafeJson(multiTxSafeJson);
+
+      expect(mockJsonWriter.write).toHaveBeenCalledWith(JSON.stringify(multiTxSafeJson), {
+        type: 'console',
+      });
+    });
+  });
+
+  describe('write', () => {
+    it('should route to writeSafeJson when format is safe-json', async () => {
+      const outputPath = 'output/safe.json';
+
+      await service.write(OUTPUT_FORMAT.SAFE_JSON, mockTransaction, mockSafeJson, outputPath);
+
+      expect(OutputWriterFactory.createJsonWriter).toHaveBeenCalled();
+      expect(mockJsonWriter.write).toHaveBeenCalled();
+    });
+
+    it('should route to writeCalldata when format is calldata', async () => {
+      const outputPath = 'output/calldata.txt';
+
+      await service.write(OUTPUT_FORMAT.CALLDATA, mockTransaction, null, outputPath);
+
+      expect(OutputWriterFactory.createCalldataWriter).toHaveBeenCalled();
+      expect(mockCalldataWriter.write).toHaveBeenCalled();
+    });
+
+    it('should throw error when safe-json format but no safeJson provided', async () => {
+      await expect(
+        service.write(OUTPUT_FORMAT.SAFE_JSON, mockTransaction, null, 'output/safe.json'),
+      ).rejects.toThrow('Safe JSON format requested but no Safe JSON provided');
+    });
+
+    it('should write to console when no outputPath provided for calldata', async () => {
+      await service.write(OUTPUT_FORMAT.CALLDATA, mockTransaction, null, undefined);
+
+      expect(mockCalldataWriter.write).toHaveBeenCalledWith(mockTransaction.data, {
+        type: 'console',
+      });
+    });
+
+    it('should write to console when no outputPath provided for safe-json', async () => {
+      await service.write(OUTPUT_FORMAT.SAFE_JSON, mockTransaction, mockSafeJson, undefined);
+
+      expect(mockJsonWriter.write).toHaveBeenCalledWith(JSON.stringify(mockSafeJson), {
+        type: 'console',
+      });
+    });
+
+    it('should handle multiple transactions with calldata format', async () => {
+      const transactions = [mockTransaction, mockTransaction];
+
+      await service.write(OUTPUT_FORMAT.CALLDATA, transactions, null, 'output/batch.txt');
+
+      expect(mockCalldataWriter.write).toHaveBeenCalledWith(
+        `${mockTransaction.data}\n${mockTransaction.data}`,
+        { type: 'file', path: 'output/batch.txt' },
+      );
+    });
+
+    it('should ignore safeJson when format is calldata', async () => {
+      await service.write(
+        OUTPUT_FORMAT.CALLDATA,
+        mockTransaction,
+        mockSafeJson, // Provided but should be ignored
+        'output/calldata.txt',
+      );
+
+      expect(mockCalldataWriter.write).toHaveBeenCalledWith(mockTransaction.data, {
+        type: 'file',
+        path: 'output/calldata.txt',
+      });
+      expect(mockJsonWriter.write).not.toHaveBeenCalled();
+    });
+  });
+});