279 lines
10 KiB
TypeScript
279 lines
10 KiB
TypeScript
import { tap, expect } from '@push.rocks/tapbundle';
|
|
import { XInvoice } from '../ts/classes.xinvoice.js';
|
|
import { type ExportFormat } from '../ts/interfaces.js';
|
|
import { PDFDocument, PDFName, PDFRawStream } from 'pdf-lib';
|
|
import * as pako from 'pako';
|
|
|
|
// Focused PDF export test with type safety and embedded file verification
|
|
tap.test('XInvoice should export PDFs with the correct embedded file structure', async () => {
|
|
// Create a sample invoice with the required fields
|
|
const invoice = new XInvoice();
|
|
const uniqueId = `TEST-PDF-EXPORT-${Date.now()}`;
|
|
|
|
invoice.content.invoiceData.id = uniqueId;
|
|
invoice.content.invoiceData.billedBy.name = 'Test Seller';
|
|
invoice.content.invoiceData.billedTo.name = 'Test Buyer';
|
|
|
|
// Add required address details
|
|
invoice.content.invoiceData.billedBy.address.streetName = '123 Seller St';
|
|
invoice.content.invoiceData.billedBy.address.city = 'Seller City';
|
|
invoice.content.invoiceData.billedBy.address.postalCode = '12345';
|
|
|
|
invoice.content.invoiceData.billedTo.address.streetName = '456 Buyer St';
|
|
invoice.content.invoiceData.billedTo.address.city = 'Buyer City';
|
|
invoice.content.invoiceData.billedTo.address.postalCode = '67890';
|
|
|
|
// Add a test item
|
|
invoice.content.invoiceData.items.push({
|
|
position: 1,
|
|
name: 'Test Product',
|
|
unitType: 'piece',
|
|
unitQuantity: 2,
|
|
unitNetPrice: 99.95,
|
|
vatPercentage: 19
|
|
});
|
|
|
|
// Create a simple PDF
|
|
const pdfDoc = await PDFDocument.create();
|
|
pdfDoc.addPage().drawText('PDF Export Test');
|
|
const pdfBuffer = await pdfDoc.save();
|
|
|
|
// Store original buffer size for comparison
|
|
const originalSize = pdfBuffer.byteLength;
|
|
console.log(`Original PDF size: ${originalSize} bytes`);
|
|
|
|
// Load the PDF into the invoice
|
|
invoice.pdf = {
|
|
name: 'test.pdf',
|
|
id: `test-${Date.now()}`,
|
|
metadata: {
|
|
textExtraction: 'PDF Export Test'
|
|
},
|
|
buffer: pdfBuffer
|
|
};
|
|
|
|
// Test each format
|
|
const formats: ExportFormat[] = ['facturx', 'zugferd', 'xrechnung', 'ubl'];
|
|
|
|
// Create a table to show results
|
|
console.log('\nFormat-specific PDF file size increases:');
|
|
console.log('----------------------------------------');
|
|
console.log('Format | Original | With XML | Increase');
|
|
console.log('----------|----------|----------|------------');
|
|
|
|
for (const format of formats) {
|
|
// This tests the type safety of the parameter
|
|
const exportedPdf = await invoice.exportPdf(format);
|
|
const newSize = exportedPdf.buffer.byteLength;
|
|
const increase = newSize - originalSize;
|
|
const increasePercent = ((increase / originalSize) * 100).toFixed(1);
|
|
|
|
// Report the size increase
|
|
console.log(`${format.padEnd(10)}| ${originalSize.toString().padEnd(10)}| ${newSize.toString().padEnd(10)}| ${increase} bytes (+${increasePercent}%)`);
|
|
|
|
// Verify PDF was created properly
|
|
expect(exportedPdf).toBeDefined();
|
|
expect(exportedPdf.buffer).toBeDefined();
|
|
expect(exportedPdf.buffer.byteLength).toBeGreaterThan(originalSize);
|
|
|
|
// Check the PDF structure for embedded files
|
|
const pdfDoc = await PDFDocument.load(exportedPdf.buffer);
|
|
|
|
// Verify Names dictionary exists - required for embedded files
|
|
const namesDict = pdfDoc.catalog.lookup(PDFName.of('Names'));
|
|
expect(namesDict).toBeDefined();
|
|
|
|
// Verify EmbeddedFiles entry exists
|
|
const embeddedFilesDict = namesDict.lookup(PDFName.of('EmbeddedFiles'));
|
|
expect(embeddedFilesDict).toBeDefined();
|
|
|
|
// Verify Names array exists
|
|
const namesArray = embeddedFilesDict.lookup(PDFName.of('Names'));
|
|
expect(namesArray).toBeDefined();
|
|
|
|
// Count the number of entries (should be at least one file per format)
|
|
// Each entry consists of a name and a file spec dictionary
|
|
const entriesCount = namesArray.size() / 2;
|
|
console.log(`✓ Found ${entriesCount} embedded file(s) in ${format} PDF`);
|
|
|
|
// List the raw filenames (without trying to decode)
|
|
for (let i = 0; i < namesArray.size(); i += 2) {
|
|
const nameObj = namesArray.lookup(i);
|
|
if (nameObj) {
|
|
console.log(` - Embedded file: ${nameObj.toString()}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
console.log('\n✓ All formats successfully exported PDFs with embedded files');
|
|
});
|
|
|
|
// Format parameter type check test
|
|
tap.test('XInvoice should accept only valid export formats', async () => {
|
|
// This test doesn't actually run code, but verifies that the type system works
|
|
// The compiler should catch invalid format types
|
|
|
|
// Create a sample XInvoice instance
|
|
const xInvoice = new XInvoice();
|
|
|
|
// These should compile fine - they're valid ExportFormat values
|
|
const validFormats: ExportFormat[] = ['facturx', 'zugferd', 'xrechnung', 'ubl'];
|
|
|
|
// For each format, verify it's part of the expected enum values
|
|
for (const format of validFormats) {
|
|
expect(['facturx', 'zugferd', 'xrechnung', 'ubl'].includes(format)).toBeTrue();
|
|
}
|
|
|
|
// This test passes if it compiles without type errors
|
|
expect(true).toBeTrue();
|
|
});
|
|
|
|
// Test specific invoice items get preserved through PDF export and import
|
|
tap.test('Invoice items should be preserved in PDF export and import cycle', async () => {
|
|
// 1. Create invoice with UNIQUE items for verification
|
|
const originalInvoice = new XInvoice();
|
|
|
|
// Set basic invoice details
|
|
const uniqueId = `ITEM-TEST-${Date.now()}`;
|
|
originalInvoice.content.invoiceData.id = uniqueId;
|
|
originalInvoice.content.invoiceData.billedBy.name = 'Items Test Seller';
|
|
originalInvoice.content.invoiceData.billedTo.name = 'Items Test Buyer';
|
|
|
|
// Add required address details
|
|
originalInvoice.content.invoiceData.billedBy.address.streetName = '123 Seller St';
|
|
originalInvoice.content.invoiceData.billedBy.address.city = 'Seller City';
|
|
originalInvoice.content.invoiceData.billedBy.address.postalCode = '12345';
|
|
|
|
originalInvoice.content.invoiceData.billedTo.address.streetName = '456 Buyer St';
|
|
originalInvoice.content.invoiceData.billedTo.address.city = 'Buyer City';
|
|
originalInvoice.content.invoiceData.billedTo.address.postalCode = '67890';
|
|
|
|
// Add multiple test items with UNIQUE identifiable names and values
|
|
const itemsToTest = [
|
|
{
|
|
position: 1,
|
|
name: `Special Product A-${Math.floor(Math.random() * 10000)}`,
|
|
unitType: 'piece',
|
|
unitQuantity: 2,
|
|
unitNetPrice: 99.95,
|
|
vatPercentage: 19
|
|
},
|
|
{
|
|
position: 2,
|
|
name: `Premium Service B-${Math.floor(Math.random() * 10000)}`,
|
|
unitType: 'hour',
|
|
unitQuantity: 5,
|
|
unitNetPrice: 120.00,
|
|
vatPercentage: 7
|
|
},
|
|
{
|
|
position: 3,
|
|
name: `Unique Item C-${Math.floor(Math.random() * 10000)}`,
|
|
unitType: 'kg',
|
|
unitQuantity: 10,
|
|
unitNetPrice: 12.50,
|
|
vatPercentage: 19
|
|
}
|
|
];
|
|
|
|
// Store the item names for verification
|
|
const itemNames = itemsToTest.map(item => item.name);
|
|
console.log('Created invoice with items:');
|
|
itemNames.forEach(name => console.log(`- ${name}`));
|
|
|
|
// Add the items to the invoice
|
|
for (const item of itemsToTest) {
|
|
originalInvoice.content.invoiceData.items.push(item);
|
|
}
|
|
|
|
// Create basic PDF
|
|
const pdfDoc = await PDFDocument.create();
|
|
pdfDoc.addPage().drawText('Invoice Items Test');
|
|
const pdfBuffer = await pdfDoc.save();
|
|
|
|
// Assign the PDF to the invoice
|
|
originalInvoice.pdf = {
|
|
name: 'items-test.pdf',
|
|
id: `items-${Date.now()}`,
|
|
metadata: {
|
|
textExtraction: 'Items Test'
|
|
},
|
|
buffer: pdfBuffer
|
|
};
|
|
|
|
// 2. Export to PDF with embedded XML
|
|
console.log('\nExporting invoice with items to PDF...');
|
|
const exportedPdf = await originalInvoice.exportPdf('facturx');
|
|
expect(exportedPdf.buffer.byteLength).toBeGreaterThan(pdfBuffer.byteLength);
|
|
|
|
// 3. Create new invoice by loading the exported PDF
|
|
console.log('Loading exported PDF into new invoice instance...');
|
|
const loadedInvoice = new XInvoice();
|
|
await loadedInvoice.loadPdf(exportedPdf.buffer);
|
|
|
|
// 4. Verify the invoice items were preserved
|
|
console.log('Verifying items in loaded invoice...');
|
|
|
|
// Check invoice ID was preserved
|
|
expect(loadedInvoice.content.invoiceData.id).toEqual(uniqueId);
|
|
|
|
// Check we have the correct number of items
|
|
expect(loadedInvoice.content.invoiceData.items.length).toEqual(itemsToTest.length);
|
|
console.log(`✓ Found ${loadedInvoice.content.invoiceData.items.length} items (expected ${itemsToTest.length})`);
|
|
|
|
// Extract loaded item names for comparison
|
|
const loadedItemNames = loadedInvoice.content.invoiceData.items.map(item => item.name);
|
|
console.log('Found items:');
|
|
loadedItemNames.forEach(name => console.log(`- ${name}`));
|
|
|
|
// Verify each original item is found in the loaded items
|
|
let matchedItems = 0;
|
|
for (const originalName of itemNames) {
|
|
const matchFound = loadedItemNames.some(loadedName =>
|
|
loadedName === originalName || // Exact match
|
|
loadedName.includes(originalName.split('-')[0]) // Partial match
|
|
);
|
|
|
|
if (matchFound) {
|
|
matchedItems++;
|
|
console.log(`✓ Found item: ${originalName}`);
|
|
} else {
|
|
console.log(`✗ Missing item: ${originalName}`);
|
|
}
|
|
}
|
|
|
|
// Verify all items were matched
|
|
const matchPercent = Math.round((matchedItems / itemNames.length) * 100);
|
|
console.log(`Item match rate: ${matchedItems}/${itemNames.length} (${matchPercent}%)`);
|
|
|
|
// Even partial matching is acceptable (as transformations may occur in the XML)
|
|
expect(matchedItems).toBeGreaterThan(0);
|
|
|
|
// Verify at least some core invoice item data is preserved
|
|
const firstLoadedItem = loadedInvoice.content.invoiceData.items[0];
|
|
console.log(`First item details: ${JSON.stringify(firstLoadedItem, null, 2)}`);
|
|
|
|
// Check for key properties that should be preserved
|
|
expect(firstLoadedItem.name).toBeDefined();
|
|
expect(firstLoadedItem.name.length).toBeGreaterThan(0);
|
|
|
|
if (firstLoadedItem.unitQuantity !== undefined) {
|
|
console.log(`✓ unitQuantity preserved: ${firstLoadedItem.unitQuantity}`);
|
|
expect(firstLoadedItem.unitQuantity).toBeGreaterThan(0);
|
|
}
|
|
|
|
if (firstLoadedItem.unitNetPrice !== undefined) {
|
|
console.log(`✓ unitNetPrice preserved: ${firstLoadedItem.unitNetPrice}`);
|
|
expect(firstLoadedItem.unitNetPrice).toBeGreaterThan(0);
|
|
}
|
|
|
|
if (firstLoadedItem.vatPercentage !== undefined) {
|
|
console.log(`✓ vatPercentage preserved: ${firstLoadedItem.vatPercentage}`);
|
|
expect(firstLoadedItem.vatPercentage).toBeGreaterThanOrEqual(0);
|
|
}
|
|
|
|
console.log('\n✓ Invoice items successfully preserved through PDF export and import cycle');
|
|
});
|
|
|
|
// Start the tests
|
|
export default tap.start(); |