fin.cx/einvoice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
Philipp Kunz
2025-05-28 08:40:26 +00:00
parent e4c762658d
commit 32f8bc192a
24 changed files with 3350 additions and 5416 deletions
Download Patch File Download Diff File Expand all files Collapse all files

786
test/suite/einvoice_pdf-operations/test.pdf-04.xml-embedding.ts
View File

@ -1,643 +1,245 @@
import { tap, expect } from '@git.zone/tstest/tapbundle';
import * as plugins from '../../../ts/plugins.ts';
import { EInvoice } from '../../../ts/classes.xinvoice.ts';
import { CorpusLoader } from '../../helpers/corpus.loader.ts';
import { PerformanceTracker } from '../../helpers/performance.tracker.ts';
import { expect, tap } from '@git.zone/tstest/tapbundle';
import { promises as fs } from 'fs';
import * as path from 'path';
import { CorpusLoader } from '../../helpers/corpus.loader.js';
import { PerformanceTracker } from '../../helpers/performance.tracker.js';
const testTimeout = 300000; // 5 minutes timeout for PDF processing
// PDF-04: XML Embedding into PDF
// Tests embedding XML invoice data into existing PDF files and creating
// new PDF/A-3 compliant files with embedded XML attachments
tap.test('PDF-04: XML Embedding - Basic Embedding Test', async (tools) => {
const startTime = Date.now();
tap.test('PDF-04: XML Embedding - Basic Embedding Test', async () => {
console.log('Testing XML embedding functionality...');
// Test basic XML embedding functionality
// Import required classes
const { EInvoice } = await import('../../../ts/index.js');
// Get existing PDF files from corpus
const pdfFiles = await CorpusLoader.getFiles('ZUGFERD_V2_CORRECT');
const existingPdfs = pdfFiles.filter(file => file.endsWith('.pdf'));
if (existingPdfs.length === 0) {
console.log('⚠ No PDF files found in corpus for embedding test');
return;
}
const basePdfPath = existingPdfs[0];
const basePdfName = path.basename(basePdfPath);
console.log(`Testing XML embedding using base PDF: ${basePdfName}`);
// Read the base PDF
const basePdfBuffer = await fs.readFile(basePdfPath);
const baseSizeKB = (basePdfBuffer.length / 1024).toFixed(1);
console.log(`Base PDF size: ${baseSizeKB}KB`);
// Create a simple invoice for embedding
const invoice = new EInvoice();
invoice.id = 'EMBED-TEST-001';
invoice.accountingDocId = 'EMBED-TEST-001';
invoice.date = Date.now();
invoice.currency = 'EUR';
invoice.from.name = 'Test Supplier for Embedding';
invoice.from.address.city = 'Berlin';
invoice.from.address.postalCode = '10115';
invoice.from.address.country = 'DE';
invoice.to.name = 'Test Customer for Embedding';
invoice.to.address.city = 'Munich';
invoice.to.address.postalCode = '80331';
invoice.to.address.country = 'DE';
// Add a simple item
invoice.addItem({
name: 'Test Item for Embedding',
unitQuantity: 1,
unitNetPrice: 100.00,
vatPercentage: 19
});
// Test embedding functionality
try {
// Create a sample XML invoice for embedding
const sampleXml = `<?xml version="1.0" encoding="UTF-8"?>
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
<ID>EMBED-TEST-001</ID>
<IssueDate>2024-01-01</IssueDate>
<InvoiceTypeCode>380</InvoiceTypeCode>
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>
<AccountingSupplierParty>
<Party>
<PartyName>
<Name>Test Supplier for Embedding</Name>
</PartyName>
</Party>
</AccountingSupplierParty>
<AccountingCustomerParty>
<Party>
<PartyName>
<Name>Test Customer for Embedding</Name>
</PartyName>
</Party>
</AccountingCustomerParty>
<LegalMonetaryTotal>
<PayableAmount currencyID="EUR">100.00</PayableAmount>
</LegalMonetaryTotal>
</Invoice>`;
const embeddedPdfBuffer = await invoice.embedInPdf(basePdfBuffer, 'facturx');
const embeddedSizeKB = (embeddedPdfBuffer.length / 1024).toFixed(1);
const invoice = new EInvoice();
console.log('✓ XML embedding completed successfully');
console.log(`Embedded PDF size: ${embeddedSizeKB}KB`);
// Parse the XML first
const parseResult = await invoice.fromXmlString(sampleXml);
expect(parseResult).toBeTruthy();
// Test embedding if the API supports it
if (typeof invoice.embedIntoPdf === 'function') {
tools.log('Testing XML embedding into PDF...');
// Create a simple base PDF for testing (mock implementation)
const outputPath = plugins.path.join(process.cwd(), '.nogit', 'test-embedded.pdf');
await plugins.fs.ensureDir(plugins.path.dirname(outputPath));
try {
const embeddingResult = await invoice.embedIntoPdf({
outputPath: outputPath,
xmlContent: sampleXml,
attachmentName: 'ZUGFeRD-invoice.xml'
});
if (embeddingResult) {
tools.log('✓ XML embedding operation completed');
// Verify output file exists
const outputExists = await plugins.fs.pathExists(outputPath);
if (outputExists) {
const outputStats = await plugins.fs.stat(outputPath);
tools.log(`✓ Output PDF created: ${(outputStats.size / 1024).toFixed(1)}KB`);
// Clean up
await plugins.fs.remove(outputPath);
} else {
tools.log('⚠ Output PDF file not found');
}
} else {
tools.log('⚠ XML embedding returned no result');
}
} catch (embeddingError) {
tools.log(`⚠ XML embedding failed: ${embeddingError.message}`);
// This might be expected if embedding is not fully implemented
}
// Verify the embedded PDF is larger than the original
if (embeddedPdfBuffer.length > basePdfBuffer.length) {
console.log('✓ Embedded PDF is larger than original (contains additional XML)');
} else {
tools.log('⚠ XML embedding functionality not available (embedIntoPdf method not found)');
// Test alternative embedding approach if available
if (typeof invoice.toPdf === 'function') {
try {
const pdfResult = await invoice.toPdf();
if (pdfResult) {
tools.log('✓ Alternative PDF generation successful');
}
} catch (pdfError) {
tools.log(`⚠ Alternative PDF generation failed: ${pdfError.message}`);
}
} else {
tools.log('⚠ No PDF embedding/generation methods available');
}
console.log('⚠ Embedded PDF is not larger than original');
}
} catch (error) {
tools.log(`Basic embedding test failed: ${error.message}`);
}
const duration = Date.now() - startTime;
PerformanceTracker.recordMetric('pdf-embedding-basic', duration);
});
tap.test('PDF-04: XML Embedding - Embedding into Existing PDF', async (tools) => {
const startTime = Date.now();
try {
// Look for existing PDF files in corpus to use as base
const existingPdfs = await CorpusLoader.getFiles('ZUGFERD_V1');
if (existingPdfs.length === 0) {
tools.log('⚠ No existing PDF files found for embedding test');
return;
}
const basePdf = existingPdfs[0];
const basePdfName = plugins.path.basename(basePdf);
tools.log(`Testing embedding into existing PDF: ${basePdfName}`);
// Create new XML content to embed
const newXmlContent = `<?xml version="1.0" encoding="UTF-8"?>
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
<ID>EMBED-EXISTING-001</ID>
<IssueDate>2024-01-01</IssueDate>
<InvoiceTypeCode>380</InvoiceTypeCode>
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>
<Note>This XML was embedded into an existing PDF</Note>
<LegalMonetaryTotal>
<PayableAmount currencyID="EUR">250.00</PayableAmount>
</LegalMonetaryTotal>
</Invoice>`;
const invoice = new EInvoice();
await invoice.fromXmlString(newXmlContent);
// Test embedding into existing PDF
const outputPath = plugins.path.join(process.cwd(), '.nogit', 'test-embed-existing.pdf');
await plugins.fs.ensureDir(plugins.path.dirname(outputPath));
// Test extraction from embedded PDF
try {
// Check if embedding into existing PDF is supported
if (typeof invoice.embedIntoPdf === 'function') {
const embeddingOptions = {
basePdfPath: basePdf,
outputPath: outputPath,
xmlContent: newXmlContent,
attachmentName: 'embedded-invoice.xml',
preserveExisting: true
};
const embeddingResult = await invoice.embedIntoPdf(embeddingOptions);
if (embeddingResult) {
tools.log('✓ Embedding into existing PDF completed');
// Verify the result
const outputExists = await plugins.fs.pathExists(outputPath);
if (outputExists) {
const outputStats = await plugins.fs.stat(outputPath);
const baseStats = await plugins.fs.stat(basePdf);
tools.log(`Base PDF size: ${(baseStats.size / 1024).toFixed(1)}KB`);
tools.log(`Output PDF size: ${(outputStats.size / 1024).toFixed(1)}KB`);
// Output should be larger than base (contains additional XML)
if (outputStats.size > baseStats.size) {
tools.log('✓ Output PDF is larger, suggesting successful embedding');
} else {
tools.log('⚠ Output PDF is not larger than base');
}
// Test extraction from embedded PDF
try {
const extractionInvoice = new EInvoice();
const extractionResult = await extractionInvoice.fromFile(outputPath);
if (extractionResult) {
const extractedXml = await extractionInvoice.toXmlString();
if (extractedXml.includes('EMBED-EXISTING-001')) {
tools.log('✓ Successfully extracted embedded XML');
} else {
tools.log('⚠ Extracted XML does not contain expected content');
}
} else {
tools.log('⚠ Could not extract XML from embedded PDF');
}
} catch (extractionError) {
tools.log(`⚠ Extraction test failed: ${extractionError.message}`);
}
// Clean up
await plugins.fs.remove(outputPath);
} else {
tools.log('⚠ Output PDF file not created');
}
} else {
tools.log('⚠ Embedding into existing PDF returned no result');
}
const extractionInvoice = new EInvoice();
await extractionInvoice.fromPdf(embeddedPdfBuffer);
if (extractionInvoice.id === 'EMBED-TEST-001') {
console.log('✓ Successfully extracted embedded XML and verified invoice ID');
} else {
tools.log('⚠ Embedding into existing PDF not supported');
console.log(`⚠ Extracted invoice ID mismatch: expected EMBED-TEST-001, got ${extractionInvoice.id}`);
}
} catch (embeddingError) {
tools.log(`⚠ Embedding into existing PDF failed: ${embeddingError.message}`);
} catch (extractionError) {
console.log(`⚠ Extraction test failed: ${extractionError.message}`);
}
} catch (error) {
tools.log(`Embedding into existing PDF test failed: ${error.message}`);
} catch (embeddingError) {
console.log(`⚠ XML embedding failed: ${embeddingError.message}`);
// This might be expected if embedding is not fully implemented
}
const duration = Date.now() - startTime;
PerformanceTracker.recordMetric('pdf-embedding-existing', duration);
// Test completed
});
tap.test('PDF-04: XML Embedding - Multiple Format Embedding', async (tools) => {
const startTime = Date.now();
tap.test('PDF-04: XML Embedding - Performance Test', async () => {
console.log('Testing embedding performance...');
// Test embedding different XML formats (UBL, CII, etc.)
const xmlFormats = [
{
name: 'UBL Invoice',
xml: `<?xml version="1.0" encoding="UTF-8"?>
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
<ID>UBL-EMBED-001</ID>
<IssueDate>2024-01-01</IssueDate>
<InvoiceTypeCode>380</InvoiceTypeCode>
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>
<LegalMonetaryTotal>
<PayableAmount currencyID="EUR">100.00</PayableAmount>
</LegalMonetaryTotal>
</Invoice>`,
attachmentName: 'ubl-invoice.xml'
},
{
name: 'CII Invoice',
xml: `<?xml version="1.0" encoding="UTF-8"?>
<CrossIndustryInvoice xmlns="urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100">
<ExchangedDocumentContext>
<GuidelineSpecifiedDocumentContextParameter>
<ID>urn:cen.eu:en16931:2017</ID>
</GuidelineSpecifiedDocumentContextParameter>
</ExchangedDocumentContext>
<ExchangedDocument>
<ID>CII-EMBED-001</ID>
<TypeCode>380</TypeCode>
<IssueDateTime>
<DateTimeString format="102">20240101</DateTimeString>
</IssueDateTime>
</ExchangedDocument>
<SupplyChainTradeTransaction>
<ApplicableHeaderTradeSettlement>
<InvoiceCurrencyCode>EUR</InvoiceCurrencyCode>
<SpecifiedTradeSettlementHeaderMonetarySummation>
<DuePayableAmount>100.00</DuePayableAmount>
</SpecifiedTradeSettlementHeaderMonetarySummation>
</ApplicableHeaderTradeSettlement>
</SupplyChainTradeTransaction>
</CrossIndustryInvoice>`,
attachmentName: 'cii-invoice.xml'
}
];
// Import required classes
const { EInvoice } = await import('../../../ts/index.js');
for (const format of xmlFormats) {
tools.log(`Testing ${format.name} embedding...`);
try {
const invoice = new EInvoice();
const parseResult = await invoice.fromXmlString(format.xml);
if (parseResult) {
// Test embedding if available
if (typeof invoice.embedIntoPdf === 'function') {
const outputPath = plugins.path.join(process.cwd(), '.nogit', `test-${format.name.toLowerCase().replace(/\s+/g, '-')}.pdf`);
await plugins.fs.ensureDir(plugins.path.dirname(outputPath));
try {
const embeddingResult = await invoice.embedIntoPdf({
outputPath: outputPath,
xmlContent: format.xml,
attachmentName: format.attachmentName
});
if (embeddingResult) {
tools.log(`✓ ${format.name} embedding completed`);
// Verify file creation
const outputExists = await plugins.fs.pathExists(outputPath);
if (outputExists) {
const outputStats = await plugins.fs.stat(outputPath);
tools.log(` Output size: ${(outputStats.size / 1024).toFixed(1)}KB`);
// Clean up
await plugins.fs.remove(outputPath);
}
} else {
tools.log(`⚠ ${format.name} embedding returned no result`);
}
} catch (embeddingError) {
tools.log(`⚠ ${format.name} embedding failed: ${embeddingError.message}`);
}
} else {
tools.log(`⚠ ${format.name} embedding not supported (no embedIntoPdf method)`);
}
} else {
tools.log(`⚠ ${format.name} XML parsing failed`);
}
} catch (error) {
tools.log(`✗ ${format.name} embedding test failed: ${error.message}`);
}
// Get a PDF file for performance testing
const pdfFiles = await CorpusLoader.getFiles('ZUGFERD_V2_CORRECT');
const existingPdfs = pdfFiles.filter(file => file.endsWith('.pdf'));
if (existingPdfs.length === 0) {
console.log('⚠ No PDF files found for performance test');
return;
}
const duration = Date.now() - startTime;
PerformanceTracker.recordMetric('pdf-embedding-multiple-formats', duration);
});
tap.test('PDF-04: XML Embedding - Metadata and Compliance', async (tools) => {
const startTime = Date.now();
// Test PDF/A-3 compliance and metadata handling
const testXml = `<?xml version="1.0" encoding="UTF-8"?>
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
<ID>METADATA-TEST-001</ID>
<IssueDate>2024-01-01</IssueDate>
<InvoiceTypeCode>380</InvoiceTypeCode>
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>
<LegalMonetaryTotal>
<PayableAmount currencyID="EUR">100.00</PayableAmount>
</LegalMonetaryTotal>
</Invoice>`;
try {
const invoice = new EInvoice();
await invoice.fromXmlString(testXml);
// Test embedding with various metadata options
const metadataOptions = [
{
name: 'PDF/A-3 Compliance',
options: {
pdfACompliance: 'PDF/A-3',
title: 'Electronic Invoice METADATA-TEST-001',
author: 'EInvoice Test Suite',
subject: 'Invoice with embedded XML',
keywords: 'invoice, electronic, PDF/A-3, ZUGFeRD'
}
},
{
name: 'ZUGFeRD Metadata',
options: {
zugferdProfile: 'BASIC',
zugferdVersion: '2.1',
conformanceLevel: 'PDFA_3B'
}
},
{
name: 'Custom Metadata',
options: {
customMetadata: {
invoiceNumber: 'METADATA-TEST-001',
issueDate: '2024-01-01',
supplier: 'Test Supplier',
customer: 'Test Customer'
}
}
}
];
for (const metadataTest of metadataOptions) {
tools.log(`Testing ${metadataTest.name}...`);
try {
if (typeof invoice.embedIntoPdf === 'function') {
const outputPath = plugins.path.join(process.cwd(), '.nogit', `test-${metadataTest.name.toLowerCase().replace(/\s+/g, '-')}.pdf`);
await plugins.fs.ensureDir(plugins.path.dirname(outputPath));
const embeddingOptions = {
outputPath: outputPath,
xmlContent: testXml,
attachmentName: 'invoice.xml',
...metadataTest.options
};
const embeddingResult = await invoice.embedIntoPdf(embeddingOptions);
if (embeddingResult) {
tools.log(`✓ ${metadataTest.name} embedding completed`);
// Verify file and basic properties
const outputExists = await plugins.fs.pathExists(outputPath);
if (outputExists) {
const outputStats = await plugins.fs.stat(outputPath);
tools.log(` Output size: ${(outputStats.size / 1024).toFixed(1)}KB`);
// TODO: Add PDF metadata validation if PDF parsing library is available
// For now, just verify file creation
// Clean up
await plugins.fs.remove(outputPath);
}
} else {
tools.log(`⚠ ${metadataTest.name} embedding returned no result`);
}
} else {
tools.log(`⚠ ${metadataTest.name} embedding not supported`);
}
} catch (metadataError) {
tools.log(`⚠ ${metadataTest.name} embedding failed: ${metadataError.message}`);
}
}
} catch (error) {
tools.log(`Metadata and compliance test failed: ${error.message}`);
}
const duration = Date.now() - startTime;
PerformanceTracker.recordMetric('pdf-embedding-metadata', duration);
});
tap.test('PDF-04: XML Embedding - Performance and Size Analysis', async (tools) => {
const startTime = Date.now();
// Test embedding performance with different XML sizes
const sizeTests = [
{
name: 'Small XML (1KB)',
xmlGenerator: () => `<?xml version="1.0" encoding="UTF-8"?>
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
<ID>SMALL-XML-001</ID>
<IssueDate>2024-01-01</IssueDate>
<InvoiceTypeCode>380</InvoiceTypeCode>
<LegalMonetaryTotal>
<PayableAmount currencyID="EUR">100.00</PayableAmount>
</LegalMonetaryTotal>
</Invoice>`
},
{
name: 'Medium XML (10KB)',
xmlGenerator: () => {
let xml = `<?xml version="1.0" encoding="UTF-8"?>
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
<ID>MEDIUM-XML-001</ID>
<IssueDate>2024-01-01</IssueDate>
<InvoiceTypeCode>380</InvoiceTypeCode>
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>`;
// Add multiple invoice lines to increase size
for (let i = 1; i <= 50; i++) {
xml += `
<InvoiceLine>
<ID>${i}</ID>
<InvoicedQuantity unitCode="C62">1</InvoicedQuantity>
<LineExtensionAmount currencyID="EUR">10.00</LineExtensionAmount>
<Item>
<Name>Test Item ${i} with description that makes this line longer</Name>
<Description>Detailed description of test item ${i} for size testing purposes</Description>
</Item>
<Price>
<PriceAmount currencyID="EUR">10.00</PriceAmount>
</Price>
</InvoiceLine>`;
}
xml += `
<LegalMonetaryTotal>
<PayableAmount currencyID="EUR">500.00</PayableAmount>
</LegalMonetaryTotal>
</Invoice>`;
return xml;
}
},
{
name: 'Large XML (50KB)',
xmlGenerator: () => {
let xml = `<?xml version="1.0" encoding="UTF-8"?>
<Invoice xmlns="urn:oasis:names:specification:ubl:schema:xsd:Invoice-2">
<ID>LARGE-XML-001</ID>
<IssueDate>2024-01-01</IssueDate>
<InvoiceTypeCode>380</InvoiceTypeCode>
<DocumentCurrencyCode>EUR</DocumentCurrencyCode>`;
// Add many invoice lines to increase size significantly
for (let i = 1; i <= 200; i++) {
xml += `
<InvoiceLine>
<ID>${i}</ID>
<InvoicedQuantity unitCode="C62">1</InvoicedQuantity>
<LineExtensionAmount currencyID="EUR">25.00</LineExtensionAmount>
<Item>
<Name>Test Item ${i} with very long description that includes many details about the product or service being invoiced</Name>
<Description>This is a very detailed description of test item ${i} for size testing purposes. It includes information about specifications, features, benefits, and other relevant details that would typically be found in a real invoice line item description.</Description>
<AdditionalItemProperty>
<Name>Property${i}</Name>
<Value>Value for property ${i} with additional text to increase size</Value>
</AdditionalItemProperty>
</Item>
<Price>
<PriceAmount currencyID="EUR">25.00</PriceAmount>
</Price>
</InvoiceLine>`;
}
xml += `
<LegalMonetaryTotal>
<PayableAmount currencyID="EUR">5000.00</PayableAmount>
</LegalMonetaryTotal>
</Invoice>`;
return xml;
}
}
];
const basePdfBuffer = await fs.readFile(existingPdfs[0]);
const performanceResults = [];
for (const sizeTest of sizeTests) {
tools.log(`Testing embedding performance: ${sizeTest.name}`);
// Test with different invoice sizes
const testSizes = [1, 5, 10]; // Number of items
for (const itemCount of testSizes) {
// Create invoice with specified number of items
const invoice = new EInvoice();
invoice.id = `PERF-TEST-${itemCount}`;
invoice.accountingDocId = `PERF-TEST-${itemCount}`;
invoice.date = Date.now();
invoice.currency = 'EUR';
invoice.from.name = 'Performance Test Supplier';
invoice.from.address.city = 'Berlin';
invoice.from.address.postalCode = '10115';
invoice.from.address.country = 'DE';
invoice.to.name = 'Performance Test Customer';
invoice.to.address.city = 'Munich';
invoice.to.address.postalCode = '80331';
invoice.to.address.country = 'DE';
// Add multiple items
for (let i = 1; i <= itemCount; i++) {
invoice.addItem({
name: `Performance Test Item ${i}`,
unitQuantity: 1,
unitNetPrice: 50.00,
vatPercentage: 19
});
}
try {
const xml = sizeTest.xmlGenerator();
const xmlSizeKB = Buffer.byteLength(xml, 'utf8') / 1024;
tools.log(` XML size: ${xmlSizeKB.toFixed(1)}KB`);
const invoice = new EInvoice();
await invoice.fromXmlString(xml);
const embeddingStartTime = Date.now();
const embeddedPdfBuffer = await invoice.embedInPdf(basePdfBuffer, 'facturx');
const embeddingTime = Date.now() - embeddingStartTime;
if (typeof invoice.embedIntoPdf === 'function') {
const outputPath = plugins.path.join(process.cwd(), '.nogit', `test-${sizeTest.name.toLowerCase().replace(/\s+/g, '-')}.pdf`);
await plugins.fs.ensureDir(plugins.path.dirname(outputPath));
try {
const embeddingResult = await invoice.embedIntoPdf({
outputPath: outputPath,
xmlContent: xml,
attachmentName: 'invoice.xml'
});
const embeddingTime = Date.now() - embeddingStartTime;
if (embeddingResult) {
const outputExists = await plugins.fs.pathExists(outputPath);
if (outputExists) {
const outputStats = await plugins.fs.stat(outputPath);
const outputSizeKB = outputStats.size / 1024;
const result = {
name: sizeTest.name,
xmlSizeKB: xmlSizeKB,
outputSizeKB: outputSizeKB,
embeddingTimeMs: embeddingTime,
timePerKB: embeddingTime / xmlSizeKB
};
performanceResults.push(result);
tools.log(` Embedding time: ${embeddingTime}ms`);
tools.log(` Output PDF size: ${outputSizeKB.toFixed(1)}KB`);
tools.log(` Time per KB: ${(embeddingTime / xmlSizeKB).toFixed(2)}ms/KB`);
// Clean up
await plugins.fs.remove(outputPath);
}
} else {
tools.log(` ⚠ Embedding returned no result`);
}
} catch (embeddingError) {
tools.log(` ⚠ Embedding failed: ${embeddingError.message}`);
}
} else {
tools.log(` ⚠ Embedding not supported`);
}
const result = {
itemCount,
embeddingTimeMs: embeddingTime,
outputSizeKB: embeddedPdfBuffer.length / 1024,
timePerItem: embeddingTime / itemCount
};
} catch (error) {
tools.log(` ✗ ${sizeTest.name} failed: ${error.message}`);
performanceResults.push(result);
console.log(`Items: ${itemCount}, Time: ${embeddingTime}ms, Size: ${result.outputSizeKB.toFixed(1)}KB`);
} catch (embeddingError) {
console.log(`⚠ Performance test failed for ${itemCount} items: ${embeddingError.message}`);
}
}
// Analyze performance results
// Analyze results
if (performanceResults.length > 0) {
tools.log(`\nEmbedding Performance Analysis:`);
const avgTimePerKB = performanceResults.reduce((sum, r) => sum + r.timePerKB, 0) / performanceResults.length;
const avgTimePerItem = performanceResults.reduce((sum, r) => sum + r.timePerItem, 0) / performanceResults.length;
const maxTime = Math.max(...performanceResults.map(r => r.embeddingTimeMs));
const minTime = Math.min(...performanceResults.map(r => r.embeddingTimeMs));
tools.log(`- Average time per KB: ${avgTimePerKB.toFixed(2)}ms/KB`);
tools.log(`- Fastest embedding: ${minTime}ms`);
tools.log(`- Slowest embedding: ${maxTime}ms`);
console.log(`\nPerformance Analysis:`);
console.log(`- Average time per item: ${avgTimePerItem.toFixed(2)}ms`);
console.log(`- Maximum embedding time: ${maxTime}ms`);
// Performance expectations
expect(avgTimePerKB).toBeLessThan(100); // 100ms per KB max
expect(maxTime).toBeLessThan(10000); // 10 seconds max for any size
// Basic performance expectations
expect(avgTimePerItem).toBeLessThan(500); // 500ms per item max
expect(maxTime).toBeLessThan(10000); // 10 seconds max overall
}
const duration = Date.now() - startTime;
PerformanceTracker.recordMetric('pdf-embedding-performance', duration);
// Performance test completed
});
tap.test('PDF-04: Performance Summary', async (tools) => {
tap.test('PDF-04: XML Embedding - Error Handling', async () => {
console.log('Testing embedding error handling...');
// Import required classes
const { EInvoice } = await import('../../../ts/index.js');
// Test error handling scenarios
const invoice = new EInvoice();
invoice.id = 'ERROR-TEST-001';
invoice.accountingDocId = 'ERROR-TEST-001';
invoice.date = Date.now();
invoice.currency = 'EUR';
invoice.from.name = 'Error Test Supplier';
invoice.from.address.city = 'Berlin';
invoice.from.address.postalCode = '10115';
invoice.from.address.country = 'DE';
invoice.to.name = 'Error Test Customer';
invoice.to.address.city = 'Munich';
invoice.to.address.postalCode = '80331';
invoice.to.address.country = 'DE';
invoice.addItem({
name: 'Error Test Item',
unitQuantity: 1,
unitNetPrice: 100.00,
vatPercentage: 19
});
// Test 1: Invalid PDF buffer
try {
const invalidPdfBuffer = Buffer.from('This is not a PDF');
await invoice.embedInPdf(invalidPdfBuffer, 'facturx');
console.log('⚠ Expected error for invalid PDF buffer, but embedding succeeded');
} catch (error) {
console.log('✓ Correctly rejected invalid PDF buffer');
}
// Test 2: Empty PDF buffer
try {
const emptyPdfBuffer = Buffer.alloc(0);
await invoice.embedInPdf(emptyPdfBuffer, 'facturx');
console.log('⚠ Expected error for empty PDF buffer, but embedding succeeded');
} catch (error) {
console.log('✓ Correctly rejected empty PDF buffer');
}
// Error handling test completed
});
tap.test('PDF-04: XML Embedding - Summary', async () => {
const operations = [
'pdf-embedding-basic',
'pdf-embedding-existing',
'pdf-embedding-multiple-formats',
'pdf-embedding-metadata',
'pdf-embedding-performance'
'pdf-embedding-performance',
'pdf-embedding-errors'
];
tools.log(`\n=== XML Embedding Performance Summary ===`);
console.log(`\n=== XML Embedding Performance Summary ===`);
for (const operation of operations) {
const summary = await PerformanceTracker.getSummary(operation);
if (summary) {
tools.log(`${operation}:`);
tools.log(` avg=${summary.average}ms, min=${summary.min}ms, max=${summary.max}ms, p95=${summary.p95}ms`);
console.log(`${operation}: avg=${summary.average}ms, min=${summary.min}ms, max=${summary.max}ms`);
}
}
tools.log(`\nXML embedding testing completed.`);
});
console.log(`\n✓ XML embedding testing completed successfully.`);
});
tap.start();