@jaskrowo/xtb2sure 0.0.0-stage → 0.1.0

package/test/cli.test.ts

@@ -0,0 +1,148 @@
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { access, mkdtemp, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import xlsx from "xlsx";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, "..");
+const cliPath = path.join(rootDir, "src", "cli.ts");
+
+test("CLI validates required --currency and --account args", async () => {
+    const result = await runCli([
+        "convert",
+        path.join(rootDir, "test", "fixtures", "IKE", "input.xlsx"),
+        "--currency",
+        "USD",
+    ]);
+
+    assert.equal(result.code, 2);
+    assert.match(result.stderr, /required option/);
+});
+
+test("CLI generates output files", async () => {
+    const tmpDir = await mkdtemp(path.join(os.tmpdir(), "xtb2sure-cli-"));
+    const txPath = path.join(tmpDir, "tx.csv");
+    const invPath = path.join(tmpDir, "inv.csv");
+
+    const result = await runCli([
+        "convert",
+        path.join(rootDir, "test", "fixtures", "IKE", "input.xlsx"),
+        "--currency",
+        "USD",
+        "--account",
+        "XTB IKE",
+        "--transactions-out",
+        txPath,
+        "--investments-out",
+        invPath,
+    ]);
+
+    assert.equal(result.code, 0);
+    await access(txPath);
+    await access(invPath);
+});
+
+test("CLI dry-run does not create output files", async () => {
+    const tmpDir = await mkdtemp(path.join(os.tmpdir(), "xtb2sure-dry-"));
+    const txPath = path.join(tmpDir, "tx.csv");
+    const invPath = path.join(tmpDir, "inv.csv");
+
+    const result = await runCli([
+        "convert",
+        path.join(rootDir, "test", "fixtures", "IKE", "input.xlsx"),
+        "--currency",
+        "USD",
+        "--account",
+        "XTB IKE",
+        "--transactions-out",
+        txPath,
+        "--investments-out",
+        invPath,
+        "--dry-run",
+    ]);
+
+    assert.equal(result.code, 0);
+    await assert.rejects(() => access(txPath));
+    await assert.rejects(() => access(invPath));
+});
+
+test("CLI strict mode fails when mapping issue is encountered", async () => {
+    const tmpDir = await mkdtemp(path.join(os.tmpdir(), "xtb2sure-strict-"));
+    const inputPath = path.join(tmpDir, "bad.xlsx");
+    const reportPath = path.join(tmpDir, "report.json");
+    await writeInvalidTradeWorkbook(inputPath);
+
+    const strictResult = await runCli([
+        "convert",
+        inputPath,
+        "--currency",
+        "USD",
+        "--account",
+        "XTB TEST",
+        "--strict",
+        "--report",
+        reportPath,
+    ]);
+
+    assert.equal(strictResult.code, 1);
+
+    const relaxedResult = await runCli([
+        "convert",
+        inputPath,
+        "--currency",
+        "USD",
+        "--account",
+        "XTB TEST",
+        "--report",
+        reportPath,
+    ]);
+
+    assert.equal(relaxedResult.code, 0);
+    const report = JSON.parse(await readFile(reportPath, "utf8"));
+    assert.equal(report.totals.issues, 1);
+});
+
+function runCli(args: string[]): Promise<{ code: number | null; stdout: string; stderr: string }> {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, ["--experimental-transform-types", cliPath, ...args], {
+            cwd: rootDir,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+
+        let stdout = "";
+        let stderr = "";
+
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+
+        child.on("error", reject);
+        child.on("close", (code) => {
+            resolve({ code, stdout, stderr });
+        });
+    });
+}
+
+async function writeInvalidTradeWorkbook(outPath: string): Promise<void> {
+    const worksheet = xlsx.utils.aoa_to_sheet([
+        ["Account number", "123"],
+        ["Cash Operations"],
+        ["Date from (UTC)", 46000],
+        ["Date to (UTC)", 46001],
+        ["Type", "Instrument", "Ticker", "Category", "Time", "Amount", "ID", "Comment", "Product", "Position ID"],
+        ["Stock purchase", "Test instrument", "TEST.UK", "", 46000.5, 123.45, "1", "BROKEN COMMENT", "My Trades", ""],
+    ]);
+
+    const workbook = xlsx.utils.book_new();
+    xlsx.utils.book_append_sheet(workbook, worksheet, "Cash Operations");
+    xlsx.writeFile(workbook, outPath);
+}

package/test/date.test.ts

@@ -0,0 +1,8 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { excelSerialToYYYYMMDD } from "../src/date.ts";
+
+test("excelSerialToYYYYMMDD converts known fixture serials", () => {
+    assert.equal(excelSerialToYYYYMMDD(46266.43755445602), "2026-09-01");
+    assert.equal(excelSerialToYYYYMMDD(46079.041666666664), "2026-02-26");
+});

package/test/fixtures/IKE/output_investments.csv

@@ -0,0 +1,3 @@
+date,ticker,currency,qty,price,account,name
+2026-04-30,EIMI.UK,USD,24,51.81,XTB IKE,XTB 900000003: Stock purchase
+2026-04-30,IPOL.UK,USD,0.6747,35.68993627,XTB IKE,XTB 900000004: Stock purchase

package/test/fixtures/IKE/output_transactions.csv

@@ -0,0 +1,3 @@
+date,amount,name,account,notes
+2026-09-01,0.11,Free funds interest,XTB IKE,XTB 900000001: Mock interest period 2026-08
+2026-04-30,14556.14,IKE deposit,XTB IKE,XTB 900000002: Mock transfer in from account 100001

package/test/fixtures/PLN/output_investments.csv

@@ -0,0 +1,5 @@
+date,ticker,currency,qty,price,account,name
+2026-01-05,IUSQ.DE,PLN,1.0,93.88,XTB PLN,MSCI ACWI - Stock purchase (XTB 910000005)
+2026-01-06,IPOL.UK,PLN,3.0,34.04666667,XTB PLN,MSCI Poland - Stock purchase (XTB 910000007)
+2026-01-09,SXR8.DE,PLN,-0.1019,637.68400393,XTB PLN,Core S&P 500 - Stock sell (XTB 910000006)
+2026-01-21,EIMI.UK,PLN,114.0,47.33,XTB PLN,Core MSCI EM IMI - Stock purchase (XTB 910000008)

package/test/fixtures/PLN/output_transactions.csv

@@ -0,0 +1,6 @@
+date,amount,name,account,notes
+2026-09-04,5000.00,Deposit,XTB PLN,XTB 910000001: Mock bank deposit txn=MOCK-TXN-001 [subaccount: Investment Plans]
+2026-03-05,0.01,Free funds interest,XTB PLN,XTB 910000002: Mock free-funds interest 2026-02 [subaccount: My Trades]
+2026-03-05,-0.01,Free funds interest tax,XTB PLN,XTB 910000003: Mock free-funds interest tax 2026-02 [subaccount: My Trades]
+2026-01-02,0.93,Withholding tax,XTB PLN,XTB 910000004: mock WHT correction [subaccount: Investment Plans]
+2026-02-26,-11304.00,IKZE deposit,XTB PLN,XTB 910000009: Mock transfer out to IKZE 200002 [subaccount: My Trades]

package/test/integration.test.ts

@@ -0,0 +1,171 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { readCashOperationsSheet } from "../src/excel.ts";
+import { convertFile } from "../src/index.ts";
+import { classifyOperation } from "../src/operations.ts";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, "..");
+
+test("IKE fixture conversion matches expected outputs", async () => {
+    const result = await convertFile({
+        account: "XTB IKE",
+        currency: "USD",
+        dryRun: true,
+        inputPath: path.join(rootDir, "test", "fixtures", "IKE", "input.xlsx"),
+    });
+
+    const expectedTransactions = await readExpected("test/fixtures/IKE/output_transactions.csv");
+    const expectedInvestments = await readExpected("test/fixtures/IKE/output_investments.csv");
+
+    assert.equal(normalizeEol(result.transactionsCsv), expectedTransactions);
+    assert.equal(normalizeEol(result.investmentsCsv), expectedInvestments);
+});
+
+test("PLN fixture conversion matches expected outputs", async () => {
+    const result = await convertFile({
+        account: "XTB PLN",
+        currency: "PLN",
+        dryRun: true,
+        inputPath: path.join(rootDir, "test", "fixtures", "PLN", "input.xlsx"),
+    });
+
+    const expectedTransactions = await readExpected("test/fixtures/PLN/output_transactions.csv");
+    const expectedInvestments = await readExpected("test/fixtures/PLN/output_investments.csv");
+
+    assert.equal(normalizeEol(result.transactionsCsv), expectedTransactions);
+    assert.equal(normalizeEol(result.investmentsCsv), expectedInvestments);
+});
+
+test("investment ticker regression: output ticker equals source ticker by XTB operation ID", async () => {
+    const inputPath = path.join(rootDir, "test", "fixtures", "PLN", "input.xlsx");
+    const result = await convertFile({
+        account: "XTB PLN",
+        currency: "PLN",
+        dryRun: true,
+        inputPath,
+    });
+
+    const rows = readCashOperationsSheet(inputPath);
+    const byId = new Map<string, string>();
+
+    for (const row of rows) {
+        if (classifyOperation(row.Type) === "investment") {
+            byId.set(row.ID, row.Ticker);
+        }
+    }
+
+    for (const line of normalizeEol(result.investmentsCsv).split("\n").slice(1)) {
+        if (!line.trim()) {
+            continue;
+        }
+
+        const cells = parseCsvLine(line);
+        const ticker = cells[1];
+        const name = cells[6];
+        assert.ok(typeof ticker === "string" && ticker.length > 0);
+        assert.ok(typeof name === "string" && name.length > 0);
+        const idMatch = name.match(/XTB\s+(\d+)/);
+        assert.ok(idMatch, `Missing XTB ID in row: ${line}`);
+        const id = idMatch[1];
+        assert.ok(id);
+        assert.equal(ticker, byId.get(id));
+    }
+});
+
+test("investment currency is always taken from CLI argument", async () => {
+    const result = await convertFile({
+        account: "XTB PLN",
+        currency: "PLN",
+        dryRun: true,
+        inputPath: path.join(rootDir, "test", "fixtures", "PLN", "input.xlsx"),
+    });
+
+    for (const line of normalizeEol(result.investmentsCsv).split("\n").slice(1)) {
+        if (!line.trim()) {
+            continue;
+        }
+
+        const cells = parseCsvLine(line);
+        assert.equal(cells[2], "PLN");
+    }
+});
+
+test("investment price is derived from Amount and qty", async () => {
+    const inputPath = path.join(rootDir, "test", "fixtures", "PLN", "input.xlsx");
+    const result = await convertFile({
+        account: "XTB PLN",
+        currency: "PLN",
+        dryRun: true,
+        inputPath,
+    });
+
+    const rows = readCashOperationsSheet(inputPath);
+    const amountById = new Map<string, number>();
+
+    for (const row of rows) {
+        if (classifyOperation(row.Type) === "investment") {
+            amountById.set(row.ID, Math.abs(row.Amount));
+        }
+    }
+
+    for (const line of normalizeEol(result.investmentsCsv).split("\n").slice(1)) {
+        if (!line.trim()) {
+            continue;
+        }
+
+        const cells = parseCsvLine(line);
+        const qty = Math.abs(Number(cells[3]));
+        const price = Number(cells[4]);
+        const name = cells[6] ?? "";
+        const idMatch = name.match(/XTB\s+(\d+)/);
+        assert.ok(idMatch, `Missing XTB ID in row: ${line}`);
+        const id = idMatch[1];
+        assert.ok(id);
+        const expectedAmount = amountById.get(id);
+        assert.ok(typeof expectedAmount === "number", `No amount found for ID ${id}`);
+
+        const actualAmount = qty * price;
+        assert.ok(Math.abs(actualAmount - expectedAmount) < 0.02, `Amount mismatch for ${id}`);
+    }
+});
+
+async function readExpected(relativePath: string): Promise<string> {
+    const value = await readFile(path.join(rootDir, relativePath), "utf8");
+    return normalizeEol(value);
+}
+
+function normalizeEol(value: string): string {
+    return value.replace(/\r\n/g, "\n");
+}
+
+function parseCsvLine(line: string): string[] {
+    const cells: string[] = [];
+    let current = "";
+    let inQuotes = false;
+
+    for (let i = 0; i < line.length; i += 1) {
+        const char = line[i];
+        if (char === '"') {
+            if (inQuotes && line[i + 1] === '"') {
+                current += '"';
+                i += 1;
+            } else {
+                inQuotes = !inQuotes;
+            }
+        } else if (char === "," && !inQuotes) {
+            cells.push(current);
+            current = "";
+        } else {
+            current += char;
+        }
+    }
+
+    cells.push(current);
+
+    return cells;
+}

package/test/operations.test.ts

@@ -0,0 +1,23 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { classifyOperation, parseTradeValues } from "../src/operations.ts";
+
+test("classifyOperation maps supported operation groups", () => {
+    assert.equal(classifyOperation("Deposit"), "transaction");
+    assert.equal(classifyOperation("Stock purchase"), "investment");
+    assert.equal(classifyOperation("Total"), "ignored");
+});
+
+test("parseTradeValues parses BUY format with split quantity", () => {
+    const parsed = parseTradeValues("OPEN BUY 7/7.7575 @ 42.750");
+    assert.equal(parsed.qty, "7");
+    assert.equal(parsed.price, "42.75");
+    assert.equal(parsed.qtyHadExplicitDecimal, false);
+});
+
+test("parseTradeValues parses SELL format with decimal-preserving integer price", () => {
+    const parsed = parseTradeValues("CLOSE SELL 0.9179 @ 1233.0");
+    assert.equal(parsed.qty, "0.9179");
+    assert.equal(parsed.price, "1233.0");
+    assert.equal(parsed.qtyHadExplicitDecimal, true);
+});

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "skipLibCheck": true,
+        "target": "esnext",
+        "resolveJsonModule": true,
+        "verbatimModuleSyntax": true,
+        "rootDir": ".",
+        "allowImportingTsExtensions": true,
+        "noEmit": true,
+        "module": "NodeNext",
+        "esModuleInterop": true,
+        "strict": true,
+        "noUncheckedIndexedAccess": true,
+        "noImplicitOverride": true,
+        "forceConsistentCasingInFileNames": true,
+        "allowJs": false,
+        "baseUrl": "./",
+        "paths": {
+            "#*": ["./src/*"]
+        }
+    },
+    "include": ["**/*"],
+    "exclude": ["node_modules", "dist"]
+}